From 30695fc70a5ca5371ceab8f2de784b9c6cb76015 Mon Sep 17 00:00:00 2001 From: Big Boss Date: Sat, 27 Jul 2024 17:11:29 -0500 Subject: [PATCH] deploy sendtag checkout contract to base --- .../8453/run-latest.json | 91 +++ .../84532/run-latest.json | 66 +- .../script/DeploySendtagCheckout.s.sol | 9 +- packages/contracts/src/Helper.sol | 6 + packages/contracts/src/SendtagCheckout.sol | 571 +++++++++++++++++- packages/contracts/test/SendtagCheckout.t.sol | 10 +- packages/shovel/etc/config.json | 4 +- .../test/__snapshots__/index.test.ts.snap | 4 +- packages/wagmi/src/generated.ts | 154 +++-- packages/wagmi/wagmi.config.ts | 6 + tilt/infra.Tiltfile | 12 - 11 files changed, 817 insertions(+), 116 deletions(-) create mode 100644 packages/contracts/broadcast/DeploySendtagCheckout.s.sol/8453/run-latest.json diff --git a/packages/contracts/broadcast/DeploySendtagCheckout.s.sol/8453/run-latest.json b/packages/contracts/broadcast/DeploySendtagCheckout.s.sol/8453/run-latest.json new file mode 100644 index 000000000..d053064ec --- /dev/null +++ b/packages/contracts/broadcast/DeploySendtagCheckout.s.sol/8453/run-latest.json @@ -0,0 +1,91 @@ +{ + "transactions": [ + { + "hash": "0xbd6569b144865fa50834992078b1a35239b690e31b6826b23fd91df94b5b3fd5", + "transactionType": "CREATE2", + "contractName": "SendtagCheckout", + "contractAddress": "0x36f43082d01df4801af2d95aeed1a0200c5510ae", + "function": null, + "arguments": [ + "0x71fa02bb11e4b119bEDbeeD2f119F62048245301", + "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", + "0x436454a68BEF94901014E2AF90f86E7355a029F3" + ], + "transaction": { + "from": "0x436454a68bef94901014e2af90f86e7355a029f3", + "to": "0x4e59b44847b379578588920ca78fbf26c0b4956c", + "gas": "0xff033", + "value": "0x0", + "input": "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", + "nonce": "0x11", + "chainId": "0x2105" + }, + "additionalContracts": [], + "isFixedGasLimit": false + } + ], + "receipts": [ + { + "status": "0x1", + "cumulativeGasUsed": "0xf41160", + "logs": [ + { + "address": "0x36f43082d01df4801af2d95aeed1a0200c5510ae", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000436454a68bef94901014e2af90f86e7355a029f3" + ], + "data": "0x", + "blockHash": "0x57b3a71dee8e44cd8f3a4ea5deadc71b2e59070a84359b9d7953bbab21757ef2", + "blockNumber": "0x10d9874", + "transactionHash": "0xbd6569b144865fa50834992078b1a35239b690e31b6826b23fd91df94b5b3fd5", + "transactionIndex": "0x43", + "logIndex": "0xca", + "removed": false + }, + { + "address": "0x36f43082d01df4801af2d95aeed1a0200c5510ae", + "topics": [ + "0x1caf761158ed03726081542723d54a061f9d0ccb46171af1a220d059a66c7153" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000001", + "blockHash": "0x57b3a71dee8e44cd8f3a4ea5deadc71b2e59070a84359b9d7953bbab21757ef2", + "blockNumber": "0x10d9874", + "transactionHash": "0xbd6569b144865fa50834992078b1a35239b690e31b6826b23fd91df94b5b3fd5", + "transactionIndex": "0x43", + "logIndex": "0xcb", + "removed": false + } + ], + "logsBloom": "0x00000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200001000000000000000000000000000000000000020000000000400000000800000000000000000000000000000000400000000000000000080000000000000000000000000000000000000000000000000000000000000000004040000000000000000000000000000000000004000020000000000000000000000000000000000000000000000000000000000020000000000000000000000008000000000000000000000008000000000000000000", + "type": "0x2", + "transactionHash": "0xbd6569b144865fa50834992078b1a35239b690e31b6826b23fd91df94b5b3fd5", + "transactionIndex": "0x43", + "blockHash": "0x57b3a71dee8e44cd8f3a4ea5deadc71b2e59070a84359b9d7953bbab21757ef2", + "blockNumber": "0x10d9874", + "gasUsed": "0xae6c6", + "effectiveGasPrice": "0xc2057a", + "from": "0x436454a68bef94901014e2af90f86e7355a029f3", + "to": "0x4e59b44847b379578588920ca78fbf26c0b4956c", + "contractAddress": "0x36f43082d01df4801af2d95aeed1a0200c5510ae", + "l1BaseFeeScalar": "0x8dd", + "l1BlobBaseFee": "0x1", + "l1BlobBaseFeeScalar": "0x101c12", + "l1Fee": "0x3a2ea28df0", + "l1GasPrice": "0xdc9fada0", + "l1GasUsed": "0x7439" + } + ], + "libraries": [], + "pending": [], + "returns": { + "0": { + "internal_type": "contract SendtagCheckout", + "value": "0x36f43082d01df4801AF2D95aeEd1a0200C5510AE" + } + }, + "timestamp": 1722125793, + "chain": 8453, + "commit": "81011083" +} \ No newline at end of file diff --git a/packages/contracts/broadcast/DeploySendtagCheckout.s.sol/84532/run-latest.json b/packages/contracts/broadcast/DeploySendtagCheckout.s.sol/84532/run-latest.json index 7f14cb9bf..5dadaec24 100644 --- a/packages/contracts/broadcast/DeploySendtagCheckout.s.sol/84532/run-latest.json +++ b/packages/contracts/broadcast/DeploySendtagCheckout.s.sol/84532/run-latest.json @@ -1,10 +1,10 @@ { "transactions": [ { - "hash": "0xaa39d3d40a0ffa9138ea1ee3dd524c318320ba575415bdecaa252c1ca7787e7e", + "hash": "0x0626abbfbb66a687708e0ba589b4132886478d3eb98b50c6c1a26147ab05c6f4", "transactionType": "CREATE2", "contractName": "SendtagCheckout", - "contractAddress": "0x0bd9297334a23de53b865c503ee874d923892cca", + "contractAddress": "0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca", "function": null, "arguments": [ "0x269cD0a2afd1BAbdA7A74ab1dC853869a37aa4a7", @@ -14,10 +14,10 @@ "transaction": { "from": "0xfb00d9cda6dad99994849d7c66fa2631f280f64f", "to": "0x4e59b44847b379578588920ca78fbf26c0b4956c", - "gas": "0xfee84", + "gas": "0xf0d75", "value": "0x0", - "input": "0x000000000000000000000000000000000000000000000000000000000000000060c060405234801561001057600080fd5b50604051610de3380380610de383398101604081905261002f916101ef565b806001600160a01b03811661005f57604051631e4fbdf760e01b8152600060048201526024015b60405180910390fd5b61006881610187565b506001600160a01b0383166100bf5760405162461bcd60e51b815260206004820152601d60248201527f496e76616c69642053656e64204d756c746973696720616464726573730000006044820152606401610056565b6001600160a01b0382166101155760405162461bcd60e51b815260206004820152601560248201527f496e76616c696420746f6b656e206164647265737300000000000000000000006044820152606401610056565b6001600160a01b03808316608052831660a0526000805460ff60a01b1916600160a01b908117918290556040517f1caf761158ed03726081542723d54a061f9d0ccb46171af1a220d059a66c71539261017792900460ff161515815260200190565b60405180910390a150505061023c565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6001600160a01b03811681146101ec57600080fd5b50565b60008060006060848603121561020457600080fd5b835161020f816101d7565b6020850151909350610220816101d7565b6040850151909250610231816101d7565b809150509250925092565b60805160a051610b6761027c6000396000818160d201526104ec01526000818161018a01528181610387015281816104a001526104cb0152610b676000f3fe608060405234801561001057600080fd5b50600436106100be5760003560e01c80639e281a9811610076578063f2fde38b1161005b578063f2fde38b14610172578063fc0c546a14610185578063fcfff16f146101ac57600080fd5b80639e281a9814610157578063e086e5ec1461016a57600080fd5b8063715018a6116100a7578063715018a61461011e5780637a53a6db146101265780638da5cb5b1461013957600080fd5b806340a3d246146100c35780634783c35b146100cd575b600080fd5b6100cb6101e1565b005b6100f47f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b6100cb61027b565b6100cb610134366004610a25565b61028f565b60005473ffffffffffffffffffffffffffffffffffffffff166100f4565b6100cb610165366004610a5d565b610577565b6100cb61058e565b6100cb610180366004610a89565b6105c5565b6100f47f000000000000000000000000000000000000000000000000000000000000000081565b6000546101d19074010000000000000000000000000000000000000000900460ff1681565b6040519015158152602001610115565b6101e9610626565b6000805460ff7401000000000000000000000000000000000000000080830482161581027fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff90931692909217928390556040517f1caf761158ed03726081542723d54a061f9d0ccb46171af1a220d059a66c7153936102719390049091161515815260200190565b60405180910390a1565b610283610626565b61028d6000610679565b565b60005474010000000000000000000000000000000000000000900460ff16610318576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600660248201527f436c6f736564000000000000000000000000000000000000000000000000000060448201526064015b60405180910390fd5b60008311610382576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600e60248201527f496e76616c696420616d6f756e74000000000000000000000000000000000000604482015260640161030f565b6103ae7f00000000000000000000000000000000000000000000000000000000000000003330866106ee565b80156104c65773ffffffffffffffffffffffffffffffffffffffff8216610431576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f496e76616c696420726566657272657220616464726573730000000000000000604482015260640161030f565b8281111561049b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f496e76616c696420726566657272657220726577617264000000000000000000604482015260640161030f565b6104c67f0000000000000000000000000000000000000000000000000000000000000000838361077d565b61051a7f00000000000000000000000000000000000000000000000000000000000000007f00000000000000000000000000000000000000000000000000000000000000006105158487610aa6565b61077d565b6040805184815273ffffffffffffffffffffffffffffffffffffffff8416602082015290810182905233907f7e13a4603bf96047c8756065bf8f579579952471ddeaf284bcd8f26996cddcda9060600160405180910390a2505050565b61057f610626565b61058a82338361077d565b5050565b610596610626565b60405133904780156108fc02916000818181858888f193505050501580156105c2573d6000803e3d6000fd5b50565b6105cd610626565b73ffffffffffffffffffffffffffffffffffffffff811661061d576040517f1e4fbdf70000000000000000000000000000000000000000000000000000000081526000600482015260240161030f565b6105c281610679565b60005473ffffffffffffffffffffffffffffffffffffffff16331461028d576040517f118cdaa700000000000000000000000000000000000000000000000000000000815233600482015260240161030f565b6000805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b60405173ffffffffffffffffffffffffffffffffffffffff84811660248301528381166044830152606482018390526107779186918216906323b872dd906084015b604051602081830303815290604052915060e01b6020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506107c0565b50505050565b60405173ffffffffffffffffffffffffffffffffffffffff8381166024830152604482018390526107bb91859182169063a9059cbb90606401610730565b505050565b60006107e273ffffffffffffffffffffffffffffffffffffffff841683610856565b905080516000141580156108075750808060200190518101906108059190610ae0565b155b156107bb576040517f5274afe700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8416600482015260240161030f565b60606108648383600061086d565b90505b92915050565b6060814710156108ab576040517fcd78605900000000000000000000000000000000000000000000000000000000815230600482015260240161030f565b6000808573ffffffffffffffffffffffffffffffffffffffff1684866040516108d49190610b02565b60006040518083038185875af1925050503d8060008114610911576040519150601f19603f3d011682016040523d82523d6000602084013e610916565b606091505b5091509150610926868383610932565b925050505b9392505050565b60608261094757610942826109c1565b61092b565b815115801561096b575073ffffffffffffffffffffffffffffffffffffffff84163b155b156109ba576040517f9996b31500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8516600482015260240161030f565b508061092b565b8051156109d15780518082602001fd5b6040517f1425ea4200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff811681146105c257600080fd5b600080600060608486031215610a3a57600080fd5b833592506020840135610a4c81610a03565b929592945050506040919091013590565b60008060408385031215610a7057600080fd5b8235610a7b81610a03565b946020939093013593505050565b600060208284031215610a9b57600080fd5b813561092b81610a03565b81810381811115610867577f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600060208284031215610af257600080fd5b8151801515811461092b57600080fd5b6000825160005b81811015610b235760208186018101518583015201610b09565b50600092019182525091905056fea2646970667358221220c49fb97760f31bcc44d9cc2d48216fcf02ee27f249a11e15b9854d10ea58342264736f6c63430008170033000000000000000000000000269cd0a2afd1babda7a74ab1dc853869a37aa4a7000000000000000000000000036cbd53842c5426634e7929541ec2318f3dcf7e000000000000000000000000fb00d9cda6dad99994849d7c66fa2631f280f64f", - "nonce": "0x3d", + "input": "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", + "nonce": "0x43", "chainId": "0x14a34" }, "additionalContracts": [], @@ -27,54 +27,54 @@ "receipts": [ { "status": "0x1", - "cumulativeGasUsed": "0x24bcaa", + "cumulativeGasUsed": "0x362446", "logs": [ { - "address": "0x0bd9297334a23de53b865c503ee874d923892cca", + "address": "0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca", "topics": [ "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x000000000000000000000000fb00d9cda6dad99994849d7c66fa2631f280f64f" ], "data": "0x", - "blockHash": "0xe3f9e7176ab4ea4c93f71f3cf79280467043273807cbe07c7d47a446237d09d1", - "blockNumber": "0xc6ca92", - "transactionHash": "0xaa39d3d40a0ffa9138ea1ee3dd524c318320ba575415bdecaa252c1ca7787e7e", - "transactionIndex": "0x5", - "logIndex": "0x2d", + "blockHash": "0x4923061021826cd812853874780cfb82bc711bb708c0f363c6fe2e72848c40b4", + "blockNumber": "0xc9174b", + "transactionHash": "0x0626abbfbb66a687708e0ba589b4132886478d3eb98b50c6c1a26147ab05c6f4", + "transactionIndex": "0xa", + "logIndex": "0x1c", "removed": false }, { - "address": "0x0bd9297334a23de53b865c503ee874d923892cca", + "address": "0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca", "topics": [ "0x1caf761158ed03726081542723d54a061f9d0ccb46171af1a220d059a66c7153" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000001", - "blockHash": "0xe3f9e7176ab4ea4c93f71f3cf79280467043273807cbe07c7d47a446237d09d1", - "blockNumber": "0xc6ca92", - "transactionHash": "0xaa39d3d40a0ffa9138ea1ee3dd524c318320ba575415bdecaa252c1ca7787e7e", - "transactionIndex": "0x5", - "logIndex": "0x2e", + "blockHash": "0x4923061021826cd812853874780cfb82bc711bb708c0f363c6fe2e72848c40b4", + "blockNumber": "0xc9174b", + "transactionHash": "0x0626abbfbb66a687708e0ba589b4132886478d3eb98b50c6c1a26147ab05c6f4", + "transactionIndex": "0xa", + "logIndex": "0x1d", "removed": false } ], - "logsBloom": "0x00000000000000000000000000000000000000000000000000800000080000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000002000200001000000000000000000000000000000000000020000000000000000000800000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004400060000000000000000000000000000000000000000000400000000000000020000000000000000000000000000000000000000000000000000000000000000000", + "logsBloom": "0x00000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000200001000000000000000000000000000000000000020000000000000000000800000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000060000000020000000000000000000000000000000000400000000001000020000000000000000000000000000000000000000000000000000000400000000000", "type": "0x2", - "transactionHash": "0xaa39d3d40a0ffa9138ea1ee3dd524c318320ba575415bdecaa252c1ca7787e7e", - "transactionIndex": "0x5", - "blockHash": "0xe3f9e7176ab4ea4c93f71f3cf79280467043273807cbe07c7d47a446237d09d1", - "blockNumber": "0xc6ca92", - "gasUsed": "0xae5a1", - "effectiveGasPrice": "0xe843c098", + "transactionHash": "0x0626abbfbb66a687708e0ba589b4132886478d3eb98b50c6c1a26147ab05c6f4", + "transactionIndex": "0xa", + "blockHash": "0x4923061021826cd812853874780cfb82bc711bb708c0f363c6fe2e72848c40b4", + "blockNumber": "0xc9174b", + "gasUsed": "0xae6ba", + "effectiveGasPrice": "0xfaffdb3", "from": "0xfb00d9cda6dad99994849d7c66fa2631f280f64f", "to": "0x4e59b44847b379578588920ca78fbf26c0b4956c", - "contractAddress": "0x0bd9297334a23de53b865c503ee874d923892cca", + "contractAddress": "0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca", "l1BaseFeeScalar": "0x44d", - "l1BlobBaseFee": "0x71129411d08", + "l1BlobBaseFee": "0x15bcf51524b", "l1BlobBaseFeeScalar": "0xa118b", - "l1Fee": "0x218b06e15659bb", - "l1GasPrice": "0x8b3b01278", - "l1GasUsed": "0x7313" + "l1Fee": "0x683e2b0af19e2", + "l1GasPrice": "0x21e925", + "l1GasUsed": "0x7447" } ], "libraries": [], @@ -82,10 +82,10 @@ "returns": { "0": { "internal_type": "contract SendtagCheckout", - "value": "0x0bD9297334a23De53b865c503Ee874d923892ccA" + "value": "0x32b6F71420a0f8286D10D83eAf9EB8F12e6f33Ca" } }, - "timestamp": 1721824282, + "timestamp": 1722125730, "chain": 84532, - "commit": "b7dd9ed6" + "commit": "81011083" } \ No newline at end of file diff --git a/packages/contracts/script/DeploySendtagCheckout.s.sol b/packages/contracts/script/DeploySendtagCheckout.s.sol index 8a649d8d3..c8a52c329 100644 --- a/packages/contracts/script/DeploySendtagCheckout.s.sol +++ b/packages/contracts/script/DeploySendtagCheckout.s.sol @@ -14,17 +14,18 @@ contract DeploySendtagCheckoutScript is Script, Helper { function run() external returns (SendtagCheckout) { address multisig = vm.envAddress("MULTISIG"); - IERC20 token = IERC20(vm.envAddress("TOKEN")); + address token = vm.envAddress("TOKEN"); address owner = vm.envAddress("OWNER"); require(multisig != address(0), "MULTISIG not set"); - require(token != IERC20(address(0)), "TOKEN not set"); + require(token != address(0), "TOKEN not set"); require(owner != address(0), "OWNER not set"); return this.deploy(multisig, token, owner); } - function deploy(address multisig, IERC20 token, address owner) external returns (SendtagCheckout) { + function deploy(address multisig, address token, address owner) external returns (SendtagCheckout) { vm.startBroadcast(); - SendtagCheckout sendtagCheckout = new SendtagCheckout{salt: 0}(multisig, token, owner); + bytes32 salt = keccak256("fjord"); + SendtagCheckout sendtagCheckout = new SendtagCheckout{salt: salt}(multisig, token, owner); vm.stopBroadcast(); return sendtagCheckout; } diff --git a/packages/contracts/src/Helper.sol b/packages/contracts/src/Helper.sol index 19ef1de1f..3fc169c17 100644 --- a/packages/contracts/src/Helper.sol +++ b/packages/contracts/src/Helper.sol @@ -42,6 +42,11 @@ abstract contract Helper is Script { * https://basescan.org/address/0x0000000071727De22E5E9d8BAf0edAc6f37da032 */ address constant AA_ENTRY_POINT_V0_7 = 0x0000000071727De22E5E9d8BAf0edAc6f37da032; + /** + * USDC on Base + * https://basescan.org/address/0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 + */ + address constant USDC_BASE = 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913; function labels() public { vm.label(SEND_TOKEN, "SEND_TOKEN"); @@ -52,5 +57,6 @@ abstract contract Helper is Script { vm.label(SEND_AIRDROPS_SAFE, "SEND_AIRDROPS_SAFE"); vm.label(AA_ENTRY_POINT_V0_6, "AA_ENTRY_POINT_V0_6"); vm.label(AA_ENTRY_POINT_V0_7, "AA_ENTRY_POINT_V0_7"); + vm.label(USDC_BASE, "USDC_BASE"); } } diff --git a/packages/contracts/src/SendtagCheckout.sol b/packages/contracts/src/SendtagCheckout.sol index 5b34653e9..a75e5037a 100644 --- a/packages/contracts/src/SendtagCheckout.sol +++ b/packages/contracts/src/SendtagCheckout.sol @@ -1,9 +1,568 @@ // SPDX-License-Identifier: GPL-3.0-or-later -pragma solidity ^0.8.23; +pragma solidity ^0.8.20 ^0.8.23; -import "@openzeppelin/contracts/access/Ownable.sol"; -import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +// lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol) + +/** + * @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 value of tokens in existence. + */ + function totalSupply() external view returns (uint256); + + /** + * @dev Returns the value of tokens owned by `account`. + */ + function balanceOf(address account) external view returns (uint256); + + /** + * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool); + + /** + * @dev Moves a `value` amount of tokens from `from` to `to` using the + * allowance mechanism. `value` 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 value) external returns (bool); +} + +// lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol) + +/** + * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in + * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. + * + * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by + * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't + * need to send a transaction, and thus is not required to hold Ether at all. + * + * ==== Security Considerations + * + * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature + * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be + * considered as an intention to spend the allowance in any specific way. The second is that because permits have + * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should + * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be + * generally recommended is: + * + * ```solidity + * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public { + * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {} + * doThing(..., value); + * } + * + * function doThing(..., uint256 value) public { + * token.safeTransferFrom(msg.sender, address(this), value); + * ... + * } + * ``` + * + * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of + * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also + * {SafeERC20-safeTransferFrom}). + * + * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so + * contracts should have entry points that don't rely on permit. + */ +interface IERC20Permit { + /** + * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, + * given ``owner``'s signed approval. + * + * IMPORTANT: The same issues {IERC20-approve} has related to transaction + * ordering also apply here. + * + * Emits an {Approval} event. + * + * Requirements: + * + * - `spender` cannot be the zero address. + * - `deadline` must be a timestamp in the future. + * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` + * over the EIP712-formatted function arguments. + * - the signature must use ``owner``'s current nonce (see {nonces}). + * + * For more information on the signature format, see the + * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP + * section]. + * + * CAUTION: See Security Considerations above. + */ + function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) + external; + + /** + * @dev Returns the current nonce for `owner`. This value must be + * included whenever a signature is generated for {permit}. + * + * Every successful call to {permit} increases ``owner``'s nonce by one. This + * prevents a signature from being used multiple times. + */ + function nonces(address owner) external view returns (uint256); + + /** + * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. + */ + // solhint-disable-next-line func-name-mixedcase + function DOMAIN_SEPARATOR() external view returns (bytes32); +} + +// lib/openzeppelin-contracts/contracts/utils/Address.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol) + +/** + * @dev Collection of functions related to the address type + */ +library Address { + /** + * @dev The ETH balance of the account is not enough to perform the operation. + */ + error AddressInsufficientBalance(address account); + + /** + * @dev There's no code at `target` (it is not a contract). + */ + error AddressEmptyCode(address target); + + /** + * @dev A call to an address target failed. The target may have reverted. + */ + error FailedInnerCall(); + + /** + * @dev Replacement for Solidity's `transfer`: sends `amount` wei to + * `recipient`, forwarding all available gas and reverting on errors. + * + * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost + * of certain opcodes, possibly making contracts go over the 2300 gas limit + * imposed by `transfer`, making them unable to receive funds via + * `transfer`. {sendValue} removes this limitation. + * + * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. + * + * IMPORTANT: because control is transferred to `recipient`, care must be + * taken to not create reentrancy vulnerabilities. Consider using + * {ReentrancyGuard} or the + * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. + */ + function sendValue(address payable recipient, uint256 amount) internal { + if (address(this).balance < amount) { + revert AddressInsufficientBalance(address(this)); + } + + (bool success,) = recipient.call{value: amount}(""); + if (!success) { + revert FailedInnerCall(); + } + } + + /** + * @dev Performs a Solidity function call using a low level `call`. A + * plain `call` is an unsafe replacement for a function call: use this + * function instead. + * + * If `target` reverts with a revert reason or custom error, it is bubbled + * up by this function (like regular Solidity function calls). However, if + * the call reverted with no returned reason, this function reverts with a + * {FailedInnerCall} error. + * + * Returns the raw returned data. To convert to the expected return value, + * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. + * + * Requirements: + * + * - `target` must be a contract. + * - calling `target` with `data` must not revert. + */ + function functionCall(address target, bytes memory data) internal returns (bytes memory) { + return functionCallWithValue(target, data, 0); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but also transferring `value` wei to `target`. + * + * Requirements: + * + * - the calling contract must have an ETH balance of at least `value`. + * - the called Solidity function must be `payable`. + */ + function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { + if (address(this).balance < value) { + revert AddressInsufficientBalance(address(this)); + } + (bool success, bytes memory returndata) = target.call{value: value}(data); + return verifyCallResultFromTarget(target, success, returndata); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a static call. + */ + function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { + (bool success, bytes memory returndata) = target.staticcall(data); + return verifyCallResultFromTarget(target, success, returndata); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a delegate call. + */ + function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { + (bool success, bytes memory returndata) = target.delegatecall(data); + return verifyCallResultFromTarget(target, success, returndata); + } + + /** + * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target + * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an + * unsuccessful call. + */ + function verifyCallResultFromTarget(address target, bool success, bytes memory returndata) + internal + view + returns (bytes memory) + { + if (!success) { + _revert(returndata); + } else { + // only check if target is a contract if the call was successful and the return data is empty + // otherwise we already know that it was a contract + if (returndata.length == 0 && target.code.length == 0) { + revert AddressEmptyCode(target); + } + return returndata; + } + } + + /** + * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the + * revert reason or with a default {FailedInnerCall} error. + */ + function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) { + if (!success) { + _revert(returndata); + } else { + return returndata; + } + } + + /** + * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}. + */ + function _revert(bytes memory returndata) private pure { + // Look for revert reason and bubble it up if present + if (returndata.length > 0) { + // The easiest way to bubble the revert reason is using memory via assembly + /// @solidity memory-safe-assembly + assembly { + let returndata_size := mload(returndata) + revert(add(32, returndata), returndata_size) + } + } else { + revert FailedInnerCall(); + } + } +} + +// lib/openzeppelin-contracts/contracts/utils/Context.sol + +// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol) + +/** + * @dev Provides information about the current execution context, including the + * sender of the transaction and its data. While these are generally available + * via msg.sender and msg.data, they should not be accessed in such a direct + * manner, since when dealing with meta-transactions the account sending and + * paying for execution may not be the actual sender (as far as an application + * is concerned). + * + * This contract is only required for intermediate, library-like contracts. + */ +abstract contract Context { + function _msgSender() internal view virtual returns (address) { + return msg.sender; + } + + function _msgData() internal view virtual returns (bytes calldata) { + return msg.data; + } + + function _contextSuffixLength() internal view virtual returns (uint256) { + return 0; + } +} + +// lib/openzeppelin-contracts/contracts/access/Ownable.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol) + +/** + * @dev Contract module which provides a basic access control mechanism, where + * there is an account (an owner) that can be granted exclusive access to + * specific functions. + * + * The initial owner is set to the address provided by the deployer. This can + * later be changed with {transferOwnership}. + * + * This module is used through inheritance. It will make available the modifier + * `onlyOwner`, which can be applied to your functions to restrict their use to + * the owner. + */ +abstract contract Ownable is Context { + address private _owner; + + /** + * @dev The caller account is not authorized to perform an operation. + */ + error OwnableUnauthorizedAccount(address account); + + /** + * @dev The owner is not a valid owner account. (eg. `address(0)`) + */ + error OwnableInvalidOwner(address owner); + + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + /** + * @dev Initializes the contract setting the address provided by the deployer as the initial owner. + */ + constructor(address initialOwner) { + if (initialOwner == address(0)) { + revert OwnableInvalidOwner(address(0)); + } + _transferOwnership(initialOwner); + } + + /** + * @dev Throws if called by any account other than the owner. + */ + modifier onlyOwner() { + _checkOwner(); + _; + } + + /** + * @dev Returns the address of the current owner. + */ + function owner() public view virtual returns (address) { + return _owner; + } + + /** + * @dev Throws if the sender is not the owner. + */ + function _checkOwner() internal view virtual { + if (owner() != _msgSender()) { + revert OwnableUnauthorizedAccount(_msgSender()); + } + } + + /** + * @dev Leaves the contract without owner. It will not be possible to call + * `onlyOwner` functions. Can only be called by the current owner. + * + * NOTE: Renouncing ownership will leave the contract without an owner, + * thereby disabling any functionality that is only available to the owner. + */ + function renounceOwnership() public virtual onlyOwner { + _transferOwnership(address(0)); + } + + /** + * @dev Transfers ownership of the contract to a new account (`newOwner`). + * Can only be called by the current owner. + */ + function transferOwnership(address newOwner) public virtual onlyOwner { + if (newOwner == address(0)) { + revert OwnableInvalidOwner(address(0)); + } + _transferOwnership(newOwner); + } + + /** + * @dev Transfers ownership of the contract to a new account (`newOwner`). + * Internal function without access restriction. + */ + function _transferOwnership(address newOwner) internal virtual { + address oldOwner = _owner; + _owner = newOwner; + emit OwnershipTransferred(oldOwner, newOwner); + } +} + +// lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol) + +/** + * @title SafeERC20 + * @dev Wrappers around ERC20 operations that throw on failure (when the token + * contract returns false). Tokens that return no value (and instead revert or + * throw on failure) are also supported, non-reverting calls are assumed to be + * successful. + * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, + * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. + */ +library SafeERC20 { + using Address for address; + + /** + * @dev An operation with an ERC20 token failed. + */ + error SafeERC20FailedOperation(address token); + + /** + * @dev Indicates a failed `decreaseAllowance` request. + */ + error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease); + + /** + * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value, + * non-reverting calls are assumed to be successful. + */ + function safeTransfer(IERC20 token, address to, uint256 value) internal { + _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value))); + } + + /** + * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the + * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful. + */ + function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { + _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value))); + } + + /** + * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value, + * non-reverting calls are assumed to be successful. + */ + function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { + uint256 oldAllowance = token.allowance(address(this), spender); + forceApprove(token, spender, oldAllowance + value); + } + + /** + * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no + * value, non-reverting calls are assumed to be successful. + */ + function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal { + unchecked { + uint256 currentAllowance = token.allowance(address(this), spender); + if (currentAllowance < requestedDecrease) { + revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease); + } + forceApprove(token, spender, currentAllowance - requestedDecrease); + } + } + + /** + * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value, + * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval + * to be set to zero before setting it to a non-zero value, such as USDT. + */ + function forceApprove(IERC20 token, address spender, uint256 value) internal { + bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value)); + + if (!_callOptionalReturnBool(token, approvalCall)) { + _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0))); + _callOptionalReturn(token, approvalCall); + } + } + + /** + * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement + * on the return value: the return value is optional (but if data is returned, it must not be false). + * @param token The token targeted by the call. + * @param data The call data (encoded using abi.encode or one of its variants). + */ + function _callOptionalReturn(IERC20 token, bytes memory data) private { + // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since + // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that + // the target address contains contract code and also asserts for success in the low-level call. + + bytes memory returndata = address(token).functionCall(data); + if (returndata.length != 0 && !abi.decode(returndata, (bool))) { + revert SafeERC20FailedOperation(address(token)); + } + } + + /** + * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement + * on the return value: the return value is optional (but if data is returned, it must not be false). + * @param token The token targeted by the call. + * @param data The call data (encoded using abi.encode or one of its variants). + * + * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead. + */ + function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) { + // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since + // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false + // and not revert is the subcall reverts. + + (bool success, bytes memory returndata) = address(token).call(data); + return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0; + } +} + +// src/SendtagCheckout.sol /// @title SendtagCheckout: A contract for handling Sendtag checkouts. /// @author Big Boss @@ -25,10 +584,10 @@ contract SendtagCheckout is Ownable { /// @notice The event emitted when the contract is toggled. event Toggled(bool open); - constructor(address _sendRevenuesMultisig, IERC20 _token, address _owner) Ownable(_owner) { + constructor(address _sendRevenuesMultisig, address _token, address _owner) Ownable(_owner) { require(_sendRevenuesMultisig != address(0), "Invalid Send Multisig address"); require(address(_token) != address(0), "Invalid token address"); - token = _token; + token = IERC20(_token); multisig = _sendRevenuesMultisig; open = true; emit Toggled(open); diff --git a/packages/contracts/test/SendtagCheckout.t.sol b/packages/contracts/test/SendtagCheckout.t.sol index 14bcbb09d..cc952f536 100644 --- a/packages/contracts/test/SendtagCheckout.t.sol +++ b/packages/contracts/test/SendtagCheckout.t.sol @@ -2,9 +2,9 @@ pragma solidity ^0.8.23; import {Test} from "forge-std/Test.sol"; -import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; +import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; -import {SendtagCheckout} from "../src/SendtagCheckout.sol"; +import {SendtagCheckout, IERC20} from "../src/SendtagCheckout.sol"; contract Tendies is ERC20 { constructor() ERC20("TENDIES", "TENDIES") {} @@ -25,7 +25,7 @@ contract SendtagCheckoutTest is Test { multisig = address(0x1337); owner = address(0xB055); vm.startPrank(owner); - checkout = new SendtagCheckout(multisig, token, owner); + checkout = new SendtagCheckout(multisig, address(token), owner); vm.stopPrank(); } @@ -125,7 +125,7 @@ contract SendtagCheckoutTest is Test { assertEq(token.balanceOf(address(checkout)), amount); vm.prank(owner); - checkout.withdrawToken(token, amount); + checkout.withdrawToken(IERC20(address(token)), amount); assertEq(token.balanceOf(address(checkout)), 0); assertEq(token.balanceOf(owner), amount); @@ -137,7 +137,7 @@ contract SendtagCheckoutTest is Test { token.mint(amount); token.transfer(address(checkout), amount); vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, address(0xb0b))); - checkout.withdrawToken(token, amount); + checkout.withdrawToken(IERC20(address(token)), amount); vm.stopPrank(); } diff --git a/packages/shovel/etc/config.json b/packages/shovel/etc/config.json index d5907172a..877f6265a 100644 --- a/packages/shovel/etc/config.json +++ b/packages/shovel/etc/config.json @@ -721,8 +721,8 @@ "column": "log_addr", "filter_op": "contains", "filter_arg": [ - "0x0bD9297334a23De53b865c503Ee874d923892ccA", - "0xc2781d5FcDE2d80886d8EB0B80930FeE89a2061D" + "0x36f43082d01df4801AF2D95aeEd1a0200C5510AE", + "0x32b6F71420a0f8286D10D83eAf9EB8F12e6f33Ca" ] } ], diff --git a/packages/shovel/test/__snapshots__/index.test.ts.snap b/packages/shovel/test/__snapshots__/index.test.ts.snap index 10ef054d6..074b67cac 100644 --- a/packages/shovel/test/__snapshots__/index.test.ts.snap +++ b/packages/shovel/test/__snapshots__/index.test.ts.snap @@ -660,8 +660,8 @@ exports[`shovel config 1`] = ` { "column": "log_addr", "filter_arg": [ - "0x0bD9297334a23De53b865c503Ee874d923892ccA", - "0xc2781d5FcDE2d80886d8EB0B80930FeE89a2061D", + "0x36f43082d01df4801AF2D95aeEd1a0200C5510AE", + "0x32b6F71420a0f8286D10D83eAf9EB8F12e6f33Ca", ], "filter_op": "contains", "name": "log_addr", diff --git a/packages/wagmi/src/generated.ts b/packages/wagmi/src/generated.ts index a83ec5870..06839708a 100644 --- a/packages/wagmi/src/generated.ts +++ b/packages/wagmi/src/generated.ts @@ -3194,14 +3194,15 @@ export const senderCreatorAbi = [ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /** - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const sendtagCheckoutAbi = [ { type: 'constructor', inputs: [ { name: '_sendRevenuesMultisig', internalType: 'address', type: 'address' }, - { name: '_token', internalType: 'contract IERC20', type: 'address' }, + { name: '_token', internalType: 'address', type: 'address' }, { name: '_owner', internalType: 'address', type: 'address' }, ], stateMutability: 'nonpayable', @@ -3326,15 +3327,18 @@ export const sendtagCheckoutAbi = [ ] as const /** - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const sendtagCheckoutAddress = { - 84532: '0x0bD9297334a23De53b865c503Ee874d923892ccA', - 845337: '0xc2781d5FcDE2d80886d8EB0B80930FeE89a2061D', + 8453: '0x36f43082d01df4801AF2D95aeEd1a0200C5510AE', + 84532: '0x32b6F71420a0f8286D10D83eAf9EB8F12e6f33Ca', + 845337: '0x36f43082d01df4801AF2D95aeEd1a0200C5510AE', } as const /** - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const sendtagCheckoutConfig = { address: sendtagCheckoutAddress, @@ -7451,7 +7455,8 @@ export const prepareWriteSenderCreatorCreateSender = /*#__PURE__*/ createSimulat /** * Wraps __{@link readContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const readSendtagCheckout = /*#__PURE__*/ createReadContract({ abi: sendtagCheckoutAbi, @@ -7461,7 +7466,8 @@ export const readSendtagCheckout = /*#__PURE__*/ createReadContract({ /** * Wraps __{@link readContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"multisig"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const readSendtagCheckoutMultisig = /*#__PURE__*/ createReadContract({ abi: sendtagCheckoutAbi, @@ -7472,7 +7478,8 @@ export const readSendtagCheckoutMultisig = /*#__PURE__*/ createReadContract({ /** * Wraps __{@link readContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"open"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const readSendtagCheckoutOpen = /*#__PURE__*/ createReadContract({ abi: sendtagCheckoutAbi, @@ -7483,7 +7490,8 @@ export const readSendtagCheckoutOpen = /*#__PURE__*/ createReadContract({ /** * Wraps __{@link readContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"owner"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const readSendtagCheckoutOwner = /*#__PURE__*/ createReadContract({ abi: sendtagCheckoutAbi, @@ -7494,7 +7502,8 @@ export const readSendtagCheckoutOwner = /*#__PURE__*/ createReadContract({ /** * Wraps __{@link readContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"token"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const readSendtagCheckoutToken = /*#__PURE__*/ createReadContract({ abi: sendtagCheckoutAbi, @@ -7505,7 +7514,8 @@ export const readSendtagCheckoutToken = /*#__PURE__*/ createReadContract({ /** * Wraps __{@link writeContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const writeSendtagCheckout = /*#__PURE__*/ createWriteContract({ abi: sendtagCheckoutAbi, @@ -7515,7 +7525,8 @@ export const writeSendtagCheckout = /*#__PURE__*/ createWriteContract({ /** * Wraps __{@link writeContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"checkout"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const writeSendtagCheckoutCheckout = /*#__PURE__*/ createWriteContract({ abi: sendtagCheckoutAbi, @@ -7526,7 +7537,8 @@ export const writeSendtagCheckoutCheckout = /*#__PURE__*/ createWriteContract({ /** * Wraps __{@link writeContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"renounceOwnership"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const writeSendtagCheckoutRenounceOwnership = /*#__PURE__*/ createWriteContract({ abi: sendtagCheckoutAbi, @@ -7537,7 +7549,8 @@ export const writeSendtagCheckoutRenounceOwnership = /*#__PURE__*/ createWriteCo /** * Wraps __{@link writeContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"toggle"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const writeSendtagCheckoutToggle = /*#__PURE__*/ createWriteContract({ abi: sendtagCheckoutAbi, @@ -7548,7 +7561,8 @@ export const writeSendtagCheckoutToggle = /*#__PURE__*/ createWriteContract({ /** * Wraps __{@link writeContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"transferOwnership"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const writeSendtagCheckoutTransferOwnership = /*#__PURE__*/ createWriteContract({ abi: sendtagCheckoutAbi, @@ -7559,7 +7573,8 @@ export const writeSendtagCheckoutTransferOwnership = /*#__PURE__*/ createWriteCo /** * Wraps __{@link writeContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"withdrawETH"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const writeSendtagCheckoutWithdrawEth = /*#__PURE__*/ createWriteContract({ abi: sendtagCheckoutAbi, @@ -7570,7 +7585,8 @@ export const writeSendtagCheckoutWithdrawEth = /*#__PURE__*/ createWriteContract /** * Wraps __{@link writeContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"withdrawToken"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const writeSendtagCheckoutWithdrawToken = /*#__PURE__*/ createWriteContract({ abi: sendtagCheckoutAbi, @@ -7581,7 +7597,8 @@ export const writeSendtagCheckoutWithdrawToken = /*#__PURE__*/ createWriteContra /** * Wraps __{@link simulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const prepareWriteSendtagCheckout = /*#__PURE__*/ createSimulateContract({ abi: sendtagCheckoutAbi, @@ -7591,7 +7608,8 @@ export const prepareWriteSendtagCheckout = /*#__PURE__*/ createSimulateContract( /** * Wraps __{@link simulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"checkout"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const prepareWriteSendtagCheckoutCheckout = /*#__PURE__*/ createSimulateContract({ abi: sendtagCheckoutAbi, @@ -7602,7 +7620,8 @@ export const prepareWriteSendtagCheckoutCheckout = /*#__PURE__*/ createSimulateC /** * Wraps __{@link simulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"renounceOwnership"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const prepareWriteSendtagCheckoutRenounceOwnership = /*#__PURE__*/ createSimulateContract({ abi: sendtagCheckoutAbi, @@ -7613,7 +7632,8 @@ export const prepareWriteSendtagCheckoutRenounceOwnership = /*#__PURE__*/ create /** * Wraps __{@link simulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"toggle"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const prepareWriteSendtagCheckoutToggle = /*#__PURE__*/ createSimulateContract({ abi: sendtagCheckoutAbi, @@ -7624,7 +7644,8 @@ export const prepareWriteSendtagCheckoutToggle = /*#__PURE__*/ createSimulateCon /** * Wraps __{@link simulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"transferOwnership"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const prepareWriteSendtagCheckoutTransferOwnership = /*#__PURE__*/ createSimulateContract({ abi: sendtagCheckoutAbi, @@ -7635,7 +7656,8 @@ export const prepareWriteSendtagCheckoutTransferOwnership = /*#__PURE__*/ create /** * Wraps __{@link simulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"withdrawETH"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const prepareWriteSendtagCheckoutWithdrawEth = /*#__PURE__*/ createSimulateContract({ abi: sendtagCheckoutAbi, @@ -7646,7 +7668,8 @@ export const prepareWriteSendtagCheckoutWithdrawEth = /*#__PURE__*/ createSimula /** * Wraps __{@link simulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"withdrawToken"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const prepareWriteSendtagCheckoutWithdrawToken = /*#__PURE__*/ createSimulateContract({ abi: sendtagCheckoutAbi, @@ -7657,7 +7680,8 @@ export const prepareWriteSendtagCheckoutWithdrawToken = /*#__PURE__*/ createSimu /** * Wraps __{@link watchContractEvent}__ with `abi` set to __{@link sendtagCheckoutAbi}__ * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const watchSendtagCheckoutEvent = /*#__PURE__*/ createWatchContractEvent({ abi: sendtagCheckoutAbi, @@ -7667,7 +7691,8 @@ export const watchSendtagCheckoutEvent = /*#__PURE__*/ createWatchContractEvent( /** * Wraps __{@link watchContractEvent}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `eventName` set to `"OwnershipTransferred"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const watchSendtagCheckoutOwnershipTransferredEvent = /*#__PURE__*/ createWatchContractEvent( { abi: sendtagCheckoutAbi, address: sendtagCheckoutAddress, eventName: 'OwnershipTransferred' } @@ -7676,7 +7701,8 @@ export const watchSendtagCheckoutOwnershipTransferredEvent = /*#__PURE__*/ creat /** * Wraps __{@link watchContractEvent}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `eventName` set to `"Receipt"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const watchSendtagCheckoutReceiptEvent = /*#__PURE__*/ createWatchContractEvent({ abi: sendtagCheckoutAbi, @@ -7687,7 +7713,8 @@ export const watchSendtagCheckoutReceiptEvent = /*#__PURE__*/ createWatchContrac /** * Wraps __{@link watchContractEvent}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `eventName` set to `"Toggled"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const watchSendtagCheckoutToggledEvent = /*#__PURE__*/ createWatchContractEvent({ abi: sendtagCheckoutAbi, @@ -12124,7 +12151,8 @@ export const useSimulateSenderCreatorCreateSender = /*#__PURE__*/ createUseSimul /** * Wraps __{@link useReadContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useReadSendtagCheckout = /*#__PURE__*/ createUseReadContract({ abi: sendtagCheckoutAbi, @@ -12134,7 +12162,8 @@ export const useReadSendtagCheckout = /*#__PURE__*/ createUseReadContract({ /** * Wraps __{@link useReadContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"multisig"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useReadSendtagCheckoutMultisig = /*#__PURE__*/ createUseReadContract({ abi: sendtagCheckoutAbi, @@ -12145,7 +12174,8 @@ export const useReadSendtagCheckoutMultisig = /*#__PURE__*/ createUseReadContrac /** * Wraps __{@link useReadContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"open"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useReadSendtagCheckoutOpen = /*#__PURE__*/ createUseReadContract({ abi: sendtagCheckoutAbi, @@ -12156,7 +12186,8 @@ export const useReadSendtagCheckoutOpen = /*#__PURE__*/ createUseReadContract({ /** * Wraps __{@link useReadContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"owner"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useReadSendtagCheckoutOwner = /*#__PURE__*/ createUseReadContract({ abi: sendtagCheckoutAbi, @@ -12167,7 +12198,8 @@ export const useReadSendtagCheckoutOwner = /*#__PURE__*/ createUseReadContract({ /** * Wraps __{@link useReadContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"token"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useReadSendtagCheckoutToken = /*#__PURE__*/ createUseReadContract({ abi: sendtagCheckoutAbi, @@ -12178,7 +12210,8 @@ export const useReadSendtagCheckoutToken = /*#__PURE__*/ createUseReadContract({ /** * Wraps __{@link useWriteContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWriteSendtagCheckout = /*#__PURE__*/ createUseWriteContract({ abi: sendtagCheckoutAbi, @@ -12188,7 +12221,8 @@ export const useWriteSendtagCheckout = /*#__PURE__*/ createUseWriteContract({ /** * Wraps __{@link useWriteContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"checkout"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWriteSendtagCheckoutCheckout = /*#__PURE__*/ createUseWriteContract({ abi: sendtagCheckoutAbi, @@ -12199,7 +12233,8 @@ export const useWriteSendtagCheckoutCheckout = /*#__PURE__*/ createUseWriteContr /** * Wraps __{@link useWriteContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"renounceOwnership"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWriteSendtagCheckoutRenounceOwnership = /*#__PURE__*/ createUseWriteContract({ abi: sendtagCheckoutAbi, @@ -12210,7 +12245,8 @@ export const useWriteSendtagCheckoutRenounceOwnership = /*#__PURE__*/ createUseW /** * Wraps __{@link useWriteContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"toggle"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWriteSendtagCheckoutToggle = /*#__PURE__*/ createUseWriteContract({ abi: sendtagCheckoutAbi, @@ -12221,7 +12257,8 @@ export const useWriteSendtagCheckoutToggle = /*#__PURE__*/ createUseWriteContrac /** * Wraps __{@link useWriteContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"transferOwnership"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWriteSendtagCheckoutTransferOwnership = /*#__PURE__*/ createUseWriteContract({ abi: sendtagCheckoutAbi, @@ -12232,7 +12269,8 @@ export const useWriteSendtagCheckoutTransferOwnership = /*#__PURE__*/ createUseW /** * Wraps __{@link useWriteContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"withdrawETH"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWriteSendtagCheckoutWithdrawEth = /*#__PURE__*/ createUseWriteContract({ abi: sendtagCheckoutAbi, @@ -12243,7 +12281,8 @@ export const useWriteSendtagCheckoutWithdrawEth = /*#__PURE__*/ createUseWriteCo /** * Wraps __{@link useWriteContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"withdrawToken"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWriteSendtagCheckoutWithdrawToken = /*#__PURE__*/ createUseWriteContract({ abi: sendtagCheckoutAbi, @@ -12254,7 +12293,8 @@ export const useWriteSendtagCheckoutWithdrawToken = /*#__PURE__*/ createUseWrite /** * Wraps __{@link useSimulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useSimulateSendtagCheckout = /*#__PURE__*/ createUseSimulateContract({ abi: sendtagCheckoutAbi, @@ -12264,7 +12304,8 @@ export const useSimulateSendtagCheckout = /*#__PURE__*/ createUseSimulateContrac /** * Wraps __{@link useSimulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"checkout"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useSimulateSendtagCheckoutCheckout = /*#__PURE__*/ createUseSimulateContract({ abi: sendtagCheckoutAbi, @@ -12275,7 +12316,8 @@ export const useSimulateSendtagCheckoutCheckout = /*#__PURE__*/ createUseSimulat /** * Wraps __{@link useSimulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"renounceOwnership"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useSimulateSendtagCheckoutRenounceOwnership = /*#__PURE__*/ createUseSimulateContract({ abi: sendtagCheckoutAbi, @@ -12286,7 +12328,8 @@ export const useSimulateSendtagCheckoutRenounceOwnership = /*#__PURE__*/ createU /** * Wraps __{@link useSimulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"toggle"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useSimulateSendtagCheckoutToggle = /*#__PURE__*/ createUseSimulateContract({ abi: sendtagCheckoutAbi, @@ -12297,7 +12340,8 @@ export const useSimulateSendtagCheckoutToggle = /*#__PURE__*/ createUseSimulateC /** * Wraps __{@link useSimulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"transferOwnership"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useSimulateSendtagCheckoutTransferOwnership = /*#__PURE__*/ createUseSimulateContract({ abi: sendtagCheckoutAbi, @@ -12308,7 +12352,8 @@ export const useSimulateSendtagCheckoutTransferOwnership = /*#__PURE__*/ createU /** * Wraps __{@link useSimulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"withdrawETH"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useSimulateSendtagCheckoutWithdrawEth = /*#__PURE__*/ createUseSimulateContract({ abi: sendtagCheckoutAbi, @@ -12319,7 +12364,8 @@ export const useSimulateSendtagCheckoutWithdrawEth = /*#__PURE__*/ createUseSimu /** * Wraps __{@link useSimulateContract}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `functionName` set to `"withdrawToken"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useSimulateSendtagCheckoutWithdrawToken = /*#__PURE__*/ createUseSimulateContract({ abi: sendtagCheckoutAbi, @@ -12330,7 +12376,8 @@ export const useSimulateSendtagCheckoutWithdrawToken = /*#__PURE__*/ createUseSi /** * Wraps __{@link useWatchContractEvent}__ with `abi` set to __{@link sendtagCheckoutAbi}__ * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWatchSendtagCheckoutEvent = /*#__PURE__*/ createUseWatchContractEvent({ abi: sendtagCheckoutAbi, @@ -12340,7 +12387,8 @@ export const useWatchSendtagCheckoutEvent = /*#__PURE__*/ createUseWatchContract /** * Wraps __{@link useWatchContractEvent}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `eventName` set to `"OwnershipTransferred"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWatchSendtagCheckoutOwnershipTransferredEvent = /*#__PURE__*/ createUseWatchContractEvent({ @@ -12352,7 +12400,8 @@ export const useWatchSendtagCheckoutOwnershipTransferredEvent = /** * Wraps __{@link useWatchContractEvent}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `eventName` set to `"Receipt"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWatchSendtagCheckoutReceiptEvent = /*#__PURE__*/ createUseWatchContractEvent({ abi: sendtagCheckoutAbi, @@ -12363,7 +12412,8 @@ export const useWatchSendtagCheckoutReceiptEvent = /*#__PURE__*/ createUseWatchC /** * Wraps __{@link useWatchContractEvent}__ with `abi` set to __{@link sendtagCheckoutAbi}__ and `eventName` set to `"Toggled"` * - * [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x0bd9297334a23de53b865c503ee874d923892cca) + * - [__View Contract on Base Basescan__](https://basescan.org/address/0x36f43082d01df4801af2d95aeed1a0200c5510ae) + * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x32b6f71420a0f8286d10d83eaf9eb8f12e6f33ca) */ export const useWatchSendtagCheckoutToggledEvent = /*#__PURE__*/ createUseWatchContractEvent({ abi: sendtagCheckoutAbi, diff --git a/packages/wagmi/wagmi.config.ts b/packages/wagmi/wagmi.config.ts index 81f28b2c5..539cbef2d 100644 --- a/packages/wagmi/wagmi.config.ts +++ b/packages/wagmi/wagmi.config.ts @@ -177,6 +177,12 @@ export default defineConfig({ '**.s.sol/*.json', '**.t.sol/*.json', 'SendPaymaster.sol/**', // avoid duplicate IMetaPaymaster + 'SendtagCheckout.sol/Address.json', + 'SendtagCheckout.sol/Context.json', + 'SendtagCheckout.sol/IERC20.json', + 'SendtagCheckout.sol/IERC20Permit.json', + 'SendtagCheckout.sol/Ownable.json', + 'SendtagCheckout.sol/SafeERC20.json', 'DummyEntryPointSimulations.sol/**', // avoid dummies ], }), diff --git a/tilt/infra.Tiltfile b/tilt/infra.Tiltfile index 92c619c90..8f50aaa77 100644 --- a/tilt/infra.Tiltfile +++ b/tilt/infra.Tiltfile @@ -206,17 +206,6 @@ local_resource( ], ) -local_resource( - "anvil:anvil-add-sendtag-checkout-fixtures", - "yarn contracts dev:anvil-add-sendtag-checkout-fixtures", - dir = _prj_root, - labels = labels, - resource_deps = _infra_resource_deps + [ - "anvil:base", - "contracts:build", - ], -) - local_resource( "anvil:fixtures", "echo 🥳", @@ -225,7 +214,6 @@ local_resource( "anvil:base", "anvil:anvil-token-paymaster-deposit", "anvil:anvil-deploy-fjord-send-verifier-fixtures", - "anvil:anvil-add-sendtag-checkout-fixtures", ], )