From fe59b0ce4a77cad1255e2d813f1b0c7fed853583 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renaud?= Date: Tue, 12 Mar 2024 17:41:56 +0100 Subject: [PATCH 01/11] add back mainnet manifest for testing on forks --- smart-contracts/.openzeppelin/mainnet.json | 3411 ++++++++++++++++++++ 1 file changed, 3411 insertions(+) create mode 100644 smart-contracts/.openzeppelin/mainnet.json diff --git a/smart-contracts/.openzeppelin/mainnet.json b/smart-contracts/.openzeppelin/mainnet.json new file mode 100644 index 00000000000..f00f16b6672 --- /dev/null +++ b/smart-contracts/.openzeppelin/mainnet.json @@ -0,0 +1,3411 @@ +{ + "manifestVersion": "3.2", + "admin": { + "address": "0xA2D9BC1ffc560Cc6F21aC09E317A3186AC1B1db8" + }, + "proxies": [ + { + "address": "0x3d5409cce1d45233de1d4ebdee74b8e004abdd13", + "kind": "transparent" + }, + { + "address": "0x90DE74265a416e1393A450752175AED98fe11517", + "kind": "transparent" + }, + { + "address": "0x9A1f43090307034DBFBE2ba20320Ce815ff046D4", + "txHash": "0x666e0cd6acc44c8da39964d5e9d4a1e0cdd0ff3140466bdcbeacdc04630d6ac8", + "kind": "transparent" + }, + { + "address": "0x440d9D4E66d39bb28FB58729Cb4D3ead2A595591", + "txHash": "0x19707e4f1839f349e616d858bdb7e9373b76b6a27364c3d0bbd60c4b5b3af63a", + "kind": "transparent" + }, + { + "address": "0xe79B93f8E22676774F2A8dAd469175ebd00029FA", + "kind": "transparent" + } + ], + "impls": { + "1c787d15bfcc8f151c3ca1db0d4a919f7d282e76566f669fa0d4f1098b1e8a36": { + "address": "0x5ACe3dc6d531d71c693A56510cC7491f48b1c4E4", + "layout": { + "storage": [ + { + "contract": "Initializable", + "label": "initialized", + "type": "t_bool", + "src": "@openzeppelin/upgrades/contracts/Initializable.sol" + }, + { + "contract": "Initializable", + "label": "initializing", + "type": "t_bool", + "src": "@openzeppelin/upgrades/contracts/Initializable.sol" + }, + { + "contract": "Initializable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "@openzeppelin/upgrades/contracts/Initializable.sol" + }, + { + "contract": "Ownable", + "label": "_owner", + "type": "t_address", + "src": "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol" + }, + { + "contract": "Ownable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol" + }, + { + "contract": "Unlock", + "label": "grossNetworkProduct", + "type": "t_uint256", + "src": "contracts/Unlock.sol" + }, + { + "contract": "Unlock", + "label": "totalDiscountGranted", + "type": "t_uint256", + "src": "contracts/Unlock.sol" + }, + { + "contract": "Unlock", + "label": "locks", + "type": "t_mapping(unknown,t_struct(LockBalances)4_storage)", + "src": "contracts/Unlock.sol" + }, + { + "contract": "Unlock", + "label": "globalBaseTokenURI", + "type": "t_string_storage", + "src": "contracts/Unlock.sol" + }, + { + "contract": "Unlock", + "label": "globalTokenSymbol", + "type": "t_string_storage", + "src": "contracts/Unlock.sol" + }, + { + "contract": "Unlock", + "label": "publicLockAddress", + "type": "t_address", + "src": "contracts/Unlock.sol" + }, + { + "contract": "Unlock", + "label": "uniswapOracles", + "type": "t_mapping(t_address,t_contract(IUniswapOracle)7444)", + "src": "contracts/Unlock.sol" + }, + { + "contract": "Unlock", + "label": "weth", + "type": "t_address", + "src": "contracts/Unlock.sol" + }, + { + "contract": "Unlock", + "label": "udt", + "type": "t_address", + "src": "contracts/Unlock.sol" + }, + { + "contract": "Unlock", + "label": "estimatedGasForPurchase", + "type": "t_uint256", + "src": "contracts/Unlock.sol" + } + ], + "types": { + "t_bool": { + "label": "bool" + }, + "t_uint256": { + "label": "uint256" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]" + }, + "t_address": { + "label": "address" + }, + "t_struct(LockBalances)4_storage": { + "label": "LockBalances", + "members": [ + { + "label": "deployed", + "type": "t_bool" + }, + { + "label": "totalSales", + "type": "t_uint256" + }, + { + "label": "yieldedDiscountTokens", + "type": "t_uint256" + } + ] + }, + "t_mapping(unknown,t_struct(LockBalances)4_storage)": { + "label": "LockBalances)" + }, + "t_string": { + "label": "string" + }, + "t_mapping(unknown,t_address)": { + "label": "mapping(key => address)" + } + } + } + }, + "3b4ab364958e28492a91a277daaf61cb1cff2a34f93b92e94b238e22e3d18fdd": { + "address": "0x433f12b9713B012D63D6e60ABf16D64B63BE207b", + "layout": { + "storage": [ + { + "contract": "Initializable", + "label": "initialized", + "type": "t_bool", + "src": "@openzeppelin/upgrades/contracts/Initializable.sol" + }, + { + "contract": "Initializable", + "label": "initializing", + "type": "t_bool", + "src": "@openzeppelin/upgrades/contracts/Initializable.sol" + }, + { + "contract": "Initializable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "@openzeppelin/upgrades/contracts/Initializable.sol" + }, + { + "contract": "ERC20", + "label": "_balances", + "type": "t_mapping(unknown,t_uint256)", + "src": "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol" + }, + { + "contract": "ERC20", + "label": "_allowances", + "type": "t_mapping(t_address,t_mapping(t_address,t_uint256))", + "src": "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol" + }, + { + "contract": "ERC20", + "label": "_totalSupply", + "type": "t_uint256", + "src": "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol" + }, + { + "contract": "ERC20", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol" + }, + { + "contract": "MinterRole", + "label": "_minters", + "type": "t_struct(Role)4_storage", + "src": "@openzeppelin/contracts-ethereum-package/contracts/access/roles/MinterRole.sol" + }, + { + "contract": "MinterRole", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "@openzeppelin/contracts-ethereum-package/contracts/access/roles/MinterRole.sol" + }, + { + "contract": "ERC20Mintable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20Mintable.sol" + }, + { + "contract": "ERC20Detailed", + "label": "_name", + "type": "t_string_storage", + "src": "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20Detailed.sol" + }, + { + "contract": "ERC20Detailed", + "label": "_symbol", + "type": "t_string_storage", + "src": "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20Detailed.sol" + }, + { + "contract": "ERC20Detailed", + "label": "_decimals", + "type": "t_uint8", + "src": "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20Detailed.sol" + }, + { + "contract": "ERC20Detailed", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20Detailed.sol" + } + ], + "types": { + "t_bool": { + "label": "bool" + }, + "t_uint256": { + "label": "uint256" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]" + }, + "t_mapping(unknown,t_uint256)": { + "label": "mapping(key => uint256)" + }, + "t_mapping(t_address,t_mapping(t_address,t_uint256))": { + "label": "mapping(address => mapping(address => uint256))" + }, + "t_struct(Role)4_storage": { + "label": "Role", + "members": [ + { + "label": "bearer", + "type": "t_mapping(unknown,t_bool)" + } + ] + }, + "t_mapping(unknown,t_bool)": { + "label": "mapping(key => bool)" + }, + "t_string": { + "label": "string" + }, + "t_string_storage": { + "label": "string_storage" + }, + "t_uint8": { + "label": "uint8" + } + } + } + }, + "0a735f100bcf67f21f25bffb161c6ad9c73bdee9f5831f4ea7b48114b0478c93": { + "address": "0x5bEf305dDC84A2c7239353eF9CA19a5e9e1E8fDF", + "txHash": "0x7770a181b75931d15047d31302c7c0d147e84a15dcc483f97141db11e66bc836", + "layout": { + "storage": [ + { + "contract": "Initializable", + "label": "initialized", + "type": "t_bool", + "src": "contracts/ERC20Patched.sol:233" + }, + { + "contract": "Initializable", + "label": "initializing", + "type": "t_bool", + "src": "contracts/ERC20Patched.sol:238" + }, + { + "contract": "ContextUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:289" + }, + { + "contract": "ERC20Upgradeable", + "label": "_balances", + "type": "t_mapping(t_address,t_uint256)", + "src": "contracts/ERC20Patched.sol:325" + }, + { + "contract": "ERC20Upgradeable", + "label": "_allowances", + "type": "t_mapping(t_address,t_mapping(t_address,t_uint256))", + "src": "contracts/ERC20Patched.sol:327" + }, + { + "contract": "ERC20Upgradeable", + "label": "_totalSupply", + "type": "t_uint256", + "src": "contracts/ERC20Patched.sol:329" + }, + { + "contract": "ERC20Upgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:650" + }, + { + "contract": "MinterRoleUpgradeable", + "label": "_minters", + "type": "t_struct(Role)7_storage", + "src": "contracts/ERC20Patched.sol:1656" + }, + { + "contract": "MinterRoleUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1691" + }, + { + "contract": "ERC20MintableUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1730" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_name", + "type": "t_string_storage", + "src": "contracts/ERC20Patched.sol:1695" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_symbol", + "type": "t_string_storage", + "src": "contracts/ERC20Patched.sol:1696" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_decimals", + "type": "t_uint8", + "src": "contracts/ERC20Patched.sol:1697" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1717" + }, + { + "contract": "EIP712Upgradeable", + "label": "_HASHED_NAME", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:821" + }, + { + "contract": "EIP712Upgradeable", + "label": "_HASHED_VERSION", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:822" + }, + { + "contract": "EIP712Upgradeable", + "label": "__gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:903" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "_nonces", + "type": "t_mapping(t_address,t_struct(Counter)1169_storage)", + "src": "contracts/ERC20Patched.sol:973" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "_PERMIT_TYPEHASH", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:976" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)49_storage", + "src": "contracts/ERC20Patched.sol:1041" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_delegates", + "type": "t_mapping(t_address,t_address)", + "src": "contracts/ERC20Patched.sol:1367" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_checkpoints", + "type": "t_mapping(t_address,t_array(t_struct(Checkpoint)1931_storage)dyn_storage)", + "src": "contracts/ERC20Patched.sol:1368" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_totalSupplyCheckpoints", + "type": "t_array(t_struct(Checkpoint)1931_storage)dyn_storage", + "src": "contracts/ERC20Patched.sol:1369" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)47_storage", + "src": "contracts/ERC20Patched.sol:1590" + }, + { + "contract": "ERC20VotesCompUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1641" + } + ], + "types": { + "t_array(t_uint256)50_storage": { + "label": "uint256[50]" + }, + "t_uint256": { + "label": "uint256" + }, + "t_mapping(t_address,t_address)": { + "label": "mapping(address => address)" + }, + "t_address": { + "label": "address" + }, + "t_mapping(t_address,t_array(t_struct(Checkpoint)1931_storage)dyn_storage)": { + "label": "mapping(address => struct ERC20VotesUpgradeable.Checkpoint[])" + }, + "t_array(t_struct(Checkpoint)1931_storage)dyn_storage": { + "label": "struct ERC20VotesUpgradeable.Checkpoint[]" + }, + "t_struct(Checkpoint)1931_storage": { + "label": "struct ERC20VotesUpgradeable.Checkpoint", + "members": [ + { + "label": "fromBlock", + "type": "t_uint32" + }, + { + "label": "votes", + "type": "t_uint224" + } + ] + }, + "t_uint32": { + "label": "uint32" + }, + "t_uint224": { + "label": "uint224" + }, + "t_array(t_uint256)47_storage": { + "label": "uint256[47]" + }, + "t_mapping(t_address,t_struct(Counter)1169_storage)": { + "label": "mapping(address => struct CountersUpgradeable.Counter)" + }, + "t_struct(Counter)1169_storage": { + "label": "struct CountersUpgradeable.Counter", + "members": [ + { + "label": "_value", + "type": "t_uint256" + } + ] + }, + "t_bytes32": { + "label": "bytes32" + }, + "t_array(t_uint256)49_storage": { + "label": "uint256[49]" + }, + "t_string_storage": { + "label": "string" + }, + "t_uint8": { + "label": "uint8" + }, + "t_struct(Role)7_storage": { + "label": "struct Roles.Role", + "members": [ + { + "label": "bearer", + "type": "t_mapping(t_address,t_bool)" + } + ] + }, + "t_mapping(t_address,t_bool)": { + "label": "mapping(address => bool)" + }, + "t_bool": { + "label": "bool" + }, + "t_mapping(t_address,t_uint256)": { + "label": "mapping(address => uint256)" + }, + "t_mapping(t_address,t_mapping(t_address,t_uint256))": { + "label": "mapping(address => mapping(address => uint256))" + } + } + } + }, + "c1cd311ce43adf0c1fea96e686ac6080a5184b3a0c75b58858174621d66d7dd9": { + "address": "0x9837f7330870506D6626B91aC027c658D81157B8", + "txHash": "0xd667f576a10d21b292a0a51775279fea25941ba6f1b49c0b6bd7f3b07925a9f6", + "layout": { + "storage": [ + { + "contract": "Initializable", + "label": "initialized", + "type": "t_bool", + "src": "@openzeppelin/upgrades/contracts/Initializable.sol:21" + }, + { + "contract": "Initializable", + "label": "initializing", + "type": "t_bool", + "src": "@openzeppelin/upgrades/contracts/Initializable.sol:26" + }, + { + "contract": "Initializable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "@openzeppelin/upgrades/contracts/Initializable.sol:61" + }, + { + "contract": "Ownable", + "label": "_owner", + "type": "t_address", + "src": "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol:17" + }, + { + "contract": "Ownable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol:80" + }, + { + "contract": "Unlock", + "label": "grossNetworkProduct", + "type": "t_uint256", + "src": "contracts/Unlock.sol:68" + }, + { + "contract": "Unlock", + "label": "totalDiscountGranted", + "type": "t_uint256", + "src": "contracts/Unlock.sol:70" + }, + { + "contract": "Unlock", + "label": "locks", + "type": "t_mapping(t_address,t_struct(LockBalances)2318_storage)", + "src": "contracts/Unlock.sol:73" + }, + { + "contract": "Unlock", + "label": "globalBaseTokenURI", + "type": "t_string_storage", + "src": "contracts/Unlock.sol:77" + }, + { + "contract": "Unlock", + "label": "globalTokenSymbol", + "type": "t_string_storage", + "src": "contracts/Unlock.sol:81" + }, + { + "contract": "Unlock", + "label": "publicLockAddress", + "type": "t_address", + "src": "contracts/Unlock.sol:84" + }, + { + "contract": "Unlock", + "label": "uniswapOracles", + "type": "t_mapping(t_address,t_contract(IUniswapOracle)7444)", + "src": "contracts/Unlock.sol:88" + }, + { + "contract": "Unlock", + "label": "weth", + "type": "t_address", + "src": "contracts/Unlock.sol:91" + }, + { + "contract": "Unlock", + "label": "udt", + "type": "t_address", + "src": "contracts/Unlock.sol:94" + }, + { + "contract": "Unlock", + "label": "estimatedGasForPurchase", + "type": "t_uint256", + "src": "contracts/Unlock.sol:97" + }, + { + "contract": "Unlock", + "label": "chainId", + "type": "t_uint256", + "src": "contracts/Unlock.sol:100" + } + ], + "types": { + "t_uint256": { + "label": "uint256" + }, + "t_mapping(t_address,t_struct(LockBalances)2318_storage)": { + "label": "mapping(address => struct Unlock.LockBalances)" + }, + "t_address": { + "label": "address" + }, + "t_struct(LockBalances)2318_storage": { + "label": "struct Unlock.LockBalances", + "members": [ + { + "label": "deployed", + "type": "t_bool" + }, + { + "label": "totalSales", + "type": "t_uint256" + }, + { + "label": "yieldedDiscountTokens", + "type": "t_uint256" + } + ] + }, + "t_bool": { + "label": "bool" + }, + "t_string_storage": { + "label": "string" + }, + "t_mapping(t_address,t_contract(IUniswapOracle)7444)": { + "label": "mapping(address => contract IUniswapOracle)" + }, + "t_contract(IUniswapOracle)7444": { + "label": "contract IUniswapOracle" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]" + } + } + } + }, + "23e8cc6f0f1ae1a772357f07e46040c6c4334b75897307db27f5c03a50e5d821": { + "address": "0x9CffbA297d62Be40cB803EB200Cd476D963742cb", + "txHash": "0x49e1260fa61c5d372d1a3fb14b1d6f3083cbe45b8f87db06e90c893d24ced797", + "layout": { + "storage": [ + { + "contract": "Initializable", + "label": "initialized", + "type": "t_bool", + "src": "contracts/ERC20Patched.sol:233" + }, + { + "contract": "Initializable", + "label": "initializing", + "type": "t_bool", + "src": "contracts/ERC20Patched.sol:238" + }, + { + "contract": "ContextUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:289" + }, + { + "contract": "ERC20Upgradeable", + "label": "_balances", + "type": "t_mapping(t_address,t_uint256)", + "src": "contracts/ERC20Patched.sol:325" + }, + { + "contract": "ERC20Upgradeable", + "label": "_allowances", + "type": "t_mapping(t_address,t_mapping(t_address,t_uint256))", + "src": "contracts/ERC20Patched.sol:327" + }, + { + "contract": "ERC20Upgradeable", + "label": "_totalSupply", + "type": "t_uint256", + "src": "contracts/ERC20Patched.sol:329" + }, + { + "contract": "ERC20Upgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:650" + }, + { + "contract": "MinterRoleUpgradeable", + "label": "_minters", + "type": "t_struct(Role)7_storage", + "src": "contracts/ERC20Patched.sol:1656" + }, + { + "contract": "MinterRoleUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1691" + }, + { + "contract": "ERC20MintableUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1730" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_name", + "type": "t_string_storage", + "src": "contracts/ERC20Patched.sol:1695" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_symbol", + "type": "t_string_storage", + "src": "contracts/ERC20Patched.sol:1696" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_decimals", + "type": "t_uint8", + "src": "contracts/ERC20Patched.sol:1697" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1717" + }, + { + "contract": "EIP712Upgradeable", + "label": "_HASHED_NAME", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:821" + }, + { + "contract": "EIP712Upgradeable", + "label": "_HASHED_VERSION", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:822" + }, + { + "contract": "EIP712Upgradeable", + "label": "__gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:903" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "_nonces", + "type": "t_mapping(t_address,t_struct(Counter)1169_storage)", + "src": "contracts/ERC20Patched.sol:973" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "_PERMIT_TYPEHASH", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:976" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)49_storage", + "src": "contracts/ERC20Patched.sol:1041" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_delegates", + "type": "t_mapping(t_address,t_address)", + "src": "contracts/ERC20Patched.sol:1367" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_checkpoints", + "type": "t_mapping(t_address,t_array(t_struct(Checkpoint)1931_storage)dyn_storage)", + "src": "contracts/ERC20Patched.sol:1368" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_totalSupplyCheckpoints", + "type": "t_array(t_struct(Checkpoint)1931_storage)dyn_storage", + "src": "contracts/ERC20Patched.sol:1369" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)47_storage", + "src": "contracts/ERC20Patched.sol:1590" + }, + { + "contract": "ERC20VotesCompUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1641" + } + ], + "types": { + "t_array(t_uint256)50_storage": { + "label": "uint256[50]" + }, + "t_uint256": { + "label": "uint256" + }, + "t_mapping(t_address,t_address)": { + "label": "mapping(address => address)" + }, + "t_address": { + "label": "address" + }, + "t_mapping(t_address,t_array(t_struct(Checkpoint)1931_storage)dyn_storage)": { + "label": "mapping(address => struct ERC20VotesUpgradeable.Checkpoint[])" + }, + "t_array(t_struct(Checkpoint)1931_storage)dyn_storage": { + "label": "struct ERC20VotesUpgradeable.Checkpoint[]" + }, + "t_struct(Checkpoint)1931_storage": { + "label": "struct ERC20VotesUpgradeable.Checkpoint", + "members": [ + { + "label": "fromBlock", + "type": "t_uint32" + }, + { + "label": "votes", + "type": "t_uint224" + } + ] + }, + "t_uint32": { + "label": "uint32" + }, + "t_uint224": { + "label": "uint224" + }, + "t_array(t_uint256)47_storage": { + "label": "uint256[47]" + }, + "t_mapping(t_address,t_struct(Counter)1169_storage)": { + "label": "mapping(address => struct CountersUpgradeable.Counter)" + }, + "t_struct(Counter)1169_storage": { + "label": "struct CountersUpgradeable.Counter", + "members": [ + { + "label": "_value", + "type": "t_uint256" + } + ] + }, + "t_bytes32": { + "label": "bytes32" + }, + "t_array(t_uint256)49_storage": { + "label": "uint256[49]" + }, + "t_string_storage": { + "label": "string" + }, + "t_uint8": { + "label": "uint8" + }, + "t_struct(Role)7_storage": { + "label": "struct Roles.Role", + "members": [ + { + "label": "bearer", + "type": "t_mapping(t_address,t_bool)" + } + ] + }, + "t_mapping(t_address,t_bool)": { + "label": "mapping(address => bool)" + }, + "t_bool": { + "label": "bool" + }, + "t_mapping(t_address,t_uint256)": { + "label": "mapping(address => uint256)" + }, + "t_mapping(t_address,t_mapping(t_address,t_uint256))": { + "label": "mapping(address => mapping(address => uint256))" + } + } + } + }, + "7747a56cb5fbae626c485b00b3831ac17f5a3e93b019220e85448f1f8a758bd5": { + "address": "0x3F27Ff20E4C53d5cd2BBA91eee90A2B71A876833", + "txHash": "0xde361c276ffb4967d6bd09af38429d0c6c584c4436f82a0be0e595101e27dcc8", + "layout": { + "storage": [ + { + "contract": "Initializable", + "label": "initialized", + "type": "t_bool", + "src": "contracts/ERC20Patched.sol:234" + }, + { + "contract": "Initializable", + "label": "initializing", + "type": "t_bool", + "src": "contracts/ERC20Patched.sol:239" + }, + { + "contract": "ContextUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:290" + }, + { + "contract": "ERC20Upgradeable", + "label": "_balances", + "type": "t_mapping(t_address,t_uint256)", + "src": "contracts/ERC20Patched.sol:326" + }, + { + "contract": "ERC20Upgradeable", + "label": "_allowances", + "type": "t_mapping(t_address,t_mapping(t_address,t_uint256))", + "src": "contracts/ERC20Patched.sol:328" + }, + { + "contract": "ERC20Upgradeable", + "label": "_totalSupply", + "type": "t_uint256", + "src": "contracts/ERC20Patched.sol:330" + }, + { + "contract": "ERC20Upgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:652" + }, + { + "contract": "MinterRoleUpgradeable", + "label": "_minters", + "type": "t_struct(Role)7_storage", + "src": "contracts/ERC20Patched.sol:1678" + }, + { + "contract": "MinterRoleUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1713" + }, + { + "contract": "ERC20MintableUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1752" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_name", + "type": "t_string_storage", + "src": "contracts/ERC20Patched.sol:1717" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_symbol", + "type": "t_string_storage", + "src": "contracts/ERC20Patched.sol:1718" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_decimals", + "type": "t_uint8", + "src": "contracts/ERC20Patched.sol:1719" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1739" + }, + { + "contract": "EIP712Upgradeable", + "label": "_HASHED_NAME", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:823" + }, + { + "contract": "EIP712Upgradeable", + "label": "_HASHED_VERSION", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:824" + }, + { + "contract": "EIP712Upgradeable", + "label": "__gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:912" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "_nonces", + "type": "t_mapping(t_address,t_struct(Counter)1203_storage)", + "src": "contracts/ERC20Patched.sol:982" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "_PERMIT_TYPEHASH", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:985" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)49_storage", + "src": "contracts/ERC20Patched.sol:1055" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_delegates", + "type": "t_mapping(t_address,t_address)", + "src": "contracts/ERC20Patched.sol:1389" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_checkpoints", + "type": "t_mapping(t_address,t_array(t_struct(Checkpoint)2008_storage)dyn_storage)", + "src": "contracts/ERC20Patched.sol:1390" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_totalSupplyCheckpoints", + "type": "t_array(t_struct(Checkpoint)2008_storage)dyn_storage", + "src": "contracts/ERC20Patched.sol:1391" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)47_storage", + "src": "contracts/ERC20Patched.sol:1612" + }, + { + "contract": "ERC20VotesCompUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1663" + } + ], + "types": { + "t_array(t_uint256)50_storage": { + "label": "uint256[50]" + }, + "t_uint256": { + "label": "uint256" + }, + "t_mapping(t_address,t_address)": { + "label": "mapping(address => address)" + }, + "t_address": { + "label": "address" + }, + "t_mapping(t_address,t_array(t_struct(Checkpoint)2008_storage)dyn_storage)": { + "label": "mapping(address => struct ERC20VotesUpgradeable.Checkpoint[])" + }, + "t_array(t_struct(Checkpoint)2008_storage)dyn_storage": { + "label": "struct ERC20VotesUpgradeable.Checkpoint[]" + }, + "t_struct(Checkpoint)2008_storage": { + "label": "struct ERC20VotesUpgradeable.Checkpoint", + "members": [ + { + "label": "fromBlock", + "type": "t_uint32" + }, + { + "label": "votes", + "type": "t_uint224" + } + ] + }, + "t_uint32": { + "label": "uint32" + }, + "t_uint224": { + "label": "uint224" + }, + "t_array(t_uint256)47_storage": { + "label": "uint256[47]" + }, + "t_mapping(t_address,t_struct(Counter)1203_storage)": { + "label": "mapping(address => struct CountersUpgradeable.Counter)" + }, + "t_struct(Counter)1203_storage": { + "label": "struct CountersUpgradeable.Counter", + "members": [ + { + "label": "_value", + "type": "t_uint256" + } + ] + }, + "t_bytes32": { + "label": "bytes32" + }, + "t_array(t_uint256)49_storage": { + "label": "uint256[49]" + }, + "t_string_storage": { + "label": "string" + }, + "t_uint8": { + "label": "uint8" + }, + "t_struct(Role)7_storage": { + "label": "struct Roles.Role", + "members": [ + { + "label": "bearer", + "type": "t_mapping(t_address,t_bool)" + } + ] + }, + "t_mapping(t_address,t_bool)": { + "label": "mapping(address => bool)" + }, + "t_bool": { + "label": "bool" + }, + "t_mapping(t_address,t_uint256)": { + "label": "mapping(address => uint256)" + }, + "t_mapping(t_address,t_mapping(t_address,t_uint256))": { + "label": "mapping(address => mapping(address => uint256))" + } + } + } + }, + "ff29041c6dd29f59e23b7732f6511869b9ca975fbb90c294a2eabe570ca3968b": { + "address": "0xb0C7bF7E8cC54670b462c5f668D56c897c1604d6", + "txHash": "0xd6499873c95461360d721d36b524a2e4805aae90a4019b8fae6bc381de23b4cd", + "layout": { + "storage": [ + { + "contract": "Initializable", + "label": "initialized", + "type": "t_bool", + "src": "contracts/ERC20Patched.sol:234" + }, + { + "contract": "Initializable", + "label": "initializing", + "type": "t_bool", + "src": "contracts/ERC20Patched.sol:239" + }, + { + "contract": "ContextUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:290" + }, + { + "contract": "ERC20Upgradeable", + "label": "_balances", + "type": "t_mapping(t_address,t_uint256)", + "src": "contracts/ERC20Patched.sol:326" + }, + { + "contract": "ERC20Upgradeable", + "label": "_allowances", + "type": "t_mapping(t_address,t_mapping(t_address,t_uint256))", + "src": "contracts/ERC20Patched.sol:328" + }, + { + "contract": "ERC20Upgradeable", + "label": "_totalSupply", + "type": "t_uint256", + "src": "contracts/ERC20Patched.sol:330" + }, + { + "contract": "ERC20Upgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:651" + }, + { + "contract": "MinterRoleUpgradeable", + "label": "_minters", + "type": "t_struct(Role)7_storage", + "src": "contracts/ERC20Patched.sol:1677" + }, + { + "contract": "MinterRoleUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1712" + }, + { + "contract": "ERC20MintableUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1751" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_name", + "type": "t_string_storage", + "src": "contracts/ERC20Patched.sol:1716" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_symbol", + "type": "t_string_storage", + "src": "contracts/ERC20Patched.sol:1717" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_decimals", + "type": "t_uint8", + "src": "contracts/ERC20Patched.sol:1718" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1738" + }, + { + "contract": "EIP712Upgradeable", + "label": "_HASHED_NAME", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:822" + }, + { + "contract": "EIP712Upgradeable", + "label": "_HASHED_VERSION", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:823" + }, + { + "contract": "EIP712Upgradeable", + "label": "__gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:911" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "_nonces", + "type": "t_mapping(t_address,t_struct(Counter)1203_storage)", + "src": "contracts/ERC20Patched.sol:981" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "_PERMIT_TYPEHASH", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:984" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)49_storage", + "src": "contracts/ERC20Patched.sol:1054" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_delegates", + "type": "t_mapping(t_address,t_address)", + "src": "contracts/ERC20Patched.sol:1388" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_checkpoints", + "type": "t_mapping(t_address,t_array(t_struct(Checkpoint)2008_storage)dyn_storage)", + "src": "contracts/ERC20Patched.sol:1389" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_totalSupplyCheckpoints", + "type": "t_array(t_struct(Checkpoint)2008_storage)dyn_storage", + "src": "contracts/ERC20Patched.sol:1390" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)47_storage", + "src": "contracts/ERC20Patched.sol:1611" + }, + { + "contract": "ERC20VotesCompUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1662" + } + ], + "types": { + "t_array(t_uint256)50_storage": { + "label": "uint256[50]" + }, + "t_uint256": { + "label": "uint256" + }, + "t_mapping(t_address,t_address)": { + "label": "mapping(address => address)" + }, + "t_address": { + "label": "address" + }, + "t_mapping(t_address,t_array(t_struct(Checkpoint)2008_storage)dyn_storage)": { + "label": "mapping(address => struct ERC20VotesUpgradeable.Checkpoint[])" + }, + "t_array(t_struct(Checkpoint)2008_storage)dyn_storage": { + "label": "struct ERC20VotesUpgradeable.Checkpoint[]" + }, + "t_struct(Checkpoint)2008_storage": { + "label": "struct ERC20VotesUpgradeable.Checkpoint", + "members": [ + { + "label": "fromBlock", + "type": "t_uint32" + }, + { + "label": "votes", + "type": "t_uint224" + } + ] + }, + "t_uint32": { + "label": "uint32" + }, + "t_uint224": { + "label": "uint224" + }, + "t_array(t_uint256)47_storage": { + "label": "uint256[47]" + }, + "t_mapping(t_address,t_struct(Counter)1203_storage)": { + "label": "mapping(address => struct CountersUpgradeable.Counter)" + }, + "t_struct(Counter)1203_storage": { + "label": "struct CountersUpgradeable.Counter", + "members": [ + { + "label": "_value", + "type": "t_uint256" + } + ] + }, + "t_bytes32": { + "label": "bytes32" + }, + "t_array(t_uint256)49_storage": { + "label": "uint256[49]" + }, + "t_string_storage": { + "label": "string" + }, + "t_uint8": { + "label": "uint8" + }, + "t_struct(Role)7_storage": { + "label": "struct Roles.Role", + "members": [ + { + "label": "bearer", + "type": "t_mapping(t_address,t_bool)" + } + ] + }, + "t_mapping(t_address,t_bool)": { + "label": "mapping(address => bool)" + }, + "t_bool": { + "label": "bool" + }, + "t_mapping(t_address,t_uint256)": { + "label": "mapping(address => uint256)" + }, + "t_mapping(t_address,t_mapping(t_address,t_uint256))": { + "label": "mapping(address => mapping(address => uint256))" + } + } + } + }, + "66f69b8418586f0677f959128ad5c436bc187e632d138b6544f2fd22fd11a5cc": { + "address": "0xcB22BD8b943879e83193F479Ec4E3c98B610B507", + "txHash": "0x61343ef4f8ac8100bade672329910e9c204e63f10073d0b3bd7638172d845912", + "layout": { + "storage": [ + { + "contract": "Initializable", + "label": "initialized", + "type": "t_bool", + "src": "contracts/ERC20Patched.sol:234" + }, + { + "contract": "Initializable", + "label": "initializing", + "type": "t_bool", + "src": "contracts/ERC20Patched.sol:239" + }, + { + "contract": "ContextUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:290" + }, + { + "contract": "ERC20Upgradeable", + "label": "_balances", + "type": "t_mapping(t_address,t_uint256)", + "src": "contracts/ERC20Patched.sol:326" + }, + { + "contract": "ERC20Upgradeable", + "label": "_allowances", + "type": "t_mapping(t_address,t_mapping(t_address,t_uint256))", + "src": "contracts/ERC20Patched.sol:328" + }, + { + "contract": "ERC20Upgradeable", + "label": "_totalSupply", + "type": "t_uint256", + "src": "contracts/ERC20Patched.sol:330" + }, + { + "contract": "ERC20Upgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:651" + }, + { + "contract": "MinterRoleUpgradeable", + "label": "_minters", + "type": "t_struct(Role)7_storage", + "src": "contracts/ERC20Patched.sol:1677" + }, + { + "contract": "MinterRoleUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1712" + }, + { + "contract": "ERC20MintableUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1751" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_name", + "type": "t_string_storage", + "src": "contracts/ERC20Patched.sol:1716" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_symbol", + "type": "t_string_storage", + "src": "contracts/ERC20Patched.sol:1717" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "_decimals", + "type": "t_uint8", + "src": "contracts/ERC20Patched.sol:1718" + }, + { + "contract": "ERC20DetailedUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1738" + }, + { + "contract": "EIP712Upgradeable", + "label": "_HASHED_NAME", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:822" + }, + { + "contract": "EIP712Upgradeable", + "label": "_HASHED_VERSION", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:823" + }, + { + "contract": "EIP712Upgradeable", + "label": "__gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:911" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "_nonces", + "type": "t_mapping(t_address,t_struct(Counter)1203_storage)", + "src": "contracts/ERC20Patched.sol:981" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "_PERMIT_TYPEHASH", + "type": "t_bytes32", + "src": "contracts/ERC20Patched.sol:984" + }, + { + "contract": "ERC20PermitUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)49_storage", + "src": "contracts/ERC20Patched.sol:1054" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_delegates", + "type": "t_mapping(t_address,t_address)", + "src": "contracts/ERC20Patched.sol:1388" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_checkpoints", + "type": "t_mapping(t_address,t_array(t_struct(Checkpoint)2008_storage)dyn_storage)", + "src": "contracts/ERC20Patched.sol:1389" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "_totalSupplyCheckpoints", + "type": "t_array(t_struct(Checkpoint)2008_storage)dyn_storage", + "src": "contracts/ERC20Patched.sol:1390" + }, + { + "contract": "ERC20VotesUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)47_storage", + "src": "contracts/ERC20Patched.sol:1611" + }, + { + "contract": "ERC20VotesCompUpgradeable", + "label": "__gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/ERC20Patched.sol:1662" + } + ], + "types": { + "t_array(t_uint256)50_storage": { + "label": "uint256[50]" + }, + "t_uint256": { + "label": "uint256" + }, + "t_mapping(t_address,t_address)": { + "label": "mapping(address => address)" + }, + "t_address": { + "label": "address" + }, + "t_mapping(t_address,t_array(t_struct(Checkpoint)2008_storage)dyn_storage)": { + "label": "mapping(address => struct ERC20VotesUpgradeable.Checkpoint[])" + }, + "t_array(t_struct(Checkpoint)2008_storage)dyn_storage": { + "label": "struct ERC20VotesUpgradeable.Checkpoint[]" + }, + "t_struct(Checkpoint)2008_storage": { + "label": "struct ERC20VotesUpgradeable.Checkpoint", + "members": [ + { + "label": "fromBlock", + "type": "t_uint32" + }, + { + "label": "votes", + "type": "t_uint224" + } + ] + }, + "t_uint32": { + "label": "uint32" + }, + "t_uint224": { + "label": "uint224" + }, + "t_array(t_uint256)47_storage": { + "label": "uint256[47]" + }, + "t_mapping(t_address,t_struct(Counter)1203_storage)": { + "label": "mapping(address => struct CountersUpgradeable.Counter)" + }, + "t_struct(Counter)1203_storage": { + "label": "struct CountersUpgradeable.Counter", + "members": [ + { + "label": "_value", + "type": "t_uint256" + } + ] + }, + "t_bytes32": { + "label": "bytes32" + }, + "t_array(t_uint256)49_storage": { + "label": "uint256[49]" + }, + "t_string_storage": { + "label": "string" + }, + "t_uint8": { + "label": "uint8" + }, + "t_struct(Role)7_storage": { + "label": "struct Roles.Role", + "members": [ + { + "label": "bearer", + "type": "t_mapping(t_address,t_bool)" + } + ] + }, + "t_mapping(t_address,t_bool)": { + "label": "mapping(address => bool)" + }, + "t_bool": { + "label": "bool" + }, + "t_mapping(t_address,t_uint256)": { + "label": "mapping(address => uint256)" + }, + "t_mapping(t_address,t_mapping(t_address,t_uint256))": { + "label": "mapping(address => mapping(address => uint256))" + } + } + } + }, + "41cfeb95a8e6bb7cfbe1d457f8fb6b99648590ab4b46e098ceab867e8c509893": { + "address": "0x646E373EAf8a4AEc31Bf62B7Fd6fB59296d6CdA9", + "txHash": "0xb616e544788d8babeb565e5bdf2658d10e79bd8d036dca38b2036bd17433fa42", + "layout": { + "storage": [ + { + "contract": "UnlockInitializable", + "label": "initialized", + "type": "t_bool", + "src": "contracts/utils/UnlockInitializable.sol:39" + }, + { + "contract": "UnlockInitializable", + "label": "initializing", + "type": "t_bool", + "src": "contracts/utils/UnlockInitializable.sol:44" + }, + { + "contract": "UnlockContextUpgradeable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/utils/UnlockContextUpgradeable.sol:31" + }, + { + "contract": "UnlockOwnable", + "label": "_owner", + "type": "t_address", + "src": "contracts/utils/UnlockOwnable.sol:23" + }, + { + "contract": "UnlockOwnable", + "label": "______gap", + "type": "t_array(t_uint256)50_storage", + "src": "contracts/utils/UnlockOwnable.sol:86" + }, + { + "contract": "Unlock", + "label": "grossNetworkProduct", + "type": "t_uint256", + "src": "contracts/Unlock.sol:63" + }, + { + "contract": "Unlock", + "label": "totalDiscountGranted", + "type": "t_uint256", + "src": "contracts/Unlock.sol:65" + }, + { + "contract": "Unlock", + "label": "locks", + "type": "t_mapping(t_address,t_struct(LockBalances)1513_storage)", + "src": "contracts/Unlock.sol:68" + }, + { + "contract": "Unlock", + "label": "globalBaseTokenURI", + "type": "t_string_storage", + "src": "contracts/Unlock.sol:72" + }, + { + "contract": "Unlock", + "label": "globalTokenSymbol", + "type": "t_string_storage", + "src": "contracts/Unlock.sol:76" + }, + { + "contract": "Unlock", + "label": "publicLockAddress", + "type": "t_address", + "src": "contracts/Unlock.sol:79" + }, + { + "contract": "Unlock", + "label": "uniswapOracles", + "type": "t_mapping(t_address,t_contract(IUniswapOracle)3350)", + "src": "contracts/Unlock.sol:83" + }, + { + "contract": "Unlock", + "label": "weth", + "type": "t_address", + "src": "contracts/Unlock.sol:86" + }, + { + "contract": "Unlock", + "label": "udt", + "type": "t_address", + "src": "contracts/Unlock.sol:89" + }, + { + "contract": "Unlock", + "label": "estimatedGasForPurchase", + "type": "t_uint256", + "src": "contracts/Unlock.sol:92" + }, + { + "contract": "Unlock", + "label": "chainId", + "type": "t_uint256", + "src": "contracts/Unlock.sol:95" + }, + { + "contract": "Unlock", + "label": "proxyAdminAddress", + "type": "t_address", + "src": "contracts/Unlock.sol:98" + }, + { + "contract": "Unlock", + "label": "proxyAdmin", + "type": "t_contract(ProxyAdmin)949", + "src": "contracts/Unlock.sol:99" + }, + { + "contract": "Unlock", + "label": "_publicLockVersions", + "type": "t_mapping(t_address,t_uint16)", + "src": "contracts/Unlock.sol:102" + }, + { + "contract": "Unlock", + "label": "_publicLockImpls", + "type": "t_mapping(t_uint16,t_address)", + "src": "contracts/Unlock.sol:103" + }, + { + "contract": "Unlock", + "label": "publicLockLatestVersion", + "type": "t_uint16", + "src": "contracts/Unlock.sol:104" + } + ], + "types": { + "t_uint256": { + "label": "uint256" + }, + "t_mapping(t_address,t_struct(LockBalances)1513_storage)": { + "label": "mapping(address => struct Unlock.LockBalances)" + }, + "t_address": { + "label": "address" + }, + "t_struct(LockBalances)1513_storage": { + "label": "struct Unlock.LockBalances", + "members": [ + { + "label": "deployed", + "type": "t_bool" + }, + { + "label": "totalSales", + "type": "t_uint256" + }, + { + "label": "yieldedDiscountTokens", + "type": "t_uint256" + } + ] + }, + "t_bool": { + "label": "bool" + }, + "t_string_storage": { + "label": "string" + }, + "t_mapping(t_address,t_contract(IUniswapOracle)3350)": { + "label": "mapping(address => contract IUniswapOracle)" + }, + "t_contract(IUniswapOracle)3350": { + "label": "contract IUniswapOracle" + }, + "t_contract(ProxyAdmin)949": { + "label": "contract ProxyAdmin" + }, + "t_mapping(t_address,t_uint16)": { + "label": "mapping(address => uint16)" + }, + "t_uint16": { + "label": "uint16" + }, + "t_mapping(t_uint16,t_address)": { + "label": "mapping(uint16 => address)" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]" + } + } + } + }, + "d17576afcd2c7a2e78751dfd43bc021446e458bc34b334e70c3b114a2d92738c": { + "address": "0x3952787d8Ec653E9179a3Fa5D8c018d7bD8e94c7", + "txHash": "0xb55cd83470d055953573363f01391e219ac99138e020c389ce62849aaf3ab17f", + "layout": { + "storage": [ + { + "label": "initialized", + "offset": 0, + "slot": "0", + "type": "t_bool", + "contract": "UnlockInitializable", + "src": "contracts/utils/UnlockInitializable.sol:39" + }, + { + "label": "initializing", + "offset": 1, + "slot": "0", + "type": "t_bool", + "contract": "UnlockInitializable", + "src": "contracts/utils/UnlockInitializable.sol:44" + }, + { + "label": "______gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage", + "contract": "UnlockContextUpgradeable", + "src": "contracts/utils/UnlockContextUpgradeable.sol:31" + }, + { + "label": "_owner", + "offset": 0, + "slot": "51", + "type": "t_address", + "contract": "UnlockOwnable", + "src": "contracts/utils/UnlockOwnable.sol:23" + }, + { + "label": "______gap", + "offset": 0, + "slot": "52", + "type": "t_array(t_uint256)50_storage", + "contract": "UnlockOwnable", + "src": "contracts/utils/UnlockOwnable.sol:86" + }, + { + "label": "grossNetworkProduct", + "offset": 0, + "slot": "102", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/Unlock.sol:63" + }, + { + "label": "totalDiscountGranted", + "offset": 0, + "slot": "103", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/Unlock.sol:65" + }, + { + "label": "locks", + "offset": 0, + "slot": "104", + "type": "t_mapping(t_address,t_struct(LockBalances)1513_storage)", + "contract": "Unlock", + "src": "contracts/Unlock.sol:68" + }, + { + "label": "globalBaseTokenURI", + "offset": 0, + "slot": "105", + "type": "t_string_storage", + "contract": "Unlock", + "src": "contracts/Unlock.sol:72" + }, + { + "label": "globalTokenSymbol", + "offset": 0, + "slot": "106", + "type": "t_string_storage", + "contract": "Unlock", + "src": "contracts/Unlock.sol:76" + }, + { + "label": "publicLockAddress", + "offset": 0, + "slot": "107", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/Unlock.sol:79" + }, + { + "label": "uniswapOracles", + "offset": 0, + "slot": "108", + "type": "t_mapping(t_address,t_contract(IUniswapOracle)3504)", + "contract": "Unlock", + "src": "contracts/Unlock.sol:83" + }, + { + "label": "weth", + "offset": 0, + "slot": "109", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/Unlock.sol:86" + }, + { + "label": "udt", + "offset": 0, + "slot": "110", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/Unlock.sol:89" + }, + { + "label": "estimatedGasForPurchase", + "offset": 0, + "slot": "111", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/Unlock.sol:92" + }, + { + "label": "chainId", + "offset": 0, + "slot": "112", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/Unlock.sol:95" + }, + { + "label": "proxyAdminAddress", + "offset": 0, + "slot": "113", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/Unlock.sol:98" + }, + { + "label": "proxyAdmin", + "offset": 0, + "slot": "114", + "type": "t_contract(ProxyAdmin)949", + "contract": "Unlock", + "src": "contracts/Unlock.sol:99" + }, + { + "label": "_publicLockVersions", + "offset": 0, + "slot": "115", + "type": "t_mapping(t_address,t_uint16)", + "contract": "Unlock", + "src": "contracts/Unlock.sol:102" + }, + { + "label": "_publicLockImpls", + "offset": 0, + "slot": "116", + "type": "t_mapping(t_uint16,t_address)", + "contract": "Unlock", + "src": "contracts/Unlock.sol:103" + }, + { + "label": "publicLockLatestVersion", + "offset": 0, + "slot": "117", + "type": "t_uint16", + "contract": "Unlock", + "src": "contracts/Unlock.sol:104" + } + ], + "types": { + "t_address": { + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "label": "bool", + "numberOfBytes": "1" + }, + "t_contract(IUniswapOracle)3504": { + "label": "contract IUniswapOracle", + "numberOfBytes": "20" + }, + "t_contract(ProxyAdmin)949": { + "label": "contract ProxyAdmin", + "numberOfBytes": "20" + }, + "t_mapping(t_address,t_contract(IUniswapOracle)3504)": { + "label": "mapping(address => contract IUniswapOracle)", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_struct(LockBalances)1513_storage)": { + "label": "mapping(address => struct Unlock.LockBalances)", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_uint16)": { + "label": "mapping(address => uint16)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint16,t_address)": { + "label": "mapping(uint16 => address)", + "numberOfBytes": "32" + }, + "t_string_storage": { + "label": "string", + "numberOfBytes": "32" + }, + "t_struct(LockBalances)1513_storage": { + "label": "struct Unlock.LockBalances", + "members": [ + { + "label": "deployed", + "type": "t_bool", + "offset": 0, + "slot": "0" + }, + { + "label": "totalSales", + "type": "t_uint256", + "offset": 0, + "slot": "1" + }, + { + "label": "yieldedDiscountTokens", + "type": "t_uint256", + "offset": 0, + "slot": "2" + } + ], + "numberOfBytes": "96" + }, + "t_uint16": { + "label": "uint16", + "numberOfBytes": "2" + }, + "t_uint256": { + "label": "uint256", + "numberOfBytes": "32" + } + } + } + }, + "2c9597ca86f576ca3b0b050dffb605382a92703e98ab1467ba70b9d00202eb29": { + "address": "0x1D135F35FBaE00F943b893627EE6440658C91Ed9", + "txHash": "0x7ac2dc0938488f9e7a61c5b45734619d690d274d60b610611d7ad4105257b8ca", + "layout": { + "storage": [ + { + "label": "_initialized", + "offset": 0, + "slot": "0", + "type": "t_uint8", + "contract": "Initializable", + "src": "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol:62", + "retypedFrom": "bool" + }, + { + "label": "_initializing", + "offset": 1, + "slot": "0", + "type": "t_bool", + "contract": "Initializable", + "src": "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol:67" + }, + { + "label": "__gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage", + "contract": "ContextUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol:36" + }, + { + "label": "_owner", + "offset": 0, + "slot": "51", + "type": "t_address", + "contract": "OwnableUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol:22" + }, + { + "label": "__gap", + "offset": 0, + "slot": "52", + "type": "t_array(t_uint256)49_storage", + "contract": "OwnableUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol:94" + }, + { + "label": "_HASHED_NAME", + "offset": 0, + "slot": "101", + "type": "t_bytes32", + "contract": "EIP712Upgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol:32" + }, + { + "label": "_HASHED_VERSION", + "offset": 0, + "slot": "102", + "type": "t_bytes32", + "contract": "EIP712Upgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol:33" + }, + { + "label": "__gap", + "offset": 0, + "slot": "103", + "type": "t_array(t_uint256)50_storage", + "contract": "EIP712Upgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol:120" + }, + { + "label": "locksmiths", + "offset": 0, + "slot": "153", + "type": "t_mapping(t_address,t_bool)", + "contract": "KeyManager", + "src": "contracts/KeyManager.sol:19" + } + ], + "types": { + "t_address": { + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_uint256)49_storage": { + "label": "uint256[49]", + "numberOfBytes": "1568" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "label": "bool", + "numberOfBytes": "1" + }, + "t_bytes32": { + "label": "bytes32", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_bool)": { + "label": "mapping(address => bool)", + "numberOfBytes": "32" + }, + "t_uint256": { + "label": "uint256", + "numberOfBytes": "32" + }, + "t_uint8": { + "label": "uint8", + "numberOfBytes": "1" + } + } + } + }, + "0f687bccb5600119016c5e403896dfbb6108bfaba56b3f786736b64293444ea8": { + "address": "0xdCB2F7d1Fb126A166e7168E1D84e415b3ffD6B93", + "txHash": "0xc40b2eac587f93d753a6ff39ed9eaaacf6792f12af03624041b112e2d008f3cb", + "layout": { + "solcVersion": "0.8.13", + "storage": [ + { + "label": "initialized", + "offset": 0, + "slot": "0", + "type": "t_bool", + "contract": "UnlockInitializable", + "src": "contracts/past-versions/UnlockV12.sol:2425" + }, + { + "label": "initializing", + "offset": 1, + "slot": "0", + "type": "t_bool", + "contract": "UnlockInitializable", + "src": "contracts/past-versions/UnlockV12.sol:2430" + }, + { + "label": "______gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage", + "contract": "UnlockContextUpgradeable", + "src": "contracts/past-versions/UnlockV12.sol:2519" + }, + { + "label": "_owner", + "offset": 0, + "slot": "51", + "type": "t_address", + "contract": "UnlockOwnable", + "src": "contracts/past-versions/UnlockV12.sol:2548" + }, + { + "label": "______gap", + "offset": 0, + "slot": "52", + "type": "t_array(t_uint256)50_storage", + "contract": "UnlockOwnable", + "src": "contracts/past-versions/UnlockV12.sol:2618" + }, + { + "label": "grossNetworkProduct", + "offset": 0, + "slot": "102", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2680" + }, + { + "label": "totalDiscountGranted", + "offset": 0, + "slot": "103", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2682" + }, + { + "label": "locks", + "offset": 0, + "slot": "104", + "type": "t_mapping(t_address,t_struct(LockBalances)2780_storage)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2685" + }, + { + "label": "globalBaseTokenURI", + "offset": 0, + "slot": "105", + "type": "t_string_storage", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2689" + }, + { + "label": "globalTokenSymbol", + "offset": 0, + "slot": "106", + "type": "t_string_storage", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2693" + }, + { + "label": "publicLockAddress", + "offset": 0, + "slot": "107", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2696" + }, + { + "label": "uniswapOracles", + "offset": 0, + "slot": "108", + "type": "t_mapping(t_address,t_contract(IUniswapOracleV3)1947)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2700" + }, + { + "label": "weth", + "offset": 0, + "slot": "109", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2703" + }, + { + "label": "udt", + "offset": 0, + "slot": "110", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2706" + }, + { + "label": "estimatedGasForPurchase", + "offset": 0, + "slot": "111", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2709" + }, + { + "label": "chainId", + "offset": 0, + "slot": "112", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2712" + }, + { + "label": "proxyAdminAddress", + "offset": 0, + "slot": "113", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2715" + }, + { + "label": "proxyAdmin", + "offset": 0, + "slot": "114", + "type": "t_contract(ProxyAdmin)1215", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2716" + }, + { + "label": "_publicLockVersions", + "offset": 0, + "slot": "115", + "type": "t_mapping(t_address,t_uint16)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2719" + }, + { + "label": "_publicLockImpls", + "offset": 0, + "slot": "116", + "type": "t_mapping(t_uint16,t_address)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2720" + }, + { + "label": "publicLockLatestVersion", + "offset": 0, + "slot": "117", + "type": "t_uint16", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2721" + }, + { + "label": "protocolFee", + "offset": 0, + "slot": "118", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2724" + } + ], + "types": { + "t_address": { + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "label": "bool", + "numberOfBytes": "1" + }, + "t_contract(IUniswapOracleV3)1947": { + "label": "contract IUniswapOracleV3", + "numberOfBytes": "20" + }, + "t_contract(ProxyAdmin)1215": { + "label": "contract ProxyAdmin", + "numberOfBytes": "20" + }, + "t_mapping(t_address,t_contract(IUniswapOracleV3)1947)": { + "label": "mapping(address => contract IUniswapOracleV3)", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_struct(LockBalances)2780_storage)": { + "label": "mapping(address => struct Unlock.LockBalances)", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_uint16)": { + "label": "mapping(address => uint16)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint16,t_address)": { + "label": "mapping(uint16 => address)", + "numberOfBytes": "32" + }, + "t_string_storage": { + "label": "string", + "numberOfBytes": "32" + }, + "t_struct(LockBalances)2780_storage": { + "label": "struct Unlock.LockBalances", + "members": [ + { + "label": "deployed", + "type": "t_bool", + "offset": 0, + "slot": "0" + }, + { + "label": "totalSales", + "type": "t_uint256", + "offset": 0, + "slot": "1" + }, + { + "label": "yieldedDiscountTokens", + "type": "t_uint256", + "offset": 0, + "slot": "2" + } + ], + "numberOfBytes": "96" + }, + "t_uint16": { + "label": "uint16", + "numberOfBytes": "2" + }, + "t_uint256": { + "label": "uint256", + "numberOfBytes": "32" + } + } + } + }, + "ce94b37ee007ad95d23ba128ffbfc3fe5843fbd2253b6c71c377f9ebf8d6b1b2": { + "address": "0x7E33dD3955b7B4a699CE75D507bfB2f044D5Df87", + "txHash": "0x550553560ce03e485c1a29036bf9913f6a95a4f96c3bd98fafcaf05974937984", + "layout": { + "solcVersion": "0.8.17", + "storage": [ + { + "label": "_initialized", + "offset": 0, + "slot": "0", + "type": "t_uint8", + "contract": "Initializable", + "src": "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol:63", + "retypedFrom": "bool" + }, + { + "label": "_initializing", + "offset": 1, + "slot": "0", + "type": "t_bool", + "contract": "Initializable", + "src": "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol:68" + }, + { + "label": "__gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage", + "contract": "ContextUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol:36" + }, + { + "label": "__gap", + "offset": 0, + "slot": "51", + "type": "t_array(t_uint256)50_storage", + "contract": "ERC165Upgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol:41" + }, + { + "label": "_hashedName", + "offset": 0, + "slot": "101", + "type": "t_bytes32", + "contract": "EIP712Upgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol:40", + "renamedFrom": "_HASHED_NAME" + }, + { + "label": "_hashedVersion", + "offset": 0, + "slot": "102", + "type": "t_bytes32", + "contract": "EIP712Upgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol:42", + "renamedFrom": "_HASHED_VERSION" + }, + { + "label": "_name", + "offset": 0, + "slot": "103", + "type": "t_string_storage", + "contract": "EIP712Upgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol:44" + }, + { + "label": "_version", + "offset": 0, + "slot": "104", + "type": "t_string_storage", + "contract": "EIP712Upgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol:45" + }, + { + "label": "__gap", + "offset": 0, + "slot": "105", + "type": "t_array(t_uint256)48_storage", + "contract": "EIP712Upgradeable", + "src": "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol:204" + }, + { + "label": "__gap", + "offset": 0, + "slot": "153", + "type": "t_array(t_uint256)50_storage", + "contract": "IGovernorUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/IGovernorUpgradeable.sol:325" + }, + { + "label": "__gap", + "offset": 0, + "slot": "203", + "type": "t_array(t_uint256)50_storage", + "contract": "IGovernorTimelockUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/extensions/IGovernorTimelockUpgradeable.sol:38" + }, + { + "label": "_name", + "offset": 0, + "slot": "253", + "type": "t_string_storage", + "contract": "GovernorUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/GovernorUpgradeable.sol:51" + }, + { + "label": "_proposals", + "offset": 0, + "slot": "254", + "type": "t_mapping(t_uint256,t_struct(ProposalCore)465_storage)", + "contract": "GovernorUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/GovernorUpgradeable.sol:54", + "retypedFrom": "mapping(uint256 => Governor.ProposalCore)" + }, + { + "label": "_governanceCall", + "offset": 0, + "slot": "255", + "type": "t_struct(Bytes32Deque)10152_storage", + "contract": "GovernorUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/GovernorUpgradeable.sol:60" + }, + { + "label": "__gap", + "offset": 0, + "slot": "257", + "type": "t_array(t_uint256)46_storage", + "contract": "GovernorUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/GovernorUpgradeable.sol:735" + }, + { + "label": "_proposalVotes", + "offset": 0, + "slot": "303", + "type": "t_mapping(t_uint256,t_struct(ProposalVote)3387_storage)", + "contract": "GovernorCountingSimpleUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorCountingSimpleUpgradeable.sol:36" + }, + { + "label": "__gap", + "offset": 0, + "slot": "304", + "type": "t_array(t_uint256)49_storage", + "contract": "GovernorCountingSimpleUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorCountingSimpleUpgradeable.sol:112" + }, + { + "label": "token", + "offset": 0, + "slot": "353", + "type": "t_contract(IERC5805Upgradeable)4530", + "contract": "GovernorVotesUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorVotesUpgradeable.sol:18" + }, + { + "label": "__gap", + "offset": 0, + "slot": "354", + "type": "t_array(t_uint256)50_storage", + "contract": "GovernorVotesUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorVotesUpgradeable.sol:68" + }, + { + "label": "_timelock", + "offset": 0, + "slot": "404", + "type": "t_contract(TimelockControllerUpgradeable)3351", + "contract": "GovernorTimelockControlUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorTimelockControlUpgradeable.sol:28" + }, + { + "label": "_timelockIds", + "offset": 0, + "slot": "405", + "type": "t_mapping(t_uint256,t_bytes32)", + "contract": "GovernorTimelockControlUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorTimelockControlUpgradeable.sol:29" + }, + { + "label": "__gap", + "offset": 0, + "slot": "406", + "type": "t_array(t_uint256)48_storage", + "contract": "GovernorTimelockControlUpgradeable", + "src": "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorTimelockControlUpgradeable.sol:177" + }, + { + "label": "_votingDelay", + "offset": 0, + "slot": "454", + "type": "t_uint256", + "contract": "UnlockProtocolGovernor", + "src": "contracts/UnlockProtocolGovernor.sol:18" + }, + { + "label": "_votingPeriod", + "offset": 0, + "slot": "455", + "type": "t_uint256", + "contract": "UnlockProtocolGovernor", + "src": "contracts/UnlockProtocolGovernor.sol:19" + }, + { + "label": "_quorum", + "offset": 0, + "slot": "456", + "type": "t_uint256", + "contract": "UnlockProtocolGovernor", + "src": "contracts/UnlockProtocolGovernor.sol:20" + } + ], + "types": { + "t_address": { + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_uint256)46_storage": { + "label": "uint256[46]", + "numberOfBytes": "1472" + }, + "t_array(t_uint256)48_storage": { + "label": "uint256[48]", + "numberOfBytes": "1536" + }, + "t_array(t_uint256)49_storage": { + "label": "uint256[49]", + "numberOfBytes": "1568" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "label": "bool", + "numberOfBytes": "1" + }, + "t_bytes24": { + "label": "bytes24", + "numberOfBytes": "24" + }, + "t_bytes32": { + "label": "bytes32", + "numberOfBytes": "32" + }, + "t_bytes4": { + "label": "bytes4", + "numberOfBytes": "4" + }, + "t_contract(IERC5805Upgradeable)4530": { + "label": "contract IERC5805Upgradeable", + "numberOfBytes": "20" + }, + "t_contract(TimelockControllerUpgradeable)3351": { + "label": "contract TimelockControllerUpgradeable", + "numberOfBytes": "20" + }, + "t_int128": { + "label": "int128", + "numberOfBytes": "16" + }, + "t_mapping(t_address,t_bool)": { + "label": "mapping(address => bool)", + "numberOfBytes": "32" + }, + "t_mapping(t_int128,t_bytes32)": { + "label": "mapping(int128 => bytes32)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint256,t_bytes32)": { + "label": "mapping(uint256 => bytes32)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint256,t_struct(ProposalCore)465_storage)": { + "label": "mapping(uint256 => struct GovernorUpgradeable.ProposalCore)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint256,t_struct(ProposalVote)3387_storage)": { + "label": "mapping(uint256 => struct GovernorCountingSimpleUpgradeable.ProposalVote)", + "numberOfBytes": "32" + }, + "t_string_storage": { + "label": "string", + "numberOfBytes": "32" + }, + "t_struct(Bytes32Deque)10152_storage": { + "label": "struct DoubleEndedQueueUpgradeable.Bytes32Deque", + "members": [ + { + "label": "_begin", + "type": "t_int128", + "offset": 0, + "slot": "0" + }, + { + "label": "_end", + "type": "t_int128", + "offset": 16, + "slot": "0" + }, + { + "label": "_data", + "type": "t_mapping(t_int128,t_bytes32)", + "offset": 0, + "slot": "1" + } + ], + "numberOfBytes": "64" + }, + "t_struct(ProposalCore)465_storage": { + "label": "struct GovernorUpgradeable.ProposalCore", + "members": [ + { + "label": "voteStart", + "type": "t_uint64", + "offset": 0, + "slot": "0" + }, + { + "label": "proposer", + "type": "t_address", + "offset": 8, + "slot": "0" + }, + { + "label": "__gap_unused0", + "type": "t_bytes4", + "offset": 28, + "slot": "0" + }, + { + "label": "voteEnd", + "type": "t_uint64", + "offset": 0, + "slot": "1" + }, + { + "label": "__gap_unused1", + "type": "t_bytes24", + "offset": 8, + "slot": "1" + }, + { + "label": "executed", + "type": "t_bool", + "offset": 0, + "slot": "2" + }, + { + "label": "canceled", + "type": "t_bool", + "offset": 1, + "slot": "2" + } + ], + "numberOfBytes": "96" + }, + "t_struct(ProposalVote)3387_storage": { + "label": "struct GovernorCountingSimpleUpgradeable.ProposalVote", + "members": [ + { + "label": "againstVotes", + "type": "t_uint256", + "offset": 0, + "slot": "0" + }, + { + "label": "forVotes", + "type": "t_uint256", + "offset": 0, + "slot": "1" + }, + { + "label": "abstainVotes", + "type": "t_uint256", + "offset": 0, + "slot": "2" + }, + { + "label": "hasVoted", + "type": "t_mapping(t_address,t_bool)", + "offset": 0, + "slot": "3" + } + ], + "numberOfBytes": "128" + }, + "t_uint256": { + "label": "uint256", + "numberOfBytes": "32" + }, + "t_uint64": { + "label": "uint64", + "numberOfBytes": "8" + }, + "t_uint8": { + "label": "uint8", + "numberOfBytes": "1" + } + } + } + }, + "1bd4fbf4af1e294da9ff860a4baeb515ff733164ece51d855c6492d1dd20d51c": { + "address": "0xA8BB5AF09B599794136B14B112e137FAf83Acf1f", + "layout": { + "solcVersion": "0.8.21", + "storage": [ + { + "label": "initialized", + "offset": 0, + "slot": "0", + "type": "t_bool", + "contract": "UnlockInitializable", + "src": "contracts/past-versions/UnlockV12.sol:2346" + }, + { + "label": "initializing", + "offset": 1, + "slot": "0", + "type": "t_bool", + "contract": "UnlockInitializable", + "src": "contracts/past-versions/UnlockV12.sol:2351" + }, + { + "label": "______gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage", + "contract": "UnlockContextUpgradeable", + "src": "contracts/past-versions/UnlockV12.sol:2423" + }, + { + "label": "_owner", + "offset": 0, + "slot": "51", + "type": "t_address", + "contract": "UnlockOwnable", + "src": "contracts/past-versions/UnlockV12.sol:2449" + }, + { + "label": "______gap", + "offset": 0, + "slot": "52", + "type": "t_array(t_uint256)50_storage", + "contract": "UnlockOwnable", + "src": "contracts/past-versions/UnlockV12.sol:2515" + }, + { + "label": "grossNetworkProduct", + "offset": 0, + "slot": "102", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2568" + }, + { + "label": "totalDiscountGranted", + "offset": 0, + "slot": "103", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2570" + }, + { + "label": "locks", + "offset": 0, + "slot": "104", + "type": "t_mapping(t_address,t_struct(LockBalances)2798_storage)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2573" + }, + { + "label": "globalBaseTokenURI", + "offset": 0, + "slot": "105", + "type": "t_string_storage", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2577" + }, + { + "label": "globalTokenSymbol", + "offset": 0, + "slot": "106", + "type": "t_string_storage", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2581" + }, + { + "label": "publicLockAddress", + "offset": 0, + "slot": "107", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2584" + }, + { + "label": "uniswapOracles", + "offset": 0, + "slot": "108", + "type": "t_mapping(t_address,t_contract(IUniswapOracleV3)1948)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2588" + }, + { + "label": "weth", + "offset": 0, + "slot": "109", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2591" + }, + { + "label": "udt", + "offset": 0, + "slot": "110", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2594" + }, + { + "label": "estimatedGasForPurchase", + "offset": 0, + "slot": "111", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2597" + }, + { + "label": "chainId", + "offset": 0, + "slot": "112", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2600" + }, + { + "label": "proxyAdminAddress", + "offset": 0, + "slot": "113", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2603" + }, + { + "label": "proxyAdmin", + "offset": 0, + "slot": "114", + "type": "t_contract(ProxyAdmin)1215", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2604" + }, + { + "label": "_publicLockVersions", + "offset": 0, + "slot": "115", + "type": "t_mapping(t_address,t_uint16)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2607" + }, + { + "label": "_publicLockImpls", + "offset": 0, + "slot": "116", + "type": "t_mapping(t_uint16,t_address)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2608" + }, + { + "label": "publicLockLatestVersion", + "offset": 0, + "slot": "117", + "type": "t_uint16", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2609" + }, + { + "label": "protocolFee", + "offset": 0, + "slot": "118", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV12.sol:2612" + } + ], + "types": { + "t_address": { + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "label": "bool", + "numberOfBytes": "1" + }, + "t_contract(IUniswapOracleV3)1948": { + "label": "contract IUniswapOracleV3", + "numberOfBytes": "20" + }, + "t_contract(ProxyAdmin)1215": { + "label": "contract ProxyAdmin", + "numberOfBytes": "20" + }, + "t_mapping(t_address,t_contract(IUniswapOracleV3)1948)": { + "label": "mapping(address => contract IUniswapOracleV3)", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_struct(LockBalances)2798_storage)": { + "label": "mapping(address => struct Unlock.LockBalances)", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_uint16)": { + "label": "mapping(address => uint16)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint16,t_address)": { + "label": "mapping(uint16 => address)", + "numberOfBytes": "32" + }, + "t_string_storage": { + "label": "string", + "numberOfBytes": "32" + }, + "t_struct(LockBalances)2798_storage": { + "label": "struct Unlock.LockBalances", + "members": [ + { + "label": "deployed", + "type": "t_bool", + "offset": 0, + "slot": "0" + }, + { + "label": "totalSales", + "type": "t_uint256", + "offset": 0, + "slot": "1" + }, + { + "label": "yieldedDiscountTokens", + "type": "t_uint256", + "offset": 0, + "slot": "2" + } + ], + "numberOfBytes": "96" + }, + "t_uint16": { + "label": "uint16", + "numberOfBytes": "2" + }, + "t_uint256": { + "label": "uint256", + "numberOfBytes": "32" + } + }, + "namespaces": {} + } + }, + "c6d805c82f3f300da2425695b00fbf12dfe20f45dc8ffdf35ed30d444ccd6d60": { + "address": "0xd8250925527e769d90C6F2Fc55384B9110f26b62", + "txHash": "0xbab405988bf803aa288b9b545ae727fec7c5cf70f399489d9b48cd053c2a24af", + "layout": { + "solcVersion": "0.8.21", + "storage": [ + { + "label": "initialized", + "offset": 0, + "slot": "0", + "type": "t_bool", + "contract": "UnlockInitializable", + "src": "contracts/past-versions/UnlockV13.sol:1327" + }, + { + "label": "initializing", + "offset": 1, + "slot": "0", + "type": "t_bool", + "contract": "UnlockInitializable", + "src": "contracts/past-versions/UnlockV13.sol:1332" + }, + { + "label": "______gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage", + "contract": "UnlockContextUpgradeable", + "src": "contracts/past-versions/UnlockV13.sol:1406" + }, + { + "label": "_owner", + "offset": 0, + "slot": "51", + "type": "t_address", + "contract": "UnlockOwnable", + "src": "contracts/past-versions/UnlockV13.sol:1435" + }, + { + "label": "______gap", + "offset": 0, + "slot": "52", + "type": "t_array(t_uint256)50_storage", + "contract": "UnlockOwnable", + "src": "contracts/past-versions/UnlockV13.sol:1501" + }, + { + "label": "grossNetworkProduct", + "offset": 0, + "slot": "102", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2786" + }, + { + "label": "totalDiscountGranted", + "offset": 0, + "slot": "103", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2788" + }, + { + "label": "locks", + "offset": 0, + "slot": "104", + "type": "t_mapping(t_address,t_struct(LockBalances)3109_storage)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2791" + }, + { + "label": "globalBaseTokenURI", + "offset": 0, + "slot": "105", + "type": "t_string_storage", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2795" + }, + { + "label": "globalTokenSymbol", + "offset": 0, + "slot": "106", + "type": "t_string_storage", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2799" + }, + { + "label": "publicLockAddress", + "offset": 0, + "slot": "107", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2802" + }, + { + "label": "uniswapOracles", + "offset": 0, + "slot": "108", + "type": "t_mapping(t_address,t_contract(IUniswapOracleV3)757)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2806" + }, + { + "label": "weth", + "offset": 0, + "slot": "109", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2809" + }, + { + "label": "udt", + "offset": 0, + "slot": "110", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2812" + }, + { + "label": "estimatedGasForPurchase", + "offset": 0, + "slot": "111", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2815" + }, + { + "label": "chainId", + "offset": 0, + "slot": "112", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2818" + }, + { + "label": "proxyAdminAddress", + "offset": 0, + "slot": "113", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2821" + }, + { + "label": "proxyAdmin", + "offset": 0, + "slot": "114", + "type": "t_contract(ProxyAdmin)3095", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2822" + }, + { + "label": "_publicLockVersions", + "offset": 0, + "slot": "115", + "type": "t_mapping(t_address,t_uint16)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2825" + }, + { + "label": "_publicLockImpls", + "offset": 0, + "slot": "116", + "type": "t_mapping(t_uint16,t_address)", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2826" + }, + { + "label": "publicLockLatestVersion", + "offset": 0, + "slot": "117", + "type": "t_uint16", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2827" + }, + { + "label": "protocolFee", + "offset": 0, + "slot": "118", + "type": "t_uint256", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2830" + }, + { + "label": "swapBurnerAddress", + "offset": 0, + "slot": "119", + "type": "t_address", + "contract": "Unlock", + "src": "contracts/past-versions/UnlockV13.sol:2833" + } + ], + "types": { + "t_address": { + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "label": "bool", + "numberOfBytes": "1" + }, + "t_contract(IUniswapOracleV3)757": { + "label": "contract IUniswapOracleV3", + "numberOfBytes": "20" + }, + "t_contract(ProxyAdmin)3095": { + "label": "contract ProxyAdmin", + "numberOfBytes": "20" + }, + "t_mapping(t_address,t_contract(IUniswapOracleV3)757)": { + "label": "mapping(address => contract IUniswapOracleV3)", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_struct(LockBalances)3109_storage)": { + "label": "mapping(address => struct Unlock.LockBalances)", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_uint16)": { + "label": "mapping(address => uint16)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint16,t_address)": { + "label": "mapping(uint16 => address)", + "numberOfBytes": "32" + }, + "t_string_storage": { + "label": "string", + "numberOfBytes": "32" + }, + "t_struct(LockBalances)3109_storage": { + "label": "struct Unlock.LockBalances", + "members": [ + { + "label": "deployed", + "type": "t_bool", + "offset": 0, + "slot": "0" + }, + { + "label": "totalSales", + "type": "t_uint256", + "offset": 0, + "slot": "1" + }, + { + "label": "yieldedDiscountTokens", + "type": "t_uint256", + "offset": 0, + "slot": "2" + } + ], + "numberOfBytes": "96" + }, + "t_uint16": { + "label": "uint16", + "numberOfBytes": "2" + }, + "t_uint256": { + "label": "uint256", + "numberOfBytes": "32" + } + }, + "namespaces": {} + } + } + } +} From a8bcf5466145d39fb85ea161659545a83772d036 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renaud?= Date: Tue, 12 Mar 2024 17:44:54 +0100 Subject: [PATCH 02/11] update USDC whale address --- packages/hardhat-helpers/src/fork.js | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/packages/hardhat-helpers/src/fork.js b/packages/hardhat-helpers/src/fork.js index c6d925491a8..2ac46a7c2ae 100644 --- a/packages/hardhat-helpers/src/fork.js +++ b/packages/hardhat-helpers/src/fork.js @@ -27,7 +27,7 @@ async function getWhales(chainId = 1) { case 1: return { [tokens.DAI]: '0x075e72a5eDf65F0A5f44699c7654C1a76941Ddc8', // PulseX - [tokens.USDC]: '0x8EB8a3b98659Cce290402893d0123abb75E3ab28', + [tokens.USDC]: '0xD6153F5af5679a75cC85D8974463545181f48772', [tokens.WBTC]: '0x845cbCb8230197F733b59cFE1795F282786f212C', [tokens.UDT]: '0xF5C28ce24Acf47849988f147d5C75787c0103534', // unlock-protocol.eth } @@ -94,10 +94,7 @@ const resetNodeState = async () => { }) } -const addSomeETH = async ( - address, - amount = ethers.utils.parseEther('1000') -) => { +const addSomeETH = async (address, amount = ethers.parseEther('1000')) => { const { network } = require('hardhat') const balance = `0x${BigInt(amount.toString()).toString(16)}` await network.provider.send('hardhat_setBalance', [address, balance]) From fd3206fe5740ca2a346d71eb9faf60bf4ce32866 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renaud?= Date: Tue, 12 Mar 2024 17:46:28 +0100 Subject: [PATCH 03/11] refactor password func into helpers --- .../test/Lock/hooks/DiscountCodeHook.js | 23 +-------------- smart-contracts/test/helpers/index.js | 2 ++ smart-contracts/test/helpers/password.js | 28 +++++++++++++++++++ 3 files changed, 31 insertions(+), 22 deletions(-) create mode 100644 smart-contracts/test/helpers/password.js diff --git a/smart-contracts/test/Lock/hooks/DiscountCodeHook.js b/smart-contracts/test/Lock/hooks/DiscountCodeHook.js index aacee853eec..8576da91749 100644 --- a/smart-contracts/test/Lock/hooks/DiscountCodeHook.js +++ b/smart-contracts/test/Lock/hooks/DiscountCodeHook.js @@ -2,28 +2,7 @@ const { assert } = require('chai') const { expect } = require('chai') const { ethers, unlock } = require('hardhat') -/** - * Helper function - * @param {*} password - * @param {*} message - * @returns - */ -const getSignatureForPassword = async (password, message) => { - // Build the signer - const encoded = ethers.utils.defaultAbiCoder.encode( - ['bytes32'], - [ethers.utils.id(password)] - ) - const privateKey = ethers.utils.keccak256(encoded) - const privateKeyAccount = new ethers.Wallet(privateKey) - - // Sign - const messageHash = ethers.utils.solidityKeccak256(['string'], [message]) - const messageHashBinary = ethers.utils.arrayify(messageHash) - const signature = await privateKeyAccount.signMessage(messageHashBinary) - - return [signature, privateKeyAccount.address] -} +const { getSignatureForPassword } = require('../../helpers') describe('DiscountHook', function () { it('should work', async function () { diff --git a/smart-contracts/test/helpers/index.js b/smart-contracts/test/helpers/index.js index e4030bf84be..eb53c51378b 100644 --- a/smart-contracts/test/helpers/index.js +++ b/smart-contracts/test/helpers/index.js @@ -16,6 +16,7 @@ const versions = require('./versions') const bridge = require('./bridge') const events = require('./events') const bigNumber = require('./bigNumber') +const password = require('./password') module.exports = { deployContracts, @@ -36,4 +37,5 @@ module.exports = { ...bridge, ...events, ...bigNumber, + ...password, } diff --git a/smart-contracts/test/helpers/password.js b/smart-contracts/test/helpers/password.js new file mode 100644 index 00000000000..b6000d0bc8d --- /dev/null +++ b/smart-contracts/test/helpers/password.js @@ -0,0 +1,28 @@ +const { ethers } = require('hardhat') + +/** + * Helper function + * @param {*} password + * @param {*} message + * @returns + */ +const getSignatureForPassword = async (password, message) => { + // Build the signer + const encoded = ethers.utils.defaultAbiCoder.encode( + ['bytes32'], + [ethers.utils.id(password)] + ) + const privateKey = ethers.utils.keccak256(encoded) + const privateKeyAccount = new ethers.Wallet(privateKey) + + // Sign + const messageHash = ethers.utils.solidityKeccak256(['string'], [message]) + const messageHashBinary = ethers.utils.arrayify(messageHash) + const signature = await privateKeyAccount.signMessage(messageHashBinary) + + return [signature, privateKeyAccount.address] +} + +module.exports = { + getSignatureForPassword, +} From e2d92198c3cdf7961a2791a7bfce6c674558d9d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renaud?= Date: Tue, 12 Mar 2024 17:46:48 +0100 Subject: [PATCH 04/11] upgrade swapAndCall test --- .../swapAndCall.mainnet.js | 25 +++++++++++++------ 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/smart-contracts/test/UnlockSwapPurchaser/swapAndCall.mainnet.js b/smart-contracts/test/UnlockSwapPurchaser/swapAndCall.mainnet.js index aed2ec4f29a..8af45eebfe4 100644 --- a/smart-contracts/test/UnlockSwapPurchaser/swapAndCall.mainnet.js +++ b/smart-contracts/test/UnlockSwapPurchaser/swapAndCall.mainnet.js @@ -1,31 +1,44 @@ const { assert } = require('chai') const { ethers } = require('hardhat') const { expect } = require('chai') -const { deployLock, purchaseKey, getUnlock, reverts } = require('../helpers') +const { deployLock, purchaseKey, reverts } = require('../helpers') const { - uniswapRouterAddresses, + addSomeETH, + getNetwork, getUniswapTokens, getUniswapRoute, ADDRESS_ZERO, PERMIT2_ADDRESS, getBalance, addERC20, + getUnlock, } = require('@unlock-protocol/hardhat-helpers') let scenarios = [] describe(`swapAndCall`, function () { let unlock, swapPurchaser, tokens + let deployer, keyOwner before(async function () { if (!process.env.RUN_FORK) { // all suite will be skipped this.skip() } + + // + ;[deployer, keyOwner] = await ethers.getSigners() + await addSomeETH(deployer.address) + // get uniswap-formatted tokens - const { chainId } = await ethers.provider.getNetwork() + const { + id: chainId, + uniswapV3: { universalRouterAddress }, + } = await getNetwork() tokens = await getUniswapTokens(chainId) + const routers = [universalRouterAddress] + scenarios = [ [tokens.native, tokens.dai], [tokens.native, tokens.usdc], @@ -35,9 +48,6 @@ describe(`swapAndCall`, function () { // [tokens.native, tokens.wBtc] // Uniswap SDK failsto generate route and parse calldata ] - const { UniversalRouter, SwapRouter02 } = uniswapRouterAddresses[chainId] - const routers = [UniversalRouter, SwapRouter02] - // get Unlock contract unlock = await getUnlock() @@ -61,11 +71,10 @@ describe(`swapAndCall`, function () { it('swaps', () => { scenarios.forEach(([srcToken, lockToken]) => { - let keyOwner, lock, keyPrice + let lock, keyPrice let swapCalldata, value, swapRouter, amountInMax describe(`use ${srcToken.symbol} with a lock priced in ${lockToken.symbol}`, () => { before(async () => { - ;[, keyOwner] = await ethers.getSigners() // parse token decimals properly (100 USDC or 1 ETH) keyPrice = ethers.utils.parseUnits( lockToken.symbol === 'USDC' ? '100' : '1', From ebdd21ce62038f0c9dde760091f3571a11190d82 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renaud?= Date: Tue, 12 Mar 2024 17:51:15 +0100 Subject: [PATCH 05/11] add test for swap and discount hook purchase --- .../usePurchaseHook.mainnet.js | 200 ++++++++++++++++++ 1 file changed, 200 insertions(+) create mode 100644 smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js diff --git a/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js b/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js new file mode 100644 index 00000000000..37f06579115 --- /dev/null +++ b/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js @@ -0,0 +1,200 @@ +const { assert } = require('chai') +const { ethers } = require('hardhat') +const { + getSignatureForPassword, + deployLock, + compareBigNumbers, + MAX_UINT, +} = require('../helpers') + +const { + ADDRESS_ZERO, + addSomeETH, + addERC20, + getUnlock, + getNetwork, + PERMIT2_ADDRESS, + getUniswapTokens, + getUniswapRoute, +} = require('@unlock-protocol/hardhat-helpers') + +const someTokens = ethers.utils.parseUnits('1', 'ether') + +let swapPurchaser, unlock, lock, tokenAddress, token + +let owner, keyOwner +let native, usdc + +// hooks params +const code = 'PROMO CODE' +const recipient = '0xF5C28ce24cf47849988f147d5C75787c0103534'.toLowerCase() +const discount = 3000 // basis points +const cap = 10 + +describe('UnlockSwapPurchaser / withdraw', () => { + before(async () => { + if (!process.env.RUN_FORK) { + // all suite will be skipped + this.skip() + } + ;[owner, keyOwner] = await ethers.getSigners() + + // fund deployer + await addSomeETH(owner.address) + + const UnlockSwapPurchaser = await ethers.getContractFactory( + 'UnlockSwapPurchaser' + ) + // use mainnet settings for testing purposes only + const { + unlockAddress, + id: chainId, + uniswapV3: { universalRouterAddress }, + } = await getNetwork(1) + + unlock = await getUnlock(unlockAddress) + + const routers = [universalRouterAddress] + swapPurchaser = await UnlockSwapPurchaser.deploy( + unlock.address, + PERMIT2_ADDRESS, + routers + ) + + // get usdc token for testing + ;({ native, usdc } = await getUniswapTokens(chainId)) + tokenAddress = usdc.address + token = await addERC20(tokenAddress, keyOwner.address, someTokens) + + // deploy hook + const DiscountHook = await ethers.getContractFactory('DiscountHook') + const hook = await DiscountHook.deploy() + await hook.deployed() + + const [dataRecipient, signerAddress] = await getSignatureForPassword( + code, + recipient + ) + + // hook works with correct password + assert.equal( + await hook.getSigner(recipient.toLowerCase(), dataRecipient), + signerAddress + ) + + // create a lock + lock = await deployLock({ + unlock, + tokenAddress, + }) + + // set allowances + await token.connect(keyOwner).approve(swapPurchaser.address, MAX_UINT) + await token.connect(keyOwner).approve(lock.address, MAX_UINT) + + // set the hook + await lock.setEventHooks( + hook.address, + ethers.constants.AddressZero, + ethers.constants.AddressZero, + ethers.constants.AddressZero, + ethers.constants.AddressZero, + ethers.constants.AddressZero, + ethers.constants.AddressZero + ) + + // price wihtout seetings is correct + compareBigNumbers( + await lock.purchasePriceFor(keyOwner.address, keyOwner.address, []), + await lock.keyPrice() + ) + + // Set the code on the hook for the lock + const [, signer] = await getSignatureForPassword( + code, + keyOwner.address.toLowerCase() + ) + await hook.setSigner(lock.address, signer, discount, cap) + }) + + it('price with promo code is correct', async () => { + const [data] = await getSignatureForPassword( + code, + keyOwner.address.toLowerCase() + ) + const price = await lock.purchasePriceFor( + keyOwner.address, + keyOwner.address, + data + ) + assert.equal(ethers.utils.formatEther(price), '0.007') + }) + + it('can buy tickets at discount', async () => { + assert.equal((await lock.balanceOf(keyOwner.address)).toNumber(), 0) + const [data] = await getSignatureForPassword( + code, + keyOwner.address.toLowerCase() + ) + const price = await lock.purchasePriceFor( + keyOwner.address, + keyOwner.address, + data + ) + assert.equal(ethers.utils.formatEther(price), '0.007') + await lock.purchase( + [price], + [keyOwner.address], + [keyOwner.address], + [keyOwner.address], + [data], + { + value: price, + } + ) + assert.equal((await lock.balanceOf(keyOwner.address)).toNumber(), 1) + }) + + it('use promocode when swap and purchase', async () => { + assert.equal((await lock.balanceOf(keyOwner.address)).toNumber(), 0) + const [data] = await getSignatureForPassword( + code, + keyOwner.address.toLowerCase() + ) + const price = await lock.purchasePriceFor( + keyOwner.address, + keyOwner.address, + data + ) + const args = [ + [price], // keyPrices + [keyOwner.address], // recipients + [ADDRESS_ZERO], + [ADDRESS_ZERO], + [[]], // _data + ] + + // parse call data + const calldata = await lock.interface.encodeFunctionData('purchase', args) + + const { swapCalldata, value, swapRouter, amountInMax } = + await getUniswapRoute({ + tokenIn: native, + tokenOut: usdc, + amoutOut: price, + recipient: swapPurchaser.address, + }) + + // do the swap and call! + await swapPurchaser.connect(keyOwner).swapAndCall( + lock.address, + tokenAddress, + amountInMax, // value in src token + swapRouter, + swapCalldata, + calldata, + { value } + ) + assert.equal((await lock.balanceOf(keyOwner.address)).toNumber(), 1) + }) +}) From 501952b49cd818f13ddc13846cc3dc1399fdd7ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renaud?= Date: Tue, 12 Mar 2024 17:51:51 +0100 Subject: [PATCH 06/11] add contract changes --- .../contracts/utils/UnlockSwapPurchaser.sol | 29 +++++++++++++++++-- 1 file changed, 26 insertions(+), 3 deletions(-) diff --git a/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol b/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol index edb8558c2d3..c6fdbb9dfa7 100644 --- a/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol +++ b/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol @@ -77,6 +77,29 @@ contract UnlockSwapPurchaser { : IMintableERC20(token).balanceOf(address(this)); } + function getKeyPrice( + address lock, + bytes memory swapCalldata + ) public view returns (uint keyPrice) { + ( + , + uint[] memory keyPrices, + address[] memory recipients, + address[] memory referrers, + address[] memory keyManagers, + bytes[] memory purchaseData + ) = abi.decode( + swapCalldata, + (bytes4, uint[], address[], address[], address[], bytes[]) + ); + + keyPrice = IPublicLock(lock).purchasePriceFor( + recipients[0], + referrers[0], + purchaseData[0] + ); + } + /** * Swap tokens and call a function a lock contract. * @@ -173,19 +196,19 @@ contract UnlockSwapPurchaser { destToken == address(0) ? getBalance(destToken) - msg.value : getBalance(destToken) - ) < balanceTokenDestBefore + IPublicLock(lock).keyPrice() + ) < balanceTokenDestBefore + getKeyPrice(lock, swapCalldata) ) { revert InsufficientBalance(); } // approve ERC20 to call the lock if (destToken != address(0)) { - IMintableERC20(destToken).approve(lock, IPublicLock(lock).keyPrice()); + IMintableERC20(destToken).approve(lock, getKeyPrice(lock, swapCalldata)); } // call the lock (bool lockCallSuccess, bytes memory returnData) = lock.call{ - value: destToken == address(0) ? IPublicLock(lock).keyPrice() : 0 + value: destToken == address(0) ? getKeyPrice(lock, swapCalldata) : 0 }(callData); if (lockCallSuccess == false) { From 0925e2bbf1f8d70ec68e25e90f74fa7d5df17397 Mon Sep 17 00:00:00 2001 From: Julien Genestoux Date: Tue, 12 Mar 2024 13:36:42 -0400 Subject: [PATCH 07/11] Apply suggestions from code review Using `callData` ! --- smart-contracts/contracts/utils/UnlockSwapPurchaser.sol | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol b/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol index c6fdbb9dfa7..94513e3c26c 100644 --- a/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol +++ b/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol @@ -196,19 +196,19 @@ contract UnlockSwapPurchaser { destToken == address(0) ? getBalance(destToken) - msg.value : getBalance(destToken) - ) < balanceTokenDestBefore + getKeyPrice(lock, swapCalldata) + ) < balanceTokenDestBefore + getKeyPrice(lock, callData) ) { revert InsufficientBalance(); } // approve ERC20 to call the lock if (destToken != address(0)) { - IMintableERC20(destToken).approve(lock, getKeyPrice(lock, swapCalldata)); + IMintableERC20(destToken).approve(lock, getKeyPrice(lock, callData)); } // call the lock (bool lockCallSuccess, bytes memory returnData) = lock.call{ - value: destToken == address(0) ? getKeyPrice(lock, swapCalldata) : 0 + value: destToken == address(0) ? getKeyPrice(lock, callData) : 0 }(callData); if (lockCallSuccess == false) { From 87111a7a937ff480c6a437716557dd3efc6d972d Mon Sep 17 00:00:00 2001 From: Julien Genestoux Date: Tue, 12 Mar 2024 13:37:16 -0400 Subject: [PATCH 08/11] Apply suggestions from code review Renaming for clarity! --- smart-contracts/contracts/utils/UnlockSwapPurchaser.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol b/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol index 94513e3c26c..9943be2fc17 100644 --- a/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol +++ b/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol @@ -79,7 +79,7 @@ contract UnlockSwapPurchaser { function getKeyPrice( address lock, - bytes memory swapCalldata + bytes memory callData ) public view returns (uint keyPrice) { ( , @@ -89,7 +89,7 @@ contract UnlockSwapPurchaser { address[] memory keyManagers, bytes[] memory purchaseData ) = abi.decode( - swapCalldata, + callData, (bytes4, uint[], address[], address[], address[], bytes[]) ); From 106a2fc49066c66156343a081653f03d47ebf305 Mon Sep 17 00:00:00 2001 From: Julien Genestoux Date: Tue, 12 Mar 2024 18:00:36 -0400 Subject: [PATCH 09/11] wip --- packages/hardhat-helpers/package.json | 3 +- packages/hardhat-helpers/src/fork.js | 19 +++-- packages/hardhat-helpers/src/uniswap.js | 12 +++- .../contracts/utils/UnlockSwapPurchaser.sol | 1 + .../usePurchaseHook.mainnet.js | 71 +++++++++++-------- yarn.lock | 37 +--------- 6 files changed, 70 insertions(+), 73 deletions(-) diff --git a/packages/hardhat-helpers/package.json b/packages/hardhat-helpers/package.json index 4ffaf0bd9b3..d94c08b20ed 100644 --- a/packages/hardhat-helpers/package.json +++ b/packages/hardhat-helpers/package.json @@ -21,13 +21,14 @@ "@nomiclabs/hardhat-waffle": "2.0.6", "@uniswap/permit2-sdk": "1.2.0", "@uniswap/sdk-core": "4.0.9", - "@uniswap/smart-order-router": "3.19.2", + "@uniswap/smart-order-router": "3.17.2", "@uniswap/v3-sdk": "3.10.2", "@unlock-protocol/contracts": "workspace:^", "@unlock-protocol/networks": "workspace:^", "@unlock-protocol/tsconfig": "workspace:^", "@unlock-protocol/types": "workspace:^", "ethers": "6.10.0", + "ethersv5": "npm:ethers@^5.7.2", "hardhat": "2.20.1", "typescript": "5.3.3", "zksync-ethers": "6.1.0" diff --git a/packages/hardhat-helpers/src/fork.js b/packages/hardhat-helpers/src/fork.js index 2ac46a7c2ae..73719979d12 100644 --- a/packages/hardhat-helpers/src/fork.js +++ b/packages/hardhat-helpers/src/fork.js @@ -61,11 +61,11 @@ const parseForkUrl = (networks) => { name: `${name} (forked locally)`, accounts: process.env.DEPLOYER_PRIVATE_KEY ? [ - { - privateKey: process.env.DEPLOYER_PRIVATE_KEY, - balance: '10000000000000000000000', // 1000 ETH yah - }, - ] + { + privateKey: process.env.DEPLOYER_PRIVATE_KEY, + balance: '10000000000000000000000', // 1000 ETH yah + }, + ] : undefined, } @@ -157,13 +157,20 @@ const addERC20 = async function ( } // otherwise use transfer from whales + const erc20Contract = await ethers.getContractAt(ERC20_ABI, tokenAddress) const whales = await getWhales() if (!whales[tokenAddress]) throw Error(`No whale for this address: ${tokenAddress}`) + + const whaleBalance = await erc20Contract.balanceOf(whales[tokenAddress]) + if (whaleBalance.lt(amount)) { + throw Error( + `Whale at address: ${whales[tokenAddress]} does not have enough ${tokenAddress} to transfer ${amount} to ${address} (only has ${whaleBalance})` + ) + } const whale = await ethers.getSigner(whales[tokenAddress]) await impersonate(whale.address) - const erc20Contract = await ethers.getContractAt(ERC20_ABI, tokenAddress) await erc20Contract.connect(whale).transfer(address, amount) return erc20Contract } diff --git a/packages/hardhat-helpers/src/uniswap.js b/packages/hardhat-helpers/src/uniswap.js index aa8425c96d2..cb137933ae0 100644 --- a/packages/hardhat-helpers/src/uniswap.js +++ b/packages/hardhat-helpers/src/uniswap.js @@ -1,4 +1,5 @@ const { ethers } = require('ethers') +const { ethers: ethersv5 } = require('ethersv5') const { AllowanceTransfer } = require('@uniswap/permit2-sdk') const { @@ -47,18 +48,23 @@ async function getUniswapRoute({ slippageTolerance = new Percent(10, 100), deadline = Math.floor(new Date().getTime() / 1000 + 100000), permitOptions: { usePermit2Sig = false, inputTokenPermit } = {}, - chainId, + chainId = 1, }) { // init router + + const provider = new ethersv5.providers.JsonRpcProvider( + `https://rpc.unlock-protocol.com/${chainId}` + ) + console.log(provider) const router = new AlphaRouter({ chainId, - provider: ethers.provider, + provider, }) // parse router args const outputAmount = CurrencyAmount.fromRawAmount( tokenOut, - JSBI.BigInt(amoutOut) + amoutOut //JSBI.BigInt(amoutOut) ) const routeArgs = [ outputAmount, diff --git a/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol b/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol index 9943be2fc17..5a9b8596848 100644 --- a/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol +++ b/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol @@ -7,6 +7,7 @@ import "../interfaces/IMintableERC20.sol"; import "../interfaces/IPermit2.sol"; import "../interfaces/IPublicLock.sol"; import "../interfaces/IUnlock.sol"; +import "hardhat/console.sol"; library SafeCast160 { error UnsafeCast(); diff --git a/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js b/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js index 37f06579115..b9260148874 100644 --- a/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js +++ b/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js @@ -18,9 +18,7 @@ const { getUniswapRoute, } = require('@unlock-protocol/hardhat-helpers') -const someTokens = ethers.utils.parseUnits('1', 'ether') - -let swapPurchaser, unlock, lock, tokenAddress, token +let swapPurchaser, unlock, lock, tokenAddress let owner, keyOwner let native, usdc @@ -31,7 +29,7 @@ const recipient = '0xF5C28ce24cf47849988f147d5C75787c0103534'.toLowerCase() const discount = 3000 // basis points const cap = 10 -describe('UnlockSwapPurchaser / withdraw', () => { +describe('UnlockSwapPurchaser / purchase with promo code', () => { before(async () => { if (!process.env.RUN_FORK) { // all suite will be skipped @@ -39,8 +37,9 @@ describe('UnlockSwapPurchaser / withdraw', () => { } ;[owner, keyOwner] = await ethers.getSigners() - // fund deployer + // fund deployer and keyOwner await addSomeETH(owner.address) + await addSomeETH(keyOwner.address) const UnlockSwapPurchaser = await ethers.getContractFactory( 'UnlockSwapPurchaser' @@ -60,11 +59,9 @@ describe('UnlockSwapPurchaser / withdraw', () => { PERMIT2_ADDRESS, routers ) - - // get usdc token for testing - ;({ native, usdc } = await getUniswapTokens(chainId)) + // get usdc token for testing + ; ({ native, usdc } = await getUniswapTokens(chainId)) tokenAddress = usdc.address - token = await addERC20(tokenAddress, keyOwner.address, someTokens) // deploy hook const DiscountHook = await ethers.getContractFactory('DiscountHook') @@ -86,12 +83,9 @@ describe('UnlockSwapPurchaser / withdraw', () => { lock = await deployLock({ unlock, tokenAddress, + keyPrice: ethers.utils.parseUnits('1', 6), // USDC has 6 decimals, we set 1 USDC }) - // set allowances - await token.connect(keyOwner).approve(swapPurchaser.address, MAX_UINT) - await token.connect(keyOwner).approve(lock.address, MAX_UINT) - // set the hook await lock.setEventHooks( hook.address, @@ -117,7 +111,7 @@ describe('UnlockSwapPurchaser / withdraw', () => { await hook.setSigner(lock.address, signer, discount, cap) }) - it('price with promo code is correct', async () => { + it.only('price with promo code is correct', async () => { const [data] = await getSignatureForPassword( code, keyOwner.address.toLowerCase() @@ -127,55 +121,73 @@ describe('UnlockSwapPurchaser / withdraw', () => { keyOwner.address, data ) - assert.equal(ethers.utils.formatEther(price), '0.007') + assert.equal(ethers.utils.formatUnits(price, 6), '0.7') }) - it('can buy tickets at discount', async () => { + it.skip('can buy tickets at discount', async () => { + // User does not have a key assert.equal((await lock.balanceOf(keyOwner.address)).toNumber(), 0) const [data] = await getSignatureForPassword( code, keyOwner.address.toLowerCase() ) + // check the price const price = await lock.purchasePriceFor( keyOwner.address, keyOwner.address, data ) - assert.equal(ethers.utils.formatEther(price), '0.007') - await lock.purchase( - [price], - [keyOwner.address], - [keyOwner.address], - [keyOwner.address], - [data], - { - value: price, - } - ) + assert.equal(ethers.utils.formatUnits(price, 6), '0.7') + + const token = await lock.tokenAddress() + + // fund! + const tokenContract = await addERC20(token, keyOwner.address, price) + + await tokenContract.connect(keyOwner).approve(lock.address, MAX_UINT) + + // purchase! + await lock + .connect(keyOwner) + .purchase( + [price], + [keyOwner.address], + [keyOwner.address], + [keyOwner.address], + [data], + { + value: price, + } + ) assert.equal((await lock.balanceOf(keyOwner.address)).toNumber(), 1) }) - it('use promocode when swap and purchase', async () => { + it.only('use promocode when swap and purchase', async () => { + // a user does have a key assert.equal((await lock.balanceOf(keyOwner.address)).toNumber(), 0) const [data] = await getSignatureForPassword( code, keyOwner.address.toLowerCase() ) + // check the price const price = await lock.purchasePriceFor( keyOwner.address, keyOwner.address, data ) + assert.equal(ethers.utils.formatUnits(price, 6), '0.7') + const args = [ [price], // keyPrices [keyOwner.address], // recipients [ADDRESS_ZERO], [ADDRESS_ZERO], - [[]], // _data + [data], // _data ] // parse call data const calldata = await lock.interface.encodeFunctionData('purchase', args) + console.log(calldata) const { swapCalldata, value, swapRouter, amountInMax } = await getUniswapRoute({ @@ -183,6 +195,7 @@ describe('UnlockSwapPurchaser / withdraw', () => { tokenOut: usdc, amoutOut: price, recipient: swapPurchaser.address, + chainId: 1, }) // do the swap and call! diff --git a/yarn.lock b/yarn.lock index 65ce52916c6..736079a7cf7 100644 --- a/yarn.lock +++ b/yarn.lock @@ -19585,38 +19585,6 @@ __metadata: languageName: node linkType: hard -"@uniswap/smart-order-router@npm:3.19.2": - version: 3.19.2 - resolution: "@uniswap/smart-order-router@npm:3.19.2" - dependencies: - "@uniswap/default-token-list": "npm:^11.2.0" - "@uniswap/permit2-sdk": "npm:^1.2.0" - "@uniswap/router-sdk": "npm:^1.6.0" - "@uniswap/sdk-core": "npm:^4.0.7" - "@uniswap/swap-router-contracts": "npm:^1.3.0" - "@uniswap/token-lists": "npm:^1.0.0-beta.31" - "@uniswap/universal-router": "npm:^1.0.1" - "@uniswap/universal-router-sdk": "npm:^1.5.8" - "@uniswap/v2-sdk": "npm:^3.2.3" - "@uniswap/v3-sdk": "npm:^3.10.0" - async-retry: "npm:^1.3.1" - await-timeout: "npm:^1.1.1" - axios: "npm:^0.21.1" - bunyan: "npm:^1.8.15" - bunyan-blackhole: "npm:^1.1.1" - ethers: "npm:^5.7.2" - graphql: "npm:^15.5.0" - graphql-request: "npm:^3.4.0" - lodash: "npm:^4.17.21" - mnemonist: "npm:^0.38.3" - node-cache: "npm:^5.1.2" - stats-lite: "npm:^2.2.0" - peerDependencies: - jsbi: ^3.2.0 - checksum: 10/95c705790d51a6e54e4cfbdfe23bdb302b68e84c3e0d482c112edfd7d0683d6dad5b84ab0d81ca6dfe64f84bb0f54ff6349c9c2b4519b6ecd10e2e6bc0ee3b7d - languageName: node - linkType: hard - "@uniswap/swap-router-contracts@npm:^1.1.0, @uniswap/swap-router-contracts@npm:^1.2.1, @uniswap/swap-router-contracts@npm:^1.3.0": version: 1.3.1 resolution: "@uniswap/swap-router-contracts@npm:1.3.1" @@ -19940,7 +19908,7 @@ __metadata: "@nomiclabs/hardhat-waffle": "npm:2.0.6" "@uniswap/permit2-sdk": "npm:1.2.0" "@uniswap/sdk-core": "npm:4.0.9" - "@uniswap/smart-order-router": "npm:3.19.2" + "@uniswap/smart-order-router": "npm:3.17.2" "@uniswap/v3-sdk": "npm:3.10.2" "@unlock-protocol/contracts": "workspace:^" "@unlock-protocol/networks": "workspace:^" @@ -19948,6 +19916,7 @@ __metadata: "@unlock-protocol/types": "workspace:^" copyfiles: "npm:2.4.1" ethers: "npm:6.10.0" + ethersv5: "npm:ethers@^5.7.2" hardhat: "npm:2.20.1" tsup: "npm:8.0.2" typescript: "npm:5.3.3" @@ -30957,7 +30926,7 @@ __metadata: languageName: node linkType: hard -"ethers@npm:5.7.2, ethers@npm:^5.3.1, ethers@npm:^5.5.4, ethers@npm:^5.6.1, ethers@npm:^5.7.0, ethers@npm:^5.7.1, ethers@npm:^5.7.2": +"ethers@npm:5.7.2, ethers@npm:^5.3.1, ethers@npm:^5.5.4, ethers@npm:^5.6.1, ethers@npm:^5.7.0, ethers@npm:^5.7.1, ethers@npm:^5.7.2, ethersv5@npm:ethers@^5.7.2": version: 5.7.2 resolution: "ethers@npm:5.7.2" dependencies: From 5c7685ac0cae476b77705bf413fc4499c26382af Mon Sep 17 00:00:00 2001 From: Julien Genestoux Date: Tue, 12 Mar 2024 18:55:47 -0400 Subject: [PATCH 10/11] more wip --- .../src/abis/utils/UnlockSwapPurchaser.json | 30 +- .../contracts/utils/UnlockSwapPurchaser.sol | 2121 ++++++++++++++--- packages/contracts/src/index.ts | 7 +- packages/networks/src/networks/sepolia.ts | 1 + .../usePurchaseHook.mainnet.js | 28 +- unlock-app/src/hooks/useUniswapRoutes.ts | 57 +- 6 files changed, 1925 insertions(+), 319 deletions(-) diff --git a/packages/contracts/src/abis/utils/UnlockSwapPurchaser.json b/packages/contracts/src/abis/utils/UnlockSwapPurchaser.json index 521e0156ac7..0822052133a 100644 --- a/packages/contracts/src/abis/utils/UnlockSwapPurchaser.json +++ b/packages/contracts/src/abis/utils/UnlockSwapPurchaser.json @@ -1,7 +1,7 @@ { "_format": "hh-sol-artifact-1", "contractName": "UnlockSwapPurchaser", - "sourceName": "contracts/utils/UnlockSwapPurchaser.sol", + "sourceName": "contracts/UnlockSwapPurchaser.flatten.sol", "abi": [ { "inputs": [ @@ -127,6 +127,30 @@ "name": "SwapCall", "type": "event" }, + { + "inputs": [ + { + "internalType": "address", + "name": "lock", + "type": "address" + }, + { + "internalType": "bytes", + "name": "callData", + "type": "bytes" + } + ], + "name": "getKeyPrice", + "outputs": [ + { + "internalType": "uint256", + "name": "keyPrice", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [], "name": "permit2", @@ -215,8 +239,8 @@ "type": "receive" } ], - "bytecode": "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", - "deployedBytecode": "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", + "bytecode": "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", + "deployedBytecode": "0x60806040526004361061004c575f3560e01c806302837f7b1461005757806312261ee7146100785780634fc85292146100ad5780635e8f4502146100da578063b30929cd146100fa575f80fd5b3661005357005b5f80fd5b348015610062575f80fd5b50610076610071366004610b42565b610118565b005b348015610083575f80fd5b50600154610097906001600160a01b031681565b6040516100a49190610b64565b60405180910390f35b3480156100b8575f80fd5b506100cc6100c7366004610c34565b610221565b6040519081526020016100a4565b6100ed6100e8366004610c80565b61030c565b6040516100a49190610d6a565b348015610105575f80fd5b505f54610097906001600160a01b031681565b5f6101228261086c565b90506001600160a01b038216156101ab575f5460405163a9059cbb60e01b81526001600160a01b038481169263a9059cbb9261016692909116908590600401610d7c565b6020604051808303815f875af1158015610182573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101a69190610da9565b505050565b5f80546040516001600160a01b039091169083908381818185875af1925050503d805f81146101f5576040519150601f19603f3d011682016040523d82523d5f602084013e6101fa565b606091505b50909150508015155f036101a657604051631d42c86760e21b815260040160405180910390fd5b5f805f805f808680602001905181019061023b9190610f74565b9550955095509550955050876001600160a01b031663097ba333855f815181106102675761026761103e565b6020026020010151855f815181106102815761028161103e565b6020026020010151845f8151811061029b5761029b61103e565b60200260200101516040518463ffffffff1660e01b81526004016102c193929190611052565b602060405180830381865afa1580156102dc573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103009190611086565b98975050505050505050565b5f8054604051635de9a13760e01b8152606092916001600160a01b031690635de9a1379061033e908b90600401610b64565b606060405180830381865afa158015610359573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061037d919061109d565b50509050806103aa5787604051637421631960e11b81526004016103a19190610b64565b60405180910390fd5b6001600160a01b0385165f9081526002602052604090205460ff1615156001146103e9578460405163f2f52fc960e01b81526004016103a19190610b64565b5f886001600160a01b0316639d76ea586040518163ffffffff1660e01b8152600401602060405180830381865afa158015610426573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061044a91906110cf565b90505f6001600160a01b0382161561046a576104658261086c565b61047e565b346104748361086c565b61047e91906110fe565b90505f6001600160a01b038a161561049e576104998a61086c565b6104b2565b346104a88b61086c565b6104b291906110fe565b90506001600160a01b038a1615610550576104cf8a33308c6108f4565b6104da8a898b6109f9565b60015460405163095ea7b360e01b81526001600160a01b038c81169263095ea7b39261050e92909116908d90600401610d7c565b6020604051808303815f875af115801561052a573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061054e9190610da9565b505b6001546001600160a01b03166387517c458b8a61056c8d610afe565b61057742603c611111565b6040516001600160e01b031960e087901b1681526001600160a01b03948516600482015292841660248401529216604482015265ffffffffffff90911660648201526084015f604051808303815f87803b1580156105d3575f80fd5b505af11580156105e5573d5f803e3d5ffd5b505f9250506001600160a01b03808b1691508c1615610604575f610606565b345b896040516106149190611124565b5f6040518083038185875af1925050503d805f811461064e576040519150601f19603f3d011682016040523d82523d5f602084013e610653565b606091505b50909150508015155f0361068457888b858c8b604051637bd486e960e11b81526004016103a195949392919061113f565b61068e8c88610221565b6106989084611111565b6001600160a01b038516156106b5576106b08561086c565b6106c9565b346106bf8661086c565b6106c991906110fe565b10156106e857604051631e9acf1760e31b815260040160405180910390fd5b6001600160a01b0384161561077057836001600160a01b031663095ea7b38d6107118f8b610221565b6040518363ffffffff1660e01b815260040161072e929190610d7c565b6020604051808303815f875af115801561074a573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061076e9190610da9565b505b5f806001600160a01b03808f169087161561078b575f610795565b6107958f8b610221565b8a6040516107a39190611124565b5f6040518083038185875af1925050503d805f81146107dd576040519150601f19603f3d011682016040523d82523d5f602084013e6107e2565b606091505b5090925090508115155f0361080a57604051637772507160e11b815260040160405180910390fd5b5f846108158f61086c565b61081f91906110fe565b108061083d57505f856108318861086c565b61083b91906110fe565b105b1561085b5760405163392032cb60e21b815260040160405180910390fd5b9d9c50505050505050505050505050565b5f6001600160a01b038216156108ec576040516370a0823160e01b81526001600160a01b038316906370a08231906108a8903090600401610b64565b602060405180830381865afa1580156108c3573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906108e79190611086565b6108ee565b475b92915050565b604080516001600160a01b0385811660248301528481166044830152606480830185905283518084039091018152608490920183526020820180516001600160e01b03166323b872dd60e01b17905291515f928392908816916109579190611124565b5f604051808303815f865af19150503d805f8114610990576040519150601f19603f3d011682016040523d82523d5f602084013e610995565b606091505b50915091508180156109bf5750805115806109bf5750808060200190518101906109bf9190610da9565b6109f15760405162461bcd60e51b815260206004820152600360248201526229aa2360e91b60448201526064016103a1565b505050505050565b5f80846001600160a01b031663095ea7b360e01b8585604051602401610a20929190610d7c565b60408051601f198184030181529181526020820180516001600160e01b03166001600160e01b0319909416939093179092529051610a5e9190611124565b5f604051808303815f865af19150503d805f8114610a97576040519150601f19603f3d011682016040523d82523d5f602084013e610a9c565b606091505b5091509150818015610ac6575080511580610ac6575080806020019051810190610ac69190610da9565b610af75760405162461bcd60e51b8152602060048201526002602482015261534160f01b60448201526064016103a1565b5050505050565b5f6001600160a01b03821115610b275760405163c4bd89a960e01b815260040160405180910390fd5b5090565b6001600160a01b0381168114610b3f575f80fd5b50565b5f60208284031215610b52575f80fd5b8135610b5d81610b2b565b9392505050565b6001600160a01b0391909116815260200190565b634e487b7160e01b5f52604160045260245ffd5b604051601f8201601f191681016001600160401b0381118282101715610bb457610bb4610b78565b604052919050565b5f6001600160401b03821115610bd457610bd4610b78565b50601f01601f191660200190565b5f82601f830112610bf1575f80fd5b8135610c04610bff82610bbc565b610b8c565b818152846020838601011115610c18575f80fd5b816020850160208301375f918101602001919091529392505050565b5f8060408385031215610c45575f80fd5b8235610c5081610b2b565b915060208301356001600160401b03811115610c6a575f80fd5b610c7685828601610be2565b9150509250929050565b5f805f805f8060c08789031215610c95575f80fd5b8635610ca081610b2b565b95506020870135610cb081610b2b565b9450604087013593506060870135610cc781610b2b565b925060808701356001600160401b0380821115610ce2575f80fd5b610cee8a838b01610be2565b935060a0890135915080821115610d03575f80fd5b50610d1089828a01610be2565b9150509295509295509295565b5f5b83811015610d37578181015183820152602001610d1f565b50505f910152565b5f8151808452610d56816020860160208601610d1d565b601f01601f19169290920160200192915050565b602081525f610b5d6020830184610d3f565b6001600160a01b03929092168252602082015260400190565b80518015158114610da4575f80fd5b919050565b5f60208284031215610db9575f80fd5b610b5d82610d95565b80516001600160e01b031981168114610da4575f80fd5b5f6001600160401b03821115610df157610df1610b78565b5060051b60200190565b5f82601f830112610e0a575f80fd5b81516020610e1a610bff83610dd9565b82815260059290921b84018101918181019086841115610e38575f80fd5b8286015b84811015610e535780518352918301918301610e3c565b509695505050505050565b5f82601f830112610e6d575f80fd5b81516020610e7d610bff83610dd9565b82815260059290921b84018101918181019086841115610e9b575f80fd5b8286015b84811015610e53578051610eb281610b2b565b8352918301918301610e9f565b5f82601f830112610ece575f80fd5b81516020610ede610bff83610dd9565b82815260059290921b84018101918181019086841115610efc575f80fd5b8286015b84811015610e535780516001600160401b03811115610f1e575f8081fd5b8701603f81018913610f2f575f8081fd5b848101516040610f41610bff83610bbc565b8281528b82848601011115610f55575f8081fd5b610f6483898301848701610d1d565b8652505050918301918301610f00565b5f805f805f8060c08789031215610f89575f80fd5b610f9287610dc2565b955060208701516001600160401b0380821115610fad575f80fd5b610fb98a838b01610dfb565b96506040890151915080821115610fce575f80fd5b610fda8a838b01610e5e565b95506060890151915080821115610fef575f80fd5b610ffb8a838b01610e5e565b94506080890151915080821115611010575f80fd5b61101c8a838b01610e5e565b935060a0890151915080821115611031575f80fd5b50610d1089828a01610ebf565b634e487b7160e01b5f52603260045260245ffd5b6001600160a01b038481168252831660208201526060604082018190525f9061107d90830184610d3f565b95945050505050565b5f60208284031215611096575f80fd5b5051919050565b5f805f606084860312156110af575f80fd5b6110b884610d95565b925060208401519150604084015190509250925092565b5f602082840312156110df575f80fd5b8151610b5d81610b2b565b634e487b7160e01b5f52601160045260245ffd5b818103818111156108ee576108ee6110ea565b808201808211156108ee576108ee6110ea565b5f8251611135818460208701610d1d565b9190910192915050565b6001600160a01b0386811682528581166020830152841660408201526060810183905260a0608082018190525f9061117990830184610d3f565b97965050505050505056fea26469706673582212205c2ba9b67715c05833fd58831c41707950da12ee85c6b1da42bd08438af9b2d464736f6c63430008150033", "linkReferences": {}, "deployedLinkReferences": {} } diff --git a/packages/contracts/src/contracts/utils/UnlockSwapPurchaser.sol b/packages/contracts/src/contracts/utils/UnlockSwapPurchaser.sol index b521bf6d5e3..ed1abd86022 100644 --- a/packages/contracts/src/contracts/utils/UnlockSwapPurchaser.sol +++ b/packages/contracts/src/contracts/utils/UnlockSwapPurchaser.sol @@ -1,4 +1,4 @@ -// Sources flattened with hardhat v2.18.3 https://hardhat.org +// Sources flattened with hardhat v2.20.1 https://hardhat.org // SPDX-License-Identifier: GPL-2.0-or-later AND MIT @@ -12,99 +12,92 @@ pragma solidity >=0.5.0; /// @title Callback for IUniswapV3PoolActions#swap /// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface interface IUniswapV3SwapCallback { - /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap. - /// @dev In the implementation you must pay the pool tokens owed for the swap. - /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory. - /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped. - /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by - /// the end of the swap. If positive, the callback must send that amount of token0 to the pool. - /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by - /// the end of the swap. If positive, the callback must send that amount of token1 to the pool. - /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call - function uniswapV3SwapCallback( - int256 amount0Delta, - int256 amount1Delta, - bytes calldata data - ) external; + /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap. + /// @dev In the implementation you must pay the pool tokens owed for the swap. + /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory. + /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped. + /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by + /// the end of the swap. If positive, the callback must send that amount of token0 to the pool. + /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by + /// the end of the swap. If positive, the callback must send that amount of token1 to the pool. + /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call + function uniswapV3SwapCallback( + int256 amount0Delta, + int256 amount1Delta, + bytes calldata data + ) external; } + // File @uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol@v1.4.4 // Original license: SPDX_License_Identifier: GPL-2.0-or-later pragma solidity >=0.7.5; - // Original pragma directive: pragma abicoder v2 /// @title Router token swapping functionality /// @notice Functions for swapping tokens via Uniswap V3 interface ISwapRouter is IUniswapV3SwapCallback { - struct ExactInputSingleParams { - address tokenIn; - address tokenOut; - uint24 fee; - address recipient; - uint256 deadline; - uint256 amountIn; - uint256 amountOutMinimum; - uint160 sqrtPriceLimitX96; - } + struct ExactInputSingleParams { + address tokenIn; + address tokenOut; + uint24 fee; + address recipient; + uint256 deadline; + uint256 amountIn; + uint256 amountOutMinimum; + uint160 sqrtPriceLimitX96; + } - /// @notice Swaps `amountIn` of one token for as much as possible of another token - /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata - /// @return amountOut The amount of the received token - function exactInputSingle( - ExactInputSingleParams calldata params - ) external payable returns (uint256 amountOut); - - struct ExactInputParams { - bytes path; - address recipient; - uint256 deadline; - uint256 amountIn; - uint256 amountOutMinimum; - } + /// @notice Swaps `amountIn` of one token for as much as possible of another token + /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata + /// @return amountOut The amount of the received token + function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut); + + struct ExactInputParams { + bytes path; + address recipient; + uint256 deadline; + uint256 amountIn; + uint256 amountOutMinimum; + } - /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path - /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata - /// @return amountOut The amount of the received token - function exactInput( - ExactInputParams calldata params - ) external payable returns (uint256 amountOut); - - struct ExactOutputSingleParams { - address tokenIn; - address tokenOut; - uint24 fee; - address recipient; - uint256 deadline; - uint256 amountOut; - uint256 amountInMaximum; - uint160 sqrtPriceLimitX96; - } + /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path + /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata + /// @return amountOut The amount of the received token + function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut); + + struct ExactOutputSingleParams { + address tokenIn; + address tokenOut; + uint24 fee; + address recipient; + uint256 deadline; + uint256 amountOut; + uint256 amountInMaximum; + uint160 sqrtPriceLimitX96; + } - /// @notice Swaps as little as possible of one token for `amountOut` of another token - /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata - /// @return amountIn The amount of the input token - function exactOutputSingle( - ExactOutputSingleParams calldata params - ) external payable returns (uint256 amountIn); - - struct ExactOutputParams { - bytes path; - address recipient; - uint256 deadline; - uint256 amountOut; - uint256 amountInMaximum; - } + /// @notice Swaps as little as possible of one token for `amountOut` of another token + /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata + /// @return amountIn The amount of the input token + function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn); + + struct ExactOutputParams { + bytes path; + address recipient; + uint256 deadline; + uint256 amountOut; + uint256 amountInMaximum; + } - /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed) - /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata - /// @return amountIn The amount of the input token - function exactOutput( - ExactOutputParams calldata params - ) external payable returns (uint256 amountIn); + /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed) + /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata + /// @return amountIn The amount of the input token + function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn); } + // File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.9.5 // Original license: SPDX_License_Identifier: MIT @@ -116,141 +109,139 @@ pragma solidity ^0.8.0; * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { - /** - * @dev Emitted when `value` tokens are moved from one account (`from`) to - * another (`to`). - * - * Note that `value` may be zero. - */ - event Transfer(address indexed from, address indexed to, uint256 value); - - /** - * @dev Emitted when the allowance of a `spender` for an `owner` is set by - * a call to {approve}. `value` is the new allowance. - */ - event Approval(address indexed owner, address indexed spender, uint256 value); - - /** - * @dev Returns the amount of tokens in existence. - */ - function totalSupply() external view returns (uint256); - - /** - * @dev Returns the amount of tokens owned by `account`. - */ - function balanceOf(address account) external view returns (uint256); - - /** - * @dev Moves `amount` tokens from the caller's account to `to`. - * - * Returns a boolean value indicating whether the operation succeeded. - * - * Emits a {Transfer} event. - */ - function transfer(address to, uint256 amount) external returns (bool); - - /** - * @dev Returns the remaining number of tokens that `spender` will be - * allowed to spend on behalf of `owner` through {transferFrom}. This is - * zero by default. - * - * This value changes when {approve} or {transferFrom} are called. - */ - function allowance( - address owner, - address spender - ) external view returns (uint256); - - /** - * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. - * - * Returns a boolean value indicating whether the operation succeeded. - * - * IMPORTANT: Beware that changing an allowance with this method brings the risk - * that someone may use both the old and the new allowance by unfortunate - * transaction ordering. One possible solution to mitigate this race - * condition is to first reduce the spender's allowance to 0 and set the - * desired value afterwards: - * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 - * - * Emits an {Approval} event. - */ - function approve(address spender, uint256 amount) external returns (bool); - - /** - * @dev Moves `amount` tokens from `from` to `to` using the - * allowance mechanism. `amount` is then deducted from the caller's - * allowance. - * - * Returns a boolean value indicating whether the operation succeeded. - * - * Emits a {Transfer} event. - */ - function transferFrom( - address from, - address to, - uint256 amount - ) external returns (bool); + /** + * @dev Emitted when `value` tokens are moved from one account (`from`) to + * another (`to`). + * + * Note that `value` may be zero. + */ + event Transfer(address indexed from, address indexed to, uint256 value); + + /** + * @dev Emitted when the allowance of a `spender` for an `owner` is set by + * a call to {approve}. `value` is the new allowance. + */ + event Approval(address indexed owner, address indexed spender, uint256 value); + + /** + * @dev Returns the amount of tokens in existence. + */ + function totalSupply() external view returns (uint256); + + /** + * @dev Returns the amount of tokens owned by `account`. + */ + function balanceOf(address account) external view returns (uint256); + + /** + * @dev Moves `amount` tokens from the caller's account to `to`. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * Emits a {Transfer} event. + */ + function transfer(address to, uint256 amount) external returns (bool); + + /** + * @dev Returns the remaining number of tokens that `spender` will be + * allowed to spend on behalf of `owner` through {transferFrom}. This is + * zero by default. + * + * This value changes when {approve} or {transferFrom} are called. + */ + function allowance(address owner, address spender) external view returns (uint256); + + /** + * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * IMPORTANT: Beware that changing an allowance with this method brings the risk + * that someone may use both the old and the new allowance by unfortunate + * transaction ordering. One possible solution to mitigate this race + * condition is to first reduce the spender's allowance to 0 and set the + * desired value afterwards: + * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + * + * Emits an {Approval} event. + */ + function approve(address spender, uint256 amount) external returns (bool); + + /** + * @dev Moves `amount` tokens from `from` to `to` using the + * allowance mechanism. `amount` is then deducted from the caller's + * allowance. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * Emits a {Transfer} event. + */ + function transferFrom(address from, address to, uint256 amount) external returns (bool); } + // File @uniswap/v3-periphery/contracts/libraries/TransferHelper.sol@v1.4.4 // Original license: SPDX_License_Identifier: GPL-2.0-or-later pragma solidity >=0.6.0; library TransferHelper { - /// @notice Transfers tokens from the targeted address to the given destination - /// @notice Errors with 'STF' if transfer fails - /// @param token The contract address of the token to be transferred - /// @param from The originating address from which the tokens will be transferred - /// @param to The destination address of the transfer - /// @param value The amount to be transferred - function safeTransferFrom( - address token, - address from, - address to, - uint256 value - ) internal { - (bool success, bytes memory data) = token.call( - abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value) - ); - require(success && (data.length == 0 || abi.decode(data, (bool))), "STF"); - } + /// @notice Transfers tokens from the targeted address to the given destination + /// @notice Errors with 'STF' if transfer fails + /// @param token The contract address of the token to be transferred + /// @param from The originating address from which the tokens will be transferred + /// @param to The destination address of the transfer + /// @param value The amount to be transferred + function safeTransferFrom( + address token, + address from, + address to, + uint256 value + ) internal { + (bool success, bytes memory data) = + token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value)); + require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF'); + } - /// @notice Transfers tokens from msg.sender to a recipient - /// @dev Errors with ST if transfer fails - /// @param token The contract address of the token which will be transferred - /// @param to The recipient of the transfer - /// @param value The value of the transfer - function safeTransfer(address token, address to, uint256 value) internal { - (bool success, bytes memory data) = token.call( - abi.encodeWithSelector(IERC20.transfer.selector, to, value) - ); - require(success && (data.length == 0 || abi.decode(data, (bool))), "ST"); - } + /// @notice Transfers tokens from msg.sender to a recipient + /// @dev Errors with ST if transfer fails + /// @param token The contract address of the token which will be transferred + /// @param to The recipient of the transfer + /// @param value The value of the transfer + function safeTransfer( + address token, + address to, + uint256 value + ) internal { + (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value)); + require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST'); + } - /// @notice Approves the stipulated contract to spend the given allowance in the given token - /// @dev Errors with 'SA' if transfer fails - /// @param token The contract address of the token to be approved - /// @param to The target of the approval - /// @param value The amount of the given token the target will be allowed to spend - function safeApprove(address token, address to, uint256 value) internal { - (bool success, bytes memory data) = token.call( - abi.encodeWithSelector(IERC20.approve.selector, to, value) - ); - require(success && (data.length == 0 || abi.decode(data, (bool))), "SA"); - } + /// @notice Approves the stipulated contract to spend the given allowance in the given token + /// @dev Errors with 'SA' if transfer fails + /// @param token The contract address of the token to be approved + /// @param to The target of the approval + /// @param value The amount of the given token the target will be allowed to spend + function safeApprove( + address token, + address to, + uint256 value + ) internal { + (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value)); + require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA'); + } - /// @notice Transfers ETH to the recipient address - /// @dev Fails with `STE` - /// @param to The destination of the transfer - /// @param value The value to be transferred - function safeTransferETH(address to, uint256 value) internal { - (bool success, ) = to.call{value: value}(new bytes(0)); - require(success, "STE"); - } + /// @notice Transfers ETH to the recipient address + /// @dev Fails with `STE` + /// @param to The destination of the transfer + /// @param value The value to be transferred + function safeTransferETH(address to, uint256 value) internal { + (bool success, ) = to.call{value: value}(new bytes(0)); + require(success, 'STE'); + } } + // File contracts/interfaces/IMintableERC20.sol // Original license: SPDX_License_Identifier: MIT @@ -270,6 +261,7 @@ interface IMintableERC20 { function decimals() external view returns (uint8); } + // File contracts/interfaces/IPermit2.sol // Original license: SPDX_License_Identifier: MIT @@ -284,11 +276,11 @@ interface IPermit2 { ) external; } + // File contracts/interfaces/IPublicLock.sol // Original license: SPDX_License_Identifier: MIT pragma solidity >=0.5.17 <0.9.0; - // Original pragma directive: pragma experimental ABIEncoderV2 /** @@ -749,17 +741,24 @@ interface IPublicLock { * - `from`, `to` cannot be zero. * - `tokenId` must be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this - * NFT by either {approve} or {setApprovalForAll}. + * NFT by either `approve` or `setApprovalForAll`. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; + function safeTransferFrom( + address from, + address to, + uint256 tokenId, + bytes calldata data + ) external; + /** * an ERC721-like function to transfer a token from one account to another. * @param from the owner of token to transfer * @param to the address that will receive the token * @param tokenId the id of the token * @dev Requirements: if the caller is not `from`, it must be approved to move this token by - * either {approve} or {setApprovalForAll}. + * either `approve` or `setApprovalForAll`. * The key manager will be reset to address zero after the transfer */ function transferFrom(address from, address to, uint256 tokenId) external; @@ -816,13 +815,6 @@ interface IPublicLock { address _operator ) external view returns (bool); - function safeTransferFrom( - address from, - address to, - uint256 tokenId, - bytes calldata data - ) external; - /** * Returns the total number of keys, including non-valid ones * @return _totalKeysCreated the total number of keys, valid or not @@ -917,6 +909,7 @@ interface IPublicLock { ) external view returns (bool); } + // File contracts/interfaces/IUnlock.sol // Original license: SPDX_License_Identifier: MIT @@ -1258,78 +1251,1664 @@ interface IUnlock { function swapBurnerAddress() external view returns (address); } -// File contracts/utils/UnlockSwapPurchaser.sol + +// File hardhat/console.sol@v2.20.1 // Original license: SPDX_License_Identifier: MIT -pragma solidity ^0.8.0; +pragma solidity >=0.4.22 <0.9.0; + +library console { + address constant CONSOLE_ADDRESS = + 0x000000000000000000636F6e736F6c652e6c6f67; + + function _sendLogPayloadImplementation(bytes memory payload) internal view { + address consoleAddress = CONSOLE_ADDRESS; + /// @solidity memory-safe-assembly + assembly { + pop( + staticcall( + gas(), + consoleAddress, + add(payload, 32), + mload(payload), + 0, + 0 + ) + ) + } + } -library SafeCast160 { - error UnsafeCast(); + function _castToPure( + function(bytes memory) internal view fnIn + ) internal pure returns (function(bytes memory) pure fnOut) { + assembly { + fnOut := fnIn + } + } - /// @notice Safely casts uint256 to uint160 - /// @param value The uint256 to be cast - function toUint160(uint256 value) internal pure returns (uint160) { - if (value > type(uint160).max) revert UnsafeCast(); - return uint160(value); - } -} + function _sendLogPayload(bytes memory payload) internal pure { + _castToPure(_sendLogPayloadImplementation)(payload); + } -contract UnlockSwapPurchaser { - // make sure we dont exceed type uint160 when casting - using SafeCast160 for uint256; + function log() internal pure { + _sendLogPayload(abi.encodeWithSignature("log()")); + } + function logInt(int256 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(int256)", p0)); + } - // Unlock address on current chain - address public unlockAddress; + function logUint(uint256 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0)); + } - // required by Uniswap Universal Router - address public permit2; + function logString(string memory p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } - mapping(address => bool) uniswapRouters; + function logBool(bool p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); + } - // events - event SwapCall(address lock, address tokenAddress, uint amountSpent); + function logAddress(address p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); + } - // errors - error SwapFailed( - address uniswapRouter, - address tokenIn, - address tokenOut, - uint amountInMax, - bytes callData - ); - error LockDoesntExist(address lockAddress); - error InsufficientBalance(); - error UnauthorizedBalanceChange(); - error LockCallFailed(); - error WithdrawFailed(); - error UnautorizedRouter(address routerAddress); + function logBytes(bytes memory p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0)); + } - /** - * Set the address of Uniswap Permit2 helper contract - * @param _unlockAddress the address of Unlock contract - * @param _permit2Address the address of Uniswap PERMIT2 contract - */ - constructor( - address _unlockAddress, - address _permit2Address, - address[] memory _uniswapRouters - ) { - unlockAddress = _unlockAddress; - permit2 = _permit2Address; - for (uint i = 0; i < _uniswapRouters.length; i++) { - uniswapRouters[_uniswapRouters[i]] = true; + function logBytes1(bytes1 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0)); } - } - /** - * Simple helper to retrieve balance in ERC20 or native tokens - * @param token the address of the token (address(0) for native token) - */ - function getBalance(address token) internal view returns (uint) { - return - token == address(0) - ? address(this).balance - : IMintableERC20(token).balanceOf(address(this)); + function logBytes2(bytes2 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0)); + } + + function logBytes3(bytes3 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0)); + } + + function logBytes4(bytes4 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0)); + } + + function logBytes5(bytes5 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0)); + } + + function logBytes6(bytes6 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0)); + } + + function logBytes7(bytes7 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0)); + } + + function logBytes8(bytes8 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0)); + } + + function logBytes9(bytes9 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0)); + } + + function logBytes10(bytes10 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0)); + } + + function logBytes11(bytes11 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0)); + } + + function logBytes12(bytes12 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0)); + } + + function logBytes13(bytes13 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0)); + } + + function logBytes14(bytes14 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0)); + } + + function logBytes15(bytes15 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0)); + } + + function logBytes16(bytes16 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0)); + } + + function logBytes17(bytes17 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0)); + } + + function logBytes18(bytes18 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0)); + } + + function logBytes19(bytes19 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0)); + } + + function logBytes20(bytes20 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0)); + } + + function logBytes21(bytes21 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0)); + } + + function logBytes22(bytes22 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0)); + } + + function logBytes23(bytes23 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0)); + } + + function logBytes24(bytes24 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0)); + } + + function logBytes25(bytes25 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0)); + } + + function logBytes26(bytes26 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0)); + } + + function logBytes27(bytes27 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0)); + } + + function logBytes28(bytes28 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0)); + } + + function logBytes29(bytes29 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0)); + } + + function logBytes30(bytes30 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0)); + } + + function logBytes31(bytes31 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0)); + } + + function logBytes32(bytes32 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0)); + } + + function log(uint256 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0)); + } + + function log(string memory p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } + + function log(bool p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); + } + + function log(address p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); + } + + function log(uint256 p0, uint256 p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1)); + } + + function log(uint256 p0, string memory p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1)); + } + + function log(uint256 p0, bool p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1)); + } + + function log(uint256 p0, address p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1)); + } + + function log(string memory p0, uint256 p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1)); + } + + function log(string memory p0, string memory p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1)); + } + + function log(string memory p0, bool p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1)); + } + + function log(string memory p0, address p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1)); + } + + function log(bool p0, uint256 p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1)); + } + + function log(bool p0, string memory p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1)); + } + + function log(bool p0, bool p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1)); + } + + function log(bool p0, address p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1)); + } + + function log(address p0, uint256 p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1)); + } + + function log(address p0, string memory p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1)); + } + + function log(address p0, bool p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1)); + } + + function log(address p0, address p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1)); + } + + function log(uint256 p0, uint256 p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2)); + } + + function log(string memory p0, address p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2)); + } + + function log(string memory p0, address p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2)); + } + + function log(string memory p0, address p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2)); + } + + function log(string memory p0, address p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2)); + } + + function log(bool p0, bool p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2)); + } + + function log(bool p0, bool p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2)); + } + + function log(bool p0, bool p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2)); + } + + function log(bool p0, bool p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2)); + } + + function log(bool p0, address p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2)); + } + + function log(bool p0, address p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2)); + } + + function log(bool p0, address p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2)); + } + + function log(bool p0, address p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2)); + } + + function log(address p0, string memory p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2)); + } + + function log(address p0, string memory p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2)); + } + + function log(address p0, string memory p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2)); + } + + function log(address p0, string memory p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2)); + } + + function log(address p0, bool p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2)); + } + + function log(address p0, bool p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2)); + } + + function log(address p0, bool p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2)); + } + + function log(address p0, bool p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2)); + } + + function log(address p0, address p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2)); + } + + function log(address p0, address p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2)); + } + + function log(address p0, address p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2)); + } + + function log(address p0, address p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3)); + } + +} + + +// File contracts/utils/UnlockSwapPurchaser.sol + +// Original license: SPDX_License_Identifier: MIT +pragma solidity ^0.8.0; + + + + + + + +library SafeCast160 { + error UnsafeCast(); + + /// @notice Safely casts uint256 to uint160 + /// @param value The uint256 to be cast + function toUint160(uint256 value) internal pure returns (uint160) { + if (value > type(uint160).max) revert UnsafeCast(); + return uint160(value); + } +} + +contract UnlockSwapPurchaser { + // make sure we dont exceed type uint160 when casting + using SafeCast160 for uint256; + + // Unlock address on current chain + address public unlockAddress; + + // required by Uniswap Universal Router + address public permit2; + + mapping(address => bool) uniswapRouters; + + // events + event SwapCall(address lock, address tokenAddress, uint amountSpent); + + // errors + error SwapFailed( + address uniswapRouter, + address tokenIn, + address tokenOut, + uint amountInMax, + bytes callData + ); + error LockDoesntExist(address lockAddress); + error InsufficientBalance(); + error UnauthorizedBalanceChange(); + error LockCallFailed(); + error WithdrawFailed(); + error UnautorizedRouter(address routerAddress); + + /** + * Set the address of Uniswap Permit2 helper contract + * @param _unlockAddress the address of Unlock contract + * @param _permit2Address the address of Uniswap PERMIT2 contract + */ + constructor( + address _unlockAddress, + address _permit2Address, + address[] memory _uniswapRouters + ) { + unlockAddress = _unlockAddress; + permit2 = _permit2Address; + for (uint i = 0; i < _uniswapRouters.length; i++) { + uniswapRouters[_uniswapRouters[i]] = true; + } + } + + /** + * Simple helper to retrieve balance in ERC20 or native tokens + * @param token the address of the token (address(0) for native token) + */ + function getBalance(address token) internal view returns (uint) { + return + token == address(0) + ? address(this).balance + : IMintableERC20(token).balanceOf(address(this)); + } + + function getKeyPrice( + address lock, + bytes memory callData + ) public view returns (uint keyPrice) { + ( + , + uint[] memory keyPrices, + address[] memory recipients, + address[] memory referrers, + address[] memory keyManagers, + bytes[] memory purchaseData + ) = abi.decode( + callData, + (bytes4, uint[], address[], address[], address[], bytes[]) + ); + + keyPrice = IPublicLock(lock).purchasePriceFor( + recipients[0], + referrers[0], + purchaseData[0] + ); } /** @@ -1428,19 +3007,19 @@ contract UnlockSwapPurchaser { destToken == address(0) ? getBalance(destToken) - msg.value : getBalance(destToken) - ) < balanceTokenDestBefore + IPublicLock(lock).keyPrice() + ) < balanceTokenDestBefore + getKeyPrice(lock, callData) ) { revert InsufficientBalance(); } // approve ERC20 to call the lock if (destToken != address(0)) { - IMintableERC20(destToken).approve(lock, IPublicLock(lock).keyPrice()); + IMintableERC20(destToken).approve(lock, getKeyPrice(lock, callData)); } // call the lock (bool lockCallSuccess, bytes memory returnData) = lock.call{ - value: destToken == address(0) ? IPublicLock(lock).keyPrice() : 0 + value: destToken == address(0) ? getKeyPrice(lock, callData) : 0 }(callData); if (lockCallSuccess == false) { diff --git a/packages/contracts/src/index.ts b/packages/contracts/src/index.ts index 078391ede36..a3029bae3c6 100644 --- a/packages/contracts/src/index.ts +++ b/packages/contracts/src/index.ts @@ -77,9 +77,4 @@ export { UnlockDiscountTokenV2 } export { UnlockDiscountTokenV3 } export { GovernorUnlockProtocol } export { GovernorUnlockProtocolTimelock } -export { - LockSerializer, - UnlockSwapPurchaser, - UnlockSwapBurner, - UniswapOracleV3, -} +export { LockSerializer,UnlockSwapPurchaser,UnlockSwapBurner,UniswapOracleV3 } diff --git a/packages/networks/src/networks/sepolia.ts b/packages/networks/src/networks/sepolia.ts index 9b8c46f9290..7b09dfbcd53 100644 --- a/packages/networks/src/networks/sepolia.ts +++ b/packages/networks/src/networks/sepolia.ts @@ -84,6 +84,7 @@ export const sepolia: NetworkConfig = { networkName: 'sepolia', studioName: 'unlock-protocol-sepolia', }, + swapPurchaser: '0x580A4a5a9612371e3832c4559026B9Ee3b23Cc11', tokens: [ { address: '0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9', diff --git a/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js b/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js index b9260148874..51e9c0de5dc 100644 --- a/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js +++ b/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js @@ -189,24 +189,28 @@ describe('UnlockSwapPurchaser / purchase with promo code', () => { const calldata = await lock.interface.encodeFunctionData('purchase', args) console.log(calldata) - const { swapCalldata, value, swapRouter, amountInMax } = - await getUniswapRoute({ - tokenIn: native, - tokenOut: usdc, - amoutOut: price, - recipient: swapPurchaser.address, - chainId: 1, - }) + // const { swapCalldata, value, swapRouter, amountInMax } = + // await getUniswapRoute({ + // tokenIn: native, + // tokenOut: usdc, + // amoutOut: price, + // recipient: swapPurchaser.address, + // chainId: 1, + // }) // do the swap and call! + const { + uniswapV3: { universalRouterAddress }, + } = await getNetwork(1) + await swapPurchaser.connect(keyOwner).swapAndCall( lock.address, tokenAddress, - amountInMax, // value in src token - swapRouter, - swapCalldata, + 10000000, //amountInMax, // value in src token + universalRouterAddress, // swapRouter, + 0, // swapCalldata, calldata, - { value } + { value: 100000000 } ) assert.equal((await lock.balanceOf(keyOwner.address)).toNumber(), 1) }) diff --git a/unlock-app/src/hooks/useUniswapRoutes.ts b/unlock-app/src/hooks/useUniswapRoutes.ts index a91cbc48734..dd19361893c 100644 --- a/unlock-app/src/hooks/useUniswapRoutes.ts +++ b/unlock-app/src/hooks/useUniswapRoutes.ts @@ -41,6 +41,7 @@ export const useUniswapRoutes = ({ ['uniswapRoutes', account, lock, recipients, purchaseData], async () => { const networkConfig = networks[lock.network] + console.log(networkConfig) if (!networkConfig || !networkConfig.swapPurchaser) { return [] } @@ -126,40 +127,42 @@ export const useUniswapRoutes = ({ route.tokenIn!.address.toLowerCase() ) }) + console.log(routesToLookup) const result = await Promise.all( routesToLookup.map(async (route: UniswapRoute) => { - try { - const params = { - network: route.network, - tokenIn: route.tokenIn, - tokenOut: route.tokenOut, - amountOut: route.amountOut, - recipient: route.recipient, - } - const response: UnlockUniswapRoute = - await web3Service.getUniswapRoute({ - params, - }) + // try { + const params = { + network: route.network, + tokenIn: route.tokenIn, + tokenOut: route.tokenOut, + amountOut: route.amountOut, + recipient: route.recipient, + } + const response: UnlockUniswapRoute = + await web3Service.getUniswapRoute({ + params, + }) - const balance = await getAccountTokenBalance( - web3Service, - account!, - route.tokenIn instanceof Token ? route.tokenIn.address : null, - route.network + console.log(response) + const balance = await getAccountTokenBalance( + web3Service, + account!, + route.tokenIn instanceof Token ? route.tokenIn.address : null, + route.network + ) + // If the balance is less than the quote, we cannot make the swap. + if (Number(balance) < Number(response.quote.toFixed())) { + console.log( + `Insufficient balance of ${response.quote.currency.symbol}` ) - // If the balance is less than the quote, we cannot make the swap. - if (Number(balance) < Number(response.quote.toFixed())) { - console.log( - `Insufficient balance of ${response.quote.currency.symbol}` - ) - return null - } - return response - } catch (error) { - console.error(error) return null } + return response + // } catch (error) { + // console.error(error) + // return null + // } }) ) return result.filter((item) => !!item) From 07f21f1468fba9b4035c1a23fea5502ace21beb1 Mon Sep 17 00:00:00 2001 From: Julien Genestoux Date: Tue, 12 Mar 2024 22:02:52 -0400 Subject: [PATCH 11/11] more wip --- packages/hardhat-helpers/package.json | 5 +- packages/hardhat-helpers/src/uniswap.js | 9 +- .../contracts/utils/UnlockSwapPurchaser.sol | 13 +- .../usePurchaseHook.mainnet.js | 59 +++++--- yarn.lock | 139 +++++++++++++++++- 5 files changed, 190 insertions(+), 35 deletions(-) diff --git a/packages/hardhat-helpers/package.json b/packages/hardhat-helpers/package.json index d94c08b20ed..201e209f0df 100644 --- a/packages/hardhat-helpers/package.json +++ b/packages/hardhat-helpers/package.json @@ -20,9 +20,8 @@ "@nomiclabs/hardhat-ethers": "2.2.3", "@nomiclabs/hardhat-waffle": "2.0.6", "@uniswap/permit2-sdk": "1.2.0", - "@uniswap/sdk-core": "4.0.9", - "@uniswap/smart-order-router": "3.17.2", - "@uniswap/v3-sdk": "3.10.2", + "@uniswap/sdk-core": "4.2.0", + "@uniswap/smart-order-router": "3.25.0", "@unlock-protocol/contracts": "workspace:^", "@unlock-protocol/networks": "workspace:^", "@unlock-protocol/tsconfig": "workspace:^", diff --git a/packages/hardhat-helpers/src/uniswap.js b/packages/hardhat-helpers/src/uniswap.js index cb137933ae0..4b96424516c 100644 --- a/packages/hardhat-helpers/src/uniswap.js +++ b/packages/hardhat-helpers/src/uniswap.js @@ -27,11 +27,11 @@ const PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3' // convert swap jsbi to ethers BigNumber const currencyAmountToBigNumber = (amount) => { const { decimals } = amount.currency - const fixed = ethers.FixedNumber.from(amount.toExact()) - const tokenScale = ethers.FixedNumber.from( - ethers.BigNumber.from(10).pow(decimals) + const fixed = ethersv5.FixedNumber.from(amount.toExact()) + const tokenScale = ethersv5.FixedNumber.from( + ethersv5.BigNumber.from(10).pow(decimals) ) - return ethers.BigNumber.from( + return ethersv5.BigNumber.from( // have to remove trailing .0 "manually" :/ fixed.mulUnsafe(tokenScale).floor().toString().split('.')[0] ) @@ -55,7 +55,6 @@ async function getUniswapRoute({ const provider = new ethersv5.providers.JsonRpcProvider( `https://rpc.unlock-protocol.com/${chainId}` ) - console.log(provider) const router = new AlphaRouter({ chainId, provider, diff --git a/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol b/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol index 5a9b8596848..3dd3d60e23a 100644 --- a/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol +++ b/smart-contracts/contracts/utils/UnlockSwapPurchaser.sol @@ -129,14 +129,17 @@ contract UnlockSwapPurchaser { ) public payable returns (bytes memory) { // check if lock exists (bool lockExists, , ) = IUnlock(unlockAddress).locks(lock); + console.log("IN THE SWAP AND CALL FUNCTION"); if (!lockExists) { revert LockDoesntExist(lock); } + console.log("LOCK EXISTS"); // make sure if (uniswapRouters[uniswapRouter] != true) { revert UnautorizedRouter(uniswapRouter); } + console.log("ROUTER OK"); // get lock pricing address destToken = IPublicLock(lock).tokenAddress(); @@ -151,21 +154,29 @@ contract UnlockSwapPurchaser { ? getBalance(srcToken) - msg.value : getBalance(srcToken); + console.log("CHECKING TOKEN"); if (srcToken != address(0)) { // Transfer the specified amount of src ERC20 to this contract + console.log("TRANSFERING TOKENS"); + console.log(srcToken); + console.log(msg.sender); + console.log(address(this)); + console.log(amountInMax); TransferHelper.safeTransferFrom( srcToken, msg.sender, address(this), amountInMax ); + console.log("TOKENS TRANSFERED"); // Approve the router to spend src ERC20 TransferHelper.safeApprove(srcToken, uniswapRouter, amountInMax); - + console.log("TOKENS APPROVDED"); // approve PERMIT2 to manipulate the token IERC20(srcToken).approve(permit2, amountInMax); } + console.log("SO FAR SO GOOD"); // issue PERMIT2 Allowance IPermit2(permit2).approve( diff --git a/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js b/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js index 51e9c0de5dc..ad1e35105a9 100644 --- a/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js +++ b/smart-contracts/test/UnlockSwapPurchaser/usePurchaseHook.mainnet.js @@ -53,7 +53,11 @@ describe('UnlockSwapPurchaser / purchase with promo code', () => { unlock = await getUnlock(unlockAddress) - const routers = [universalRouterAddress] + const routers = [ + universalRouterAddress, + '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD', + ] + swapPurchaser = await UnlockSwapPurchaser.deploy( unlock.address, PERMIT2_ADDRESS, @@ -187,30 +191,49 @@ describe('UnlockSwapPurchaser / purchase with promo code', () => { // parse call data const calldata = await lock.interface.encodeFunctionData('purchase', args) - console.log(calldata) - // const { swapCalldata, value, swapRouter, amountInMax } = - // await getUniswapRoute({ - // tokenIn: native, - // tokenOut: usdc, - // amoutOut: price, - // recipient: swapPurchaser.address, - // chainId: 1, - // }) + const { swapCalldata, value, swapRouter, amountInMax } = + await getUniswapRoute({ + tokenIn: native, + tokenOut: usdc, + amoutOut: price, + recipient: swapPurchaser.address, + chainId: 1, + }) - // do the swap and call! - const { - uniswapV3: { universalRouterAddress }, - } = await getNetwork(1) + const token = await lock.tokenAddress() + const tokenContract = await addERC20(token, keyOwner.address, price) + console.log('APPROVAL') + console.log(`- contract: ${tokenContract.address}`) + console.log(`- approver: ${keyOwner.address}`) + console.log(`- approved: ${swapPurchaser.address}`) + console.log(`- amount : ${MAX_UINT}`) + await tokenContract + .connect(keyOwner) + .approve(swapPurchaser.address, MAX_UINT) + console.log('APPROVAL DONE') + + console.log(await tokenContract.balanceOf(keyOwner.address)) + console.log( + await tokenContract.allowance(keyOwner.address, swapPurchaser.address) + ) + // WHY DOES THIS FAIL? + await tokenContract + .connect(keyOwner) + .transferFrom(keyOwner.address, swapPurchaser.address, 1) + + console.log('TRANSFERED') + + // do the swap and call! await swapPurchaser.connect(keyOwner).swapAndCall( lock.address, tokenAddress, - 10000000, //amountInMax, // value in src token - universalRouterAddress, // swapRouter, - 0, // swapCalldata, + amountInMax, // value in src token + swapRouter, + swapCalldata, calldata, - { value: 100000000 } + { value } ) assert.equal((await lock.balanceOf(keyOwner.address)).toNumber(), 1) }) diff --git a/yarn.lock b/yarn.lock index 736079a7cf7..8069fc948e0 100644 --- a/yarn.lock +++ b/yarn.lock @@ -17916,6 +17916,15 @@ __metadata: languageName: node linkType: hard +"@types/brotli@npm:^1.3.4": + version: 1.3.4 + resolution: "@types/brotli@npm:1.3.4" + dependencies: + "@types/node": "npm:*" + checksum: 10/4ff49c2cefb40d6e745e5b4e110c12587fc8f25a6c71220b10f60406ff9905dbf21d796180d1bfbdb266d98b73d8947a734597560c56b9d70432963d7301ffa5 + languageName: node + linkType: hard + "@types/cacheable-request@npm:^6.0.1, @types/cacheable-request@npm:^6.0.2": version: 6.0.3 resolution: "@types/cacheable-request@npm:6.0.3" @@ -19481,7 +19490,7 @@ __metadata: languageName: node linkType: hard -"@uniswap/default-token-list@npm:^11.2.0": +"@uniswap/default-token-list@npm:^11.13.0, @uniswap/default-token-list@npm:^11.2.0": version: 11.15.0 resolution: "@uniswap/default-token-list@npm:11.15.0" checksum: 10/87fdd00fc28940c1dfbad85dbf9836e29fd4460e787af59cfb16782dd15ac2e8d3f5e3b75c0fb1334772c5291505321b59c14c250f6fb7b95f571fc19b145a0b @@ -19525,6 +19534,19 @@ __metadata: languageName: node linkType: hard +"@uniswap/router-sdk@npm:^1.9.0": + version: 1.9.0 + resolution: "@uniswap/router-sdk@npm:1.9.0" + dependencies: + "@ethersproject/abi": "npm:^5.5.0" + "@uniswap/sdk-core": "npm:^4.2.0" + "@uniswap/swap-router-contracts": "npm:^1.1.0" + "@uniswap/v2-sdk": "npm:^4.3.0" + "@uniswap/v3-sdk": "npm:^3.11.0" + checksum: 10/45af379ce7c1fb5fb43c7b6e57a664ea7bb4eeebfa09c73a3fe50cfc31abdfe1453a89bb955d08972cd8a2767d5cdcdc113143a3a5aa6115c95f228177e82569 + languageName: node + linkType: hard + "@uniswap/sdk-core@npm:4.0.9": version: 4.0.9 resolution: "@uniswap/sdk-core@npm:4.0.9" @@ -19539,6 +19561,20 @@ __metadata: languageName: node linkType: hard +"@uniswap/sdk-core@npm:4.2.0, @uniswap/sdk-core@npm:^4.2.0": + version: 4.2.0 + resolution: "@uniswap/sdk-core@npm:4.2.0" + dependencies: + "@ethersproject/address": "npm:^5.0.2" + big.js: "npm:^5.2.2" + decimal.js-light: "npm:^2.5.0" + jsbi: "npm:^3.1.4" + tiny-invariant: "npm:^1.1.0" + toformat: "npm:^2.0.0" + checksum: 10/8a0d2dc1ddf6f96413be7f3cd707f815eaa6861625b3befa4af9818508c3066933455754a90022498770a4321e6642420d1ab3f9bba1ed9ef2f35e1cc71d3621 + languageName: node + linkType: hard + "@uniswap/sdk-core@npm:^4.0.7, @uniswap/sdk-core@npm:^4.1.3": version: 4.1.4 resolution: "@uniswap/sdk-core@npm:4.1.4" @@ -19585,7 +19621,41 @@ __metadata: languageName: node linkType: hard -"@uniswap/swap-router-contracts@npm:^1.1.0, @uniswap/swap-router-contracts@npm:^1.2.1, @uniswap/swap-router-contracts@npm:^1.3.0": +"@uniswap/smart-order-router@npm:3.25.0": + version: 3.25.0 + resolution: "@uniswap/smart-order-router@npm:3.25.0" + dependencies: + "@types/brotli": "npm:^1.3.4" + "@uniswap/default-token-list": "npm:^11.13.0" + "@uniswap/permit2-sdk": "npm:^1.2.0" + "@uniswap/router-sdk": "npm:^1.9.0" + "@uniswap/sdk-core": "npm:^4.2.0" + "@uniswap/swap-router-contracts": "npm:^1.3.1" + "@uniswap/token-lists": "npm:^1.0.0-beta.31" + "@uniswap/universal-router": "npm:^1.6.0" + "@uniswap/universal-router-sdk": "npm:^1.8.1" + "@uniswap/v2-sdk": "npm:^4.3.0" + "@uniswap/v3-sdk": "npm:^3.11.0" + async-retry: "npm:^1.3.1" + await-timeout: "npm:^1.1.1" + axios: "npm:^0.21.1" + brotli: "npm:^1.3.3" + bunyan: "npm:^1.8.15" + bunyan-blackhole: "npm:^1.1.1" + ethers: "npm:^5.7.2" + graphql: "npm:^15.5.0" + graphql-request: "npm:^3.4.0" + lodash: "npm:^4.17.21" + mnemonist: "npm:^0.38.3" + node-cache: "npm:^5.1.2" + stats-lite: "npm:^2.2.0" + peerDependencies: + jsbi: ^3.2.0 + checksum: 10/46e10b0667d93ca8d9382fa74cc516d340872be04f2000f79606b800e8367ca124858e89dd791e6d78f8701ea96e22e8d8dd59fb81b8f40ab7b752fc067e4782 + languageName: node + linkType: hard + +"@uniswap/swap-router-contracts@npm:^1.1.0, @uniswap/swap-router-contracts@npm:^1.2.1, @uniswap/swap-router-contracts@npm:^1.3.0, @uniswap/swap-router-contracts@npm:^1.3.1": version: 1.3.1 resolution: "@uniswap/swap-router-contracts@npm:1.3.1" dependencies: @@ -19622,7 +19692,23 @@ __metadata: languageName: node linkType: hard -"@uniswap/universal-router@npm:1.6.0": +"@uniswap/universal-router-sdk@npm:^1.8.1": + version: 1.8.1 + resolution: "@uniswap/universal-router-sdk@npm:1.8.1" + dependencies: + "@uniswap/permit2-sdk": "npm:^1.2.0" + "@uniswap/router-sdk": "npm:^1.9.0" + "@uniswap/sdk-core": "npm:^4.2.0" + "@uniswap/universal-router": "npm:1.6.0" + "@uniswap/v2-sdk": "npm:^4.2.0" + "@uniswap/v3-sdk": "npm:^3.11.0" + bignumber.js: "npm:^9.0.2" + ethers: "npm:^5.3.1" + checksum: 10/8ebacfe8230d592d07228f28f2974d242707d8324dc3f0170c0564c7ee55297fd20925d0a3a2fe6e861a8bea7f26b20e78e85c9a4874b9da5ccb5dc56f3816c0 + languageName: node + linkType: hard + +"@uniswap/universal-router@npm:1.6.0, @uniswap/universal-router@npm:^1.6.0": version: 1.6.0 resolution: "@uniswap/universal-router@npm:1.6.0" dependencies: @@ -19694,6 +19780,19 @@ __metadata: languageName: node linkType: hard +"@uniswap/v2-sdk@npm:^4.2.0, @uniswap/v2-sdk@npm:^4.3.0": + version: 4.3.0 + resolution: "@uniswap/v2-sdk@npm:4.3.0" + dependencies: + "@ethersproject/address": "npm:^5.0.0" + "@ethersproject/solidity": "npm:^5.0.0" + "@uniswap/sdk-core": "npm:^4.2.0" + tiny-invariant: "npm:^1.1.0" + tiny-warning: "npm:^1.0.3" + checksum: 10/8bdb246e5c253779104cd308a22a7f678456a5c90ec3a34738e8e471ff8da322ebed953827af13d1dda43559813e71297371e2941cb14ec2b0eae9fa571f4d86 + languageName: node + linkType: hard + "@uniswap/v3-core@npm:1.0.0": version: 1.0.0 resolution: "@uniswap/v3-core@npm:1.0.0" @@ -19721,7 +19820,7 @@ __metadata: languageName: node linkType: hard -"@uniswap/v3-sdk@npm:3.10.2, @uniswap/v3-sdk@npm:^3.10.0, @uniswap/v3-sdk@npm:^3.10.1": +"@uniswap/v3-sdk@npm:^3.10.0, @uniswap/v3-sdk@npm:^3.10.1": version: 3.10.2 resolution: "@uniswap/v3-sdk@npm:3.10.2" dependencies: @@ -19737,6 +19836,22 @@ __metadata: languageName: node linkType: hard +"@uniswap/v3-sdk@npm:^3.11.0": + version: 3.11.0 + resolution: "@uniswap/v3-sdk@npm:3.11.0" + dependencies: + "@ethersproject/abi": "npm:^5.0.12" + "@ethersproject/solidity": "npm:^5.0.9" + "@uniswap/sdk-core": "npm:^4.2.0" + "@uniswap/swap-router-contracts": "npm:^1.2.1" + "@uniswap/v3-periphery": "npm:^1.1.1" + "@uniswap/v3-staker": "npm:1.0.0" + tiny-invariant: "npm:^1.1.0" + tiny-warning: "npm:^1.0.3" + checksum: 10/6bd4738ffa25f8a6d6c77ea4d5928483c69c73789ab87b1b48c33377a4765b6fcd337a6ca09bd7f346c17191e49adc36e64fd604aaf15aed5d275ce232047300 + languageName: node + linkType: hard + "@uniswap/v3-staker@npm:1.0.0": version: 1.0.0 resolution: "@uniswap/v3-staker@npm:1.0.0" @@ -19907,9 +20022,8 @@ __metadata: "@nomiclabs/hardhat-ethers": "npm:2.2.3" "@nomiclabs/hardhat-waffle": "npm:2.0.6" "@uniswap/permit2-sdk": "npm:1.2.0" - "@uniswap/sdk-core": "npm:4.0.9" - "@uniswap/smart-order-router": "npm:3.17.2" - "@uniswap/v3-sdk": "npm:3.10.2" + "@uniswap/sdk-core": "npm:4.2.0" + "@uniswap/smart-order-router": "npm:3.25.0" "@unlock-protocol/contracts": "workspace:^" "@unlock-protocol/networks": "workspace:^" "@unlock-protocol/tsconfig": "workspace:^" @@ -23879,7 +23993,7 @@ __metadata: languageName: node linkType: hard -"base64-js@npm:^1.0.2, base64-js@npm:^1.3.1": +"base64-js@npm:^1.0.2, base64-js@npm:^1.1.2, base64-js@npm:^1.3.1": version: 1.5.1 resolution: "base64-js@npm:1.5.1" checksum: 10/669632eb3745404c2f822a18fc3a0122d2f9a7a13f7fb8b5823ee19d1d2ff9ee5b52c53367176ea4ad093c332fd5ab4bd0ebae5a8e27917a4105a4cfc86b1005 @@ -24393,6 +24507,15 @@ __metadata: languageName: node linkType: hard +"brotli@npm:^1.3.3": + version: 1.3.3 + resolution: "brotli@npm:1.3.3" + dependencies: + base64-js: "npm:^1.1.2" + checksum: 10/78b412f54be3c96b86e2d9805ddc26aa5a52bba45588ff7f8468b80aa84c90052c60eeb2e26ad032c39bab6baa58e0b0625cf4f738279961a31c34cbe4b4b490 + languageName: node + linkType: hard + "browser-assert@npm:^1.2.1": version: 1.2.1 resolution: "browser-assert@npm:1.2.1"