diff --git a/contracts-abi/abi/FastSettlementV3.abi b/contracts-abi/abi/FastSettlementV3.abi new file mode 100644 index 0000000..1e51b8e --- /dev/null +++ b/contracts-abi/abi/FastSettlementV3.abi @@ -0,0 +1,875 @@ +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_permit2", + "type": "address", + "internalType": "address" + }, + { + "name": "_weth", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "receive", + "stateMutability": "payable" + }, + { + "type": "function", + "name": "INTENT_TYPEHASH", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "PERMIT2", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IPermit2" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "UPGRADE_INTERFACE_VERSION", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "WETH", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IWETH" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "WITNESS_TYPE_STRING", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "acceptOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "allowedSwapTargets", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "executeWithETH", + "inputs": [ + { + "name": "intent", + "type": "tuple", + "internalType": "struct IFastSettlementV3.Intent", + "components": [ + { + "name": "user", + "type": "address", + "internalType": "address" + }, + { + "name": "inputToken", + "type": "address", + "internalType": "address" + }, + { + "name": "outputToken", + "type": "address", + "internalType": "address" + }, + { + "name": "inputAmt", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "userAmtOut", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "deadline", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "nonce", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "swapData", + "type": "tuple", + "internalType": "struct IFastSettlementV3.SwapCall", + "components": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "data", + "type": "bytes", + "internalType": "bytes" + } + ] + } + ], + "outputs": [ + { + "name": "received", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "surplus", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "executeWithPermit", + "inputs": [ + { + "name": "intent", + "type": "tuple", + "internalType": "struct IFastSettlementV3.Intent", + "components": [ + { + "name": "user", + "type": "address", + "internalType": "address" + }, + { + "name": "inputToken", + "type": "address", + "internalType": "address" + }, + { + "name": "outputToken", + "type": "address", + "internalType": "address" + }, + { + "name": "inputAmt", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "userAmtOut", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "deadline", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "nonce", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "signature", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "swapData", + "type": "tuple", + "internalType": "struct IFastSettlementV3.SwapCall", + "components": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "data", + "type": "bytes", + "internalType": "bytes" + } + ] + } + ], + "outputs": [ + { + "name": "received", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "surplus", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "executor", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [ + { + "name": "_owner", + "type": "address", + "internalType": "address" + }, + { + "name": "_executor", + "type": "address", + "internalType": "address" + }, + { + "name": "_treasury", + "type": "address", + "internalType": "address" + }, + { + "name": "_initialSwapTargets", + "type": "address[]", + "internalType": "address[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "pendingOwner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxiableUUID", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "rescueTokens", + "inputs": [ + { + "name": "token", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setExecutor", + "inputs": [ + { + "name": "_newExecutor", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setSwapTargets", + "inputs": [ + { + "name": "targets", + "type": "address[]", + "internalType": "address[]" + }, + { + "name": "allowed", + "type": "bool[]", + "internalType": "bool[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setTreasury", + "inputs": [ + { + "name": "_newTreasury", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "treasury", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "upgradeToAndCall", + "inputs": [ + { + "name": "newImplementation", + "type": "address", + "internalType": "address" + }, + { + "name": "data", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "event", + "name": "ExecutorUpdated", + "inputs": [ + { + "name": "oldExecutor", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newExecutor", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Initialized", + "inputs": [ + { + "name": "version", + "type": "uint64", + "indexed": false, + "internalType": "uint64" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "IntentExecuted", + "inputs": [ + { + "name": "user", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "inputToken", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "outputToken", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "inputAmt", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "userAmtOut", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "received", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "surplus", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OwnershipTransferStarted", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "SwapTargetsUpdated", + "inputs": [ + { + "name": "targets", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + }, + { + "name": "allowed", + "type": "bool[]", + "indexed": false, + "internalType": "bool[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "TreasuryUpdated", + "inputs": [ + { + "name": "oldTreasury", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newTreasury", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Upgraded", + "inputs": [ + { + "name": "implementation", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "AddressEmptyCode", + "inputs": [ + { + "name": "target", + "type": "address", + "internalType": "address" + } + ] + }, + { + "type": "error", + "name": "ArrayLengthMismatch", + "inputs": [] + }, + { + "type": "error", + "name": "BadCallTarget", + "inputs": [] + }, + { + "type": "error", + "name": "BadExecutor", + "inputs": [] + }, + { + "type": "error", + "name": "BadInputAmt", + "inputs": [] + }, + { + "type": "error", + "name": "BadInputToken", + "inputs": [] + }, + { + "type": "error", + "name": "BadNonce", + "inputs": [] + }, + { + "type": "error", + "name": "BadOwner", + "inputs": [] + }, + { + "type": "error", + "name": "BadRecipient", + "inputs": [] + }, + { + "type": "error", + "name": "BadTreasury", + "inputs": [] + }, + { + "type": "error", + "name": "BadUserAmtOut", + "inputs": [] + }, + { + "type": "error", + "name": "ERC1967InvalidImplementation", + "inputs": [ + { + "name": "implementation", + "type": "address", + "internalType": "address" + } + ] + }, + { + "type": "error", + "name": "ERC1967NonPayable", + "inputs": [] + }, + { + "type": "error", + "name": "ExpectedETHInput", + "inputs": [] + }, + { + "type": "error", + "name": "FailedCall", + "inputs": [] + }, + { + "type": "error", + "name": "InsufficientBalance", + "inputs": [ + { + "name": "balance", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "needed", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "type": "error", + "name": "InsufficientOut", + "inputs": [ + { + "name": "received", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "userAmtOut", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "type": "error", + "name": "IntentExpired", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidETHAmount", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidInitialization", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidPermit2", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidWETH", + "inputs": [] + }, + { + "type": "error", + "name": "NotInitializing", + "inputs": [] + }, + { + "type": "error", + "name": "OwnableInvalidOwner", + "inputs": [ + { + "name": "owner", + "type": "address", + "internalType": "address" + } + ] + }, + { + "type": "error", + "name": "OwnableUnauthorizedAccount", + "inputs": [ + { + "name": "account", + "type": "address", + "internalType": "address" + } + ] + }, + { + "type": "error", + "name": "ReentrancyGuardReentrantCall", + "inputs": [] + }, + { + "type": "error", + "name": "SafeERC20FailedOperation", + "inputs": [ + { + "name": "token", + "type": "address", + "internalType": "address" + } + ] + }, + { + "type": "error", + "name": "UUPSUnauthorizedCallContext", + "inputs": [] + }, + { + "type": "error", + "name": "UUPSUnsupportedProxiableUUID", + "inputs": [ + { + "name": "slot", + "type": "bytes32", + "internalType": "bytes32" + } + ] + }, + { + "type": "error", + "name": "UnauthorizedCaller", + "inputs": [] + }, + { + "type": "error", + "name": "UnauthorizedExecutor", + "inputs": [] + }, + { + "type": "error", + "name": "UnauthorizedSwapTarget", + "inputs": [] + } +] diff --git a/contracts-abi/abi/IFastSettlementV3.abi b/contracts-abi/abi/IFastSettlementV3.abi new file mode 100644 index 0000000..383faf2 --- /dev/null +++ b/contracts-abi/abi/IFastSettlementV3.abi @@ -0,0 +1,457 @@ +[ + { + "type": "function", + "name": "executeWithETH", + "inputs": [ + { + "name": "intent", + "type": "tuple", + "internalType": "struct IFastSettlementV3.Intent", + "components": [ + { + "name": "user", + "type": "address", + "internalType": "address" + }, + { + "name": "inputToken", + "type": "address", + "internalType": "address" + }, + { + "name": "outputToken", + "type": "address", + "internalType": "address" + }, + { + "name": "inputAmt", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "userAmtOut", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "deadline", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "nonce", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "swapData", + "type": "tuple", + "internalType": "struct IFastSettlementV3.SwapCall", + "components": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "data", + "type": "bytes", + "internalType": "bytes" + } + ] + } + ], + "outputs": [ + { + "name": "received", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "surplus", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "executeWithPermit", + "inputs": [ + { + "name": "intent", + "type": "tuple", + "internalType": "struct IFastSettlementV3.Intent", + "components": [ + { + "name": "user", + "type": "address", + "internalType": "address" + }, + { + "name": "inputToken", + "type": "address", + "internalType": "address" + }, + { + "name": "outputToken", + "type": "address", + "internalType": "address" + }, + { + "name": "inputAmt", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "userAmtOut", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "deadline", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "nonce", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "signature", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "swapData", + "type": "tuple", + "internalType": "struct IFastSettlementV3.SwapCall", + "components": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "data", + "type": "bytes", + "internalType": "bytes" + } + ] + } + ], + "outputs": [ + { + "name": "received", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "surplus", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "rescueTokens", + "inputs": [ + { + "name": "token", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setExecutor", + "inputs": [ + { + "name": "_newExecutor", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setSwapTargets", + "inputs": [ + { + "name": "targets", + "type": "address[]", + "internalType": "address[]" + }, + { + "name": "allowed", + "type": "bool[]", + "internalType": "bool[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setTreasury", + "inputs": [ + { + "name": "_newTreasury", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "ExecutorUpdated", + "inputs": [ + { + "name": "oldExecutor", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newExecutor", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "IntentExecuted", + "inputs": [ + { + "name": "user", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "inputToken", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "outputToken", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "inputAmt", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "userAmtOut", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "received", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "surplus", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "SwapTargetsUpdated", + "inputs": [ + { + "name": "targets", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + }, + { + "name": "allowed", + "type": "bool[]", + "indexed": false, + "internalType": "bool[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "TreasuryUpdated", + "inputs": [ + { + "name": "oldTreasury", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newTreasury", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "ArrayLengthMismatch", + "inputs": [] + }, + { + "type": "error", + "name": "BadCallTarget", + "inputs": [] + }, + { + "type": "error", + "name": "BadExecutor", + "inputs": [] + }, + { + "type": "error", + "name": "BadInputAmt", + "inputs": [] + }, + { + "type": "error", + "name": "BadInputToken", + "inputs": [] + }, + { + "type": "error", + "name": "BadNonce", + "inputs": [] + }, + { + "type": "error", + "name": "BadOwner", + "inputs": [] + }, + { + "type": "error", + "name": "BadRecipient", + "inputs": [] + }, + { + "type": "error", + "name": "BadTreasury", + "inputs": [] + }, + { + "type": "error", + "name": "BadUserAmtOut", + "inputs": [] + }, + { + "type": "error", + "name": "ExpectedETHInput", + "inputs": [] + }, + { + "type": "error", + "name": "InsufficientOut", + "inputs": [ + { + "name": "received", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "userAmtOut", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "type": "error", + "name": "IntentExpired", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidETHAmount", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidPermit2", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidWETH", + "inputs": [] + }, + { + "type": "error", + "name": "UnauthorizedCaller", + "inputs": [] + }, + { + "type": "error", + "name": "UnauthorizedExecutor", + "inputs": [] + }, + { + "type": "error", + "name": "UnauthorizedSwapTarget", + "inputs": [] + } +] diff --git a/contracts-abi/clients/FastSettlementV3/FastSettlementV3.go b/contracts-abi/clients/FastSettlementV3/FastSettlementV3.go new file mode 100644 index 0000000..31f6fd4 --- /dev/null +++ b/contracts-abi/clients/FastSettlementV3/FastSettlementV3.go @@ -0,0 +1,1984 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package fastsettlementv3 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IFastSettlementV3Intent is an auto generated low-level Go binding around an user-defined struct. +type IFastSettlementV3Intent struct { + User common.Address + InputToken common.Address + OutputToken common.Address + InputAmt *big.Int + UserAmtOut *big.Int + Recipient common.Address + Deadline *big.Int + Nonce *big.Int +} + +// IFastSettlementV3SwapCall is an auto generated low-level Go binding around an user-defined struct. +type IFastSettlementV3SwapCall struct { + To common.Address + Value *big.Int + Data []byte +} + +// Fastsettlementv3MetaData contains all meta data concerning the Fastsettlementv3 contract. +var Fastsettlementv3MetaData = &bind.MetaData{ + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_permit2\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_weth\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"receive\",\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"INTENT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"PERMIT2\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPermit2\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"UPGRADE_INTERFACE_VERSION\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"WETH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIWETH\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"WITNESS_TYPE_STRING\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"acceptOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"allowedSwapTargets\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"executeWithETH\",\"inputs\":[{\"name\":\"intent\",\"type\":\"tuple\",\"internalType\":\"structIFastSettlementV3.Intent\",\"components\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"inputToken\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"outputToken\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"inputAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"userAmtOut\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"deadline\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"swapData\",\"type\":\"tuple\",\"internalType\":\"structIFastSettlementV3.SwapCall\",\"components\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"received\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"surplus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"executeWithPermit\",\"inputs\":[{\"name\":\"intent\",\"type\":\"tuple\",\"internalType\":\"structIFastSettlementV3.Intent\",\"components\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"inputToken\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"outputToken\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"inputAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"userAmtOut\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"deadline\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"swapData\",\"type\":\"tuple\",\"internalType\":\"structIFastSettlementV3.SwapCall\",\"components\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"received\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"surplus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"executor\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_executor\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_treasury\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_initialSwapTargets\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingOwner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"proxiableUUID\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"rescueTokens\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setExecutor\",\"inputs\":[{\"name\":\"_newExecutor\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setSwapTargets\",\"inputs\":[{\"name\":\"targets\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"allowed\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setTreasury\",\"inputs\":[{\"name\":\"_newTreasury\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"treasury\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"upgradeToAndCall\",\"inputs\":[{\"name\":\"newImplementation\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"event\",\"name\":\"ExecutorUpdated\",\"inputs\":[{\"name\":\"oldExecutor\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newExecutor\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"IntentExecuted\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"inputToken\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"outputToken\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"inputAmt\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"userAmtOut\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"received\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"surplus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferStarted\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SwapTargetsUpdated\",\"inputs\":[{\"name\":\"targets\",\"type\":\"address[]\",\"indexed\":false,\"internalType\":\"address[]\"},{\"name\":\"allowed\",\"type\":\"bool[]\",\"indexed\":false,\"internalType\":\"bool[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TreasuryUpdated\",\"inputs\":[{\"name\":\"oldTreasury\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newTreasury\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Upgraded\",\"inputs\":[{\"name\":\"implementation\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AddressEmptyCode\",\"inputs\":[{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadCallTarget\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadExecutor\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadInputAmt\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadInputToken\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadNonce\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadOwner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadRecipient\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadTreasury\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadUserAmtOut\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ERC1967InvalidImplementation\",\"inputs\":[{\"name\":\"implementation\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ERC1967NonPayable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ExpectedETHInput\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FailedCall\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientBalance\",\"inputs\":[{\"name\":\"balance\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"needed\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"InsufficientOut\",\"inputs\":[{\"name\":\"received\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"userAmtOut\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"IntentExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidETHAmount\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidInitialization\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidPermit2\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidWETH\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotInitializing\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OwnableInvalidOwner\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"OwnableUnauthorizedAccount\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ReentrancyGuardReentrantCall\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SafeERC20FailedOperation\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"UUPSUnauthorizedCallContext\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UUPSUnsupportedProxiableUUID\",\"inputs\":[{\"name\":\"slot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"UnauthorizedCaller\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UnauthorizedExecutor\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UnauthorizedSwapTarget\",\"inputs\":[]}]", +} + +// Fastsettlementv3ABI is the input ABI used to generate the binding from. +// Deprecated: Use Fastsettlementv3MetaData.ABI instead. +var Fastsettlementv3ABI = Fastsettlementv3MetaData.ABI + +// Fastsettlementv3 is an auto generated Go binding around an Ethereum contract. +type Fastsettlementv3 struct { + Fastsettlementv3Caller // Read-only binding to the contract + Fastsettlementv3Transactor // Write-only binding to the contract + Fastsettlementv3Filterer // Log filterer for contract events +} + +// Fastsettlementv3Caller is an auto generated read-only Go binding around an Ethereum contract. +type Fastsettlementv3Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// Fastsettlementv3Transactor is an auto generated write-only Go binding around an Ethereum contract. +type Fastsettlementv3Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// Fastsettlementv3Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type Fastsettlementv3Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// Fastsettlementv3Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type Fastsettlementv3Session struct { + Contract *Fastsettlementv3 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// Fastsettlementv3CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type Fastsettlementv3CallerSession struct { + Contract *Fastsettlementv3Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// Fastsettlementv3TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type Fastsettlementv3TransactorSession struct { + Contract *Fastsettlementv3Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// Fastsettlementv3Raw is an auto generated low-level Go binding around an Ethereum contract. +type Fastsettlementv3Raw struct { + Contract *Fastsettlementv3 // Generic contract binding to access the raw methods on +} + +// Fastsettlementv3CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type Fastsettlementv3CallerRaw struct { + Contract *Fastsettlementv3Caller // Generic read-only contract binding to access the raw methods on +} + +// Fastsettlementv3TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type Fastsettlementv3TransactorRaw struct { + Contract *Fastsettlementv3Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewFastsettlementv3 creates a new instance of Fastsettlementv3, bound to a specific deployed contract. +func NewFastsettlementv3(address common.Address, backend bind.ContractBackend) (*Fastsettlementv3, error) { + contract, err := bindFastsettlementv3(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Fastsettlementv3{Fastsettlementv3Caller: Fastsettlementv3Caller{contract: contract}, Fastsettlementv3Transactor: Fastsettlementv3Transactor{contract: contract}, Fastsettlementv3Filterer: Fastsettlementv3Filterer{contract: contract}}, nil +} + +// NewFastsettlementv3Caller creates a new read-only instance of Fastsettlementv3, bound to a specific deployed contract. +func NewFastsettlementv3Caller(address common.Address, caller bind.ContractCaller) (*Fastsettlementv3Caller, error) { + contract, err := bindFastsettlementv3(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &Fastsettlementv3Caller{contract: contract}, nil +} + +// NewFastsettlementv3Transactor creates a new write-only instance of Fastsettlementv3, bound to a specific deployed contract. +func NewFastsettlementv3Transactor(address common.Address, transactor bind.ContractTransactor) (*Fastsettlementv3Transactor, error) { + contract, err := bindFastsettlementv3(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &Fastsettlementv3Transactor{contract: contract}, nil +} + +// NewFastsettlementv3Filterer creates a new log filterer instance of Fastsettlementv3, bound to a specific deployed contract. +func NewFastsettlementv3Filterer(address common.Address, filterer bind.ContractFilterer) (*Fastsettlementv3Filterer, error) { + contract, err := bindFastsettlementv3(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &Fastsettlementv3Filterer{contract: contract}, nil +} + +// bindFastsettlementv3 binds a generic wrapper to an already deployed contract. +func bindFastsettlementv3(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := Fastsettlementv3MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Fastsettlementv3 *Fastsettlementv3Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Fastsettlementv3.Contract.Fastsettlementv3Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Fastsettlementv3 *Fastsettlementv3Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.Fastsettlementv3Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Fastsettlementv3 *Fastsettlementv3Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.Fastsettlementv3Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Fastsettlementv3 *Fastsettlementv3CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Fastsettlementv3.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Fastsettlementv3 *Fastsettlementv3TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Fastsettlementv3 *Fastsettlementv3TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.contract.Transact(opts, method, params...) +} + +// INTENTTYPEHASH is a free data retrieval call binding the contract method 0xb082a274. +// +// Solidity: function INTENT_TYPEHASH() view returns(bytes32) +func (_Fastsettlementv3 *Fastsettlementv3Caller) INTENTTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "INTENT_TYPEHASH") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// INTENTTYPEHASH is a free data retrieval call binding the contract method 0xb082a274. +// +// Solidity: function INTENT_TYPEHASH() view returns(bytes32) +func (_Fastsettlementv3 *Fastsettlementv3Session) INTENTTYPEHASH() ([32]byte, error) { + return _Fastsettlementv3.Contract.INTENTTYPEHASH(&_Fastsettlementv3.CallOpts) +} + +// INTENTTYPEHASH is a free data retrieval call binding the contract method 0xb082a274. +// +// Solidity: function INTENT_TYPEHASH() view returns(bytes32) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) INTENTTYPEHASH() ([32]byte, error) { + return _Fastsettlementv3.Contract.INTENTTYPEHASH(&_Fastsettlementv3.CallOpts) +} + +// PERMIT2 is a free data retrieval call binding the contract method 0x6afdd850. +// +// Solidity: function PERMIT2() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Caller) PERMIT2(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "PERMIT2") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// PERMIT2 is a free data retrieval call binding the contract method 0x6afdd850. +// +// Solidity: function PERMIT2() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Session) PERMIT2() (common.Address, error) { + return _Fastsettlementv3.Contract.PERMIT2(&_Fastsettlementv3.CallOpts) +} + +// PERMIT2 is a free data retrieval call binding the contract method 0x6afdd850. +// +// Solidity: function PERMIT2() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) PERMIT2() (common.Address, error) { + return _Fastsettlementv3.Contract.PERMIT2(&_Fastsettlementv3.CallOpts) +} + +// UPGRADEINTERFACEVERSION is a free data retrieval call binding the contract method 0xad3cb1cc. +// +// Solidity: function UPGRADE_INTERFACE_VERSION() view returns(string) +func (_Fastsettlementv3 *Fastsettlementv3Caller) UPGRADEINTERFACEVERSION(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "UPGRADE_INTERFACE_VERSION") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// UPGRADEINTERFACEVERSION is a free data retrieval call binding the contract method 0xad3cb1cc. +// +// Solidity: function UPGRADE_INTERFACE_VERSION() view returns(string) +func (_Fastsettlementv3 *Fastsettlementv3Session) UPGRADEINTERFACEVERSION() (string, error) { + return _Fastsettlementv3.Contract.UPGRADEINTERFACEVERSION(&_Fastsettlementv3.CallOpts) +} + +// UPGRADEINTERFACEVERSION is a free data retrieval call binding the contract method 0xad3cb1cc. +// +// Solidity: function UPGRADE_INTERFACE_VERSION() view returns(string) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) UPGRADEINTERFACEVERSION() (string, error) { + return _Fastsettlementv3.Contract.UPGRADEINTERFACEVERSION(&_Fastsettlementv3.CallOpts) +} + +// WETH is a free data retrieval call binding the contract method 0xad5c4648. +// +// Solidity: function WETH() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Caller) WETH(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "WETH") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// WETH is a free data retrieval call binding the contract method 0xad5c4648. +// +// Solidity: function WETH() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Session) WETH() (common.Address, error) { + return _Fastsettlementv3.Contract.WETH(&_Fastsettlementv3.CallOpts) +} + +// WETH is a free data retrieval call binding the contract method 0xad5c4648. +// +// Solidity: function WETH() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) WETH() (common.Address, error) { + return _Fastsettlementv3.Contract.WETH(&_Fastsettlementv3.CallOpts) +} + +// WITNESSTYPESTRING is a free data retrieval call binding the contract method 0x156e2152. +// +// Solidity: function WITNESS_TYPE_STRING() view returns(string) +func (_Fastsettlementv3 *Fastsettlementv3Caller) WITNESSTYPESTRING(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "WITNESS_TYPE_STRING") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// WITNESSTYPESTRING is a free data retrieval call binding the contract method 0x156e2152. +// +// Solidity: function WITNESS_TYPE_STRING() view returns(string) +func (_Fastsettlementv3 *Fastsettlementv3Session) WITNESSTYPESTRING() (string, error) { + return _Fastsettlementv3.Contract.WITNESSTYPESTRING(&_Fastsettlementv3.CallOpts) +} + +// WITNESSTYPESTRING is a free data retrieval call binding the contract method 0x156e2152. +// +// Solidity: function WITNESS_TYPE_STRING() view returns(string) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) WITNESSTYPESTRING() (string, error) { + return _Fastsettlementv3.Contract.WITNESSTYPESTRING(&_Fastsettlementv3.CallOpts) +} + +// AllowedSwapTargets is a free data retrieval call binding the contract method 0x1fa1fe36. +// +// Solidity: function allowedSwapTargets(address ) view returns(bool) +func (_Fastsettlementv3 *Fastsettlementv3Caller) AllowedSwapTargets(opts *bind.CallOpts, arg0 common.Address) (bool, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "allowedSwapTargets", arg0) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// AllowedSwapTargets is a free data retrieval call binding the contract method 0x1fa1fe36. +// +// Solidity: function allowedSwapTargets(address ) view returns(bool) +func (_Fastsettlementv3 *Fastsettlementv3Session) AllowedSwapTargets(arg0 common.Address) (bool, error) { + return _Fastsettlementv3.Contract.AllowedSwapTargets(&_Fastsettlementv3.CallOpts, arg0) +} + +// AllowedSwapTargets is a free data retrieval call binding the contract method 0x1fa1fe36. +// +// Solidity: function allowedSwapTargets(address ) view returns(bool) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) AllowedSwapTargets(arg0 common.Address) (bool, error) { + return _Fastsettlementv3.Contract.AllowedSwapTargets(&_Fastsettlementv3.CallOpts, arg0) +} + +// Executor is a free data retrieval call binding the contract method 0xc34c08e5. +// +// Solidity: function executor() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Caller) Executor(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "executor") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Executor is a free data retrieval call binding the contract method 0xc34c08e5. +// +// Solidity: function executor() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Session) Executor() (common.Address, error) { + return _Fastsettlementv3.Contract.Executor(&_Fastsettlementv3.CallOpts) +} + +// Executor is a free data retrieval call binding the contract method 0xc34c08e5. +// +// Solidity: function executor() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) Executor() (common.Address, error) { + return _Fastsettlementv3.Contract.Executor(&_Fastsettlementv3.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Caller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Session) Owner() (common.Address, error) { + return _Fastsettlementv3.Contract.Owner(&_Fastsettlementv3.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) Owner() (common.Address, error) { + return _Fastsettlementv3.Contract.Owner(&_Fastsettlementv3.CallOpts) +} + +// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978. +// +// Solidity: function pendingOwner() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Caller) PendingOwner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "pendingOwner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978. +// +// Solidity: function pendingOwner() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Session) PendingOwner() (common.Address, error) { + return _Fastsettlementv3.Contract.PendingOwner(&_Fastsettlementv3.CallOpts) +} + +// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978. +// +// Solidity: function pendingOwner() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) PendingOwner() (common.Address, error) { + return _Fastsettlementv3.Contract.PendingOwner(&_Fastsettlementv3.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_Fastsettlementv3 *Fastsettlementv3Caller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "proxiableUUID") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_Fastsettlementv3 *Fastsettlementv3Session) ProxiableUUID() ([32]byte, error) { + return _Fastsettlementv3.Contract.ProxiableUUID(&_Fastsettlementv3.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) ProxiableUUID() ([32]byte, error) { + return _Fastsettlementv3.Contract.ProxiableUUID(&_Fastsettlementv3.CallOpts) +} + +// Treasury is a free data retrieval call binding the contract method 0x61d027b3. +// +// Solidity: function treasury() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Caller) Treasury(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Fastsettlementv3.contract.Call(opts, &out, "treasury") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Treasury is a free data retrieval call binding the contract method 0x61d027b3. +// +// Solidity: function treasury() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3Session) Treasury() (common.Address, error) { + return _Fastsettlementv3.Contract.Treasury(&_Fastsettlementv3.CallOpts) +} + +// Treasury is a free data retrieval call binding the contract method 0x61d027b3. +// +// Solidity: function treasury() view returns(address) +func (_Fastsettlementv3 *Fastsettlementv3CallerSession) Treasury() (common.Address, error) { + return _Fastsettlementv3.Contract.Treasury(&_Fastsettlementv3.CallOpts) +} + +// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097. +// +// Solidity: function acceptOwnership() returns() +func (_Fastsettlementv3 *Fastsettlementv3Transactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "acceptOwnership") +} + +// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097. +// +// Solidity: function acceptOwnership() returns() +func (_Fastsettlementv3 *Fastsettlementv3Session) AcceptOwnership() (*types.Transaction, error) { + return _Fastsettlementv3.Contract.AcceptOwnership(&_Fastsettlementv3.TransactOpts) +} + +// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097. +// +// Solidity: function acceptOwnership() returns() +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) AcceptOwnership() (*types.Transaction, error) { + return _Fastsettlementv3.Contract.AcceptOwnership(&_Fastsettlementv3.TransactOpts) +} + +// ExecuteWithETH is a paid mutator transaction binding the contract method 0x1fb7a307. +// +// Solidity: function executeWithETH((address,address,address,uint256,uint256,address,uint256,uint256) intent, (address,uint256,bytes) swapData) payable returns(uint256 received, uint256 surplus) +func (_Fastsettlementv3 *Fastsettlementv3Transactor) ExecuteWithETH(opts *bind.TransactOpts, intent IFastSettlementV3Intent, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "executeWithETH", intent, swapData) +} + +// ExecuteWithETH is a paid mutator transaction binding the contract method 0x1fb7a307. +// +// Solidity: function executeWithETH((address,address,address,uint256,uint256,address,uint256,uint256) intent, (address,uint256,bytes) swapData) payable returns(uint256 received, uint256 surplus) +func (_Fastsettlementv3 *Fastsettlementv3Session) ExecuteWithETH(intent IFastSettlementV3Intent, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.ExecuteWithETH(&_Fastsettlementv3.TransactOpts, intent, swapData) +} + +// ExecuteWithETH is a paid mutator transaction binding the contract method 0x1fb7a307. +// +// Solidity: function executeWithETH((address,address,address,uint256,uint256,address,uint256,uint256) intent, (address,uint256,bytes) swapData) payable returns(uint256 received, uint256 surplus) +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) ExecuteWithETH(intent IFastSettlementV3Intent, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.ExecuteWithETH(&_Fastsettlementv3.TransactOpts, intent, swapData) +} + +// ExecuteWithPermit is a paid mutator transaction binding the contract method 0x02c52a55. +// +// Solidity: function executeWithPermit((address,address,address,uint256,uint256,address,uint256,uint256) intent, bytes signature, (address,uint256,bytes) swapData) returns(uint256 received, uint256 surplus) +func (_Fastsettlementv3 *Fastsettlementv3Transactor) ExecuteWithPermit(opts *bind.TransactOpts, intent IFastSettlementV3Intent, signature []byte, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "executeWithPermit", intent, signature, swapData) +} + +// ExecuteWithPermit is a paid mutator transaction binding the contract method 0x02c52a55. +// +// Solidity: function executeWithPermit((address,address,address,uint256,uint256,address,uint256,uint256) intent, bytes signature, (address,uint256,bytes) swapData) returns(uint256 received, uint256 surplus) +func (_Fastsettlementv3 *Fastsettlementv3Session) ExecuteWithPermit(intent IFastSettlementV3Intent, signature []byte, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.ExecuteWithPermit(&_Fastsettlementv3.TransactOpts, intent, signature, swapData) +} + +// ExecuteWithPermit is a paid mutator transaction binding the contract method 0x02c52a55. +// +// Solidity: function executeWithPermit((address,address,address,uint256,uint256,address,uint256,uint256) intent, bytes signature, (address,uint256,bytes) swapData) returns(uint256 received, uint256 surplus) +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) ExecuteWithPermit(intent IFastSettlementV3Intent, signature []byte, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.ExecuteWithPermit(&_Fastsettlementv3.TransactOpts, intent, signature, swapData) +} + +// Initialize is a paid mutator transaction binding the contract method 0xe6bfbfd8. +// +// Solidity: function initialize(address _owner, address _executor, address _treasury, address[] _initialSwapTargets) returns() +func (_Fastsettlementv3 *Fastsettlementv3Transactor) Initialize(opts *bind.TransactOpts, _owner common.Address, _executor common.Address, _treasury common.Address, _initialSwapTargets []common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "initialize", _owner, _executor, _treasury, _initialSwapTargets) +} + +// Initialize is a paid mutator transaction binding the contract method 0xe6bfbfd8. +// +// Solidity: function initialize(address _owner, address _executor, address _treasury, address[] _initialSwapTargets) returns() +func (_Fastsettlementv3 *Fastsettlementv3Session) Initialize(_owner common.Address, _executor common.Address, _treasury common.Address, _initialSwapTargets []common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.Initialize(&_Fastsettlementv3.TransactOpts, _owner, _executor, _treasury, _initialSwapTargets) +} + +// Initialize is a paid mutator transaction binding the contract method 0xe6bfbfd8. +// +// Solidity: function initialize(address _owner, address _executor, address _treasury, address[] _initialSwapTargets) returns() +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) Initialize(_owner common.Address, _executor common.Address, _treasury common.Address, _initialSwapTargets []common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.Initialize(&_Fastsettlementv3.TransactOpts, _owner, _executor, _treasury, _initialSwapTargets) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Fastsettlementv3 *Fastsettlementv3Transactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Fastsettlementv3 *Fastsettlementv3Session) RenounceOwnership() (*types.Transaction, error) { + return _Fastsettlementv3.Contract.RenounceOwnership(&_Fastsettlementv3.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _Fastsettlementv3.Contract.RenounceOwnership(&_Fastsettlementv3.TransactOpts) +} + +// RescueTokens is a paid mutator transaction binding the contract method 0x57376198. +// +// Solidity: function rescueTokens(address token, uint256 amount) returns() +func (_Fastsettlementv3 *Fastsettlementv3Transactor) RescueTokens(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "rescueTokens", token, amount) +} + +// RescueTokens is a paid mutator transaction binding the contract method 0x57376198. +// +// Solidity: function rescueTokens(address token, uint256 amount) returns() +func (_Fastsettlementv3 *Fastsettlementv3Session) RescueTokens(token common.Address, amount *big.Int) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.RescueTokens(&_Fastsettlementv3.TransactOpts, token, amount) +} + +// RescueTokens is a paid mutator transaction binding the contract method 0x57376198. +// +// Solidity: function rescueTokens(address token, uint256 amount) returns() +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) RescueTokens(token common.Address, amount *big.Int) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.RescueTokens(&_Fastsettlementv3.TransactOpts, token, amount) +} + +// SetExecutor is a paid mutator transaction binding the contract method 0x1c3c0ea8. +// +// Solidity: function setExecutor(address _newExecutor) returns() +func (_Fastsettlementv3 *Fastsettlementv3Transactor) SetExecutor(opts *bind.TransactOpts, _newExecutor common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "setExecutor", _newExecutor) +} + +// SetExecutor is a paid mutator transaction binding the contract method 0x1c3c0ea8. +// +// Solidity: function setExecutor(address _newExecutor) returns() +func (_Fastsettlementv3 *Fastsettlementv3Session) SetExecutor(_newExecutor common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.SetExecutor(&_Fastsettlementv3.TransactOpts, _newExecutor) +} + +// SetExecutor is a paid mutator transaction binding the contract method 0x1c3c0ea8. +// +// Solidity: function setExecutor(address _newExecutor) returns() +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) SetExecutor(_newExecutor common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.SetExecutor(&_Fastsettlementv3.TransactOpts, _newExecutor) +} + +// SetSwapTargets is a paid mutator transaction binding the contract method 0x57d6924c. +// +// Solidity: function setSwapTargets(address[] targets, bool[] allowed) returns() +func (_Fastsettlementv3 *Fastsettlementv3Transactor) SetSwapTargets(opts *bind.TransactOpts, targets []common.Address, allowed []bool) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "setSwapTargets", targets, allowed) +} + +// SetSwapTargets is a paid mutator transaction binding the contract method 0x57d6924c. +// +// Solidity: function setSwapTargets(address[] targets, bool[] allowed) returns() +func (_Fastsettlementv3 *Fastsettlementv3Session) SetSwapTargets(targets []common.Address, allowed []bool) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.SetSwapTargets(&_Fastsettlementv3.TransactOpts, targets, allowed) +} + +// SetSwapTargets is a paid mutator transaction binding the contract method 0x57d6924c. +// +// Solidity: function setSwapTargets(address[] targets, bool[] allowed) returns() +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) SetSwapTargets(targets []common.Address, allowed []bool) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.SetSwapTargets(&_Fastsettlementv3.TransactOpts, targets, allowed) +} + +// SetTreasury is a paid mutator transaction binding the contract method 0xf0f44260. +// +// Solidity: function setTreasury(address _newTreasury) returns() +func (_Fastsettlementv3 *Fastsettlementv3Transactor) SetTreasury(opts *bind.TransactOpts, _newTreasury common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "setTreasury", _newTreasury) +} + +// SetTreasury is a paid mutator transaction binding the contract method 0xf0f44260. +// +// Solidity: function setTreasury(address _newTreasury) returns() +func (_Fastsettlementv3 *Fastsettlementv3Session) SetTreasury(_newTreasury common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.SetTreasury(&_Fastsettlementv3.TransactOpts, _newTreasury) +} + +// SetTreasury is a paid mutator transaction binding the contract method 0xf0f44260. +// +// Solidity: function setTreasury(address _newTreasury) returns() +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) SetTreasury(_newTreasury common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.SetTreasury(&_Fastsettlementv3.TransactOpts, _newTreasury) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Fastsettlementv3 *Fastsettlementv3Transactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Fastsettlementv3 *Fastsettlementv3Session) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.TransferOwnership(&_Fastsettlementv3.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.TransferOwnership(&_Fastsettlementv3.TransactOpts, newOwner) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Fastsettlementv3 *Fastsettlementv3Transactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Fastsettlementv3.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Fastsettlementv3 *Fastsettlementv3Session) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.UpgradeToAndCall(&_Fastsettlementv3.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Fastsettlementv3.Contract.UpgradeToAndCall(&_Fastsettlementv3.TransactOpts, newImplementation, data) +} + +// Receive is a paid mutator transaction binding the contract receive function. +// +// Solidity: receive() payable returns() +func (_Fastsettlementv3 *Fastsettlementv3Transactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Fastsettlementv3.contract.RawTransact(opts, nil) // calldata is disallowed for receive function +} + +// Receive is a paid mutator transaction binding the contract receive function. +// +// Solidity: receive() payable returns() +func (_Fastsettlementv3 *Fastsettlementv3Session) Receive() (*types.Transaction, error) { + return _Fastsettlementv3.Contract.Receive(&_Fastsettlementv3.TransactOpts) +} + +// Receive is a paid mutator transaction binding the contract receive function. +// +// Solidity: receive() payable returns() +func (_Fastsettlementv3 *Fastsettlementv3TransactorSession) Receive() (*types.Transaction, error) { + return _Fastsettlementv3.Contract.Receive(&_Fastsettlementv3.TransactOpts) +} + +// Fastsettlementv3ExecutorUpdatedIterator is returned from FilterExecutorUpdated and is used to iterate over the raw logs and unpacked data for ExecutorUpdated events raised by the Fastsettlementv3 contract. +type Fastsettlementv3ExecutorUpdatedIterator struct { + Event *Fastsettlementv3ExecutorUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Fastsettlementv3ExecutorUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3ExecutorUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3ExecutorUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Fastsettlementv3ExecutorUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Fastsettlementv3ExecutorUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Fastsettlementv3ExecutorUpdated represents a ExecutorUpdated event raised by the Fastsettlementv3 contract. +type Fastsettlementv3ExecutorUpdated struct { + OldExecutor common.Address + NewExecutor common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutorUpdated is a free log retrieval operation binding the contract event 0x0ef3c7eb9dbcf33ddf032f4cce366a07eda85eed03e3172e4a90c4cc16d57886. +// +// Solidity: event ExecutorUpdated(address indexed oldExecutor, address indexed newExecutor) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) FilterExecutorUpdated(opts *bind.FilterOpts, oldExecutor []common.Address, newExecutor []common.Address) (*Fastsettlementv3ExecutorUpdatedIterator, error) { + + var oldExecutorRule []interface{} + for _, oldExecutorItem := range oldExecutor { + oldExecutorRule = append(oldExecutorRule, oldExecutorItem) + } + var newExecutorRule []interface{} + for _, newExecutorItem := range newExecutor { + newExecutorRule = append(newExecutorRule, newExecutorItem) + } + + logs, sub, err := _Fastsettlementv3.contract.FilterLogs(opts, "ExecutorUpdated", oldExecutorRule, newExecutorRule) + if err != nil { + return nil, err + } + return &Fastsettlementv3ExecutorUpdatedIterator{contract: _Fastsettlementv3.contract, event: "ExecutorUpdated", logs: logs, sub: sub}, nil +} + +// WatchExecutorUpdated is a free log subscription operation binding the contract event 0x0ef3c7eb9dbcf33ddf032f4cce366a07eda85eed03e3172e4a90c4cc16d57886. +// +// Solidity: event ExecutorUpdated(address indexed oldExecutor, address indexed newExecutor) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) WatchExecutorUpdated(opts *bind.WatchOpts, sink chan<- *Fastsettlementv3ExecutorUpdated, oldExecutor []common.Address, newExecutor []common.Address) (event.Subscription, error) { + + var oldExecutorRule []interface{} + for _, oldExecutorItem := range oldExecutor { + oldExecutorRule = append(oldExecutorRule, oldExecutorItem) + } + var newExecutorRule []interface{} + for _, newExecutorItem := range newExecutor { + newExecutorRule = append(newExecutorRule, newExecutorItem) + } + + logs, sub, err := _Fastsettlementv3.contract.WatchLogs(opts, "ExecutorUpdated", oldExecutorRule, newExecutorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Fastsettlementv3ExecutorUpdated) + if err := _Fastsettlementv3.contract.UnpackLog(event, "ExecutorUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseExecutorUpdated is a log parse operation binding the contract event 0x0ef3c7eb9dbcf33ddf032f4cce366a07eda85eed03e3172e4a90c4cc16d57886. +// +// Solidity: event ExecutorUpdated(address indexed oldExecutor, address indexed newExecutor) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) ParseExecutorUpdated(log types.Log) (*Fastsettlementv3ExecutorUpdated, error) { + event := new(Fastsettlementv3ExecutorUpdated) + if err := _Fastsettlementv3.contract.UnpackLog(event, "ExecutorUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// Fastsettlementv3InitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Fastsettlementv3 contract. +type Fastsettlementv3InitializedIterator struct { + Event *Fastsettlementv3Initialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Fastsettlementv3InitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3Initialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3Initialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Fastsettlementv3InitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Fastsettlementv3InitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Fastsettlementv3Initialized represents a Initialized event raised by the Fastsettlementv3 contract. +type Fastsettlementv3Initialized struct { + Version uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2. +// +// Solidity: event Initialized(uint64 version) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) FilterInitialized(opts *bind.FilterOpts) (*Fastsettlementv3InitializedIterator, error) { + + logs, sub, err := _Fastsettlementv3.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &Fastsettlementv3InitializedIterator{contract: _Fastsettlementv3.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2. +// +// Solidity: event Initialized(uint64 version) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *Fastsettlementv3Initialized) (event.Subscription, error) { + + logs, sub, err := _Fastsettlementv3.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Fastsettlementv3Initialized) + if err := _Fastsettlementv3.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2. +// +// Solidity: event Initialized(uint64 version) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) ParseInitialized(log types.Log) (*Fastsettlementv3Initialized, error) { + event := new(Fastsettlementv3Initialized) + if err := _Fastsettlementv3.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// Fastsettlementv3IntentExecutedIterator is returned from FilterIntentExecuted and is used to iterate over the raw logs and unpacked data for IntentExecuted events raised by the Fastsettlementv3 contract. +type Fastsettlementv3IntentExecutedIterator struct { + Event *Fastsettlementv3IntentExecuted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Fastsettlementv3IntentExecutedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3IntentExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3IntentExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Fastsettlementv3IntentExecutedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Fastsettlementv3IntentExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Fastsettlementv3IntentExecuted represents a IntentExecuted event raised by the Fastsettlementv3 contract. +type Fastsettlementv3IntentExecuted struct { + User common.Address + InputToken common.Address + OutputToken common.Address + InputAmt *big.Int + UserAmtOut *big.Int + Received *big.Int + Surplus *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterIntentExecuted is a free log retrieval operation binding the contract event 0x1ad6a4af59e844de3a921ec3dba60cb46f0b9051c9a106258624709dff629a87. +// +// Solidity: event IntentExecuted(address indexed user, address indexed inputToken, address indexed outputToken, uint256 inputAmt, uint256 userAmtOut, uint256 received, uint256 surplus) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) FilterIntentExecuted(opts *bind.FilterOpts, user []common.Address, inputToken []common.Address, outputToken []common.Address) (*Fastsettlementv3IntentExecutedIterator, error) { + + var userRule []interface{} + for _, userItem := range user { + userRule = append(userRule, userItem) + } + var inputTokenRule []interface{} + for _, inputTokenItem := range inputToken { + inputTokenRule = append(inputTokenRule, inputTokenItem) + } + var outputTokenRule []interface{} + for _, outputTokenItem := range outputToken { + outputTokenRule = append(outputTokenRule, outputTokenItem) + } + + logs, sub, err := _Fastsettlementv3.contract.FilterLogs(opts, "IntentExecuted", userRule, inputTokenRule, outputTokenRule) + if err != nil { + return nil, err + } + return &Fastsettlementv3IntentExecutedIterator{contract: _Fastsettlementv3.contract, event: "IntentExecuted", logs: logs, sub: sub}, nil +} + +// WatchIntentExecuted is a free log subscription operation binding the contract event 0x1ad6a4af59e844de3a921ec3dba60cb46f0b9051c9a106258624709dff629a87. +// +// Solidity: event IntentExecuted(address indexed user, address indexed inputToken, address indexed outputToken, uint256 inputAmt, uint256 userAmtOut, uint256 received, uint256 surplus) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) WatchIntentExecuted(opts *bind.WatchOpts, sink chan<- *Fastsettlementv3IntentExecuted, user []common.Address, inputToken []common.Address, outputToken []common.Address) (event.Subscription, error) { + + var userRule []interface{} + for _, userItem := range user { + userRule = append(userRule, userItem) + } + var inputTokenRule []interface{} + for _, inputTokenItem := range inputToken { + inputTokenRule = append(inputTokenRule, inputTokenItem) + } + var outputTokenRule []interface{} + for _, outputTokenItem := range outputToken { + outputTokenRule = append(outputTokenRule, outputTokenItem) + } + + logs, sub, err := _Fastsettlementv3.contract.WatchLogs(opts, "IntentExecuted", userRule, inputTokenRule, outputTokenRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Fastsettlementv3IntentExecuted) + if err := _Fastsettlementv3.contract.UnpackLog(event, "IntentExecuted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseIntentExecuted is a log parse operation binding the contract event 0x1ad6a4af59e844de3a921ec3dba60cb46f0b9051c9a106258624709dff629a87. +// +// Solidity: event IntentExecuted(address indexed user, address indexed inputToken, address indexed outputToken, uint256 inputAmt, uint256 userAmtOut, uint256 received, uint256 surplus) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) ParseIntentExecuted(log types.Log) (*Fastsettlementv3IntentExecuted, error) { + event := new(Fastsettlementv3IntentExecuted) + if err := _Fastsettlementv3.contract.UnpackLog(event, "IntentExecuted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// Fastsettlementv3OwnershipTransferStartedIterator is returned from FilterOwnershipTransferStarted and is used to iterate over the raw logs and unpacked data for OwnershipTransferStarted events raised by the Fastsettlementv3 contract. +type Fastsettlementv3OwnershipTransferStartedIterator struct { + Event *Fastsettlementv3OwnershipTransferStarted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Fastsettlementv3OwnershipTransferStartedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3OwnershipTransferStarted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3OwnershipTransferStarted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Fastsettlementv3OwnershipTransferStartedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Fastsettlementv3OwnershipTransferStartedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Fastsettlementv3OwnershipTransferStarted represents a OwnershipTransferStarted event raised by the Fastsettlementv3 contract. +type Fastsettlementv3OwnershipTransferStarted struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferStarted is a free log retrieval operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700. +// +// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) FilterOwnershipTransferStarted(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*Fastsettlementv3OwnershipTransferStartedIterator, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _Fastsettlementv3.contract.FilterLogs(opts, "OwnershipTransferStarted", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &Fastsettlementv3OwnershipTransferStartedIterator{contract: _Fastsettlementv3.contract, event: "OwnershipTransferStarted", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferStarted is a free log subscription operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700. +// +// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) WatchOwnershipTransferStarted(opts *bind.WatchOpts, sink chan<- *Fastsettlementv3OwnershipTransferStarted, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _Fastsettlementv3.contract.WatchLogs(opts, "OwnershipTransferStarted", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Fastsettlementv3OwnershipTransferStarted) + if err := _Fastsettlementv3.contract.UnpackLog(event, "OwnershipTransferStarted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferStarted is a log parse operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700. +// +// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) ParseOwnershipTransferStarted(log types.Log) (*Fastsettlementv3OwnershipTransferStarted, error) { + event := new(Fastsettlementv3OwnershipTransferStarted) + if err := _Fastsettlementv3.contract.UnpackLog(event, "OwnershipTransferStarted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// Fastsettlementv3OwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Fastsettlementv3 contract. +type Fastsettlementv3OwnershipTransferredIterator struct { + Event *Fastsettlementv3OwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Fastsettlementv3OwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3OwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3OwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Fastsettlementv3OwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Fastsettlementv3OwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Fastsettlementv3OwnershipTransferred represents a OwnershipTransferred event raised by the Fastsettlementv3 contract. +type Fastsettlementv3OwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*Fastsettlementv3OwnershipTransferredIterator, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _Fastsettlementv3.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &Fastsettlementv3OwnershipTransferredIterator{contract: _Fastsettlementv3.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *Fastsettlementv3OwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _Fastsettlementv3.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Fastsettlementv3OwnershipTransferred) + if err := _Fastsettlementv3.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) ParseOwnershipTransferred(log types.Log) (*Fastsettlementv3OwnershipTransferred, error) { + event := new(Fastsettlementv3OwnershipTransferred) + if err := _Fastsettlementv3.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// Fastsettlementv3SwapTargetsUpdatedIterator is returned from FilterSwapTargetsUpdated and is used to iterate over the raw logs and unpacked data for SwapTargetsUpdated events raised by the Fastsettlementv3 contract. +type Fastsettlementv3SwapTargetsUpdatedIterator struct { + Event *Fastsettlementv3SwapTargetsUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Fastsettlementv3SwapTargetsUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3SwapTargetsUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3SwapTargetsUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Fastsettlementv3SwapTargetsUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Fastsettlementv3SwapTargetsUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Fastsettlementv3SwapTargetsUpdated represents a SwapTargetsUpdated event raised by the Fastsettlementv3 contract. +type Fastsettlementv3SwapTargetsUpdated struct { + Targets []common.Address + Allowed []bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSwapTargetsUpdated is a free log retrieval operation binding the contract event 0xe18e0ae71e84871d203445f1d9d5c51bd93bb2e362ee0e455940a88475dc13bc. +// +// Solidity: event SwapTargetsUpdated(address[] targets, bool[] allowed) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) FilterSwapTargetsUpdated(opts *bind.FilterOpts) (*Fastsettlementv3SwapTargetsUpdatedIterator, error) { + + logs, sub, err := _Fastsettlementv3.contract.FilterLogs(opts, "SwapTargetsUpdated") + if err != nil { + return nil, err + } + return &Fastsettlementv3SwapTargetsUpdatedIterator{contract: _Fastsettlementv3.contract, event: "SwapTargetsUpdated", logs: logs, sub: sub}, nil +} + +// WatchSwapTargetsUpdated is a free log subscription operation binding the contract event 0xe18e0ae71e84871d203445f1d9d5c51bd93bb2e362ee0e455940a88475dc13bc. +// +// Solidity: event SwapTargetsUpdated(address[] targets, bool[] allowed) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) WatchSwapTargetsUpdated(opts *bind.WatchOpts, sink chan<- *Fastsettlementv3SwapTargetsUpdated) (event.Subscription, error) { + + logs, sub, err := _Fastsettlementv3.contract.WatchLogs(opts, "SwapTargetsUpdated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Fastsettlementv3SwapTargetsUpdated) + if err := _Fastsettlementv3.contract.UnpackLog(event, "SwapTargetsUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSwapTargetsUpdated is a log parse operation binding the contract event 0xe18e0ae71e84871d203445f1d9d5c51bd93bb2e362ee0e455940a88475dc13bc. +// +// Solidity: event SwapTargetsUpdated(address[] targets, bool[] allowed) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) ParseSwapTargetsUpdated(log types.Log) (*Fastsettlementv3SwapTargetsUpdated, error) { + event := new(Fastsettlementv3SwapTargetsUpdated) + if err := _Fastsettlementv3.contract.UnpackLog(event, "SwapTargetsUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// Fastsettlementv3TreasuryUpdatedIterator is returned from FilterTreasuryUpdated and is used to iterate over the raw logs and unpacked data for TreasuryUpdated events raised by the Fastsettlementv3 contract. +type Fastsettlementv3TreasuryUpdatedIterator struct { + Event *Fastsettlementv3TreasuryUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Fastsettlementv3TreasuryUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3TreasuryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3TreasuryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Fastsettlementv3TreasuryUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Fastsettlementv3TreasuryUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Fastsettlementv3TreasuryUpdated represents a TreasuryUpdated event raised by the Fastsettlementv3 contract. +type Fastsettlementv3TreasuryUpdated struct { + OldTreasury common.Address + NewTreasury common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTreasuryUpdated is a free log retrieval operation binding the contract event 0x4ab5be82436d353e61ca18726e984e561f5c1cc7c6d38b29d2553c790434705a. +// +// Solidity: event TreasuryUpdated(address indexed oldTreasury, address indexed newTreasury) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) FilterTreasuryUpdated(opts *bind.FilterOpts, oldTreasury []common.Address, newTreasury []common.Address) (*Fastsettlementv3TreasuryUpdatedIterator, error) { + + var oldTreasuryRule []interface{} + for _, oldTreasuryItem := range oldTreasury { + oldTreasuryRule = append(oldTreasuryRule, oldTreasuryItem) + } + var newTreasuryRule []interface{} + for _, newTreasuryItem := range newTreasury { + newTreasuryRule = append(newTreasuryRule, newTreasuryItem) + } + + logs, sub, err := _Fastsettlementv3.contract.FilterLogs(opts, "TreasuryUpdated", oldTreasuryRule, newTreasuryRule) + if err != nil { + return nil, err + } + return &Fastsettlementv3TreasuryUpdatedIterator{contract: _Fastsettlementv3.contract, event: "TreasuryUpdated", logs: logs, sub: sub}, nil +} + +// WatchTreasuryUpdated is a free log subscription operation binding the contract event 0x4ab5be82436d353e61ca18726e984e561f5c1cc7c6d38b29d2553c790434705a. +// +// Solidity: event TreasuryUpdated(address indexed oldTreasury, address indexed newTreasury) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) WatchTreasuryUpdated(opts *bind.WatchOpts, sink chan<- *Fastsettlementv3TreasuryUpdated, oldTreasury []common.Address, newTreasury []common.Address) (event.Subscription, error) { + + var oldTreasuryRule []interface{} + for _, oldTreasuryItem := range oldTreasury { + oldTreasuryRule = append(oldTreasuryRule, oldTreasuryItem) + } + var newTreasuryRule []interface{} + for _, newTreasuryItem := range newTreasury { + newTreasuryRule = append(newTreasuryRule, newTreasuryItem) + } + + logs, sub, err := _Fastsettlementv3.contract.WatchLogs(opts, "TreasuryUpdated", oldTreasuryRule, newTreasuryRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Fastsettlementv3TreasuryUpdated) + if err := _Fastsettlementv3.contract.UnpackLog(event, "TreasuryUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTreasuryUpdated is a log parse operation binding the contract event 0x4ab5be82436d353e61ca18726e984e561f5c1cc7c6d38b29d2553c790434705a. +// +// Solidity: event TreasuryUpdated(address indexed oldTreasury, address indexed newTreasury) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) ParseTreasuryUpdated(log types.Log) (*Fastsettlementv3TreasuryUpdated, error) { + event := new(Fastsettlementv3TreasuryUpdated) + if err := _Fastsettlementv3.contract.UnpackLog(event, "TreasuryUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// Fastsettlementv3UpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the Fastsettlementv3 contract. +type Fastsettlementv3UpgradedIterator struct { + Event *Fastsettlementv3Upgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Fastsettlementv3UpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3Upgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Fastsettlementv3Upgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Fastsettlementv3UpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Fastsettlementv3UpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Fastsettlementv3Upgraded represents a Upgraded event raised by the Fastsettlementv3 contract. +type Fastsettlementv3Upgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*Fastsettlementv3UpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _Fastsettlementv3.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &Fastsettlementv3UpgradedIterator{contract: _Fastsettlementv3.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *Fastsettlementv3Upgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _Fastsettlementv3.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Fastsettlementv3Upgraded) + if err := _Fastsettlementv3.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Fastsettlementv3 *Fastsettlementv3Filterer) ParseUpgraded(log types.Log) (*Fastsettlementv3Upgraded, error) { + event := new(Fastsettlementv3Upgraded) + if err := _Fastsettlementv3.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/contracts-abi/clients/IFastSettlementV3/IFastSettlementV3.go b/contracts-abi/clients/IFastSettlementV3/IFastSettlementV3.go new file mode 100644 index 0000000..d1ad112 --- /dev/null +++ b/contracts-abi/clients/IFastSettlementV3/IFastSettlementV3.go @@ -0,0 +1,933 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ifastsettlementv3 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IFastSettlementV3Intent is an auto generated low-level Go binding around an user-defined struct. +type IFastSettlementV3Intent struct { + User common.Address + InputToken common.Address + OutputToken common.Address + InputAmt *big.Int + UserAmtOut *big.Int + Recipient common.Address + Deadline *big.Int + Nonce *big.Int +} + +// IFastSettlementV3SwapCall is an auto generated low-level Go binding around an user-defined struct. +type IFastSettlementV3SwapCall struct { + To common.Address + Value *big.Int + Data []byte +} + +// Ifastsettlementv3MetaData contains all meta data concerning the Ifastsettlementv3 contract. +var Ifastsettlementv3MetaData = &bind.MetaData{ + ABI: "[{\"type\":\"function\",\"name\":\"executeWithETH\",\"inputs\":[{\"name\":\"intent\",\"type\":\"tuple\",\"internalType\":\"structIFastSettlementV3.Intent\",\"components\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"inputToken\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"outputToken\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"inputAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"userAmtOut\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"deadline\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"swapData\",\"type\":\"tuple\",\"internalType\":\"structIFastSettlementV3.SwapCall\",\"components\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"received\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"surplus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"executeWithPermit\",\"inputs\":[{\"name\":\"intent\",\"type\":\"tuple\",\"internalType\":\"structIFastSettlementV3.Intent\",\"components\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"inputToken\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"outputToken\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"inputAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"userAmtOut\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"deadline\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"swapData\",\"type\":\"tuple\",\"internalType\":\"structIFastSettlementV3.SwapCall\",\"components\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"received\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"surplus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"rescueTokens\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setExecutor\",\"inputs\":[{\"name\":\"_newExecutor\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setSwapTargets\",\"inputs\":[{\"name\":\"targets\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"allowed\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setTreasury\",\"inputs\":[{\"name\":\"_newTreasury\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"ExecutorUpdated\",\"inputs\":[{\"name\":\"oldExecutor\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newExecutor\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"IntentExecuted\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"inputToken\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"outputToken\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"inputAmt\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"userAmtOut\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"received\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"surplus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SwapTargetsUpdated\",\"inputs\":[{\"name\":\"targets\",\"type\":\"address[]\",\"indexed\":false,\"internalType\":\"address[]\"},{\"name\":\"allowed\",\"type\":\"bool[]\",\"indexed\":false,\"internalType\":\"bool[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TreasuryUpdated\",\"inputs\":[{\"name\":\"oldTreasury\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newTreasury\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadCallTarget\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadExecutor\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadInputAmt\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadInputToken\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadNonce\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadOwner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadRecipient\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadTreasury\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BadUserAmtOut\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ExpectedETHInput\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientOut\",\"inputs\":[{\"name\":\"received\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"userAmtOut\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"IntentExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidETHAmount\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidPermit2\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidWETH\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UnauthorizedCaller\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UnauthorizedExecutor\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UnauthorizedSwapTarget\",\"inputs\":[]}]", +} + +// Ifastsettlementv3ABI is the input ABI used to generate the binding from. +// Deprecated: Use Ifastsettlementv3MetaData.ABI instead. +var Ifastsettlementv3ABI = Ifastsettlementv3MetaData.ABI + +// Ifastsettlementv3 is an auto generated Go binding around an Ethereum contract. +type Ifastsettlementv3 struct { + Ifastsettlementv3Caller // Read-only binding to the contract + Ifastsettlementv3Transactor // Write-only binding to the contract + Ifastsettlementv3Filterer // Log filterer for contract events +} + +// Ifastsettlementv3Caller is an auto generated read-only Go binding around an Ethereum contract. +type Ifastsettlementv3Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// Ifastsettlementv3Transactor is an auto generated write-only Go binding around an Ethereum contract. +type Ifastsettlementv3Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// Ifastsettlementv3Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type Ifastsettlementv3Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// Ifastsettlementv3Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type Ifastsettlementv3Session struct { + Contract *Ifastsettlementv3 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// Ifastsettlementv3CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type Ifastsettlementv3CallerSession struct { + Contract *Ifastsettlementv3Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// Ifastsettlementv3TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type Ifastsettlementv3TransactorSession struct { + Contract *Ifastsettlementv3Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// Ifastsettlementv3Raw is an auto generated low-level Go binding around an Ethereum contract. +type Ifastsettlementv3Raw struct { + Contract *Ifastsettlementv3 // Generic contract binding to access the raw methods on +} + +// Ifastsettlementv3CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type Ifastsettlementv3CallerRaw struct { + Contract *Ifastsettlementv3Caller // Generic read-only contract binding to access the raw methods on +} + +// Ifastsettlementv3TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type Ifastsettlementv3TransactorRaw struct { + Contract *Ifastsettlementv3Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewIfastsettlementv3 creates a new instance of Ifastsettlementv3, bound to a specific deployed contract. +func NewIfastsettlementv3(address common.Address, backend bind.ContractBackend) (*Ifastsettlementv3, error) { + contract, err := bindIfastsettlementv3(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Ifastsettlementv3{Ifastsettlementv3Caller: Ifastsettlementv3Caller{contract: contract}, Ifastsettlementv3Transactor: Ifastsettlementv3Transactor{contract: contract}, Ifastsettlementv3Filterer: Ifastsettlementv3Filterer{contract: contract}}, nil +} + +// NewIfastsettlementv3Caller creates a new read-only instance of Ifastsettlementv3, bound to a specific deployed contract. +func NewIfastsettlementv3Caller(address common.Address, caller bind.ContractCaller) (*Ifastsettlementv3Caller, error) { + contract, err := bindIfastsettlementv3(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &Ifastsettlementv3Caller{contract: contract}, nil +} + +// NewIfastsettlementv3Transactor creates a new write-only instance of Ifastsettlementv3, bound to a specific deployed contract. +func NewIfastsettlementv3Transactor(address common.Address, transactor bind.ContractTransactor) (*Ifastsettlementv3Transactor, error) { + contract, err := bindIfastsettlementv3(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &Ifastsettlementv3Transactor{contract: contract}, nil +} + +// NewIfastsettlementv3Filterer creates a new log filterer instance of Ifastsettlementv3, bound to a specific deployed contract. +func NewIfastsettlementv3Filterer(address common.Address, filterer bind.ContractFilterer) (*Ifastsettlementv3Filterer, error) { + contract, err := bindIfastsettlementv3(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &Ifastsettlementv3Filterer{contract: contract}, nil +} + +// bindIfastsettlementv3 binds a generic wrapper to an already deployed contract. +func bindIfastsettlementv3(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := Ifastsettlementv3MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Ifastsettlementv3 *Ifastsettlementv3Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Ifastsettlementv3.Contract.Ifastsettlementv3Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Ifastsettlementv3 *Ifastsettlementv3Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.Ifastsettlementv3Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Ifastsettlementv3 *Ifastsettlementv3Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.Ifastsettlementv3Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Ifastsettlementv3 *Ifastsettlementv3CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Ifastsettlementv3.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Ifastsettlementv3 *Ifastsettlementv3TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Ifastsettlementv3 *Ifastsettlementv3TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.contract.Transact(opts, method, params...) +} + +// ExecuteWithETH is a paid mutator transaction binding the contract method 0x1fb7a307. +// +// Solidity: function executeWithETH((address,address,address,uint256,uint256,address,uint256,uint256) intent, (address,uint256,bytes) swapData) payable returns(uint256 received, uint256 surplus) +func (_Ifastsettlementv3 *Ifastsettlementv3Transactor) ExecuteWithETH(opts *bind.TransactOpts, intent IFastSettlementV3Intent, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Ifastsettlementv3.contract.Transact(opts, "executeWithETH", intent, swapData) +} + +// ExecuteWithETH is a paid mutator transaction binding the contract method 0x1fb7a307. +// +// Solidity: function executeWithETH((address,address,address,uint256,uint256,address,uint256,uint256) intent, (address,uint256,bytes) swapData) payable returns(uint256 received, uint256 surplus) +func (_Ifastsettlementv3 *Ifastsettlementv3Session) ExecuteWithETH(intent IFastSettlementV3Intent, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.ExecuteWithETH(&_Ifastsettlementv3.TransactOpts, intent, swapData) +} + +// ExecuteWithETH is a paid mutator transaction binding the contract method 0x1fb7a307. +// +// Solidity: function executeWithETH((address,address,address,uint256,uint256,address,uint256,uint256) intent, (address,uint256,bytes) swapData) payable returns(uint256 received, uint256 surplus) +func (_Ifastsettlementv3 *Ifastsettlementv3TransactorSession) ExecuteWithETH(intent IFastSettlementV3Intent, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.ExecuteWithETH(&_Ifastsettlementv3.TransactOpts, intent, swapData) +} + +// ExecuteWithPermit is a paid mutator transaction binding the contract method 0x02c52a55. +// +// Solidity: function executeWithPermit((address,address,address,uint256,uint256,address,uint256,uint256) intent, bytes signature, (address,uint256,bytes) swapData) returns(uint256 received, uint256 surplus) +func (_Ifastsettlementv3 *Ifastsettlementv3Transactor) ExecuteWithPermit(opts *bind.TransactOpts, intent IFastSettlementV3Intent, signature []byte, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Ifastsettlementv3.contract.Transact(opts, "executeWithPermit", intent, signature, swapData) +} + +// ExecuteWithPermit is a paid mutator transaction binding the contract method 0x02c52a55. +// +// Solidity: function executeWithPermit((address,address,address,uint256,uint256,address,uint256,uint256) intent, bytes signature, (address,uint256,bytes) swapData) returns(uint256 received, uint256 surplus) +func (_Ifastsettlementv3 *Ifastsettlementv3Session) ExecuteWithPermit(intent IFastSettlementV3Intent, signature []byte, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.ExecuteWithPermit(&_Ifastsettlementv3.TransactOpts, intent, signature, swapData) +} + +// ExecuteWithPermit is a paid mutator transaction binding the contract method 0x02c52a55. +// +// Solidity: function executeWithPermit((address,address,address,uint256,uint256,address,uint256,uint256) intent, bytes signature, (address,uint256,bytes) swapData) returns(uint256 received, uint256 surplus) +func (_Ifastsettlementv3 *Ifastsettlementv3TransactorSession) ExecuteWithPermit(intent IFastSettlementV3Intent, signature []byte, swapData IFastSettlementV3SwapCall) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.ExecuteWithPermit(&_Ifastsettlementv3.TransactOpts, intent, signature, swapData) +} + +// RescueTokens is a paid mutator transaction binding the contract method 0x57376198. +// +// Solidity: function rescueTokens(address token, uint256 amount) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3Transactor) RescueTokens(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _Ifastsettlementv3.contract.Transact(opts, "rescueTokens", token, amount) +} + +// RescueTokens is a paid mutator transaction binding the contract method 0x57376198. +// +// Solidity: function rescueTokens(address token, uint256 amount) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3Session) RescueTokens(token common.Address, amount *big.Int) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.RescueTokens(&_Ifastsettlementv3.TransactOpts, token, amount) +} + +// RescueTokens is a paid mutator transaction binding the contract method 0x57376198. +// +// Solidity: function rescueTokens(address token, uint256 amount) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3TransactorSession) RescueTokens(token common.Address, amount *big.Int) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.RescueTokens(&_Ifastsettlementv3.TransactOpts, token, amount) +} + +// SetExecutor is a paid mutator transaction binding the contract method 0x1c3c0ea8. +// +// Solidity: function setExecutor(address _newExecutor) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3Transactor) SetExecutor(opts *bind.TransactOpts, _newExecutor common.Address) (*types.Transaction, error) { + return _Ifastsettlementv3.contract.Transact(opts, "setExecutor", _newExecutor) +} + +// SetExecutor is a paid mutator transaction binding the contract method 0x1c3c0ea8. +// +// Solidity: function setExecutor(address _newExecutor) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3Session) SetExecutor(_newExecutor common.Address) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.SetExecutor(&_Ifastsettlementv3.TransactOpts, _newExecutor) +} + +// SetExecutor is a paid mutator transaction binding the contract method 0x1c3c0ea8. +// +// Solidity: function setExecutor(address _newExecutor) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3TransactorSession) SetExecutor(_newExecutor common.Address) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.SetExecutor(&_Ifastsettlementv3.TransactOpts, _newExecutor) +} + +// SetSwapTargets is a paid mutator transaction binding the contract method 0x57d6924c. +// +// Solidity: function setSwapTargets(address[] targets, bool[] allowed) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3Transactor) SetSwapTargets(opts *bind.TransactOpts, targets []common.Address, allowed []bool) (*types.Transaction, error) { + return _Ifastsettlementv3.contract.Transact(opts, "setSwapTargets", targets, allowed) +} + +// SetSwapTargets is a paid mutator transaction binding the contract method 0x57d6924c. +// +// Solidity: function setSwapTargets(address[] targets, bool[] allowed) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3Session) SetSwapTargets(targets []common.Address, allowed []bool) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.SetSwapTargets(&_Ifastsettlementv3.TransactOpts, targets, allowed) +} + +// SetSwapTargets is a paid mutator transaction binding the contract method 0x57d6924c. +// +// Solidity: function setSwapTargets(address[] targets, bool[] allowed) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3TransactorSession) SetSwapTargets(targets []common.Address, allowed []bool) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.SetSwapTargets(&_Ifastsettlementv3.TransactOpts, targets, allowed) +} + +// SetTreasury is a paid mutator transaction binding the contract method 0xf0f44260. +// +// Solidity: function setTreasury(address _newTreasury) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3Transactor) SetTreasury(opts *bind.TransactOpts, _newTreasury common.Address) (*types.Transaction, error) { + return _Ifastsettlementv3.contract.Transact(opts, "setTreasury", _newTreasury) +} + +// SetTreasury is a paid mutator transaction binding the contract method 0xf0f44260. +// +// Solidity: function setTreasury(address _newTreasury) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3Session) SetTreasury(_newTreasury common.Address) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.SetTreasury(&_Ifastsettlementv3.TransactOpts, _newTreasury) +} + +// SetTreasury is a paid mutator transaction binding the contract method 0xf0f44260. +// +// Solidity: function setTreasury(address _newTreasury) returns() +func (_Ifastsettlementv3 *Ifastsettlementv3TransactorSession) SetTreasury(_newTreasury common.Address) (*types.Transaction, error) { + return _Ifastsettlementv3.Contract.SetTreasury(&_Ifastsettlementv3.TransactOpts, _newTreasury) +} + +// Ifastsettlementv3ExecutorUpdatedIterator is returned from FilterExecutorUpdated and is used to iterate over the raw logs and unpacked data for ExecutorUpdated events raised by the Ifastsettlementv3 contract. +type Ifastsettlementv3ExecutorUpdatedIterator struct { + Event *Ifastsettlementv3ExecutorUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Ifastsettlementv3ExecutorUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Ifastsettlementv3ExecutorUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Ifastsettlementv3ExecutorUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Ifastsettlementv3ExecutorUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Ifastsettlementv3ExecutorUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Ifastsettlementv3ExecutorUpdated represents a ExecutorUpdated event raised by the Ifastsettlementv3 contract. +type Ifastsettlementv3ExecutorUpdated struct { + OldExecutor common.Address + NewExecutor common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutorUpdated is a free log retrieval operation binding the contract event 0x0ef3c7eb9dbcf33ddf032f4cce366a07eda85eed03e3172e4a90c4cc16d57886. +// +// Solidity: event ExecutorUpdated(address indexed oldExecutor, address indexed newExecutor) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) FilterExecutorUpdated(opts *bind.FilterOpts, oldExecutor []common.Address, newExecutor []common.Address) (*Ifastsettlementv3ExecutorUpdatedIterator, error) { + + var oldExecutorRule []interface{} + for _, oldExecutorItem := range oldExecutor { + oldExecutorRule = append(oldExecutorRule, oldExecutorItem) + } + var newExecutorRule []interface{} + for _, newExecutorItem := range newExecutor { + newExecutorRule = append(newExecutorRule, newExecutorItem) + } + + logs, sub, err := _Ifastsettlementv3.contract.FilterLogs(opts, "ExecutorUpdated", oldExecutorRule, newExecutorRule) + if err != nil { + return nil, err + } + return &Ifastsettlementv3ExecutorUpdatedIterator{contract: _Ifastsettlementv3.contract, event: "ExecutorUpdated", logs: logs, sub: sub}, nil +} + +// WatchExecutorUpdated is a free log subscription operation binding the contract event 0x0ef3c7eb9dbcf33ddf032f4cce366a07eda85eed03e3172e4a90c4cc16d57886. +// +// Solidity: event ExecutorUpdated(address indexed oldExecutor, address indexed newExecutor) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) WatchExecutorUpdated(opts *bind.WatchOpts, sink chan<- *Ifastsettlementv3ExecutorUpdated, oldExecutor []common.Address, newExecutor []common.Address) (event.Subscription, error) { + + var oldExecutorRule []interface{} + for _, oldExecutorItem := range oldExecutor { + oldExecutorRule = append(oldExecutorRule, oldExecutorItem) + } + var newExecutorRule []interface{} + for _, newExecutorItem := range newExecutor { + newExecutorRule = append(newExecutorRule, newExecutorItem) + } + + logs, sub, err := _Ifastsettlementv3.contract.WatchLogs(opts, "ExecutorUpdated", oldExecutorRule, newExecutorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Ifastsettlementv3ExecutorUpdated) + if err := _Ifastsettlementv3.contract.UnpackLog(event, "ExecutorUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseExecutorUpdated is a log parse operation binding the contract event 0x0ef3c7eb9dbcf33ddf032f4cce366a07eda85eed03e3172e4a90c4cc16d57886. +// +// Solidity: event ExecutorUpdated(address indexed oldExecutor, address indexed newExecutor) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) ParseExecutorUpdated(log types.Log) (*Ifastsettlementv3ExecutorUpdated, error) { + event := new(Ifastsettlementv3ExecutorUpdated) + if err := _Ifastsettlementv3.contract.UnpackLog(event, "ExecutorUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// Ifastsettlementv3IntentExecutedIterator is returned from FilterIntentExecuted and is used to iterate over the raw logs and unpacked data for IntentExecuted events raised by the Ifastsettlementv3 contract. +type Ifastsettlementv3IntentExecutedIterator struct { + Event *Ifastsettlementv3IntentExecuted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Ifastsettlementv3IntentExecutedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Ifastsettlementv3IntentExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Ifastsettlementv3IntentExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Ifastsettlementv3IntentExecutedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Ifastsettlementv3IntentExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Ifastsettlementv3IntentExecuted represents a IntentExecuted event raised by the Ifastsettlementv3 contract. +type Ifastsettlementv3IntentExecuted struct { + User common.Address + InputToken common.Address + OutputToken common.Address + InputAmt *big.Int + UserAmtOut *big.Int + Received *big.Int + Surplus *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterIntentExecuted is a free log retrieval operation binding the contract event 0x1ad6a4af59e844de3a921ec3dba60cb46f0b9051c9a106258624709dff629a87. +// +// Solidity: event IntentExecuted(address indexed user, address indexed inputToken, address indexed outputToken, uint256 inputAmt, uint256 userAmtOut, uint256 received, uint256 surplus) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) FilterIntentExecuted(opts *bind.FilterOpts, user []common.Address, inputToken []common.Address, outputToken []common.Address) (*Ifastsettlementv3IntentExecutedIterator, error) { + + var userRule []interface{} + for _, userItem := range user { + userRule = append(userRule, userItem) + } + var inputTokenRule []interface{} + for _, inputTokenItem := range inputToken { + inputTokenRule = append(inputTokenRule, inputTokenItem) + } + var outputTokenRule []interface{} + for _, outputTokenItem := range outputToken { + outputTokenRule = append(outputTokenRule, outputTokenItem) + } + + logs, sub, err := _Ifastsettlementv3.contract.FilterLogs(opts, "IntentExecuted", userRule, inputTokenRule, outputTokenRule) + if err != nil { + return nil, err + } + return &Ifastsettlementv3IntentExecutedIterator{contract: _Ifastsettlementv3.contract, event: "IntentExecuted", logs: logs, sub: sub}, nil +} + +// WatchIntentExecuted is a free log subscription operation binding the contract event 0x1ad6a4af59e844de3a921ec3dba60cb46f0b9051c9a106258624709dff629a87. +// +// Solidity: event IntentExecuted(address indexed user, address indexed inputToken, address indexed outputToken, uint256 inputAmt, uint256 userAmtOut, uint256 received, uint256 surplus) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) WatchIntentExecuted(opts *bind.WatchOpts, sink chan<- *Ifastsettlementv3IntentExecuted, user []common.Address, inputToken []common.Address, outputToken []common.Address) (event.Subscription, error) { + + var userRule []interface{} + for _, userItem := range user { + userRule = append(userRule, userItem) + } + var inputTokenRule []interface{} + for _, inputTokenItem := range inputToken { + inputTokenRule = append(inputTokenRule, inputTokenItem) + } + var outputTokenRule []interface{} + for _, outputTokenItem := range outputToken { + outputTokenRule = append(outputTokenRule, outputTokenItem) + } + + logs, sub, err := _Ifastsettlementv3.contract.WatchLogs(opts, "IntentExecuted", userRule, inputTokenRule, outputTokenRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Ifastsettlementv3IntentExecuted) + if err := _Ifastsettlementv3.contract.UnpackLog(event, "IntentExecuted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseIntentExecuted is a log parse operation binding the contract event 0x1ad6a4af59e844de3a921ec3dba60cb46f0b9051c9a106258624709dff629a87. +// +// Solidity: event IntentExecuted(address indexed user, address indexed inputToken, address indexed outputToken, uint256 inputAmt, uint256 userAmtOut, uint256 received, uint256 surplus) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) ParseIntentExecuted(log types.Log) (*Ifastsettlementv3IntentExecuted, error) { + event := new(Ifastsettlementv3IntentExecuted) + if err := _Ifastsettlementv3.contract.UnpackLog(event, "IntentExecuted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// Ifastsettlementv3SwapTargetsUpdatedIterator is returned from FilterSwapTargetsUpdated and is used to iterate over the raw logs and unpacked data for SwapTargetsUpdated events raised by the Ifastsettlementv3 contract. +type Ifastsettlementv3SwapTargetsUpdatedIterator struct { + Event *Ifastsettlementv3SwapTargetsUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Ifastsettlementv3SwapTargetsUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Ifastsettlementv3SwapTargetsUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Ifastsettlementv3SwapTargetsUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Ifastsettlementv3SwapTargetsUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Ifastsettlementv3SwapTargetsUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Ifastsettlementv3SwapTargetsUpdated represents a SwapTargetsUpdated event raised by the Ifastsettlementv3 contract. +type Ifastsettlementv3SwapTargetsUpdated struct { + Targets []common.Address + Allowed []bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSwapTargetsUpdated is a free log retrieval operation binding the contract event 0xe18e0ae71e84871d203445f1d9d5c51bd93bb2e362ee0e455940a88475dc13bc. +// +// Solidity: event SwapTargetsUpdated(address[] targets, bool[] allowed) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) FilterSwapTargetsUpdated(opts *bind.FilterOpts) (*Ifastsettlementv3SwapTargetsUpdatedIterator, error) { + + logs, sub, err := _Ifastsettlementv3.contract.FilterLogs(opts, "SwapTargetsUpdated") + if err != nil { + return nil, err + } + return &Ifastsettlementv3SwapTargetsUpdatedIterator{contract: _Ifastsettlementv3.contract, event: "SwapTargetsUpdated", logs: logs, sub: sub}, nil +} + +// WatchSwapTargetsUpdated is a free log subscription operation binding the contract event 0xe18e0ae71e84871d203445f1d9d5c51bd93bb2e362ee0e455940a88475dc13bc. +// +// Solidity: event SwapTargetsUpdated(address[] targets, bool[] allowed) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) WatchSwapTargetsUpdated(opts *bind.WatchOpts, sink chan<- *Ifastsettlementv3SwapTargetsUpdated) (event.Subscription, error) { + + logs, sub, err := _Ifastsettlementv3.contract.WatchLogs(opts, "SwapTargetsUpdated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Ifastsettlementv3SwapTargetsUpdated) + if err := _Ifastsettlementv3.contract.UnpackLog(event, "SwapTargetsUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSwapTargetsUpdated is a log parse operation binding the contract event 0xe18e0ae71e84871d203445f1d9d5c51bd93bb2e362ee0e455940a88475dc13bc. +// +// Solidity: event SwapTargetsUpdated(address[] targets, bool[] allowed) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) ParseSwapTargetsUpdated(log types.Log) (*Ifastsettlementv3SwapTargetsUpdated, error) { + event := new(Ifastsettlementv3SwapTargetsUpdated) + if err := _Ifastsettlementv3.contract.UnpackLog(event, "SwapTargetsUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// Ifastsettlementv3TreasuryUpdatedIterator is returned from FilterTreasuryUpdated and is used to iterate over the raw logs and unpacked data for TreasuryUpdated events raised by the Ifastsettlementv3 contract. +type Ifastsettlementv3TreasuryUpdatedIterator struct { + Event *Ifastsettlementv3TreasuryUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *Ifastsettlementv3TreasuryUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(Ifastsettlementv3TreasuryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(Ifastsettlementv3TreasuryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *Ifastsettlementv3TreasuryUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *Ifastsettlementv3TreasuryUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Ifastsettlementv3TreasuryUpdated represents a TreasuryUpdated event raised by the Ifastsettlementv3 contract. +type Ifastsettlementv3TreasuryUpdated struct { + OldTreasury common.Address + NewTreasury common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTreasuryUpdated is a free log retrieval operation binding the contract event 0x4ab5be82436d353e61ca18726e984e561f5c1cc7c6d38b29d2553c790434705a. +// +// Solidity: event TreasuryUpdated(address indexed oldTreasury, address indexed newTreasury) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) FilterTreasuryUpdated(opts *bind.FilterOpts, oldTreasury []common.Address, newTreasury []common.Address) (*Ifastsettlementv3TreasuryUpdatedIterator, error) { + + var oldTreasuryRule []interface{} + for _, oldTreasuryItem := range oldTreasury { + oldTreasuryRule = append(oldTreasuryRule, oldTreasuryItem) + } + var newTreasuryRule []interface{} + for _, newTreasuryItem := range newTreasury { + newTreasuryRule = append(newTreasuryRule, newTreasuryItem) + } + + logs, sub, err := _Ifastsettlementv3.contract.FilterLogs(opts, "TreasuryUpdated", oldTreasuryRule, newTreasuryRule) + if err != nil { + return nil, err + } + return &Ifastsettlementv3TreasuryUpdatedIterator{contract: _Ifastsettlementv3.contract, event: "TreasuryUpdated", logs: logs, sub: sub}, nil +} + +// WatchTreasuryUpdated is a free log subscription operation binding the contract event 0x4ab5be82436d353e61ca18726e984e561f5c1cc7c6d38b29d2553c790434705a. +// +// Solidity: event TreasuryUpdated(address indexed oldTreasury, address indexed newTreasury) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) WatchTreasuryUpdated(opts *bind.WatchOpts, sink chan<- *Ifastsettlementv3TreasuryUpdated, oldTreasury []common.Address, newTreasury []common.Address) (event.Subscription, error) { + + var oldTreasuryRule []interface{} + for _, oldTreasuryItem := range oldTreasury { + oldTreasuryRule = append(oldTreasuryRule, oldTreasuryItem) + } + var newTreasuryRule []interface{} + for _, newTreasuryItem := range newTreasury { + newTreasuryRule = append(newTreasuryRule, newTreasuryItem) + } + + logs, sub, err := _Ifastsettlementv3.contract.WatchLogs(opts, "TreasuryUpdated", oldTreasuryRule, newTreasuryRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(Ifastsettlementv3TreasuryUpdated) + if err := _Ifastsettlementv3.contract.UnpackLog(event, "TreasuryUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTreasuryUpdated is a log parse operation binding the contract event 0x4ab5be82436d353e61ca18726e984e561f5c1cc7c6d38b29d2553c790434705a. +// +// Solidity: event TreasuryUpdated(address indexed oldTreasury, address indexed newTreasury) +func (_Ifastsettlementv3 *Ifastsettlementv3Filterer) ParseTreasuryUpdated(log types.Log) (*Ifastsettlementv3TreasuryUpdated, error) { + event := new(Ifastsettlementv3TreasuryUpdated) + if err := _Ifastsettlementv3.contract.UnpackLog(event, "TreasuryUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/contracts-abi/go.mod b/contracts-abi/go.mod new file mode 100644 index 0000000..f74b846 --- /dev/null +++ b/contracts-abi/go.mod @@ -0,0 +1,35 @@ +module github.com/primev/fastprotocolapp/contracts-abi + +go 1.22 + +require github.com/ethereum/go-ethereum v1.14.9 + +require ( + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/StackExchange/wmi v1.2.1 // indirect + github.com/bits-and-blooms/bitset v1.13.0 // indirect + github.com/btcsuite/btcd/btcec/v2 v2.3.4 // indirect + github.com/consensys/bavard v0.1.13 // indirect + github.com/consensys/gnark-crypto v0.12.1 // indirect + github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c // indirect + github.com/crate-crypto/go-kzg-4844 v1.0.0 // indirect + github.com/deckarep/golang-set/v2 v2.6.0 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect + github.com/ethereum/c-kzg-4844 v1.0.0 // indirect + github.com/ethereum/go-verkle v0.1.1-0.20240829091221-dffa7562dbe9 // indirect + github.com/fsnotify/fsnotify v1.6.0 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/google/uuid v1.3.0 // indirect + github.com/gorilla/websocket v1.4.2 // indirect + github.com/holiman/uint256 v1.3.1 // indirect + github.com/mmcloughlin/addchain v0.4.0 // indirect + github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect + github.com/supranational/blst v0.3.11 // indirect + github.com/tklauser/go-sysconf v0.3.12 // indirect + github.com/tklauser/numcpus v0.6.1 // indirect + golang.org/x/crypto v0.22.0 // indirect + golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect + golang.org/x/sync v0.7.0 // indirect + golang.org/x/sys v0.22.0 // indirect + rsc.io/tmplfunc v0.0.3 // indirect +) diff --git a/contracts-abi/go.sum b/contracts-abi/go.sum new file mode 100644 index 0000000..9c3f164 --- /dev/null +++ b/contracts-abi/go.sum @@ -0,0 +1,188 @@ +github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ= +github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= +github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= +github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI= +github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI= +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bits-and-blooms/bitset v1.13.0 h1:bAQ9OPNFYbGHV6Nez0tmNI0RiEu7/hxlYJRUA0wFAVE= +github.com/bits-and-blooms/bitset v1.13.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/btcsuite/btcd/btcec/v2 v2.3.4 h1:3EJjcN70HCu/mwqlUsGK8GcNVyLVxFDlWurTXGPFfiQ= +github.com/btcsuite/btcd/btcec/v2 v2.3.4/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= +github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cockroachdb/errors v1.11.3 h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I= +github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8= +github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce h1:giXvy4KSc/6g/esnpM7Geqxka4WSqI1SZc7sMJFd3y4= +github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M= +github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= +github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= +github.com/cockroachdb/pebble v1.1.2 h1:CUh2IPtR4swHlEj48Rhfzw6l/d0qA31fItcIszQVIsA= +github.com/cockroachdb/pebble v1.1.2/go.mod h1:4exszw1r40423ZsmkG/09AFEG83I0uDgfujJdbL6kYU= +github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= +github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= +github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= +github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= +github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= +github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w= +github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c h1:uQYC5Z1mdLRPrZhHjHxufI8+2UG/i25QG92j0Er9p6I= +github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= +github.com/crate-crypto/go-kzg-4844 v1.0.0 h1:TsSgHwrkTKecKJ4kadtHi4b3xHW5dCFUDFnUp1TsawI= +github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/deckarep/golang-set/v2 v2.6.0 h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM= +github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= +github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= +github.com/ethereum/c-kzg-4844 v1.0.0 h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA= +github.com/ethereum/c-kzg-4844 v1.0.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.14.9 h1:J7iwXDrtUyE9FUjUYbd4c9tyzwMh6dTJsKzo9i6SrwA= +github.com/ethereum/go-ethereum v1.14.9/go.mod h1:QeW+MtTpRdBEm2pUFoonByee8zfHv7kGp0wK0odvU1I= +github.com/ethereum/go-verkle v0.1.1-0.20240829091221-dffa7562dbe9 h1:8NfxH2iXvJ60YRB8ChToFTUzl8awsc3cJ8CbLjGIl/A= +github.com/ethereum/go-verkle v0.1.1-0.20240829091221-dffa7562dbe9/go.mod h1:M3b90YRnzqKyyzBEWJGqj8Qff4IDeXnzFw0P9bFw3uk= +github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= +github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= +github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= +github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= +github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= +github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= +github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= +github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= +github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= +github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4= +github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= +github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= +github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= +github.com/holiman/uint256 v1.3.1 h1:JfTzmih28bittyHM8z360dCjIA9dbPIBlcTI6lmctQs= +github.com/holiman/uint256 v1.3.1/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= +github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= +github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= +github.com/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4= +github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= +github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= +github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag= +github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= +github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= +github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= +github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= +github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v1.12.0 h1:C+UIj/QWtmqY13Arb8kwMt5j34/0Z2iKamrJ+ryC0Gg= +github.com/prometheus/client_golang v1.12.0/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY= +github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a h1:CmF68hwI0XsOQ5UwlBopMi2Ow4Pbg32akc4KIVCOm+Y= +github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= +github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4= +github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= +github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU= +github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= +github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= +github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= +github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= +github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= +github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= +github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= +github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= +github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= +github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= +github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= +github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= +github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs= +github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= +golang.org/x/crypto v0.22.0 h1:g1v0xeRhjcugydODzvb3mEM9SQ0HGp9s/nh3COQ/C30= +golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= +golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= +golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI= +golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= +google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= +gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= +rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/contracts-abi/script.sh b/contracts-abi/script.sh new file mode 100755 index 0000000..86e00f1 --- /dev/null +++ b/contracts-abi/script.sh @@ -0,0 +1,52 @@ +#!/bin/bash + +# Generate Go bindings for FastSettlement contracts +# Run from the contracts-abi directory + +set -e + +# Define paths +CONTRACTS_DIR="../contracts" +ABI_DIR="./abi" +GO_CODE_BASE_DIR="./clients" + +# Create directories +mkdir -p "$ABI_DIR" +mkdir -p "$GO_CODE_BASE_DIR" + +# Compile contracts with forge +echo "Compiling contracts..." +forge compile --root "$CONTRACTS_DIR" + +# Function to extract and save the ABI +extract_and_save_abi() { + local json_file="$1" + local abi_file="$2" + echo "Extracting ABI: $json_file -> $abi_file" + jq .abi "$json_file" > "$abi_file" +} + +# Function to generate Go code from ABI +generate_go_code() { + local abi_file="$1" + local contract_name="$2" + local pkg_name="$3" + + local contract_dir="$GO_CODE_BASE_DIR/$contract_name" + mkdir -p "$contract_dir" + + echo "Generating Go bindings: $contract_name" + abigen --abi "$abi_file" --pkg "$pkg_name" --out "$contract_dir/$contract_name.go" +} + +# Extract ABIs +extract_and_save_abi "$CONTRACTS_DIR/out/FastSettlementV3.sol/FastSettlementV3.json" "$ABI_DIR/FastSettlementV3.abi" +extract_and_save_abi "$CONTRACTS_DIR/out/IFastSettlementV3.sol/IFastSettlementV3.json" "$ABI_DIR/IFastSettlementV3.abi" + +echo "ABI files extracted successfully." + +# Generate Go bindings +generate_go_code "$ABI_DIR/FastSettlementV3.abi" "FastSettlementV3" "fastsettlementv3" +generate_go_code "$ABI_DIR/IFastSettlementV3.abi" "IFastSettlementV3" "ifastsettlementv3" + +echo "Go bindings generated successfully in $GO_CODE_BASE_DIR" diff --git a/contracts/script/DeployFastSettlementV3.s.sol b/contracts/script/DeployFastSettlementV3.s.sol new file mode 100644 index 0000000..290b9d1 --- /dev/null +++ b/contracts/script/DeployFastSettlementV3.s.sol @@ -0,0 +1,222 @@ +// Deployment using trezor +// +// - DRY RUN: +// forge script script/DeployFastSettlementV3.s.sol:DeployFastSettlementV3 \ +// --rpc-url $RPC_URL \ +// --sender \ +// -vvvv +// +// - EXECUTE DEPLOYMENT: +// forge script script/DeployFastSettlementV3.s.sol:DeployFastSettlementV3 \ +// --rpc-url $RPC_URL \ +// --broadcast \ +// --verify \ +// --etherscan-api-key $ETHERSCAN_API_KEY \ +// --trezor \ +// --sender \ +// -vvvv + +pragma solidity ^0.8.24; + +import {Script} from "forge-std/Script.sol"; +import {console} from "forge-std/console.sol"; +import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol"; +import {FastSettlementV3} from "../src/FastSettlementV3.sol"; + +/// @dev Deploy script for FastSettlementV3 contract +contract DeployFastSettlementV3 is Script { + struct DeploymentParams { + address owner; + address executor; + address treasury; + address permit2; + address weth; + address[] initialSwapTargets; + } + + struct DeploymentAddresses { + address implementation; + address proxy; + address fastSettlement; + } + + // ============================================================= + // CONFIGURATION + // ============================================================= + + // Ethereum Mainnet addresses + address constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3; + address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; + address constant PRIMEV_TEAM_MULTISIG = 0x9101eda106A443A0fA82375936D0D1680D5a64F5; + address constant TREASURY = 0xfA0B0f5d298d28EFE4d35641724141ef19C05684; + address constant EXECUTOR = 0x959DAD78D5B68986A43cd270134A2704A990AA68; + + // ============================================================= + // MAIN FUNCTION + // ============================================================= + + /// @dev Main deployment function + /// @dev Signer is determined by CLI flags: --trezor, --ledger, or --private-key + function run() external { + DeploymentParams memory params = _loadAndValidateParams(); + _logDeploymentParams(params); + + // vm.startBroadcast() uses the signer from CLI flags + vm.startBroadcast(); + + DeploymentAddresses memory addresses = _deploy(params); + + vm.stopBroadcast(); + + _verifyDeployment(addresses, params); + _logDeploymentSummary(addresses); + } + + /// @dev Loads and validates deployment parameters from constants + function _loadAndValidateParams() internal pure returns (DeploymentParams memory) { + // Barter swap router - whitelisted at deployment + address[] memory initialSwapTargets = new address[](1); + initialSwapTargets[0] = 0x179dC3fb0F2230094894317f307241A52CdB38Aa; + + _validateParams(PRIMEV_TEAM_MULTISIG, EXECUTOR, TREASURY, PERMIT2, WETH); + + return + DeploymentParams({ + owner: PRIMEV_TEAM_MULTISIG, + executor: EXECUTOR, + treasury: TREASURY, + permit2: PERMIT2, + weth: WETH, + initialSwapTargets: initialSwapTargets + }); + } + + /// @dev Validates deployment parameters + function _validateParams( + address owner, + address executor, + address treasury, + address permit2, + address weth + ) internal pure { + require(owner != address(0), "DeployScript: owner cannot be zero address"); + require( + executor != address(0), + "DeployScript: executor cannot be zero address - UPDATE EXECUTOR CONSTANT" + ); + require(treasury != address(0), "DeployScript: treasury cannot be zero address"); + require(permit2 != address(0), "DeployScript: permit2 cannot be zero address"); + require(weth != address(0), "DeployScript: weth cannot be zero address"); + } + + /// @dev Deploys implementation and proxy contracts + /// @dev In dry run mode (without --broadcast), Foundry simulates the deployment + /// @dev In broadcast mode (with --broadcast), this actually deploys to the network + function _deploy(DeploymentParams memory params) internal returns (DeploymentAddresses memory) { + address implementation = _deployImplementation(params); + address proxy = _deployProxy(implementation, params); + address fastSettlement = address(proxy); + + return + DeploymentAddresses({ + implementation: implementation, + proxy: proxy, + fastSettlement: fastSettlement + }); + } + + /// @dev Deploys the implementation contract (with immutables set in constructor) + function _deployImplementation(DeploymentParams memory params) internal returns (address) { + console.log("\n=== Deploying Implementation ==="); + FastSettlementV3 implementation = new FastSettlementV3(params.permit2, params.weth); + console.log("Implementation deployed at:", address(implementation)); + require( + address(implementation) != address(0), + "DeployScript: implementation deployment failed" + ); + return address(implementation); + } + + /// @dev Deploys the proxy contract with initialization + function _deployProxy( + address implementation, + DeploymentParams memory params + ) internal returns (address) { + console.log("\n=== Deploying Proxy ==="); + require(implementation != address(0), "DeployScript: implementation address is zero"); + + bytes memory initData = abi.encodeCall( + FastSettlementV3.initialize, + (params.owner, params.executor, params.treasury, params.initialSwapTargets) + ); + + require(initData.length > 0, "DeployScript: initData cannot be empty"); + + ERC1967Proxy proxy = new ERC1967Proxy(implementation, initData); + address proxyAddress = address(proxy); + console.log("Proxy deployed at:", proxyAddress); + require(proxyAddress != address(0), "DeployScript: proxy deployment failed"); + + return proxyAddress; + } + + /// @dev Verifies the deployment was successful + function _verifyDeployment( + DeploymentAddresses memory addresses, + DeploymentParams memory params + ) internal view { + console.log("\n=== Verifying Deployment ==="); + FastSettlementV3 settlement = FastSettlementV3(payable(addresses.fastSettlement)); + + require(addresses.implementation != address(0), "DeployScript: implementation is zero"); + require(addresses.proxy != address(0), "DeployScript: proxy is zero"); + require(addresses.fastSettlement != address(0), "DeployScript: fastSettlement is zero"); + require( + addresses.implementation != addresses.proxy, + "DeployScript: implementation and proxy cannot be same" + ); + + // Verify immutables + require(address(settlement.PERMIT2()) == params.permit2, "DeployScript: PERMIT2 mismatch"); + require(address(settlement.WETH()) == params.weth, "DeployScript: WETH mismatch"); + + // Verify initialization + require(settlement.executor() == params.executor, "DeployScript: executor mismatch"); + require(settlement.treasury() == params.treasury, "DeployScript: treasury mismatch"); + + console.log("PERMIT2:", address(settlement.PERMIT2())); + console.log("WETH:", address(settlement.WETH())); + console.log("Executor:", settlement.executor()); + console.log("Treasury:", settlement.treasury()); + console.log("Owner:", settlement.owner()); + console.log("Pending Owner:", settlement.pendingOwner()); + console.log("Deployment verified successfully"); + } + + // ============================================================= + // LOGGING FUNCTIONS + // ============================================================= + + /// @dev Logs deployment parameters + function _logDeploymentParams(DeploymentParams memory params) internal pure { + console.log("\n=== Deployment Parameters ==="); + console.log("Owner:", params.owner); + console.log("Executor:", params.executor); + console.log("Treasury:", params.treasury); + console.log("Permit2:", params.permit2); + console.log("WETH:", params.weth); + console.log("Initial Swap Targets:", params.initialSwapTargets.length); + } + + /// @dev Logs deployment summary + function _logDeploymentSummary(DeploymentAddresses memory addresses) internal pure { + console.log("\n=== Deployment Summary ==="); + console.log("Implementation:", addresses.implementation); + console.log("Proxy:", addresses.proxy); + console.log("FastSettlementV3 (proxy):", addresses.fastSettlement); + console.log("\n=== NEXT STEPS ==="); + console.log("1. Configure swap targets via setSwapTargets()"); + console.log("2. Verify contract on Etherscan (if not auto-verified)"); + console.log("\nDeployment completed successfully!"); + } +} diff --git a/contracts/src/FastSettlementV3.sol b/contracts/src/FastSettlementV3.sol index c968498..2a53589 100644 --- a/contracts/src/FastSettlementV3.sol +++ b/contracts/src/FastSettlementV3.sol @@ -55,13 +55,15 @@ contract FastSettlementV3 is } function initialize( + address _owner, address _executor, address _treasury, address[] calldata _initialSwapTargets ) public initializer { + if (_owner == address(0)) revert BadOwner(); if (_treasury == address(0)) revert BadTreasury(); if (_executor == address(0)) revert BadExecutor(); - __Ownable_init(msg.sender); + __Ownable_init(_owner); executor = _executor; treasury = _treasury; diff --git a/contracts/src/interfaces/IFastSettlementV3.sol b/contracts/src/interfaces/IFastSettlementV3.sol index a0444c4..4fff93a 100644 --- a/contracts/src/interfaces/IFastSettlementV3.sol +++ b/contracts/src/interfaces/IFastSettlementV3.sol @@ -43,6 +43,7 @@ interface IFastSettlementV3 { error IntentExpired(); error BadNonce(); + error BadOwner(); error BadTreasury(); error BadExecutor(); error BadRecipient(); diff --git a/contracts/test/FastSettlementV3.t.sol b/contracts/test/FastSettlementV3.t.sol index 348f8e5..4196c8b 100644 --- a/contracts/test/FastSettlementV3.t.sol +++ b/contracts/test/FastSettlementV3.t.sol @@ -144,7 +144,10 @@ contract FastSettlementV3Test is Test { FastSettlementV3 impl = new FastSettlementV3(address(permit2), address(weth)); ERC1967Proxy proxy = new ERC1967Proxy( address(impl), - abi.encodeCall(FastSettlementV3.initialize, (executor, treasury, initialTargets)) + abi.encodeCall( + FastSettlementV3.initialize, + (address(this), executor, treasury, initialTargets) + ) ); settlement = FastSettlementV3(payable(address(proxy))); diff --git a/contracts/test/FastSettlementV3_Integration.t.sol b/contracts/test/FastSettlementV3_Integration.t.sol index 6e59c25..266080e 100644 --- a/contracts/test/FastSettlementV3_Integration.t.sol +++ b/contracts/test/FastSettlementV3_Integration.t.sol @@ -109,7 +109,7 @@ contract FastSettlementV3IntegrationTest is Test { FastSettlementV3 impl = new FastSettlementV3(permit2, address(weth)); ERC1967Proxy proxy = new ERC1967Proxy( address(impl), - abi.encodeCall(FastSettlementV3.initialize, (executor, treasury, initialTargets)) + abi.encodeCall(FastSettlementV3.initialize, (owner, executor, treasury, initialTargets)) ); settlement = FastSettlementV3(payable(address(proxy))); vm.stopPrank();