diff --git a/CHANGELOG.md b/CHANGELOG.md index 4cde95bf2d..b8c6a7903d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,7 @@ ### State Machine Breaking - [#1232](https://github.com/crypto-org-chain/cronos/pull/1232) Adjust require gas in relayer precompile to be closed with actual consumed. +- [#1209](https://github.com/crypto-org-chain/cronos/pull/1209) Support accurate estimate gas in evm tx from relayer. - [#1247](https://github.com/crypto-org-chain/cronos/pull/1247) Update ethermint to develop, go-ethereum to `v1.11.2`. - [#1235](https://github.com/crypto-org-chain/cronos/pull/1235) Add channel detail in ica packet callback. @@ -21,7 +22,6 @@ - [#1239](https://github.com/crypto-org-chain/cronos/pull/1239) Refactor websocket/subscription system to improve performance and stability. - [#1241](https://github.com/crypto-org-chain/cronos/pull/1241) Improve parallelization of memiavl restoration. - *October 17, 2023* ## v1.1.0-rc1 diff --git a/integration_tests/configs/ibc_rly.jsonnet b/integration_tests/configs/ibc_rly.jsonnet index db80c79b02..f8755a7d45 100644 --- a/integration_tests/configs/ibc_rly.jsonnet +++ b/integration_tests/configs/ibc_rly.jsonnet @@ -18,7 +18,7 @@ ibc { relayer+: { chains: [super.chains[0] { max_gas: 1000000, - gas_multiplier: 1.2, + gas_multiplier: 1.1, }] + super.chains[1:], }, } diff --git a/integration_tests/ibc_utils.py b/integration_tests/ibc_utils.py index 2b64e19825..37ce3606b2 100644 --- a/integration_tests/ibc_utils.py +++ b/integration_tests/ibc_utils.py @@ -267,7 +267,6 @@ def check_balance_change(): wait_for_fn("balance change", check_balance_change) assert old_dst_balance + dst_amount == new_dst_balance - # assert that the relayer transactions do enables the dynamic fee extension option. cli = ibc.cronos.cosmos_cli() criteria = "message.action=/ibc.core.channel.v1.MsgChannelOpenInit" @@ -666,9 +665,6 @@ def log_gas_records(cli): records = [] for tx in txs: res = tx["tx_result"] - actions = [] - for event in res["events"]: - for attribute in event["attributes"]: - if attribute["key"] == "action": - actions.append(attribute["value"]) - records.append(res["gas_used"]) + if res["gas_used"]: + records.append(res["gas_used"]) + return records diff --git a/integration_tests/test_ibc_rly_gas.py b/integration_tests/test_ibc_rly_gas.py index fecc15a07d..1c96710fef 100644 --- a/integration_tests/test_ibc_rly_gas.py +++ b/integration_tests/test_ibc_rly_gas.py @@ -21,11 +21,11 @@ def test_ibc(ibc): cli = ibc.cronos.cosmos_cli() wait_for_new_blocks(cli, 1) rly_transfer(ibc) - diff = 0.5 + diff = 0.004 record = log_gas_records(cli) if record: records.append(record) if len(records) == 2: for e1, e2 in zip(*records): - res = e2 / e1 + res = float(e2) / float(e1) assert 1 - diff <= res <= 1 + diff, res diff --git a/nix/default.nix b/nix/default.nix index de060f0175..53b6f64b95 100644 --- a/nix/default.nix +++ b/nix/default.nix @@ -56,7 +56,7 @@ import sources.nixpkgs { name = "rly"; src = sources.relayer; subPackages = [ "." ]; - vendorSha256 = "sha256-IoaGLD3XKRmD61qcr/sPn3aWaa7zYAO9EbMiJFnF5BY="; + vendorSha256 = "sha256-5s5URiAZk59mOfZdUcqYAB/IvzFuBiQH5jDBuh6huTE="; doCheck = false; GOWORK = "off"; postInstall = '' diff --git a/nix/sources.json b/nix/sources.json index e7d83917be..526c6d83ef 100644 --- a/nix/sources.json +++ b/nix/sources.json @@ -126,10 +126,10 @@ "homepage": "https://github.com/crypto-org-chain/relayer", "owner": "crypto-org-chain", "repo": "relayer", - "rev": "e097df316002173930a408cb5a7bce3040131c9c", - "sha256": "0xhgba9db9i56gglpgznpilkv0kb98m299yzgvpla60ldsd41imp", + "rev": "1432eb16fae943d7da2878893129cbf22406238d", + "sha256": "1i1270z9j68vpz0p4awl9v9br1cyp39qfwzsfy8vks1k33ibyzws", "type": "tarball", - "url": "https://github.com/crypto-org-chain/relayer/archive/e097df316002173930a408cb5a7bce3040131c9c.tar.gz", + "url": "https://github.com/crypto-org-chain/relayer/archive/1432eb16fae943d7da2878893129cbf22406238d.tar.gz", "url_template": "https://github.com///archive/.tar.gz" } } diff --git a/scripts/gen-bindings-contracts b/scripts/gen-bindings-contracts index 4c55e25c2b..b32930e0fc 100755 --- a/scripts/gen-bindings-contracts +++ b/scripts/gen-bindings-contracts @@ -2,6 +2,7 @@ solc08 --abi --bin x/cronos/events/bindings/src/CosmosTypes.sol -o build --overwrite solc08 --abi --bin x/cronos/events/bindings/src/Relayer.sol -o build --overwrite +solc08 --abi --bin x/cronos/events/bindings/src/RelayerFunctions.sol -o build --overwrite solc08 --abi --bin x/cronos/events/bindings/src/Bank.sol -o build --overwrite solc08 --abi --bin x/cronos/events/bindings/src/ICA.sol -o build --overwrite solc08 --abi --bin x/cronos/events/bindings/src/ICACallback.sol -o build --overwrite @@ -9,6 +10,7 @@ solc08 --abi --bin x/cronos/events/bindings/src/ICACallback.sol -o build --overw abigen --pkg lib --abi build/CosmosTypes.abi --bin build/CosmosTypes.bin --out x/cronos/events/bindings/cosmos/lib/cosmos_types.abigen.go --type CosmosTypes abigen --pkg relayer --abi build/IRelayerModule.abi --bin build/IRelayerModule.bin --out x/cronos/events/bindings/cosmos/precompile/relayer/i_relayer_module.abigen.go --type RelayerModule +abigen --pkg relayer --abi build/IRelayerFunctions.abi --bin build/IRelayerFunctions.bin --out x/cronos/events/bindings/cosmos/precompile/relayer/i_relayer_functions.abigen.go --type RelayerFunctions abigen --pkg bank --abi build/IBankModule.abi --bin build/IBankModule.bin --out x/cronos/events/bindings/cosmos/precompile/bank/i_bank_module.abigen.go --type BankModule abigen --pkg ica --abi build/IICAModule.abi --bin build/IICAModule.bin --out x/cronos/events/bindings/cosmos/precompile/ica/i_ica_module.abigen.go --type ICAModule abigen --pkg icacallback --abi build/IICACallback.abi --bin build/IICACallback.bin --out x/cronos/events/bindings/cosmos/precompile/icacallback/i_ica_callback.abigen.go --type ICACallback diff --git a/x/cronos/events/bindings/cosmos/precompile/relayer/i_relayer_functions.abigen.go b/x/cronos/events/bindings/cosmos/precompile/relayer/i_relayer_functions.abigen.go new file mode 100644 index 0000000000..cb2702d0b8 --- /dev/null +++ b/x/cronos/events/bindings/cosmos/precompile/relayer/i_relayer_functions.abigen.go @@ -0,0 +1,831 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package relayer + +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 +) + +// RelayerFunctionsMetaData contains all meta data concerning the RelayerFunctions contract. +var RelayerFunctionsMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"acknowledgement\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"channelCloseConfirm\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"channelCloseInit\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"channelOpenAck\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"channelOpenConfirm\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"channelOpenInit\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"channelOpenTry\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"connectionOpenAck\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"connectionOpenConfirm\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"connectionOpenInit\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"connectionOpenTry\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"createClient\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"recvPacket\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"submitMisbehaviour\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"timeout\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"timeoutOnClose\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"updateClient\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndAcknowledgement\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndChannelCloseConfirm\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndChannelCloseInit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndChannelOpenAck\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndChannelOpenConfirm\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndChannelOpenInit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndChannelOpenTry\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndConnectionOpenAck\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndConnectionOpenConfirm\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndConnectionOpenInit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndConnectionOpenTry\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndRecvPacket\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data1\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data2\",\"type\":\"bytes\"}],\"name\":\"updateClientAndTimeout\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeClient\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"}]", +} + +// RelayerFunctionsABI is the input ABI used to generate the binding from. +// Deprecated: Use RelayerFunctionsMetaData.ABI instead. +var RelayerFunctionsABI = RelayerFunctionsMetaData.ABI + +// RelayerFunctions is an auto generated Go binding around an Ethereum contract. +type RelayerFunctions struct { + RelayerFunctionsCaller // Read-only binding to the contract + RelayerFunctionsTransactor // Write-only binding to the contract + RelayerFunctionsFilterer // Log filterer for contract events +} + +// RelayerFunctionsCaller is an auto generated read-only Go binding around an Ethereum contract. +type RelayerFunctionsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// RelayerFunctionsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type RelayerFunctionsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// RelayerFunctionsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type RelayerFunctionsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// RelayerFunctionsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type RelayerFunctionsSession struct { + Contract *RelayerFunctions // 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 +} + +// RelayerFunctionsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type RelayerFunctionsCallerSession struct { + Contract *RelayerFunctionsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// RelayerFunctionsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type RelayerFunctionsTransactorSession struct { + Contract *RelayerFunctionsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// RelayerFunctionsRaw is an auto generated low-level Go binding around an Ethereum contract. +type RelayerFunctionsRaw struct { + Contract *RelayerFunctions // Generic contract binding to access the raw methods on +} + +// RelayerFunctionsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type RelayerFunctionsCallerRaw struct { + Contract *RelayerFunctionsCaller // Generic read-only contract binding to access the raw methods on +} + +// RelayerFunctionsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type RelayerFunctionsTransactorRaw struct { + Contract *RelayerFunctionsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewRelayerFunctions creates a new instance of RelayerFunctions, bound to a specific deployed contract. +func NewRelayerFunctions(address common.Address, backend bind.ContractBackend) (*RelayerFunctions, error) { + contract, err := bindRelayerFunctions(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &RelayerFunctions{RelayerFunctionsCaller: RelayerFunctionsCaller{contract: contract}, RelayerFunctionsTransactor: RelayerFunctionsTransactor{contract: contract}, RelayerFunctionsFilterer: RelayerFunctionsFilterer{contract: contract}}, nil +} + +// NewRelayerFunctionsCaller creates a new read-only instance of RelayerFunctions, bound to a specific deployed contract. +func NewRelayerFunctionsCaller(address common.Address, caller bind.ContractCaller) (*RelayerFunctionsCaller, error) { + contract, err := bindRelayerFunctions(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &RelayerFunctionsCaller{contract: contract}, nil +} + +// NewRelayerFunctionsTransactor creates a new write-only instance of RelayerFunctions, bound to a specific deployed contract. +func NewRelayerFunctionsTransactor(address common.Address, transactor bind.ContractTransactor) (*RelayerFunctionsTransactor, error) { + contract, err := bindRelayerFunctions(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &RelayerFunctionsTransactor{contract: contract}, nil +} + +// NewRelayerFunctionsFilterer creates a new log filterer instance of RelayerFunctions, bound to a specific deployed contract. +func NewRelayerFunctionsFilterer(address common.Address, filterer bind.ContractFilterer) (*RelayerFunctionsFilterer, error) { + contract, err := bindRelayerFunctions(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &RelayerFunctionsFilterer{contract: contract}, nil +} + +// bindRelayerFunctions binds a generic wrapper to an already deployed contract. +func bindRelayerFunctions(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(RelayerFunctionsABI)) + 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 (_RelayerFunctions *RelayerFunctionsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _RelayerFunctions.Contract.RelayerFunctionsCaller.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 (_RelayerFunctions *RelayerFunctionsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _RelayerFunctions.Contract.RelayerFunctionsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_RelayerFunctions *RelayerFunctionsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _RelayerFunctions.Contract.RelayerFunctionsTransactor.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 (_RelayerFunctions *RelayerFunctionsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _RelayerFunctions.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 (_RelayerFunctions *RelayerFunctionsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _RelayerFunctions.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_RelayerFunctions *RelayerFunctionsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _RelayerFunctions.Contract.contract.Transact(opts, method, params...) +} + +// Acknowledgement is a paid mutator transaction binding the contract method 0x07ed2b37. +// +// Solidity: function acknowledgement(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) Acknowledgement(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "acknowledgement", data) +} + +// Acknowledgement is a paid mutator transaction binding the contract method 0x07ed2b37. +// +// Solidity: function acknowledgement(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) Acknowledgement(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.Acknowledgement(&_RelayerFunctions.TransactOpts, data) +} + +// Acknowledgement is a paid mutator transaction binding the contract method 0x07ed2b37. +// +// Solidity: function acknowledgement(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) Acknowledgement(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.Acknowledgement(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelCloseConfirm is a paid mutator transaction binding the contract method 0xc9741674. +// +// Solidity: function channelCloseConfirm(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) ChannelCloseConfirm(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "channelCloseConfirm", data) +} + +// ChannelCloseConfirm is a paid mutator transaction binding the contract method 0xc9741674. +// +// Solidity: function channelCloseConfirm(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) ChannelCloseConfirm(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelCloseConfirm(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelCloseConfirm is a paid mutator transaction binding the contract method 0xc9741674. +// +// Solidity: function channelCloseConfirm(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) ChannelCloseConfirm(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelCloseConfirm(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelCloseInit is a paid mutator transaction binding the contract method 0x44ba8a17. +// +// Solidity: function channelCloseInit(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) ChannelCloseInit(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "channelCloseInit", data) +} + +// ChannelCloseInit is a paid mutator transaction binding the contract method 0x44ba8a17. +// +// Solidity: function channelCloseInit(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) ChannelCloseInit(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelCloseInit(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelCloseInit is a paid mutator transaction binding the contract method 0x44ba8a17. +// +// Solidity: function channelCloseInit(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) ChannelCloseInit(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelCloseInit(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelOpenAck is a paid mutator transaction binding the contract method 0xd859b9f4. +// +// Solidity: function channelOpenAck(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) ChannelOpenAck(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "channelOpenAck", data) +} + +// ChannelOpenAck is a paid mutator transaction binding the contract method 0xd859b9f4. +// +// Solidity: function channelOpenAck(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) ChannelOpenAck(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelOpenAck(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelOpenAck is a paid mutator transaction binding the contract method 0xd859b9f4. +// +// Solidity: function channelOpenAck(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) ChannelOpenAck(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelOpenAck(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelOpenConfirm is a paid mutator transaction binding the contract method 0x5e1fad7d. +// +// Solidity: function channelOpenConfirm(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) ChannelOpenConfirm(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "channelOpenConfirm", data) +} + +// ChannelOpenConfirm is a paid mutator transaction binding the contract method 0x5e1fad7d. +// +// Solidity: function channelOpenConfirm(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) ChannelOpenConfirm(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelOpenConfirm(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelOpenConfirm is a paid mutator transaction binding the contract method 0x5e1fad7d. +// +// Solidity: function channelOpenConfirm(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) ChannelOpenConfirm(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelOpenConfirm(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelOpenInit is a paid mutator transaction binding the contract method 0x63d2dc06. +// +// Solidity: function channelOpenInit(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) ChannelOpenInit(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "channelOpenInit", data) +} + +// ChannelOpenInit is a paid mutator transaction binding the contract method 0x63d2dc06. +// +// Solidity: function channelOpenInit(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) ChannelOpenInit(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelOpenInit(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelOpenInit is a paid mutator transaction binding the contract method 0x63d2dc06. +// +// Solidity: function channelOpenInit(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) ChannelOpenInit(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelOpenInit(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelOpenTry is a paid mutator transaction binding the contract method 0xf45b605e. +// +// Solidity: function channelOpenTry(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) ChannelOpenTry(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "channelOpenTry", data) +} + +// ChannelOpenTry is a paid mutator transaction binding the contract method 0xf45b605e. +// +// Solidity: function channelOpenTry(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) ChannelOpenTry(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelOpenTry(&_RelayerFunctions.TransactOpts, data) +} + +// ChannelOpenTry is a paid mutator transaction binding the contract method 0xf45b605e. +// +// Solidity: function channelOpenTry(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) ChannelOpenTry(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ChannelOpenTry(&_RelayerFunctions.TransactOpts, data) +} + +// ConnectionOpenAck is a paid mutator transaction binding the contract method 0xe9984826. +// +// Solidity: function connectionOpenAck(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) ConnectionOpenAck(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "connectionOpenAck", data) +} + +// ConnectionOpenAck is a paid mutator transaction binding the contract method 0xe9984826. +// +// Solidity: function connectionOpenAck(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) ConnectionOpenAck(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ConnectionOpenAck(&_RelayerFunctions.TransactOpts, data) +} + +// ConnectionOpenAck is a paid mutator transaction binding the contract method 0xe9984826. +// +// Solidity: function connectionOpenAck(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) ConnectionOpenAck(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ConnectionOpenAck(&_RelayerFunctions.TransactOpts, data) +} + +// ConnectionOpenConfirm is a paid mutator transaction binding the contract method 0xb710bcf2. +// +// Solidity: function connectionOpenConfirm(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) ConnectionOpenConfirm(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "connectionOpenConfirm", data) +} + +// ConnectionOpenConfirm is a paid mutator transaction binding the contract method 0xb710bcf2. +// +// Solidity: function connectionOpenConfirm(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) ConnectionOpenConfirm(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ConnectionOpenConfirm(&_RelayerFunctions.TransactOpts, data) +} + +// ConnectionOpenConfirm is a paid mutator transaction binding the contract method 0xb710bcf2. +// +// Solidity: function connectionOpenConfirm(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) ConnectionOpenConfirm(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ConnectionOpenConfirm(&_RelayerFunctions.TransactOpts, data) +} + +// ConnectionOpenInit is a paid mutator transaction binding the contract method 0x528e6644. +// +// Solidity: function connectionOpenInit(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) ConnectionOpenInit(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "connectionOpenInit", data) +} + +// ConnectionOpenInit is a paid mutator transaction binding the contract method 0x528e6644. +// +// Solidity: function connectionOpenInit(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) ConnectionOpenInit(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ConnectionOpenInit(&_RelayerFunctions.TransactOpts, data) +} + +// ConnectionOpenInit is a paid mutator transaction binding the contract method 0x528e6644. +// +// Solidity: function connectionOpenInit(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) ConnectionOpenInit(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ConnectionOpenInit(&_RelayerFunctions.TransactOpts, data) +} + +// ConnectionOpenTry is a paid mutator transaction binding the contract method 0x986fa270. +// +// Solidity: function connectionOpenTry(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) ConnectionOpenTry(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "connectionOpenTry", data) +} + +// ConnectionOpenTry is a paid mutator transaction binding the contract method 0x986fa270. +// +// Solidity: function connectionOpenTry(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) ConnectionOpenTry(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ConnectionOpenTry(&_RelayerFunctions.TransactOpts, data) +} + +// ConnectionOpenTry is a paid mutator transaction binding the contract method 0x986fa270. +// +// Solidity: function connectionOpenTry(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) ConnectionOpenTry(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.ConnectionOpenTry(&_RelayerFunctions.TransactOpts, data) +} + +// CreateClient is a paid mutator transaction binding the contract method 0x3df83afa. +// +// Solidity: function createClient(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) CreateClient(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "createClient", data) +} + +// CreateClient is a paid mutator transaction binding the contract method 0x3df83afa. +// +// Solidity: function createClient(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) CreateClient(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.CreateClient(&_RelayerFunctions.TransactOpts, data) +} + +// CreateClient is a paid mutator transaction binding the contract method 0x3df83afa. +// +// Solidity: function createClient(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) CreateClient(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.CreateClient(&_RelayerFunctions.TransactOpts, data) +} + +// RecvPacket is a paid mutator transaction binding the contract method 0xf6a1539d. +// +// Solidity: function recvPacket(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) RecvPacket(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "recvPacket", data) +} + +// RecvPacket is a paid mutator transaction binding the contract method 0xf6a1539d. +// +// Solidity: function recvPacket(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) RecvPacket(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.RecvPacket(&_RelayerFunctions.TransactOpts, data) +} + +// RecvPacket is a paid mutator transaction binding the contract method 0xf6a1539d. +// +// Solidity: function recvPacket(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) RecvPacket(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.RecvPacket(&_RelayerFunctions.TransactOpts, data) +} + +// SubmitMisbehaviour is a paid mutator transaction binding the contract method 0xa53b1c82. +// +// Solidity: function submitMisbehaviour(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) SubmitMisbehaviour(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "submitMisbehaviour", data) +} + +// SubmitMisbehaviour is a paid mutator transaction binding the contract method 0xa53b1c82. +// +// Solidity: function submitMisbehaviour(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) SubmitMisbehaviour(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.SubmitMisbehaviour(&_RelayerFunctions.TransactOpts, data) +} + +// SubmitMisbehaviour is a paid mutator transaction binding the contract method 0xa53b1c82. +// +// Solidity: function submitMisbehaviour(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) SubmitMisbehaviour(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.SubmitMisbehaviour(&_RelayerFunctions.TransactOpts, data) +} + +// Timeout is a paid mutator transaction binding the contract method 0x6d2a27f6. +// +// Solidity: function timeout(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) Timeout(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "timeout", data) +} + +// Timeout is a paid mutator transaction binding the contract method 0x6d2a27f6. +// +// Solidity: function timeout(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) Timeout(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.Timeout(&_RelayerFunctions.TransactOpts, data) +} + +// Timeout is a paid mutator transaction binding the contract method 0x6d2a27f6. +// +// Solidity: function timeout(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) Timeout(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.Timeout(&_RelayerFunctions.TransactOpts, data) +} + +// TimeoutOnClose is a paid mutator transaction binding the contract method 0x08f5d079. +// +// Solidity: function timeoutOnClose(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) TimeoutOnClose(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "timeoutOnClose", data) +} + +// TimeoutOnClose is a paid mutator transaction binding the contract method 0x08f5d079. +// +// Solidity: function timeoutOnClose(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) TimeoutOnClose(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.TimeoutOnClose(&_RelayerFunctions.TransactOpts, data) +} + +// TimeoutOnClose is a paid mutator transaction binding the contract method 0x08f5d079. +// +// Solidity: function timeoutOnClose(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) TimeoutOnClose(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.TimeoutOnClose(&_RelayerFunctions.TransactOpts, data) +} + +// UpdateClient is a paid mutator transaction binding the contract method 0x0bece356. +// +// Solidity: function updateClient(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClient(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClient", data) +} + +// UpdateClient is a paid mutator transaction binding the contract method 0x0bece356. +// +// Solidity: function updateClient(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClient(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClient(&_RelayerFunctions.TransactOpts, data) +} + +// UpdateClient is a paid mutator transaction binding the contract method 0x0bece356. +// +// Solidity: function updateClient(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClient(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClient(&_RelayerFunctions.TransactOpts, data) +} + +// UpdateClientAndAcknowledgement is a paid mutator transaction binding the contract method 0x65a939c6. +// +// Solidity: function updateClientAndAcknowledgement(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndAcknowledgement(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndAcknowledgement", data1, data2) +} + +// UpdateClientAndAcknowledgement is a paid mutator transaction binding the contract method 0x65a939c6. +// +// Solidity: function updateClientAndAcknowledgement(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndAcknowledgement(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndAcknowledgement(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndAcknowledgement is a paid mutator transaction binding the contract method 0x65a939c6. +// +// Solidity: function updateClientAndAcknowledgement(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndAcknowledgement(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndAcknowledgement(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelCloseConfirm is a paid mutator transaction binding the contract method 0x9bbcbfd2. +// +// Solidity: function updateClientAndChannelCloseConfirm(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndChannelCloseConfirm(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndChannelCloseConfirm", data1, data2) +} + +// UpdateClientAndChannelCloseConfirm is a paid mutator transaction binding the contract method 0x9bbcbfd2. +// +// Solidity: function updateClientAndChannelCloseConfirm(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndChannelCloseConfirm(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelCloseConfirm(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelCloseConfirm is a paid mutator transaction binding the contract method 0x9bbcbfd2. +// +// Solidity: function updateClientAndChannelCloseConfirm(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndChannelCloseConfirm(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelCloseConfirm(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelCloseInit is a paid mutator transaction binding the contract method 0x5447448d. +// +// Solidity: function updateClientAndChannelCloseInit(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndChannelCloseInit(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndChannelCloseInit", data1, data2) +} + +// UpdateClientAndChannelCloseInit is a paid mutator transaction binding the contract method 0x5447448d. +// +// Solidity: function updateClientAndChannelCloseInit(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndChannelCloseInit(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelCloseInit(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelCloseInit is a paid mutator transaction binding the contract method 0x5447448d. +// +// Solidity: function updateClientAndChannelCloseInit(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndChannelCloseInit(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelCloseInit(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelOpenAck is a paid mutator transaction binding the contract method 0xc518ffc8. +// +// Solidity: function updateClientAndChannelOpenAck(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndChannelOpenAck(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndChannelOpenAck", data1, data2) +} + +// UpdateClientAndChannelOpenAck is a paid mutator transaction binding the contract method 0xc518ffc8. +// +// Solidity: function updateClientAndChannelOpenAck(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndChannelOpenAck(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelOpenAck(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelOpenAck is a paid mutator transaction binding the contract method 0xc518ffc8. +// +// Solidity: function updateClientAndChannelOpenAck(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndChannelOpenAck(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelOpenAck(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelOpenConfirm is a paid mutator transaction binding the contract method 0x0982b806. +// +// Solidity: function updateClientAndChannelOpenConfirm(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndChannelOpenConfirm(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndChannelOpenConfirm", data1, data2) +} + +// UpdateClientAndChannelOpenConfirm is a paid mutator transaction binding the contract method 0x0982b806. +// +// Solidity: function updateClientAndChannelOpenConfirm(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndChannelOpenConfirm(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelOpenConfirm(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelOpenConfirm is a paid mutator transaction binding the contract method 0x0982b806. +// +// Solidity: function updateClientAndChannelOpenConfirm(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndChannelOpenConfirm(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelOpenConfirm(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelOpenInit is a paid mutator transaction binding the contract method 0x66365fc4. +// +// Solidity: function updateClientAndChannelOpenInit(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndChannelOpenInit(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndChannelOpenInit", data1, data2) +} + +// UpdateClientAndChannelOpenInit is a paid mutator transaction binding the contract method 0x66365fc4. +// +// Solidity: function updateClientAndChannelOpenInit(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndChannelOpenInit(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelOpenInit(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelOpenInit is a paid mutator transaction binding the contract method 0x66365fc4. +// +// Solidity: function updateClientAndChannelOpenInit(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndChannelOpenInit(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelOpenInit(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelOpenTry is a paid mutator transaction binding the contract method 0x33978088. +// +// Solidity: function updateClientAndChannelOpenTry(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndChannelOpenTry(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndChannelOpenTry", data1, data2) +} + +// UpdateClientAndChannelOpenTry is a paid mutator transaction binding the contract method 0x33978088. +// +// Solidity: function updateClientAndChannelOpenTry(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndChannelOpenTry(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelOpenTry(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndChannelOpenTry is a paid mutator transaction binding the contract method 0x33978088. +// +// Solidity: function updateClientAndChannelOpenTry(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndChannelOpenTry(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndChannelOpenTry(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndConnectionOpenAck is a paid mutator transaction binding the contract method 0xfedb9353. +// +// Solidity: function updateClientAndConnectionOpenAck(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndConnectionOpenAck(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndConnectionOpenAck", data1, data2) +} + +// UpdateClientAndConnectionOpenAck is a paid mutator transaction binding the contract method 0xfedb9353. +// +// Solidity: function updateClientAndConnectionOpenAck(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndConnectionOpenAck(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndConnectionOpenAck(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndConnectionOpenAck is a paid mutator transaction binding the contract method 0xfedb9353. +// +// Solidity: function updateClientAndConnectionOpenAck(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndConnectionOpenAck(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndConnectionOpenAck(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndConnectionOpenConfirm is a paid mutator transaction binding the contract method 0x70009dfc. +// +// Solidity: function updateClientAndConnectionOpenConfirm(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndConnectionOpenConfirm(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndConnectionOpenConfirm", data1, data2) +} + +// UpdateClientAndConnectionOpenConfirm is a paid mutator transaction binding the contract method 0x70009dfc. +// +// Solidity: function updateClientAndConnectionOpenConfirm(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndConnectionOpenConfirm(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndConnectionOpenConfirm(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndConnectionOpenConfirm is a paid mutator transaction binding the contract method 0x70009dfc. +// +// Solidity: function updateClientAndConnectionOpenConfirm(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndConnectionOpenConfirm(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndConnectionOpenConfirm(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndConnectionOpenInit is a paid mutator transaction binding the contract method 0x491e69c7. +// +// Solidity: function updateClientAndConnectionOpenInit(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndConnectionOpenInit(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndConnectionOpenInit", data1, data2) +} + +// UpdateClientAndConnectionOpenInit is a paid mutator transaction binding the contract method 0x491e69c7. +// +// Solidity: function updateClientAndConnectionOpenInit(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndConnectionOpenInit(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndConnectionOpenInit(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndConnectionOpenInit is a paid mutator transaction binding the contract method 0x491e69c7. +// +// Solidity: function updateClientAndConnectionOpenInit(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndConnectionOpenInit(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndConnectionOpenInit(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndConnectionOpenTry is a paid mutator transaction binding the contract method 0x5f3a7169. +// +// Solidity: function updateClientAndConnectionOpenTry(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndConnectionOpenTry(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndConnectionOpenTry", data1, data2) +} + +// UpdateClientAndConnectionOpenTry is a paid mutator transaction binding the contract method 0x5f3a7169. +// +// Solidity: function updateClientAndConnectionOpenTry(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndConnectionOpenTry(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndConnectionOpenTry(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndConnectionOpenTry is a paid mutator transaction binding the contract method 0x5f3a7169. +// +// Solidity: function updateClientAndConnectionOpenTry(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndConnectionOpenTry(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndConnectionOpenTry(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndRecvPacket is a paid mutator transaction binding the contract method 0xd3cffc28. +// +// Solidity: function updateClientAndRecvPacket(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndRecvPacket(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndRecvPacket", data1, data2) +} + +// UpdateClientAndRecvPacket is a paid mutator transaction binding the contract method 0xd3cffc28. +// +// Solidity: function updateClientAndRecvPacket(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndRecvPacket(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndRecvPacket(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndRecvPacket is a paid mutator transaction binding the contract method 0xd3cffc28. +// +// Solidity: function updateClientAndRecvPacket(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndRecvPacket(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndRecvPacket(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndTimeout is a paid mutator transaction binding the contract method 0xca4c72a0. +// +// Solidity: function updateClientAndTimeout(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpdateClientAndTimeout(opts *bind.TransactOpts, data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "updateClientAndTimeout", data1, data2) +} + +// UpdateClientAndTimeout is a paid mutator transaction binding the contract method 0xca4c72a0. +// +// Solidity: function updateClientAndTimeout(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsSession) UpdateClientAndTimeout(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndTimeout(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpdateClientAndTimeout is a paid mutator transaction binding the contract method 0xca4c72a0. +// +// Solidity: function updateClientAndTimeout(bytes data1, bytes data2) payable returns(bool) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpdateClientAndTimeout(data1 []byte, data2 []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpdateClientAndTimeout(&_RelayerFunctions.TransactOpts, data1, data2) +} + +// UpgradeClient is a paid mutator transaction binding the contract method 0x8a8e4c5d. +// +// Solidity: function upgradeClient(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactor) UpgradeClient(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) { + return _RelayerFunctions.contract.Transact(opts, "upgradeClient", data) +} + +// UpgradeClient is a paid mutator transaction binding the contract method 0x8a8e4c5d. +// +// Solidity: function upgradeClient(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsSession) UpgradeClient(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpgradeClient(&_RelayerFunctions.TransactOpts, data) +} + +// UpgradeClient is a paid mutator transaction binding the contract method 0x8a8e4c5d. +// +// Solidity: function upgradeClient(bytes data) payable returns(bytes) +func (_RelayerFunctions *RelayerFunctionsTransactorSession) UpgradeClient(data []byte) (*types.Transaction, error) { + return _RelayerFunctions.Contract.UpgradeClient(&_RelayerFunctions.TransactOpts, data) +} diff --git a/x/cronos/events/bindings/src/RelayerFunctions.sol b/x/cronos/events/bindings/src/RelayerFunctions.sol new file mode 100644 index 0000000000..f580fe5ccb --- /dev/null +++ b/x/cronos/events/bindings/src/RelayerFunctions.sol @@ -0,0 +1,36 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.4; + +interface IRelayerFunctions { + function createClient(bytes calldata data) external payable returns (bytes calldata); + function updateClient(bytes calldata data) external payable returns (bytes calldata); + function upgradeClient(bytes calldata data) external payable returns (bytes calldata); + function submitMisbehaviour(bytes calldata data) external payable returns (bytes calldata); + function connectionOpenInit(bytes calldata data) external payable returns (bytes calldata); + function connectionOpenTry(bytes calldata data) external payable returns (bytes calldata); + function connectionOpenAck(bytes calldata data) external payable returns (bytes calldata); + function connectionOpenConfirm(bytes calldata data) external payable returns (bytes calldata); + function channelOpenInit(bytes calldata data) external payable returns (bytes calldata); + function channelOpenTry(bytes calldata data) external payable returns (bytes calldata); + function channelOpenAck(bytes calldata data) external payable returns (bytes calldata); + function channelOpenConfirm(bytes calldata data) external payable returns (bytes calldata); + function channelCloseInit(bytes calldata data) external payable returns (bytes calldata); + function channelCloseConfirm(bytes calldata data) external payable returns (bytes calldata); + function recvPacket(bytes calldata data) external payable returns (bytes calldata); + function acknowledgement(bytes calldata data) external payable returns (bytes calldata); + function timeout(bytes calldata data) external payable returns (bytes calldata); + function timeoutOnClose(bytes calldata data) external payable returns (bytes calldata); + function updateClientAndConnectionOpenInit(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndConnectionOpenTry(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndConnectionOpenAck(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndConnectionOpenConfirm(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndChannelOpenInit(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndChannelOpenTry(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndChannelOpenAck(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndChannelOpenConfirm(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndRecvPacket(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndAcknowledgement(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndTimeout(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndChannelCloseInit(bytes calldata data1, bytes calldata data2) external payable returns (bool); + function updateClientAndChannelCloseConfirm(bytes calldata data1, bytes calldata data2) external payable returns (bool); +} diff --git a/x/cronos/keeper/precompiles/relayer.go b/x/cronos/keeper/precompiles/relayer.go index 33d6d0b259..88d9d3b17d 100644 --- a/x/cronos/keeper/precompiles/relayer.go +++ b/x/cronos/keeper/precompiles/relayer.go @@ -1,12 +1,12 @@ package precompiles import ( - "encoding/binary" "errors" + "fmt" "github.com/cometbft/cometbft/libs/log" - "github.com/cosmos/cosmos-sdk/codec" + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/vm" @@ -14,33 +14,119 @@ import ( authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" cronosevents "github.com/crypto-org-chain/cronos/v2/x/cronos/events" + "github.com/crypto-org-chain/cronos/v2/x/cronos/events/bindings/cosmos/precompile/relayer" "github.com/crypto-org-chain/cronos/v2/x/cronos/types" ) var ( + irelayerABI abi.ABI relayerContractAddress = common.BytesToAddress([]byte{101}) - relayerGasRequiredByMethod = map[int]uint64{} + relayerMethodNamedByMethod = map[[4]byte]string{} + relayerGasRequiredByMethod = map[[4]byte]uint64{} +) + +const ( + CreateClient = "createClient" + UpdateClient = "updateClient" + UpgradeClient = "upgradeClient" + SubmitMisbehaviour = "submitMisbehaviour" + ConnectionOpenInit = "connectionOpenInit" + ConnectionOpenTry = "connectionOpenTry" + ConnectionOpenAck = "connectionOpenAck" + ConnectionOpenConfirm = "connectionOpenConfirm" + ChannelOpenInit = "channelOpenInit" + ChannelOpenTry = "channelOpenTry" + ChannelOpenAck = "channelOpenAck" + ChannelOpenConfirm = "channelOpenConfirm" + ChannelCloseInit = "channelCloseInit" + ChannelCloseConfirm = "channelCloseConfirm" + RecvPacket = "recvPacket" + Acknowledgement = "acknowledgement" + Timeout = "timeout" + TimeoutOnClose = "timeoutOnClose" + UpdateClientAndConnectionOpenInit = "updateClientAndConnectionOpenInit" + UpdateClientAndConnectionOpenTry = "updateClientAndConnectionOpenTry" + UpdateClientAndConnectionOpenAck = "updateClientAndConnectionOpenAck" + UpdateClientAndConnectionOpenConfirm = "updateClientAndConnectionOpenConfirm" + UpdateClientAndChannelOpenInit = "updateClientAndChannelOpenInit" + UpdateClientAndChannelOpenTry = "updateClientAndChannelOpenTry" + UpdateClientAndChannelOpenAck = "updateClientAndChannelOpenAck" + UpdateClientAndChannelCloseInit = "updateClientAndChannelCloseInit" + UpdateClientAndChannelCloseConfirm = "updateClientAndChannelCloseConfirm" + UpdateClientAndChannelOpenConfirm = "updateClientAndChannelOpenConfirm" + UpdateClientAndRecvPacket = "updateClientAndRecvPacket" + UpdateClientAndAcknowledgement = "updateClientAndAcknowledgement" + UpdateClientAndTimeout = "updateClientAndTimeout" + UpdateClientAndTimeoutOnClose = "updateClientAndTimeoutOnClose" ) func init() { - relayerGasRequiredByMethod[prefixCreateClient] = 117462 - relayerGasRequiredByMethod[prefixUpdateClient] = 111894 - relayerGasRequiredByMethod[prefixUpgradeClient] = 400000 - relayerGasRequiredByMethod[prefixSubmitMisbehaviour] = 100000 - relayerGasRequiredByMethod[prefixConnectionOpenInit] = 19755 - relayerGasRequiredByMethod[prefixConnectionOpenTry] = 38468 - relayerGasRequiredByMethod[prefixConnectionOpenAck] = 29603 - relayerGasRequiredByMethod[prefixConnectionOpenConfirm] = 12865 - relayerGasRequiredByMethod[prefixChannelOpenInit] = 68701 - relayerGasRequiredByMethod[prefixChannelOpenTry] = 70562 - relayerGasRequiredByMethod[prefixChannelOpenAck] = 22127 - relayerGasRequiredByMethod[prefixChannelOpenConfirm] = 21190 - relayerGasRequiredByMethod[prefixChannelCloseInit] = 100000 - relayerGasRequiredByMethod[prefixChannelCloseConfirm] = 31199 - relayerGasRequiredByMethod[prefixRecvPacket] = 144025 - relayerGasRequiredByMethod[prefixAcknowledgement] = 61781 - relayerGasRequiredByMethod[prefixTimeout] = 104283 - relayerGasRequiredByMethod[prefixTimeoutOnClose] = 100000 + if err := irelayerABI.UnmarshalJSON([]byte(relayer.RelayerFunctionsMetaData.ABI)); err != nil { + panic(err) + } + for methodName := range irelayerABI.Methods { + var methodID [4]byte + copy(methodID[:], irelayerABI.Methods[methodName].ID[:4]) + switch methodName { + case CreateClient: + relayerGasRequiredByMethod[methodID] = 117462 + case UpdateClient: + relayerGasRequiredByMethod[methodID] = 111894 + case UpgradeClient: + relayerGasRequiredByMethod[methodID] = 400000 + case ConnectionOpenInit: + relayerGasRequiredByMethod[methodID] = 19755 + case ConnectionOpenTry: + relayerGasRequiredByMethod[methodID] = 38468 + case ConnectionOpenAck: + relayerGasRequiredByMethod[methodID] = 29603 + case ConnectionOpenConfirm: + relayerGasRequiredByMethod[methodID] = 12865 + case ChannelOpenInit: + relayerGasRequiredByMethod[methodID] = 68701 + case ChannelOpenTry: + relayerGasRequiredByMethod[methodID] = 70562 + case ChannelOpenAck: + relayerGasRequiredByMethod[methodID] = 22127 + case ChannelOpenConfirm: + relayerGasRequiredByMethod[methodID] = 21190 + case ChannelCloseConfirm: + relayerGasRequiredByMethod[methodID] = 31199 + case RecvPacket: + relayerGasRequiredByMethod[methodID] = 144025 + case Acknowledgement: + relayerGasRequiredByMethod[methodID] = 61781 + case Timeout: + relayerGasRequiredByMethod[methodID] = 104283 + case UpdateClientAndConnectionOpenTry: + relayerGasRequiredByMethod[methodID] = 150362 + case UpdateClientAndConnectionOpenConfirm: + relayerGasRequiredByMethod[methodID] = 124820 + case UpdateClientAndChannelOpenTry: + relayerGasRequiredByMethod[methodID] = 182676 + case UpdateClientAndChannelOpenConfirm: + relayerGasRequiredByMethod[methodID] = 132734 + case UpdateClientAndRecvPacket: + relayerGasRequiredByMethod[methodID] = 257120 + case UpdateClientAndConnectionOpenInit: + relayerGasRequiredByMethod[methodID] = 131649 + case UpdateClientAndConnectionOpenAck: + relayerGasRequiredByMethod[methodID] = 141558 + case UpdateClientAndChannelOpenInit: + relayerGasRequiredByMethod[methodID] = 180815 + case UpdateClientAndChannelOpenAck: + relayerGasRequiredByMethod[methodID] = 133834 + case UpdateClientAndChannelCloseConfirm: + relayerGasRequiredByMethod[methodID] = 143366 + case UpdateClientAndTimeout: + relayerGasRequiredByMethod[methodID] = 230638 + case UpdateClientAndAcknowledgement: + relayerGasRequiredByMethod[methodID] = 174785 + default: + relayerGasRequiredByMethod[methodID] = 100000 + } + relayerMethodNamedByMethod[methodID] = methodName + } } type RelayerContract struct { @@ -73,23 +159,20 @@ func (bc *RelayerContract) Address() common.Address { // RequiredGas calculates the contract gas use // `max(0, len(input) * DefaultTxSizeCostPerByte + requiredGasTable[methodPrefix] - intrinsicGas)` func (bc *RelayerContract) RequiredGas(input []byte) (gas uint64) { - if len(input) < prefixSize4Bytes { - return 0 - } - intrinsicGas, err := core.IntrinsicGas(input, nil, false, bc.isHomestead, bc.isIstanbul, bc.isShanghai) - if err != nil { - return 0 - } - prefix := int(binary.LittleEndian.Uint32(input[:prefixSize4Bytes])) - requiredGas, ok := relayerGasRequiredByMethod[prefix] - if !ok { - requiredGas = 0 - } // base cost to prevent large input size - baseCost := uint64(len(input)) * authtypes.DefaultTxSizeCostPerByte + inputLen := len(input) + baseCost := uint64(inputLen) * authtypes.DefaultTxSizeCostPerByte + var methodID [4]byte + copy(methodID[:], input[:4]) + requiredGas, ok := relayerGasRequiredByMethod[methodID] + intrinsicGas, _ := core.IntrinsicGas(input, nil, false, bc.isHomestead, bc.isIstanbul, bc.isShanghai) defer func() { - bc.logger.Debug("required", "gas", gas, "method", prefix, "len", len(input), "intrinsic", intrinsicGas) + methodName := relayerMethodNamedByMethod[methodID] + bc.logger.Debug("required", "gas", gas, "method", methodName, "len", inputLen, "intrinsic", intrinsicGas) }() + if !ok { + requiredGas = 0 + } total := requiredGas + baseCost if total < intrinsicGas { return 0 @@ -97,89 +180,107 @@ func (bc *RelayerContract) RequiredGas(input []byte) (gas uint64) { return total - intrinsicGas } -// prefix bytes for the relayer msg type -const ( - prefixSize4Bytes = 4 - // Client - prefixCreateClient = iota + 1 - prefixUpdateClient - prefixUpgradeClient - prefixSubmitMisbehaviour - // Connection - prefixConnectionOpenInit - prefixConnectionOpenTry - prefixConnectionOpenAck - prefixConnectionOpenConfirm - // Channel - prefixChannelOpenInit - prefixChannelOpenTry - prefixChannelOpenAck - prefixChannelOpenConfirm - prefixChannelCloseInit - prefixChannelCloseConfirm - prefixRecvPacket - prefixAcknowledgement - prefixTimeout - prefixTimeoutOnClose -) - func (bc *RelayerContract) Run(evm *vm.EVM, contract *vm.Contract, readonly bool) ([]byte, error) { if readonly { return nil, errors.New("the method is not readonly") } + if len(contract.Input) < 4 { + return nil, errors.New("input too short") + } // parse input - if len(contract.Input) < int(prefixSize4Bytes) { - return nil, errors.New("data too short to contain prefix") + methodID := contract.Input[:4] + method, err := irelayerABI.MethodById(methodID) + if err != nil { + return nil, err } - prefix := int(binary.LittleEndian.Uint32(contract.Input[:prefixSize4Bytes])) - input := contract.Input[prefixSize4Bytes:] stateDB := evm.StateDB.(ExtStateDB) - var ( - err error - res []byte - ) + var res []byte precompileAddr := bc.Address() + args, err := method.Inputs.Unpack(contract.Input[4:]) + if err != nil { + return nil, errors.New("fail to unpack input arguments") + } + input := args[0].([]byte) converter := cronosevents.RelayerConvertEvent - switch prefix { - case prefixCreateClient: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.CreateClient, converter) - case prefixUpdateClient: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.UpdateClient, converter) - case prefixUpgradeClient: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.UpgradeClient, converter) - case prefixSubmitMisbehaviour: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.SubmitMisbehaviour, converter) - case prefixConnectionOpenInit: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.ConnectionOpenInit, converter) - case prefixConnectionOpenTry: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.ConnectionOpenTry, converter) - case prefixConnectionOpenAck: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.ConnectionOpenAck, converter) - case prefixConnectionOpenConfirm: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.ConnectionOpenConfirm, converter) - case prefixChannelOpenInit: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.ChannelOpenInit, converter) - case prefixChannelOpenTry: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.ChannelOpenTry, converter) - case prefixChannelOpenAck: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.ChannelOpenAck, converter) - case prefixChannelOpenConfirm: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.ChannelOpenConfirm, converter) - case prefixChannelCloseInit: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.ChannelCloseInit, converter) - case prefixChannelCloseConfirm: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.ChannelCloseConfirm, converter) - case prefixRecvPacket: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.RecvPacket, converter) - case prefixAcknowledgement: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.Acknowledgement, converter) - case prefixTimeout: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.Timeout, converter) - case prefixTimeoutOnClose: - res, err = exec(bc.cdc, stateDB, contract.CallerAddress, precompileAddr, input, bc.ibcKeeper.TimeoutOnClose, converter) + e := &Executor{ + cdc: bc.cdc, + stateDB: stateDB, + caller: contract.CallerAddress, + contract: precompileAddr, + input: input, + converter: converter, + } + if len(args) > 1 { + e.input2 = args[1].([]byte) + } + switch method.Name { + case CreateClient: + res, err = exec(e, bc.ibcKeeper.CreateClient) + case UpdateClient: + res, err = exec(e, bc.ibcKeeper.UpdateClient) + case UpgradeClient: + res, err = exec(e, bc.ibcKeeper.UpgradeClient) + case SubmitMisbehaviour: + res, err = exec(e, bc.ibcKeeper.SubmitMisbehaviour) + case ConnectionOpenInit: + res, err = exec(e, bc.ibcKeeper.ConnectionOpenInit) + case ConnectionOpenTry: + res, err = exec(e, bc.ibcKeeper.ConnectionOpenTry) + case ConnectionOpenAck: + res, err = exec(e, bc.ibcKeeper.ConnectionOpenAck) + case ConnectionOpenConfirm: + res, err = exec(e, bc.ibcKeeper.ConnectionOpenConfirm) + case ChannelOpenInit: + res, err = exec(e, bc.ibcKeeper.ChannelOpenInit) + case ChannelOpenTry: + res, err = exec(e, bc.ibcKeeper.ChannelOpenTry) + case ChannelOpenAck: + res, err = exec(e, bc.ibcKeeper.ChannelOpenAck) + case ChannelOpenConfirm: + res, err = exec(e, bc.ibcKeeper.ChannelOpenConfirm) + case ChannelCloseInit: + res, err = exec(e, bc.ibcKeeper.ChannelCloseInit) + case ChannelCloseConfirm: + res, err = exec(e, bc.ibcKeeper.ChannelCloseConfirm) + case RecvPacket: + res, err = exec(e, bc.ibcKeeper.RecvPacket) + case Acknowledgement: + res, err = exec(e, bc.ibcKeeper.Acknowledgement) + case Timeout: + res, err = exec(e, bc.ibcKeeper.Timeout) + case TimeoutOnClose: + res, err = exec(e, bc.ibcKeeper.TimeoutOnClose) + case UpdateClientAndConnectionOpenInit: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.ConnectionOpenInit) + case UpdateClientAndConnectionOpenTry: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.ConnectionOpenTry) + case UpdateClientAndConnectionOpenAck: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.ConnectionOpenAck) + case UpdateClientAndConnectionOpenConfirm: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.ConnectionOpenConfirm) + case UpdateClientAndChannelOpenInit: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.ChannelOpenInit) + case UpdateClientAndChannelOpenTry: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.ChannelOpenTry) + case UpdateClientAndChannelCloseInit: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.ChannelCloseInit) + case UpdateClientAndChannelCloseConfirm: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.ChannelCloseConfirm) + case UpdateClientAndChannelOpenAck: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.ChannelOpenAck) + case UpdateClientAndChannelOpenConfirm: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.ChannelOpenConfirm) + case UpdateClientAndRecvPacket: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.RecvPacket) + case UpdateClientAndAcknowledgement: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.Acknowledgement) + case UpdateClientAndTimeout: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.Timeout) + case UpdateClientAndTimeoutOnClose: + res, err = execMultiple(e, bc.ibcKeeper.UpdateClient, bc.ibcKeeper.TimeoutOnClose) default: - return nil, errors.New("unknown method") + return nil, fmt.Errorf("unknown method: %s", method.Name) } return res, err } diff --git a/x/cronos/keeper/precompiles/utils.go b/x/cronos/keeper/precompiles/utils.go index 34c70ceb0d..6c18271abe 100644 --- a/x/cronos/keeper/precompiles/utils.go +++ b/x/cronos/keeper/precompiles/utils.go @@ -16,21 +16,26 @@ type NativeMessage interface { GetSigners() []sdk.AccAddress } +type Executor struct { + cdc codec.Codec + stateDB ExtStateDB + caller common.Address + contract common.Address + input []byte + input2 []byte + converter statedb.EventConverter +} + // exec is a generic function that executes the given action in statedb, and marshal/unmarshal the input/output func exec[Req any, PReq interface { *Req NativeMessage }, Resp codec.ProtoMarshaler]( - cdc codec.Codec, - stateDB ExtStateDB, - caller common.Address, - contract common.Address, - input []byte, + e *Executor, action func(context.Context, PReq) (Resp, error), - converter statedb.EventConverter, ) ([]byte, error) { msg := PReq(new(Req)) - if err := cdc.Unmarshal(input, msg); err != nil { + if err := e.cdc.Unmarshal(e.input, msg); err != nil { return nil, fmt.Errorf("fail to Unmarshal %T %w", msg, err) } @@ -38,12 +43,13 @@ func exec[Req any, PReq interface { if len(signers) != 1 { return nil, errors.New("don't support multi-signers message") } - if common.BytesToAddress(signers[0].Bytes()) != caller { - return nil, errors.New("caller is not authenticated") + caller := common.BytesToAddress(signers[0].Bytes()) + if caller != e.caller { + return nil, fmt.Errorf("caller is not authenticated: expected %s, got %s", e.caller.Hex(), caller.Hex()) } var res Resp - if err := stateDB.ExecuteNativeAction(contract, converter, func(ctx sdk.Context) error { + if err := e.stateDB.ExecuteNativeAction(e.contract, e.converter, func(ctx sdk.Context) error { var err error res, err = action(ctx, msg) return err @@ -51,5 +57,84 @@ func exec[Req any, PReq interface { return nil, err } - return cdc.Marshal(res) + output, err := e.cdc.Marshal(res) + if err != nil { + return nil, fmt.Errorf("fail to Marshal %T %w", res, err) + } + return output, nil +} + +func execMultipleWithHooks[Req any, + PReq interface { + *Req + NativeMessage + }, + Resp codec.ProtoMarshaler, + Req2 any, + PReq2 interface { + *Req2 + NativeMessage + }, + Resp2 codec.ProtoMarshaler, +]( + e *Executor, + preAction func(sdk.Context, PReq, PReq2) error, + action func(context.Context, PReq) (Resp, error), + action2 func(context.Context, PReq2) (Resp2, error), +) ([]byte, error) { + msg := PReq(new(Req)) + if err := e.cdc.Unmarshal(e.input, msg); err != nil { + return nil, fmt.Errorf("fail to Unmarshal %T %w", msg, err) + } + + msg2 := PReq2(new(Req2)) + if err := e.cdc.Unmarshal(e.input2, msg2); err != nil { + return nil, fmt.Errorf("fail to Unmarshal %T %w", msg2, err) + } + + signers := msg.GetSigners() + if len(signers) != 1 { + return nil, fmt.Errorf("expected 1 signer, got %d", len(signers)) + } + if common.BytesToAddress(signers[0].Bytes()) != e.caller { + return nil, errors.New("caller is not authenticated") + } + + var res Resp + if err := e.stateDB.ExecuteNativeAction(e.contract, e.converter, func(ctx sdk.Context) (err error) { + if preAction != nil { + if err = preAction(ctx, msg, msg2); err != nil { + return err + } + } + + res, err = action(ctx, msg) + if err == nil && len(e.input2) > 0 { + _, err = action2(ctx, msg2) + } + return + }); err != nil { + return nil, err + } + return e.cdc.Marshal(res) +} + +func execMultiple[Req any, + PReq interface { + *Req + NativeMessage + }, + Resp codec.ProtoMarshaler, + Req2 any, + PReq2 interface { + *Req2 + NativeMessage + }, + Resp2 codec.ProtoMarshaler, +]( + e *Executor, + action func(context.Context, PReq) (Resp, error), + action2 func(context.Context, PReq2) (Resp2, error), +) ([]byte, error) { + return execMultipleWithHooks(e, nil, action, action2) }