// Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. package mocktokenmessenger 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 ) // AddressMetaData contains all meta data concerning the Address contract. var AddressMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212204751db3d3fcbfa211147ae7cf195b5d5a7cf565d7301c4706af60c8d8e93727f64736f6c63430008110033", } // AddressABI is the input ABI used to generate the binding from. // Deprecated: Use AddressMetaData.ABI instead. var AddressABI = AddressMetaData.ABI // AddressBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use AddressMetaData.Bin instead. var AddressBin = AddressMetaData.Bin // DeployAddress deploys a new Ethereum contract, binding an instance of Address to it. func DeployAddress(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Address, error) { parsed, err := AddressMetaData.GetAbi() if err != nil { return common.Address{}, nil, nil, err } if parsed == nil { return common.Address{}, nil, nil, errors.New("GetABI returned nil") } address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(AddressBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &Address{AddressCaller: AddressCaller{contract: contract}, AddressTransactor: AddressTransactor{contract: contract}, AddressFilterer: AddressFilterer{contract: contract}}, nil } // Address is an auto generated Go binding around an Ethereum contract. type Address struct { AddressCaller // Read-only binding to the contract AddressTransactor // Write-only binding to the contract AddressFilterer // Log filterer for contract events } // AddressCaller is an auto generated read-only Go binding around an Ethereum contract. type AddressCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // AddressTransactor is an auto generated write-only Go binding around an Ethereum contract. type AddressTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // AddressFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type AddressFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // AddressSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type AddressSession struct { Contract *Address // 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 } // AddressCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type AddressCallerSession struct { Contract *AddressCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // AddressTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type AddressTransactorSession struct { Contract *AddressTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // AddressRaw is an auto generated low-level Go binding around an Ethereum contract. type AddressRaw struct { Contract *Address // Generic contract binding to access the raw methods on } // AddressCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type AddressCallerRaw struct { Contract *AddressCaller // Generic read-only contract binding to access the raw methods on } // AddressTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type AddressTransactorRaw struct { Contract *AddressTransactor // Generic write-only contract binding to access the raw methods on } // NewAddress creates a new instance of Address, bound to a specific deployed contract. func NewAddress(address common.Address, backend bind.ContractBackend) (*Address, error) { contract, err := bindAddress(address, backend, backend, backend) if err != nil { return nil, err } return &Address{AddressCaller: AddressCaller{contract: contract}, AddressTransactor: AddressTransactor{contract: contract}, AddressFilterer: AddressFilterer{contract: contract}}, nil } // NewAddressCaller creates a new read-only instance of Address, bound to a specific deployed contract. func NewAddressCaller(address common.Address, caller bind.ContractCaller) (*AddressCaller, error) { contract, err := bindAddress(address, caller, nil, nil) if err != nil { return nil, err } return &AddressCaller{contract: contract}, nil } // NewAddressTransactor creates a new write-only instance of Address, bound to a specific deployed contract. func NewAddressTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressTransactor, error) { contract, err := bindAddress(address, nil, transactor, nil) if err != nil { return nil, err } return &AddressTransactor{contract: contract}, nil } // NewAddressFilterer creates a new log filterer instance of Address, bound to a specific deployed contract. func NewAddressFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressFilterer, error) { contract, err := bindAddress(address, nil, nil, filterer) if err != nil { return nil, err } return &AddressFilterer{contract: contract}, nil } // bindAddress binds a generic wrapper to an already deployed contract. func bindAddress(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := abi.JSON(strings.NewReader(AddressABI)) 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 (_Address *AddressRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _Address.Contract.AddressCaller.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 (_Address *AddressRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _Address.Contract.AddressTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_Address *AddressRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _Address.Contract.AddressTransactor.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 (_Address *AddressCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _Address.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 (_Address *AddressTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _Address.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_Address *AddressTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _Address.Contract.contract.Transact(opts, method, params...) } // IERC20MetaData contains all meta data concerning the IERC20 contract. var IERC20MetaData = &bind.MetaData{ ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", Sigs: map[string]string{ "dd62ed3e": "allowance(address,address)", "095ea7b3": "approve(address,uint256)", "70a08231": "balanceOf(address)", "18160ddd": "totalSupply()", "a9059cbb": "transfer(address,uint256)", "23b872dd": "transferFrom(address,address,uint256)", }, } // IERC20ABI is the input ABI used to generate the binding from. // Deprecated: Use IERC20MetaData.ABI instead. var IERC20ABI = IERC20MetaData.ABI // Deprecated: Use IERC20MetaData.Sigs instead. // IERC20FuncSigs maps the 4-byte function signature to its string representation. var IERC20FuncSigs = IERC20MetaData.Sigs // IERC20 is an auto generated Go binding around an Ethereum contract. type IERC20 struct { IERC20Caller // Read-only binding to the contract IERC20Transactor // Write-only binding to the contract IERC20Filterer // Log filterer for contract events } // IERC20Caller is an auto generated read-only Go binding around an Ethereum contract. type IERC20Caller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // IERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. type IERC20Transactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // IERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. type IERC20Filterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // IERC20Session is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type IERC20Session struct { Contract *IERC20 // 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 } // IERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type IERC20CallerSession struct { Contract *IERC20Caller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // IERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type IERC20TransactorSession struct { Contract *IERC20Transactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // IERC20Raw is an auto generated low-level Go binding around an Ethereum contract. type IERC20Raw struct { Contract *IERC20 // Generic contract binding to access the raw methods on } // IERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type IERC20CallerRaw struct { Contract *IERC20Caller // Generic read-only contract binding to access the raw methods on } // IERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type IERC20TransactorRaw struct { Contract *IERC20Transactor // Generic write-only contract binding to access the raw methods on } // NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract. func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error) { contract, err := bindIERC20(address, backend, backend, backend) if err != nil { return nil, err } return &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, nil } // NewIERC20Caller creates a new read-only instance of IERC20, bound to a specific deployed contract. func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error) { contract, err := bindIERC20(address, caller, nil, nil) if err != nil { return nil, err } return &IERC20Caller{contract: contract}, nil } // NewIERC20Transactor creates a new write-only instance of IERC20, bound to a specific deployed contract. func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error) { contract, err := bindIERC20(address, nil, transactor, nil) if err != nil { return nil, err } return &IERC20Transactor{contract: contract}, nil } // NewIERC20Filterer creates a new log filterer instance of IERC20, bound to a specific deployed contract. func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error) { contract, err := bindIERC20(address, nil, nil, filterer) if err != nil { return nil, err } return &IERC20Filterer{contract: contract}, nil } // bindIERC20 binds a generic wrapper to an already deployed contract. func bindIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := abi.JSON(strings.NewReader(IERC20ABI)) 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 (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _IERC20.Contract.IERC20Caller.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 (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _IERC20.Contract.IERC20Transactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _IERC20.Contract.IERC20Transactor.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 (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _IERC20.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 (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _IERC20.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _IERC20.Contract.contract.Transact(opts, method, params...) } // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. // // Solidity: function allowance(address owner, address spender) view returns(uint256) func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { var out []interface{} err := _IERC20.contract.Call(opts, &out, "allowance", owner, spender) if err != nil { return *new(*big.Int), err } out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) return out0, err } // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. // // Solidity: function allowance(address owner, address spender) view returns(uint256) func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) } // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. // // Solidity: function allowance(address owner, address spender) view returns(uint256) func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) } // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. // // Solidity: function balanceOf(address account) view returns(uint256) func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { var out []interface{} err := _IERC20.contract.Call(opts, &out, "balanceOf", account) if err != nil { return *new(*big.Int), err } out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) return out0, err } // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. // // Solidity: function balanceOf(address account) view returns(uint256) func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error) { return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account) } // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. // // Solidity: function balanceOf(address account) view returns(uint256) func (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account) } // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. // // Solidity: function totalSupply() view returns(uint256) func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { var out []interface{} err := _IERC20.contract.Call(opts, &out, "totalSupply") if err != nil { return *new(*big.Int), err } out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) return out0, err } // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. // // Solidity: function totalSupply() view returns(uint256) func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error) { return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) } // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. // // Solidity: function totalSupply() view returns(uint256) func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error) { return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) } // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. // // Solidity: function approve(address spender, uint256 amount) returns(bool) func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { return _IERC20.contract.Transact(opts, "approve", spender, amount) } // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. // // Solidity: function approve(address spender, uint256 amount) returns(bool) func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount) } // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. // // Solidity: function approve(address spender, uint256 amount) returns(bool) func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount) } // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. // // Solidity: function transfer(address to, uint256 amount) returns(bool) func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { return _IERC20.contract.Transact(opts, "transfer", to, amount) } // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. // // Solidity: function transfer(address to, uint256 amount) returns(bool) func (_IERC20 *IERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, to, amount) } // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. // // Solidity: function transfer(address to, uint256 amount) returns(bool) func (_IERC20 *IERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, to, amount) } // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. // // Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { return _IERC20.contract.Transact(opts, "transferFrom", from, to, amount) } // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. // // Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) func (_IERC20 *IERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, from, to, amount) } // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. // // Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) func (_IERC20 *IERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, from, to, amount) } // IERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC20 contract. type IERC20ApprovalIterator struct { Event *IERC20Approval // 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 *IERC20ApprovalIterator) 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(IERC20Approval) 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(IERC20Approval) 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 *IERC20ApprovalIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *IERC20ApprovalIterator) Close() error { it.sub.Unsubscribe() return nil } // IERC20Approval represents a Approval event raised by the IERC20 contract. type IERC20Approval struct { Owner common.Address Spender common.Address Value *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. // // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error) { var ownerRule []interface{} for _, ownerItem := range owner { ownerRule = append(ownerRule, ownerItem) } var spenderRule []interface{} for _, spenderItem := range spender { spenderRule = append(spenderRule, spenderItem) } logs, sub, err := _IERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) if err != nil { return nil, err } return &IERC20ApprovalIterator{contract: _IERC20.contract, event: "Approval", logs: logs, sub: sub}, nil } // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. // // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { var ownerRule []interface{} for _, ownerItem := range owner { ownerRule = append(ownerRule, ownerItem) } var spenderRule []interface{} for _, spenderItem := range spender { spenderRule = append(spenderRule, spenderItem) } logs, sub, err := _IERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 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(IERC20Approval) if err := _IERC20.contract.UnpackLog(event, "Approval", 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 } // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. // // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error) { event := new(IERC20Approval) if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil { return nil, err } event.Raw = log return event, nil } // IERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC20 contract. type IERC20TransferIterator struct { Event *IERC20Transfer // 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 *IERC20TransferIterator) 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(IERC20Transfer) 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(IERC20Transfer) 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 *IERC20TransferIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *IERC20TransferIterator) Close() error { it.sub.Unsubscribe() return nil } // IERC20Transfer represents a Transfer event raised by the IERC20 contract. type IERC20Transfer struct { From common.Address To common.Address Value *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. // // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error) { var fromRule []interface{} for _, fromItem := range from { fromRule = append(fromRule, fromItem) } var toRule []interface{} for _, toItem := range to { toRule = append(toRule, toItem) } logs, sub, err := _IERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) if err != nil { return nil, err } return &IERC20TransferIterator{contract: _IERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil } // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. // // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { var fromRule []interface{} for _, fromItem := range from { fromRule = append(fromRule, fromItem) } var toRule []interface{} for _, toItem := range to { toRule = append(toRule, toItem) } logs, sub, err := _IERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 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(IERC20Transfer) if err := _IERC20.contract.UnpackLog(event, "Transfer", 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 } // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. // // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error) { event := new(IERC20Transfer) if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil { return nil, err } event.Raw = log return event, nil } // IMessageTransmitterMetaData contains all meta data concerning the IMessageTransmitter contract. var IMessageTransmitterMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"localDomain\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nextAvailableNonce\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"receiveMessage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"destinationDomain\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"recipient\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"destinationCaller\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"messageBody\",\"type\":\"bytes\"}],\"name\":\"sendMessageWithCaller\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", Sigs: map[string]string{ "8d3638f4": "localDomain()", "8371744e": "nextAvailableNonce()", "57ecfd28": "receiveMessage(bytes,bytes)", "f7259a75": "sendMessageWithCaller(uint32,bytes32,bytes32,bytes)", }, } // IMessageTransmitterABI is the input ABI used to generate the binding from. // Deprecated: Use IMessageTransmitterMetaData.ABI instead. var IMessageTransmitterABI = IMessageTransmitterMetaData.ABI // Deprecated: Use IMessageTransmitterMetaData.Sigs instead. // IMessageTransmitterFuncSigs maps the 4-byte function signature to its string representation. var IMessageTransmitterFuncSigs = IMessageTransmitterMetaData.Sigs // IMessageTransmitter is an auto generated Go binding around an Ethereum contract. type IMessageTransmitter struct { IMessageTransmitterCaller // Read-only binding to the contract IMessageTransmitterTransactor // Write-only binding to the contract IMessageTransmitterFilterer // Log filterer for contract events } // IMessageTransmitterCaller is an auto generated read-only Go binding around an Ethereum contract. type IMessageTransmitterCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // IMessageTransmitterTransactor is an auto generated write-only Go binding around an Ethereum contract. type IMessageTransmitterTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // IMessageTransmitterFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type IMessageTransmitterFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // IMessageTransmitterSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type IMessageTransmitterSession struct { Contract *IMessageTransmitter // 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 } // IMessageTransmitterCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type IMessageTransmitterCallerSession struct { Contract *IMessageTransmitterCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // IMessageTransmitterTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type IMessageTransmitterTransactorSession struct { Contract *IMessageTransmitterTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // IMessageTransmitterRaw is an auto generated low-level Go binding around an Ethereum contract. type IMessageTransmitterRaw struct { Contract *IMessageTransmitter // Generic contract binding to access the raw methods on } // IMessageTransmitterCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type IMessageTransmitterCallerRaw struct { Contract *IMessageTransmitterCaller // Generic read-only contract binding to access the raw methods on } // IMessageTransmitterTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type IMessageTransmitterTransactorRaw struct { Contract *IMessageTransmitterTransactor // Generic write-only contract binding to access the raw methods on } // NewIMessageTransmitter creates a new instance of IMessageTransmitter, bound to a specific deployed contract. func NewIMessageTransmitter(address common.Address, backend bind.ContractBackend) (*IMessageTransmitter, error) { contract, err := bindIMessageTransmitter(address, backend, backend, backend) if err != nil { return nil, err } return &IMessageTransmitter{IMessageTransmitterCaller: IMessageTransmitterCaller{contract: contract}, IMessageTransmitterTransactor: IMessageTransmitterTransactor{contract: contract}, IMessageTransmitterFilterer: IMessageTransmitterFilterer{contract: contract}}, nil } // NewIMessageTransmitterCaller creates a new read-only instance of IMessageTransmitter, bound to a specific deployed contract. func NewIMessageTransmitterCaller(address common.Address, caller bind.ContractCaller) (*IMessageTransmitterCaller, error) { contract, err := bindIMessageTransmitter(address, caller, nil, nil) if err != nil { return nil, err } return &IMessageTransmitterCaller{contract: contract}, nil } // NewIMessageTransmitterTransactor creates a new write-only instance of IMessageTransmitter, bound to a specific deployed contract. func NewIMessageTransmitterTransactor(address common.Address, transactor bind.ContractTransactor) (*IMessageTransmitterTransactor, error) { contract, err := bindIMessageTransmitter(address, nil, transactor, nil) if err != nil { return nil, err } return &IMessageTransmitterTransactor{contract: contract}, nil } // NewIMessageTransmitterFilterer creates a new log filterer instance of IMessageTransmitter, bound to a specific deployed contract. func NewIMessageTransmitterFilterer(address common.Address, filterer bind.ContractFilterer) (*IMessageTransmitterFilterer, error) { contract, err := bindIMessageTransmitter(address, nil, nil, filterer) if err != nil { return nil, err } return &IMessageTransmitterFilterer{contract: contract}, nil } // bindIMessageTransmitter binds a generic wrapper to an already deployed contract. func bindIMessageTransmitter(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := abi.JSON(strings.NewReader(IMessageTransmitterABI)) 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 (_IMessageTransmitter *IMessageTransmitterRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _IMessageTransmitter.Contract.IMessageTransmitterCaller.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 (_IMessageTransmitter *IMessageTransmitterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _IMessageTransmitter.Contract.IMessageTransmitterTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_IMessageTransmitter *IMessageTransmitterRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _IMessageTransmitter.Contract.IMessageTransmitterTransactor.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 (_IMessageTransmitter *IMessageTransmitterCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _IMessageTransmitter.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 (_IMessageTransmitter *IMessageTransmitterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _IMessageTransmitter.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_IMessageTransmitter *IMessageTransmitterTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _IMessageTransmitter.Contract.contract.Transact(opts, method, params...) } // LocalDomain is a free data retrieval call binding the contract method 0x8d3638f4. // // Solidity: function localDomain() view returns(uint32) func (_IMessageTransmitter *IMessageTransmitterCaller) LocalDomain(opts *bind.CallOpts) (uint32, error) { var out []interface{} err := _IMessageTransmitter.contract.Call(opts, &out, "localDomain") if err != nil { return *new(uint32), err } out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) return out0, err } // LocalDomain is a free data retrieval call binding the contract method 0x8d3638f4. // // Solidity: function localDomain() view returns(uint32) func (_IMessageTransmitter *IMessageTransmitterSession) LocalDomain() (uint32, error) { return _IMessageTransmitter.Contract.LocalDomain(&_IMessageTransmitter.CallOpts) } // LocalDomain is a free data retrieval call binding the contract method 0x8d3638f4. // // Solidity: function localDomain() view returns(uint32) func (_IMessageTransmitter *IMessageTransmitterCallerSession) LocalDomain() (uint32, error) { return _IMessageTransmitter.Contract.LocalDomain(&_IMessageTransmitter.CallOpts) } // NextAvailableNonce is a free data retrieval call binding the contract method 0x8371744e. // // Solidity: function nextAvailableNonce() view returns(uint64) func (_IMessageTransmitter *IMessageTransmitterCaller) NextAvailableNonce(opts *bind.CallOpts) (uint64, error) { var out []interface{} err := _IMessageTransmitter.contract.Call(opts, &out, "nextAvailableNonce") if err != nil { return *new(uint64), err } out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) return out0, err } // NextAvailableNonce is a free data retrieval call binding the contract method 0x8371744e. // // Solidity: function nextAvailableNonce() view returns(uint64) func (_IMessageTransmitter *IMessageTransmitterSession) NextAvailableNonce() (uint64, error) { return _IMessageTransmitter.Contract.NextAvailableNonce(&_IMessageTransmitter.CallOpts) } // NextAvailableNonce is a free data retrieval call binding the contract method 0x8371744e. // // Solidity: function nextAvailableNonce() view returns(uint64) func (_IMessageTransmitter *IMessageTransmitterCallerSession) NextAvailableNonce() (uint64, error) { return _IMessageTransmitter.Contract.NextAvailableNonce(&_IMessageTransmitter.CallOpts) } // ReceiveMessage is a paid mutator transaction binding the contract method 0x57ecfd28. // // Solidity: function receiveMessage(bytes message, bytes signature) returns(bool success) func (_IMessageTransmitter *IMessageTransmitterTransactor) ReceiveMessage(opts *bind.TransactOpts, message []byte, signature []byte) (*types.Transaction, error) { return _IMessageTransmitter.contract.Transact(opts, "receiveMessage", message, signature) } // ReceiveMessage is a paid mutator transaction binding the contract method 0x57ecfd28. // // Solidity: function receiveMessage(bytes message, bytes signature) returns(bool success) func (_IMessageTransmitter *IMessageTransmitterSession) ReceiveMessage(message []byte, signature []byte) (*types.Transaction, error) { return _IMessageTransmitter.Contract.ReceiveMessage(&_IMessageTransmitter.TransactOpts, message, signature) } // ReceiveMessage is a paid mutator transaction binding the contract method 0x57ecfd28. // // Solidity: function receiveMessage(bytes message, bytes signature) returns(bool success) func (_IMessageTransmitter *IMessageTransmitterTransactorSession) ReceiveMessage(message []byte, signature []byte) (*types.Transaction, error) { return _IMessageTransmitter.Contract.ReceiveMessage(&_IMessageTransmitter.TransactOpts, message, signature) } // SendMessageWithCaller is a paid mutator transaction binding the contract method 0xf7259a75. // // Solidity: function sendMessageWithCaller(uint32 destinationDomain, bytes32 recipient, bytes32 destinationCaller, bytes messageBody) returns(uint64) func (_IMessageTransmitter *IMessageTransmitterTransactor) SendMessageWithCaller(opts *bind.TransactOpts, destinationDomain uint32, recipient [32]byte, destinationCaller [32]byte, messageBody []byte) (*types.Transaction, error) { return _IMessageTransmitter.contract.Transact(opts, "sendMessageWithCaller", destinationDomain, recipient, destinationCaller, messageBody) } // SendMessageWithCaller is a paid mutator transaction binding the contract method 0xf7259a75. // // Solidity: function sendMessageWithCaller(uint32 destinationDomain, bytes32 recipient, bytes32 destinationCaller, bytes messageBody) returns(uint64) func (_IMessageTransmitter *IMessageTransmitterSession) SendMessageWithCaller(destinationDomain uint32, recipient [32]byte, destinationCaller [32]byte, messageBody []byte) (*types.Transaction, error) { return _IMessageTransmitter.Contract.SendMessageWithCaller(&_IMessageTransmitter.TransactOpts, destinationDomain, recipient, destinationCaller, messageBody) } // SendMessageWithCaller is a paid mutator transaction binding the contract method 0xf7259a75. // // Solidity: function sendMessageWithCaller(uint32 destinationDomain, bytes32 recipient, bytes32 destinationCaller, bytes messageBody) returns(uint64) func (_IMessageTransmitter *IMessageTransmitterTransactorSession) SendMessageWithCaller(destinationDomain uint32, recipient [32]byte, destinationCaller [32]byte, messageBody []byte) (*types.Transaction, error) { return _IMessageTransmitter.Contract.SendMessageWithCaller(&_IMessageTransmitter.TransactOpts, destinationDomain, recipient, destinationCaller, messageBody) } // ITokenMessengerMetaData contains all meta data concerning the ITokenMessenger contract. var ITokenMessengerMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"destinationDomain\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"mintRecipient\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"burnToken\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"destinationCaller\",\"type\":\"bytes32\"}],\"name\":\"depositForBurnWithCaller\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"remoteDomain\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"sender\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"messageBody\",\"type\":\"bytes\"}],\"name\":\"handleReceiveMessage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"localMessageTransmitter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"localMinter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", Sigs: map[string]string{ "f856ddb6": "depositForBurnWithCaller(uint256,uint32,bytes32,address,bytes32)", "96abeb70": "handleReceiveMessage(uint32,bytes32,bytes)", "2c121921": "localMessageTransmitter()", "cb75c11c": "localMinter()", }, } // ITokenMessengerABI is the input ABI used to generate the binding from. // Deprecated: Use ITokenMessengerMetaData.ABI instead. var ITokenMessengerABI = ITokenMessengerMetaData.ABI // Deprecated: Use ITokenMessengerMetaData.Sigs instead. // ITokenMessengerFuncSigs maps the 4-byte function signature to its string representation. var ITokenMessengerFuncSigs = ITokenMessengerMetaData.Sigs // ITokenMessenger is an auto generated Go binding around an Ethereum contract. type ITokenMessenger struct { ITokenMessengerCaller // Read-only binding to the contract ITokenMessengerTransactor // Write-only binding to the contract ITokenMessengerFilterer // Log filterer for contract events } // ITokenMessengerCaller is an auto generated read-only Go binding around an Ethereum contract. type ITokenMessengerCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // ITokenMessengerTransactor is an auto generated write-only Go binding around an Ethereum contract. type ITokenMessengerTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // ITokenMessengerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type ITokenMessengerFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // ITokenMessengerSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type ITokenMessengerSession struct { Contract *ITokenMessenger // 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 } // ITokenMessengerCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type ITokenMessengerCallerSession struct { Contract *ITokenMessengerCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // ITokenMessengerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type ITokenMessengerTransactorSession struct { Contract *ITokenMessengerTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // ITokenMessengerRaw is an auto generated low-level Go binding around an Ethereum contract. type ITokenMessengerRaw struct { Contract *ITokenMessenger // Generic contract binding to access the raw methods on } // ITokenMessengerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type ITokenMessengerCallerRaw struct { Contract *ITokenMessengerCaller // Generic read-only contract binding to access the raw methods on } // ITokenMessengerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type ITokenMessengerTransactorRaw struct { Contract *ITokenMessengerTransactor // Generic write-only contract binding to access the raw methods on } // NewITokenMessenger creates a new instance of ITokenMessenger, bound to a specific deployed contract. func NewITokenMessenger(address common.Address, backend bind.ContractBackend) (*ITokenMessenger, error) { contract, err := bindITokenMessenger(address, backend, backend, backend) if err != nil { return nil, err } return &ITokenMessenger{ITokenMessengerCaller: ITokenMessengerCaller{contract: contract}, ITokenMessengerTransactor: ITokenMessengerTransactor{contract: contract}, ITokenMessengerFilterer: ITokenMessengerFilterer{contract: contract}}, nil } // NewITokenMessengerCaller creates a new read-only instance of ITokenMessenger, bound to a specific deployed contract. func NewITokenMessengerCaller(address common.Address, caller bind.ContractCaller) (*ITokenMessengerCaller, error) { contract, err := bindITokenMessenger(address, caller, nil, nil) if err != nil { return nil, err } return &ITokenMessengerCaller{contract: contract}, nil } // NewITokenMessengerTransactor creates a new write-only instance of ITokenMessenger, bound to a specific deployed contract. func NewITokenMessengerTransactor(address common.Address, transactor bind.ContractTransactor) (*ITokenMessengerTransactor, error) { contract, err := bindITokenMessenger(address, nil, transactor, nil) if err != nil { return nil, err } return &ITokenMessengerTransactor{contract: contract}, nil } // NewITokenMessengerFilterer creates a new log filterer instance of ITokenMessenger, bound to a specific deployed contract. func NewITokenMessengerFilterer(address common.Address, filterer bind.ContractFilterer) (*ITokenMessengerFilterer, error) { contract, err := bindITokenMessenger(address, nil, nil, filterer) if err != nil { return nil, err } return &ITokenMessengerFilterer{contract: contract}, nil } // bindITokenMessenger binds a generic wrapper to an already deployed contract. func bindITokenMessenger(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := abi.JSON(strings.NewReader(ITokenMessengerABI)) 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 (_ITokenMessenger *ITokenMessengerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _ITokenMessenger.Contract.ITokenMessengerCaller.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 (_ITokenMessenger *ITokenMessengerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _ITokenMessenger.Contract.ITokenMessengerTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_ITokenMessenger *ITokenMessengerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _ITokenMessenger.Contract.ITokenMessengerTransactor.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 (_ITokenMessenger *ITokenMessengerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _ITokenMessenger.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 (_ITokenMessenger *ITokenMessengerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _ITokenMessenger.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_ITokenMessenger *ITokenMessengerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _ITokenMessenger.Contract.contract.Transact(opts, method, params...) } // LocalMessageTransmitter is a free data retrieval call binding the contract method 0x2c121921. // // Solidity: function localMessageTransmitter() view returns(address) func (_ITokenMessenger *ITokenMessengerCaller) LocalMessageTransmitter(opts *bind.CallOpts) (common.Address, error) { var out []interface{} err := _ITokenMessenger.contract.Call(opts, &out, "localMessageTransmitter") if err != nil { return *new(common.Address), err } out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) return out0, err } // LocalMessageTransmitter is a free data retrieval call binding the contract method 0x2c121921. // // Solidity: function localMessageTransmitter() view returns(address) func (_ITokenMessenger *ITokenMessengerSession) LocalMessageTransmitter() (common.Address, error) { return _ITokenMessenger.Contract.LocalMessageTransmitter(&_ITokenMessenger.CallOpts) } // LocalMessageTransmitter is a free data retrieval call binding the contract method 0x2c121921. // // Solidity: function localMessageTransmitter() view returns(address) func (_ITokenMessenger *ITokenMessengerCallerSession) LocalMessageTransmitter() (common.Address, error) { return _ITokenMessenger.Contract.LocalMessageTransmitter(&_ITokenMessenger.CallOpts) } // LocalMinter is a free data retrieval call binding the contract method 0xcb75c11c. // // Solidity: function localMinter() view returns(address) func (_ITokenMessenger *ITokenMessengerCaller) LocalMinter(opts *bind.CallOpts) (common.Address, error) { var out []interface{} err := _ITokenMessenger.contract.Call(opts, &out, "localMinter") if err != nil { return *new(common.Address), err } out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) return out0, err } // LocalMinter is a free data retrieval call binding the contract method 0xcb75c11c. // // Solidity: function localMinter() view returns(address) func (_ITokenMessenger *ITokenMessengerSession) LocalMinter() (common.Address, error) { return _ITokenMessenger.Contract.LocalMinter(&_ITokenMessenger.CallOpts) } // LocalMinter is a free data retrieval call binding the contract method 0xcb75c11c. // // Solidity: function localMinter() view returns(address) func (_ITokenMessenger *ITokenMessengerCallerSession) LocalMinter() (common.Address, error) { return _ITokenMessenger.Contract.LocalMinter(&_ITokenMessenger.CallOpts) } // DepositForBurnWithCaller is a paid mutator transaction binding the contract method 0xf856ddb6. // // Solidity: function depositForBurnWithCaller(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller) returns(uint64 nonce) func (_ITokenMessenger *ITokenMessengerTransactor) DepositForBurnWithCaller(opts *bind.TransactOpts, amount *big.Int, destinationDomain uint32, mintRecipient [32]byte, burnToken common.Address, destinationCaller [32]byte) (*types.Transaction, error) { return _ITokenMessenger.contract.Transact(opts, "depositForBurnWithCaller", amount, destinationDomain, mintRecipient, burnToken, destinationCaller) } // DepositForBurnWithCaller is a paid mutator transaction binding the contract method 0xf856ddb6. // // Solidity: function depositForBurnWithCaller(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller) returns(uint64 nonce) func (_ITokenMessenger *ITokenMessengerSession) DepositForBurnWithCaller(amount *big.Int, destinationDomain uint32, mintRecipient [32]byte, burnToken common.Address, destinationCaller [32]byte) (*types.Transaction, error) { return _ITokenMessenger.Contract.DepositForBurnWithCaller(&_ITokenMessenger.TransactOpts, amount, destinationDomain, mintRecipient, burnToken, destinationCaller) } // DepositForBurnWithCaller is a paid mutator transaction binding the contract method 0xf856ddb6. // // Solidity: function depositForBurnWithCaller(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller) returns(uint64 nonce) func (_ITokenMessenger *ITokenMessengerTransactorSession) DepositForBurnWithCaller(amount *big.Int, destinationDomain uint32, mintRecipient [32]byte, burnToken common.Address, destinationCaller [32]byte) (*types.Transaction, error) { return _ITokenMessenger.Contract.DepositForBurnWithCaller(&_ITokenMessenger.TransactOpts, amount, destinationDomain, mintRecipient, burnToken, destinationCaller) } // HandleReceiveMessage is a paid mutator transaction binding the contract method 0x96abeb70. // // Solidity: function handleReceiveMessage(uint32 remoteDomain, bytes32 sender, bytes messageBody) returns(bool success) func (_ITokenMessenger *ITokenMessengerTransactor) HandleReceiveMessage(opts *bind.TransactOpts, remoteDomain uint32, sender [32]byte, messageBody []byte) (*types.Transaction, error) { return _ITokenMessenger.contract.Transact(opts, "handleReceiveMessage", remoteDomain, sender, messageBody) } // HandleReceiveMessage is a paid mutator transaction binding the contract method 0x96abeb70. // // Solidity: function handleReceiveMessage(uint32 remoteDomain, bytes32 sender, bytes messageBody) returns(bool success) func (_ITokenMessenger *ITokenMessengerSession) HandleReceiveMessage(remoteDomain uint32, sender [32]byte, messageBody []byte) (*types.Transaction, error) { return _ITokenMessenger.Contract.HandleReceiveMessage(&_ITokenMessenger.TransactOpts, remoteDomain, sender, messageBody) } // HandleReceiveMessage is a paid mutator transaction binding the contract method 0x96abeb70. // // Solidity: function handleReceiveMessage(uint32 remoteDomain, bytes32 sender, bytes messageBody) returns(bool success) func (_ITokenMessenger *ITokenMessengerTransactorSession) HandleReceiveMessage(remoteDomain uint32, sender [32]byte, messageBody []byte) (*types.Transaction, error) { return _ITokenMessenger.Contract.HandleReceiveMessage(&_ITokenMessenger.TransactOpts, remoteDomain, sender, messageBody) } // ITokenMinterMetaData contains all meta data concerning the ITokenMinter contract. var ITokenMinterMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"burnToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"burnLimitsPerMessage\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"remoteDomain\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"remoteToken\",\"type\":\"bytes32\"}],\"name\":\"getLocalToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"sourceDomain\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"burnToken\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"mintToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", Sigs: map[string]string{ "9dc29fac": "burn(address,uint256)", "a56ec632": "burnLimitsPerMessage(address)", "78a0565e": "getLocalToken(uint32,bytes32)", "d54de06f": "mint(uint32,bytes32,address,uint256)", }, } // ITokenMinterABI is the input ABI used to generate the binding from. // Deprecated: Use ITokenMinterMetaData.ABI instead. var ITokenMinterABI = ITokenMinterMetaData.ABI // Deprecated: Use ITokenMinterMetaData.Sigs instead. // ITokenMinterFuncSigs maps the 4-byte function signature to its string representation. var ITokenMinterFuncSigs = ITokenMinterMetaData.Sigs // ITokenMinter is an auto generated Go binding around an Ethereum contract. type ITokenMinter struct { ITokenMinterCaller // Read-only binding to the contract ITokenMinterTransactor // Write-only binding to the contract ITokenMinterFilterer // Log filterer for contract events } // ITokenMinterCaller is an auto generated read-only Go binding around an Ethereum contract. type ITokenMinterCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // ITokenMinterTransactor is an auto generated write-only Go binding around an Ethereum contract. type ITokenMinterTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // ITokenMinterFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type ITokenMinterFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // ITokenMinterSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type ITokenMinterSession struct { Contract *ITokenMinter // 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 } // ITokenMinterCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type ITokenMinterCallerSession struct { Contract *ITokenMinterCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // ITokenMinterTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type ITokenMinterTransactorSession struct { Contract *ITokenMinterTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // ITokenMinterRaw is an auto generated low-level Go binding around an Ethereum contract. type ITokenMinterRaw struct { Contract *ITokenMinter // Generic contract binding to access the raw methods on } // ITokenMinterCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type ITokenMinterCallerRaw struct { Contract *ITokenMinterCaller // Generic read-only contract binding to access the raw methods on } // ITokenMinterTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type ITokenMinterTransactorRaw struct { Contract *ITokenMinterTransactor // Generic write-only contract binding to access the raw methods on } // NewITokenMinter creates a new instance of ITokenMinter, bound to a specific deployed contract. func NewITokenMinter(address common.Address, backend bind.ContractBackend) (*ITokenMinter, error) { contract, err := bindITokenMinter(address, backend, backend, backend) if err != nil { return nil, err } return &ITokenMinter{ITokenMinterCaller: ITokenMinterCaller{contract: contract}, ITokenMinterTransactor: ITokenMinterTransactor{contract: contract}, ITokenMinterFilterer: ITokenMinterFilterer{contract: contract}}, nil } // NewITokenMinterCaller creates a new read-only instance of ITokenMinter, bound to a specific deployed contract. func NewITokenMinterCaller(address common.Address, caller bind.ContractCaller) (*ITokenMinterCaller, error) { contract, err := bindITokenMinter(address, caller, nil, nil) if err != nil { return nil, err } return &ITokenMinterCaller{contract: contract}, nil } // NewITokenMinterTransactor creates a new write-only instance of ITokenMinter, bound to a specific deployed contract. func NewITokenMinterTransactor(address common.Address, transactor bind.ContractTransactor) (*ITokenMinterTransactor, error) { contract, err := bindITokenMinter(address, nil, transactor, nil) if err != nil { return nil, err } return &ITokenMinterTransactor{contract: contract}, nil } // NewITokenMinterFilterer creates a new log filterer instance of ITokenMinter, bound to a specific deployed contract. func NewITokenMinterFilterer(address common.Address, filterer bind.ContractFilterer) (*ITokenMinterFilterer, error) { contract, err := bindITokenMinter(address, nil, nil, filterer) if err != nil { return nil, err } return &ITokenMinterFilterer{contract: contract}, nil } // bindITokenMinter binds a generic wrapper to an already deployed contract. func bindITokenMinter(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := abi.JSON(strings.NewReader(ITokenMinterABI)) 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 (_ITokenMinter *ITokenMinterRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _ITokenMinter.Contract.ITokenMinterCaller.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 (_ITokenMinter *ITokenMinterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _ITokenMinter.Contract.ITokenMinterTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_ITokenMinter *ITokenMinterRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _ITokenMinter.Contract.ITokenMinterTransactor.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 (_ITokenMinter *ITokenMinterCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _ITokenMinter.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 (_ITokenMinter *ITokenMinterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _ITokenMinter.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_ITokenMinter *ITokenMinterTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _ITokenMinter.Contract.contract.Transact(opts, method, params...) } // BurnLimitsPerMessage is a free data retrieval call binding the contract method 0xa56ec632. // // Solidity: function burnLimitsPerMessage(address token) view returns(uint256) func (_ITokenMinter *ITokenMinterCaller) BurnLimitsPerMessage(opts *bind.CallOpts, token common.Address) (*big.Int, error) { var out []interface{} err := _ITokenMinter.contract.Call(opts, &out, "burnLimitsPerMessage", token) if err != nil { return *new(*big.Int), err } out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) return out0, err } // BurnLimitsPerMessage is a free data retrieval call binding the contract method 0xa56ec632. // // Solidity: function burnLimitsPerMessage(address token) view returns(uint256) func (_ITokenMinter *ITokenMinterSession) BurnLimitsPerMessage(token common.Address) (*big.Int, error) { return _ITokenMinter.Contract.BurnLimitsPerMessage(&_ITokenMinter.CallOpts, token) } // BurnLimitsPerMessage is a free data retrieval call binding the contract method 0xa56ec632. // // Solidity: function burnLimitsPerMessage(address token) view returns(uint256) func (_ITokenMinter *ITokenMinterCallerSession) BurnLimitsPerMessage(token common.Address) (*big.Int, error) { return _ITokenMinter.Contract.BurnLimitsPerMessage(&_ITokenMinter.CallOpts, token) } // GetLocalToken is a free data retrieval call binding the contract method 0x78a0565e. // // Solidity: function getLocalToken(uint32 remoteDomain, bytes32 remoteToken) view returns(address) func (_ITokenMinter *ITokenMinterCaller) GetLocalToken(opts *bind.CallOpts, remoteDomain uint32, remoteToken [32]byte) (common.Address, error) { var out []interface{} err := _ITokenMinter.contract.Call(opts, &out, "getLocalToken", remoteDomain, remoteToken) if err != nil { return *new(common.Address), err } out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) return out0, err } // GetLocalToken is a free data retrieval call binding the contract method 0x78a0565e. // // Solidity: function getLocalToken(uint32 remoteDomain, bytes32 remoteToken) view returns(address) func (_ITokenMinter *ITokenMinterSession) GetLocalToken(remoteDomain uint32, remoteToken [32]byte) (common.Address, error) { return _ITokenMinter.Contract.GetLocalToken(&_ITokenMinter.CallOpts, remoteDomain, remoteToken) } // GetLocalToken is a free data retrieval call binding the contract method 0x78a0565e. // // Solidity: function getLocalToken(uint32 remoteDomain, bytes32 remoteToken) view returns(address) func (_ITokenMinter *ITokenMinterCallerSession) GetLocalToken(remoteDomain uint32, remoteToken [32]byte) (common.Address, error) { return _ITokenMinter.Contract.GetLocalToken(&_ITokenMinter.CallOpts, remoteDomain, remoteToken) } // Burn is a paid mutator transaction binding the contract method 0x9dc29fac. // // Solidity: function burn(address burnToken, uint256 amount) returns() func (_ITokenMinter *ITokenMinterTransactor) Burn(opts *bind.TransactOpts, burnToken common.Address, amount *big.Int) (*types.Transaction, error) { return _ITokenMinter.contract.Transact(opts, "burn", burnToken, amount) } // Burn is a paid mutator transaction binding the contract method 0x9dc29fac. // // Solidity: function burn(address burnToken, uint256 amount) returns() func (_ITokenMinter *ITokenMinterSession) Burn(burnToken common.Address, amount *big.Int) (*types.Transaction, error) { return _ITokenMinter.Contract.Burn(&_ITokenMinter.TransactOpts, burnToken, amount) } // Burn is a paid mutator transaction binding the contract method 0x9dc29fac. // // Solidity: function burn(address burnToken, uint256 amount) returns() func (_ITokenMinter *ITokenMinterTransactorSession) Burn(burnToken common.Address, amount *big.Int) (*types.Transaction, error) { return _ITokenMinter.Contract.Burn(&_ITokenMinter.TransactOpts, burnToken, amount) } // Mint is a paid mutator transaction binding the contract method 0xd54de06f. // // Solidity: function mint(uint32 sourceDomain, bytes32 burnToken, address to, uint256 amount) returns(address mintToken) func (_ITokenMinter *ITokenMinterTransactor) Mint(opts *bind.TransactOpts, sourceDomain uint32, burnToken [32]byte, to common.Address, amount *big.Int) (*types.Transaction, error) { return _ITokenMinter.contract.Transact(opts, "mint", sourceDomain, burnToken, to, amount) } // Mint is a paid mutator transaction binding the contract method 0xd54de06f. // // Solidity: function mint(uint32 sourceDomain, bytes32 burnToken, address to, uint256 amount) returns(address mintToken) func (_ITokenMinter *ITokenMinterSession) Mint(sourceDomain uint32, burnToken [32]byte, to common.Address, amount *big.Int) (*types.Transaction, error) { return _ITokenMinter.Contract.Mint(&_ITokenMinter.TransactOpts, sourceDomain, burnToken, to, amount) } // Mint is a paid mutator transaction binding the contract method 0xd54de06f. // // Solidity: function mint(uint32 sourceDomain, bytes32 burnToken, address to, uint256 amount) returns(address mintToken) func (_ITokenMinter *ITokenMinterTransactorSession) Mint(sourceDomain uint32, burnToken [32]byte, to common.Address, amount *big.Int) (*types.Transaction, error) { return _ITokenMinter.Contract.Mint(&_ITokenMinter.TransactOpts, sourceDomain, burnToken, to, amount) } // MockTokenMessengerMetaData contains all meta data concerning the MockTokenMessenger contract. var MockTokenMessengerMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"localMessageTransmitter_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"burnToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"depositor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"mintRecipient\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"destinationDomain\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"destinationTokenMessenger\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"destinationCaller\",\"type\":\"bytes32\"}],\"name\":\"DepositForBurn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"mintRecipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"mintToken\",\"type\":\"address\"}],\"name\":\"MintAndWithdraw\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"destinationDomain\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"mintRecipient\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"burnToken\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"destinationCaller\",\"type\":\"bytes32\"}],\"name\":\"depositForBurnWithCaller\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"mintRecipient\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"burnToken\",\"type\":\"address\"}],\"name\":\"formatTokenMessage\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"tokenMessage\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"remoteDomain\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"sender\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"messageBody\",\"type\":\"bytes\"}],\"name\":\"handleReceiveMessage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"localMessageTransmitter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"localMinter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"name\":\"remoteTokenMessenger\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"localMinter_\",\"type\":\"address\"}],\"name\":\"setLocalMinter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"remoteDomain\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"remoteTokenMessenger_\",\"type\":\"bytes32\"}],\"name\":\"setRemoteTokenMessenger\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", Sigs: map[string]string{ "f856ddb6": "depositForBurnWithCaller(uint256,uint32,bytes32,address,bytes32)", "b6aa3fe3": "formatTokenMessage(uint256,bytes32,address)", "96abeb70": "handleReceiveMessage(uint32,bytes32,bytes)", "2c121921": "localMessageTransmitter()", "cb75c11c": "localMinter()", "b35b0464": "remoteTokenMessenger(uint32)", "f5af2a45": "setLocalMinter(address)", "6b51d203": "setRemoteTokenMessenger(uint32,bytes32)", }, Bin: "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", } // MockTokenMessengerABI is the input ABI used to generate the binding from. // Deprecated: Use MockTokenMessengerMetaData.ABI instead. var MockTokenMessengerABI = MockTokenMessengerMetaData.ABI // Deprecated: Use MockTokenMessengerMetaData.Sigs instead. // MockTokenMessengerFuncSigs maps the 4-byte function signature to its string representation. var MockTokenMessengerFuncSigs = MockTokenMessengerMetaData.Sigs // MockTokenMessengerBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use MockTokenMessengerMetaData.Bin instead. var MockTokenMessengerBin = MockTokenMessengerMetaData.Bin // DeployMockTokenMessenger deploys a new Ethereum contract, binding an instance of MockTokenMessenger to it. func DeployMockTokenMessenger(auth *bind.TransactOpts, backend bind.ContractBackend, localMessageTransmitter_ common.Address) (common.Address, *types.Transaction, *MockTokenMessenger, error) { parsed, err := MockTokenMessengerMetaData.GetAbi() if err != nil { return common.Address{}, nil, nil, err } if parsed == nil { return common.Address{}, nil, nil, errors.New("GetABI returned nil") } address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(MockTokenMessengerBin), backend, localMessageTransmitter_) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &MockTokenMessenger{MockTokenMessengerCaller: MockTokenMessengerCaller{contract: contract}, MockTokenMessengerTransactor: MockTokenMessengerTransactor{contract: contract}, MockTokenMessengerFilterer: MockTokenMessengerFilterer{contract: contract}}, nil } // MockTokenMessenger is an auto generated Go binding around an Ethereum contract. type MockTokenMessenger struct { MockTokenMessengerCaller // Read-only binding to the contract MockTokenMessengerTransactor // Write-only binding to the contract MockTokenMessengerFilterer // Log filterer for contract events } // MockTokenMessengerCaller is an auto generated read-only Go binding around an Ethereum contract. type MockTokenMessengerCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MockTokenMessengerTransactor is an auto generated write-only Go binding around an Ethereum contract. type MockTokenMessengerTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MockTokenMessengerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type MockTokenMessengerFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MockTokenMessengerSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type MockTokenMessengerSession struct { Contract *MockTokenMessenger // 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 } // MockTokenMessengerCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type MockTokenMessengerCallerSession struct { Contract *MockTokenMessengerCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // MockTokenMessengerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type MockTokenMessengerTransactorSession struct { Contract *MockTokenMessengerTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // MockTokenMessengerRaw is an auto generated low-level Go binding around an Ethereum contract. type MockTokenMessengerRaw struct { Contract *MockTokenMessenger // Generic contract binding to access the raw methods on } // MockTokenMessengerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type MockTokenMessengerCallerRaw struct { Contract *MockTokenMessengerCaller // Generic read-only contract binding to access the raw methods on } // MockTokenMessengerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type MockTokenMessengerTransactorRaw struct { Contract *MockTokenMessengerTransactor // Generic write-only contract binding to access the raw methods on } // NewMockTokenMessenger creates a new instance of MockTokenMessenger, bound to a specific deployed contract. func NewMockTokenMessenger(address common.Address, backend bind.ContractBackend) (*MockTokenMessenger, error) { contract, err := bindMockTokenMessenger(address, backend, backend, backend) if err != nil { return nil, err } return &MockTokenMessenger{MockTokenMessengerCaller: MockTokenMessengerCaller{contract: contract}, MockTokenMessengerTransactor: MockTokenMessengerTransactor{contract: contract}, MockTokenMessengerFilterer: MockTokenMessengerFilterer{contract: contract}}, nil } // NewMockTokenMessengerCaller creates a new read-only instance of MockTokenMessenger, bound to a specific deployed contract. func NewMockTokenMessengerCaller(address common.Address, caller bind.ContractCaller) (*MockTokenMessengerCaller, error) { contract, err := bindMockTokenMessenger(address, caller, nil, nil) if err != nil { return nil, err } return &MockTokenMessengerCaller{contract: contract}, nil } // NewMockTokenMessengerTransactor creates a new write-only instance of MockTokenMessenger, bound to a specific deployed contract. func NewMockTokenMessengerTransactor(address common.Address, transactor bind.ContractTransactor) (*MockTokenMessengerTransactor, error) { contract, err := bindMockTokenMessenger(address, nil, transactor, nil) if err != nil { return nil, err } return &MockTokenMessengerTransactor{contract: contract}, nil } // NewMockTokenMessengerFilterer creates a new log filterer instance of MockTokenMessenger, bound to a specific deployed contract. func NewMockTokenMessengerFilterer(address common.Address, filterer bind.ContractFilterer) (*MockTokenMessengerFilterer, error) { contract, err := bindMockTokenMessenger(address, nil, nil, filterer) if err != nil { return nil, err } return &MockTokenMessengerFilterer{contract: contract}, nil } // bindMockTokenMessenger binds a generic wrapper to an already deployed contract. func bindMockTokenMessenger(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := abi.JSON(strings.NewReader(MockTokenMessengerABI)) 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 (_MockTokenMessenger *MockTokenMessengerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MockTokenMessenger.Contract.MockTokenMessengerCaller.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 (_MockTokenMessenger *MockTokenMessengerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MockTokenMessenger.Contract.MockTokenMessengerTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MockTokenMessenger *MockTokenMessengerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MockTokenMessenger.Contract.MockTokenMessengerTransactor.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 (_MockTokenMessenger *MockTokenMessengerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MockTokenMessenger.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 (_MockTokenMessenger *MockTokenMessengerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MockTokenMessenger.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MockTokenMessenger *MockTokenMessengerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MockTokenMessenger.Contract.contract.Transact(opts, method, params...) } // FormatTokenMessage is a free data retrieval call binding the contract method 0xb6aa3fe3. // // Solidity: function formatTokenMessage(uint256 amount, bytes32 mintRecipient, address burnToken) pure returns(bytes tokenMessage) func (_MockTokenMessenger *MockTokenMessengerCaller) FormatTokenMessage(opts *bind.CallOpts, amount *big.Int, mintRecipient [32]byte, burnToken common.Address) ([]byte, error) { var out []interface{} err := _MockTokenMessenger.contract.Call(opts, &out, "formatTokenMessage", amount, mintRecipient, burnToken) if err != nil { return *new([]byte), err } out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) return out0, err } // FormatTokenMessage is a free data retrieval call binding the contract method 0xb6aa3fe3. // // Solidity: function formatTokenMessage(uint256 amount, bytes32 mintRecipient, address burnToken) pure returns(bytes tokenMessage) func (_MockTokenMessenger *MockTokenMessengerSession) FormatTokenMessage(amount *big.Int, mintRecipient [32]byte, burnToken common.Address) ([]byte, error) { return _MockTokenMessenger.Contract.FormatTokenMessage(&_MockTokenMessenger.CallOpts, amount, mintRecipient, burnToken) } // FormatTokenMessage is a free data retrieval call binding the contract method 0xb6aa3fe3. // // Solidity: function formatTokenMessage(uint256 amount, bytes32 mintRecipient, address burnToken) pure returns(bytes tokenMessage) func (_MockTokenMessenger *MockTokenMessengerCallerSession) FormatTokenMessage(amount *big.Int, mintRecipient [32]byte, burnToken common.Address) ([]byte, error) { return _MockTokenMessenger.Contract.FormatTokenMessage(&_MockTokenMessenger.CallOpts, amount, mintRecipient, burnToken) } // LocalMessageTransmitter is a free data retrieval call binding the contract method 0x2c121921. // // Solidity: function localMessageTransmitter() view returns(address) func (_MockTokenMessenger *MockTokenMessengerCaller) LocalMessageTransmitter(opts *bind.CallOpts) (common.Address, error) { var out []interface{} err := _MockTokenMessenger.contract.Call(opts, &out, "localMessageTransmitter") if err != nil { return *new(common.Address), err } out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) return out0, err } // LocalMessageTransmitter is a free data retrieval call binding the contract method 0x2c121921. // // Solidity: function localMessageTransmitter() view returns(address) func (_MockTokenMessenger *MockTokenMessengerSession) LocalMessageTransmitter() (common.Address, error) { return _MockTokenMessenger.Contract.LocalMessageTransmitter(&_MockTokenMessenger.CallOpts) } // LocalMessageTransmitter is a free data retrieval call binding the contract method 0x2c121921. // // Solidity: function localMessageTransmitter() view returns(address) func (_MockTokenMessenger *MockTokenMessengerCallerSession) LocalMessageTransmitter() (common.Address, error) { return _MockTokenMessenger.Contract.LocalMessageTransmitter(&_MockTokenMessenger.CallOpts) } // LocalMinter is a free data retrieval call binding the contract method 0xcb75c11c. // // Solidity: function localMinter() view returns(address) func (_MockTokenMessenger *MockTokenMessengerCaller) LocalMinter(opts *bind.CallOpts) (common.Address, error) { var out []interface{} err := _MockTokenMessenger.contract.Call(opts, &out, "localMinter") if err != nil { return *new(common.Address), err } out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) return out0, err } // LocalMinter is a free data retrieval call binding the contract method 0xcb75c11c. // // Solidity: function localMinter() view returns(address) func (_MockTokenMessenger *MockTokenMessengerSession) LocalMinter() (common.Address, error) { return _MockTokenMessenger.Contract.LocalMinter(&_MockTokenMessenger.CallOpts) } // LocalMinter is a free data retrieval call binding the contract method 0xcb75c11c. // // Solidity: function localMinter() view returns(address) func (_MockTokenMessenger *MockTokenMessengerCallerSession) LocalMinter() (common.Address, error) { return _MockTokenMessenger.Contract.LocalMinter(&_MockTokenMessenger.CallOpts) } // RemoteTokenMessenger is a free data retrieval call binding the contract method 0xb35b0464. // // Solidity: function remoteTokenMessenger(uint32 ) view returns(bytes32) func (_MockTokenMessenger *MockTokenMessengerCaller) RemoteTokenMessenger(opts *bind.CallOpts, arg0 uint32) ([32]byte, error) { var out []interface{} err := _MockTokenMessenger.contract.Call(opts, &out, "remoteTokenMessenger", arg0) if err != nil { return *new([32]byte), err } out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) return out0, err } // RemoteTokenMessenger is a free data retrieval call binding the contract method 0xb35b0464. // // Solidity: function remoteTokenMessenger(uint32 ) view returns(bytes32) func (_MockTokenMessenger *MockTokenMessengerSession) RemoteTokenMessenger(arg0 uint32) ([32]byte, error) { return _MockTokenMessenger.Contract.RemoteTokenMessenger(&_MockTokenMessenger.CallOpts, arg0) } // RemoteTokenMessenger is a free data retrieval call binding the contract method 0xb35b0464. // // Solidity: function remoteTokenMessenger(uint32 ) view returns(bytes32) func (_MockTokenMessenger *MockTokenMessengerCallerSession) RemoteTokenMessenger(arg0 uint32) ([32]byte, error) { return _MockTokenMessenger.Contract.RemoteTokenMessenger(&_MockTokenMessenger.CallOpts, arg0) } // DepositForBurnWithCaller is a paid mutator transaction binding the contract method 0xf856ddb6. // // Solidity: function depositForBurnWithCaller(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller) returns(uint64 nonce) func (_MockTokenMessenger *MockTokenMessengerTransactor) DepositForBurnWithCaller(opts *bind.TransactOpts, amount *big.Int, destinationDomain uint32, mintRecipient [32]byte, burnToken common.Address, destinationCaller [32]byte) (*types.Transaction, error) { return _MockTokenMessenger.contract.Transact(opts, "depositForBurnWithCaller", amount, destinationDomain, mintRecipient, burnToken, destinationCaller) } // DepositForBurnWithCaller is a paid mutator transaction binding the contract method 0xf856ddb6. // // Solidity: function depositForBurnWithCaller(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller) returns(uint64 nonce) func (_MockTokenMessenger *MockTokenMessengerSession) DepositForBurnWithCaller(amount *big.Int, destinationDomain uint32, mintRecipient [32]byte, burnToken common.Address, destinationCaller [32]byte) (*types.Transaction, error) { return _MockTokenMessenger.Contract.DepositForBurnWithCaller(&_MockTokenMessenger.TransactOpts, amount, destinationDomain, mintRecipient, burnToken, destinationCaller) } // DepositForBurnWithCaller is a paid mutator transaction binding the contract method 0xf856ddb6. // // Solidity: function depositForBurnWithCaller(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller) returns(uint64 nonce) func (_MockTokenMessenger *MockTokenMessengerTransactorSession) DepositForBurnWithCaller(amount *big.Int, destinationDomain uint32, mintRecipient [32]byte, burnToken common.Address, destinationCaller [32]byte) (*types.Transaction, error) { return _MockTokenMessenger.Contract.DepositForBurnWithCaller(&_MockTokenMessenger.TransactOpts, amount, destinationDomain, mintRecipient, burnToken, destinationCaller) } // HandleReceiveMessage is a paid mutator transaction binding the contract method 0x96abeb70. // // Solidity: function handleReceiveMessage(uint32 remoteDomain, bytes32 sender, bytes messageBody) returns(bool success) func (_MockTokenMessenger *MockTokenMessengerTransactor) HandleReceiveMessage(opts *bind.TransactOpts, remoteDomain uint32, sender [32]byte, messageBody []byte) (*types.Transaction, error) { return _MockTokenMessenger.contract.Transact(opts, "handleReceiveMessage", remoteDomain, sender, messageBody) } // HandleReceiveMessage is a paid mutator transaction binding the contract method 0x96abeb70. // // Solidity: function handleReceiveMessage(uint32 remoteDomain, bytes32 sender, bytes messageBody) returns(bool success) func (_MockTokenMessenger *MockTokenMessengerSession) HandleReceiveMessage(remoteDomain uint32, sender [32]byte, messageBody []byte) (*types.Transaction, error) { return _MockTokenMessenger.Contract.HandleReceiveMessage(&_MockTokenMessenger.TransactOpts, remoteDomain, sender, messageBody) } // HandleReceiveMessage is a paid mutator transaction binding the contract method 0x96abeb70. // // Solidity: function handleReceiveMessage(uint32 remoteDomain, bytes32 sender, bytes messageBody) returns(bool success) func (_MockTokenMessenger *MockTokenMessengerTransactorSession) HandleReceiveMessage(remoteDomain uint32, sender [32]byte, messageBody []byte) (*types.Transaction, error) { return _MockTokenMessenger.Contract.HandleReceiveMessage(&_MockTokenMessenger.TransactOpts, remoteDomain, sender, messageBody) } // SetLocalMinter is a paid mutator transaction binding the contract method 0xf5af2a45. // // Solidity: function setLocalMinter(address localMinter_) returns() func (_MockTokenMessenger *MockTokenMessengerTransactor) SetLocalMinter(opts *bind.TransactOpts, localMinter_ common.Address) (*types.Transaction, error) { return _MockTokenMessenger.contract.Transact(opts, "setLocalMinter", localMinter_) } // SetLocalMinter is a paid mutator transaction binding the contract method 0xf5af2a45. // // Solidity: function setLocalMinter(address localMinter_) returns() func (_MockTokenMessenger *MockTokenMessengerSession) SetLocalMinter(localMinter_ common.Address) (*types.Transaction, error) { return _MockTokenMessenger.Contract.SetLocalMinter(&_MockTokenMessenger.TransactOpts, localMinter_) } // SetLocalMinter is a paid mutator transaction binding the contract method 0xf5af2a45. // // Solidity: function setLocalMinter(address localMinter_) returns() func (_MockTokenMessenger *MockTokenMessengerTransactorSession) SetLocalMinter(localMinter_ common.Address) (*types.Transaction, error) { return _MockTokenMessenger.Contract.SetLocalMinter(&_MockTokenMessenger.TransactOpts, localMinter_) } // SetRemoteTokenMessenger is a paid mutator transaction binding the contract method 0x6b51d203. // // Solidity: function setRemoteTokenMessenger(uint32 remoteDomain, bytes32 remoteTokenMessenger_) returns() func (_MockTokenMessenger *MockTokenMessengerTransactor) SetRemoteTokenMessenger(opts *bind.TransactOpts, remoteDomain uint32, remoteTokenMessenger_ [32]byte) (*types.Transaction, error) { return _MockTokenMessenger.contract.Transact(opts, "setRemoteTokenMessenger", remoteDomain, remoteTokenMessenger_) } // SetRemoteTokenMessenger is a paid mutator transaction binding the contract method 0x6b51d203. // // Solidity: function setRemoteTokenMessenger(uint32 remoteDomain, bytes32 remoteTokenMessenger_) returns() func (_MockTokenMessenger *MockTokenMessengerSession) SetRemoteTokenMessenger(remoteDomain uint32, remoteTokenMessenger_ [32]byte) (*types.Transaction, error) { return _MockTokenMessenger.Contract.SetRemoteTokenMessenger(&_MockTokenMessenger.TransactOpts, remoteDomain, remoteTokenMessenger_) } // SetRemoteTokenMessenger is a paid mutator transaction binding the contract method 0x6b51d203. // // Solidity: function setRemoteTokenMessenger(uint32 remoteDomain, bytes32 remoteTokenMessenger_) returns() func (_MockTokenMessenger *MockTokenMessengerTransactorSession) SetRemoteTokenMessenger(remoteDomain uint32, remoteTokenMessenger_ [32]byte) (*types.Transaction, error) { return _MockTokenMessenger.Contract.SetRemoteTokenMessenger(&_MockTokenMessenger.TransactOpts, remoteDomain, remoteTokenMessenger_) } // MockTokenMessengerDepositForBurnIterator is returned from FilterDepositForBurn and is used to iterate over the raw logs and unpacked data for DepositForBurn events raised by the MockTokenMessenger contract. type MockTokenMessengerDepositForBurnIterator struct { Event *MockTokenMessengerDepositForBurn // 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 *MockTokenMessengerDepositForBurnIterator) 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(MockTokenMessengerDepositForBurn) 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(MockTokenMessengerDepositForBurn) 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 *MockTokenMessengerDepositForBurnIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MockTokenMessengerDepositForBurnIterator) Close() error { it.sub.Unsubscribe() return nil } // MockTokenMessengerDepositForBurn represents a DepositForBurn event raised by the MockTokenMessenger contract. type MockTokenMessengerDepositForBurn struct { Nonce uint64 BurnToken common.Address Amount *big.Int Depositor common.Address MintRecipient [32]byte DestinationDomain uint32 DestinationTokenMessenger [32]byte DestinationCaller [32]byte Raw types.Log // Blockchain specific contextual infos } // FilterDepositForBurn is a free log retrieval operation binding the contract event 0x2fa9ca894982930190727e75500a97d8dc500233a5065e0f3126c48fbe0343c0. // // Solidity: event DepositForBurn(uint64 indexed nonce, address indexed burnToken, uint256 amount, address indexed depositor, bytes32 mintRecipient, uint32 destinationDomain, bytes32 destinationTokenMessenger, bytes32 destinationCaller) func (_MockTokenMessenger *MockTokenMessengerFilterer) FilterDepositForBurn(opts *bind.FilterOpts, nonce []uint64, burnToken []common.Address, depositor []common.Address) (*MockTokenMessengerDepositForBurnIterator, error) { var nonceRule []interface{} for _, nonceItem := range nonce { nonceRule = append(nonceRule, nonceItem) } var burnTokenRule []interface{} for _, burnTokenItem := range burnToken { burnTokenRule = append(burnTokenRule, burnTokenItem) } var depositorRule []interface{} for _, depositorItem := range depositor { depositorRule = append(depositorRule, depositorItem) } logs, sub, err := _MockTokenMessenger.contract.FilterLogs(opts, "DepositForBurn", nonceRule, burnTokenRule, depositorRule) if err != nil { return nil, err } return &MockTokenMessengerDepositForBurnIterator{contract: _MockTokenMessenger.contract, event: "DepositForBurn", logs: logs, sub: sub}, nil } // WatchDepositForBurn is a free log subscription operation binding the contract event 0x2fa9ca894982930190727e75500a97d8dc500233a5065e0f3126c48fbe0343c0. // // Solidity: event DepositForBurn(uint64 indexed nonce, address indexed burnToken, uint256 amount, address indexed depositor, bytes32 mintRecipient, uint32 destinationDomain, bytes32 destinationTokenMessenger, bytes32 destinationCaller) func (_MockTokenMessenger *MockTokenMessengerFilterer) WatchDepositForBurn(opts *bind.WatchOpts, sink chan<- *MockTokenMessengerDepositForBurn, nonce []uint64, burnToken []common.Address, depositor []common.Address) (event.Subscription, error) { var nonceRule []interface{} for _, nonceItem := range nonce { nonceRule = append(nonceRule, nonceItem) } var burnTokenRule []interface{} for _, burnTokenItem := range burnToken { burnTokenRule = append(burnTokenRule, burnTokenItem) } var depositorRule []interface{} for _, depositorItem := range depositor { depositorRule = append(depositorRule, depositorItem) } logs, sub, err := _MockTokenMessenger.contract.WatchLogs(opts, "DepositForBurn", nonceRule, burnTokenRule, depositorRule) 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(MockTokenMessengerDepositForBurn) if err := _MockTokenMessenger.contract.UnpackLog(event, "DepositForBurn", 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 } // ParseDepositForBurn is a log parse operation binding the contract event 0x2fa9ca894982930190727e75500a97d8dc500233a5065e0f3126c48fbe0343c0. // // Solidity: event DepositForBurn(uint64 indexed nonce, address indexed burnToken, uint256 amount, address indexed depositor, bytes32 mintRecipient, uint32 destinationDomain, bytes32 destinationTokenMessenger, bytes32 destinationCaller) func (_MockTokenMessenger *MockTokenMessengerFilterer) ParseDepositForBurn(log types.Log) (*MockTokenMessengerDepositForBurn, error) { event := new(MockTokenMessengerDepositForBurn) if err := _MockTokenMessenger.contract.UnpackLog(event, "DepositForBurn", log); err != nil { return nil, err } event.Raw = log return event, nil } // MockTokenMessengerMintAndWithdrawIterator is returned from FilterMintAndWithdraw and is used to iterate over the raw logs and unpacked data for MintAndWithdraw events raised by the MockTokenMessenger contract. type MockTokenMessengerMintAndWithdrawIterator struct { Event *MockTokenMessengerMintAndWithdraw // 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 *MockTokenMessengerMintAndWithdrawIterator) 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(MockTokenMessengerMintAndWithdraw) 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(MockTokenMessengerMintAndWithdraw) 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 *MockTokenMessengerMintAndWithdrawIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MockTokenMessengerMintAndWithdrawIterator) Close() error { it.sub.Unsubscribe() return nil } // MockTokenMessengerMintAndWithdraw represents a MintAndWithdraw event raised by the MockTokenMessenger contract. type MockTokenMessengerMintAndWithdraw struct { MintRecipient common.Address Amount *big.Int MintToken common.Address Raw types.Log // Blockchain specific contextual infos } // FilterMintAndWithdraw is a free log retrieval operation binding the contract event 0x1b2a7ff080b8cb6ff436ce0372e399692bbfb6d4ae5766fd8d58a7b8cc6142e6. // // Solidity: event MintAndWithdraw(address indexed mintRecipient, uint256 amount, address indexed mintToken) func (_MockTokenMessenger *MockTokenMessengerFilterer) FilterMintAndWithdraw(opts *bind.FilterOpts, mintRecipient []common.Address, mintToken []common.Address) (*MockTokenMessengerMintAndWithdrawIterator, error) { var mintRecipientRule []interface{} for _, mintRecipientItem := range mintRecipient { mintRecipientRule = append(mintRecipientRule, mintRecipientItem) } var mintTokenRule []interface{} for _, mintTokenItem := range mintToken { mintTokenRule = append(mintTokenRule, mintTokenItem) } logs, sub, err := _MockTokenMessenger.contract.FilterLogs(opts, "MintAndWithdraw", mintRecipientRule, mintTokenRule) if err != nil { return nil, err } return &MockTokenMessengerMintAndWithdrawIterator{contract: _MockTokenMessenger.contract, event: "MintAndWithdraw", logs: logs, sub: sub}, nil } // WatchMintAndWithdraw is a free log subscription operation binding the contract event 0x1b2a7ff080b8cb6ff436ce0372e399692bbfb6d4ae5766fd8d58a7b8cc6142e6. // // Solidity: event MintAndWithdraw(address indexed mintRecipient, uint256 amount, address indexed mintToken) func (_MockTokenMessenger *MockTokenMessengerFilterer) WatchMintAndWithdraw(opts *bind.WatchOpts, sink chan<- *MockTokenMessengerMintAndWithdraw, mintRecipient []common.Address, mintToken []common.Address) (event.Subscription, error) { var mintRecipientRule []interface{} for _, mintRecipientItem := range mintRecipient { mintRecipientRule = append(mintRecipientRule, mintRecipientItem) } var mintTokenRule []interface{} for _, mintTokenItem := range mintToken { mintTokenRule = append(mintTokenRule, mintTokenItem) } logs, sub, err := _MockTokenMessenger.contract.WatchLogs(opts, "MintAndWithdraw", mintRecipientRule, mintTokenRule) 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(MockTokenMessengerMintAndWithdraw) if err := _MockTokenMessenger.contract.UnpackLog(event, "MintAndWithdraw", 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 } // ParseMintAndWithdraw is a log parse operation binding the contract event 0x1b2a7ff080b8cb6ff436ce0372e399692bbfb6d4ae5766fd8d58a7b8cc6142e6. // // Solidity: event MintAndWithdraw(address indexed mintRecipient, uint256 amount, address indexed mintToken) func (_MockTokenMessenger *MockTokenMessengerFilterer) ParseMintAndWithdraw(log types.Log) (*MockTokenMessengerMintAndWithdraw, error) { event := new(MockTokenMessengerMintAndWithdraw) if err := _MockTokenMessenger.contract.UnpackLog(event, "MintAndWithdraw", log); err != nil { return nil, err } event.Raw = log return event, nil } // SafeERC20MetaData contains all meta data concerning the SafeERC20 contract. var SafeERC20MetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220e451fbb2ae2021d046e31729b8bbb8de266bb8126a0e9afcff2e64f68c67ab1b64736f6c63430008110033", } // SafeERC20ABI is the input ABI used to generate the binding from. // Deprecated: Use SafeERC20MetaData.ABI instead. var SafeERC20ABI = SafeERC20MetaData.ABI // SafeERC20Bin is the compiled bytecode used for deploying new contracts. // Deprecated: Use SafeERC20MetaData.Bin instead. var SafeERC20Bin = SafeERC20MetaData.Bin // DeploySafeERC20 deploys a new Ethereum contract, binding an instance of SafeERC20 to it. func DeploySafeERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeERC20, error) { parsed, err := SafeERC20MetaData.GetAbi() if err != nil { return common.Address{}, nil, nil, err } if parsed == nil { return common.Address{}, nil, nil, errors.New("GetABI returned nil") } address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(SafeERC20Bin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &SafeERC20{SafeERC20Caller: SafeERC20Caller{contract: contract}, SafeERC20Transactor: SafeERC20Transactor{contract: contract}, SafeERC20Filterer: SafeERC20Filterer{contract: contract}}, nil } // SafeERC20 is an auto generated Go binding around an Ethereum contract. type SafeERC20 struct { SafeERC20Caller // Read-only binding to the contract SafeERC20Transactor // Write-only binding to the contract SafeERC20Filterer // Log filterer for contract events } // SafeERC20Caller is an auto generated read-only Go binding around an Ethereum contract. type SafeERC20Caller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SafeERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. type SafeERC20Transactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SafeERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. type SafeERC20Filterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SafeERC20Session is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type SafeERC20Session struct { Contract *SafeERC20 // 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 } // SafeERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type SafeERC20CallerSession struct { Contract *SafeERC20Caller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // SafeERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type SafeERC20TransactorSession struct { Contract *SafeERC20Transactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // SafeERC20Raw is an auto generated low-level Go binding around an Ethereum contract. type SafeERC20Raw struct { Contract *SafeERC20 // Generic contract binding to access the raw methods on } // SafeERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type SafeERC20CallerRaw struct { Contract *SafeERC20Caller // Generic read-only contract binding to access the raw methods on } // SafeERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type SafeERC20TransactorRaw struct { Contract *SafeERC20Transactor // Generic write-only contract binding to access the raw methods on } // NewSafeERC20 creates a new instance of SafeERC20, bound to a specific deployed contract. func NewSafeERC20(address common.Address, backend bind.ContractBackend) (*SafeERC20, error) { contract, err := bindSafeERC20(address, backend, backend, backend) if err != nil { return nil, err } return &SafeERC20{SafeERC20Caller: SafeERC20Caller{contract: contract}, SafeERC20Transactor: SafeERC20Transactor{contract: contract}, SafeERC20Filterer: SafeERC20Filterer{contract: contract}}, nil } // NewSafeERC20Caller creates a new read-only instance of SafeERC20, bound to a specific deployed contract. func NewSafeERC20Caller(address common.Address, caller bind.ContractCaller) (*SafeERC20Caller, error) { contract, err := bindSafeERC20(address, caller, nil, nil) if err != nil { return nil, err } return &SafeERC20Caller{contract: contract}, nil } // NewSafeERC20Transactor creates a new write-only instance of SafeERC20, bound to a specific deployed contract. func NewSafeERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*SafeERC20Transactor, error) { contract, err := bindSafeERC20(address, nil, transactor, nil) if err != nil { return nil, err } return &SafeERC20Transactor{contract: contract}, nil } // NewSafeERC20Filterer creates a new log filterer instance of SafeERC20, bound to a specific deployed contract. func NewSafeERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*SafeERC20Filterer, error) { contract, err := bindSafeERC20(address, nil, nil, filterer) if err != nil { return nil, err } return &SafeERC20Filterer{contract: contract}, nil } // bindSafeERC20 binds a generic wrapper to an already deployed contract. func bindSafeERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := abi.JSON(strings.NewReader(SafeERC20ABI)) 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 (_SafeERC20 *SafeERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _SafeERC20.Contract.SafeERC20Caller.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 (_SafeERC20 *SafeERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _SafeERC20.Contract.SafeERC20Transactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_SafeERC20 *SafeERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _SafeERC20.Contract.SafeERC20Transactor.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 (_SafeERC20 *SafeERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _SafeERC20.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 (_SafeERC20 *SafeERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _SafeERC20.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_SafeERC20 *SafeERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _SafeERC20.Contract.contract.Transact(opts, method, params...) } // TokenMessengerEventsMetaData contains all meta data concerning the TokenMessengerEvents contract. var TokenMessengerEventsMetaData = &bind.MetaData{ ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"burnToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"depositor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"mintRecipient\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"destinationDomain\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"destinationTokenMessenger\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"destinationCaller\",\"type\":\"bytes32\"}],\"name\":\"DepositForBurn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"mintRecipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"mintToken\",\"type\":\"address\"}],\"name\":\"MintAndWithdraw\",\"type\":\"event\"}]", } // TokenMessengerEventsABI is the input ABI used to generate the binding from. // Deprecated: Use TokenMessengerEventsMetaData.ABI instead. var TokenMessengerEventsABI = TokenMessengerEventsMetaData.ABI // TokenMessengerEvents is an auto generated Go binding around an Ethereum contract. type TokenMessengerEvents struct { TokenMessengerEventsCaller // Read-only binding to the contract TokenMessengerEventsTransactor // Write-only binding to the contract TokenMessengerEventsFilterer // Log filterer for contract events } // TokenMessengerEventsCaller is an auto generated read-only Go binding around an Ethereum contract. type TokenMessengerEventsCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // TokenMessengerEventsTransactor is an auto generated write-only Go binding around an Ethereum contract. type TokenMessengerEventsTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // TokenMessengerEventsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type TokenMessengerEventsFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // TokenMessengerEventsSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type TokenMessengerEventsSession struct { Contract *TokenMessengerEvents // 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 } // TokenMessengerEventsCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type TokenMessengerEventsCallerSession struct { Contract *TokenMessengerEventsCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // TokenMessengerEventsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type TokenMessengerEventsTransactorSession struct { Contract *TokenMessengerEventsTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // TokenMessengerEventsRaw is an auto generated low-level Go binding around an Ethereum contract. type TokenMessengerEventsRaw struct { Contract *TokenMessengerEvents // Generic contract binding to access the raw methods on } // TokenMessengerEventsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type TokenMessengerEventsCallerRaw struct { Contract *TokenMessengerEventsCaller // Generic read-only contract binding to access the raw methods on } // TokenMessengerEventsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type TokenMessengerEventsTransactorRaw struct { Contract *TokenMessengerEventsTransactor // Generic write-only contract binding to access the raw methods on } // NewTokenMessengerEvents creates a new instance of TokenMessengerEvents, bound to a specific deployed contract. func NewTokenMessengerEvents(address common.Address, backend bind.ContractBackend) (*TokenMessengerEvents, error) { contract, err := bindTokenMessengerEvents(address, backend, backend, backend) if err != nil { return nil, err } return &TokenMessengerEvents{TokenMessengerEventsCaller: TokenMessengerEventsCaller{contract: contract}, TokenMessengerEventsTransactor: TokenMessengerEventsTransactor{contract: contract}, TokenMessengerEventsFilterer: TokenMessengerEventsFilterer{contract: contract}}, nil } // NewTokenMessengerEventsCaller creates a new read-only instance of TokenMessengerEvents, bound to a specific deployed contract. func NewTokenMessengerEventsCaller(address common.Address, caller bind.ContractCaller) (*TokenMessengerEventsCaller, error) { contract, err := bindTokenMessengerEvents(address, caller, nil, nil) if err != nil { return nil, err } return &TokenMessengerEventsCaller{contract: contract}, nil } // NewTokenMessengerEventsTransactor creates a new write-only instance of TokenMessengerEvents, bound to a specific deployed contract. func NewTokenMessengerEventsTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenMessengerEventsTransactor, error) { contract, err := bindTokenMessengerEvents(address, nil, transactor, nil) if err != nil { return nil, err } return &TokenMessengerEventsTransactor{contract: contract}, nil } // NewTokenMessengerEventsFilterer creates a new log filterer instance of TokenMessengerEvents, bound to a specific deployed contract. func NewTokenMessengerEventsFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenMessengerEventsFilterer, error) { contract, err := bindTokenMessengerEvents(address, nil, nil, filterer) if err != nil { return nil, err } return &TokenMessengerEventsFilterer{contract: contract}, nil } // bindTokenMessengerEvents binds a generic wrapper to an already deployed contract. func bindTokenMessengerEvents(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := abi.JSON(strings.NewReader(TokenMessengerEventsABI)) 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 (_TokenMessengerEvents *TokenMessengerEventsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _TokenMessengerEvents.Contract.TokenMessengerEventsCaller.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 (_TokenMessengerEvents *TokenMessengerEventsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _TokenMessengerEvents.Contract.TokenMessengerEventsTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_TokenMessengerEvents *TokenMessengerEventsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _TokenMessengerEvents.Contract.TokenMessengerEventsTransactor.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 (_TokenMessengerEvents *TokenMessengerEventsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _TokenMessengerEvents.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 (_TokenMessengerEvents *TokenMessengerEventsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _TokenMessengerEvents.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_TokenMessengerEvents *TokenMessengerEventsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _TokenMessengerEvents.Contract.contract.Transact(opts, method, params...) } // TokenMessengerEventsDepositForBurnIterator is returned from FilterDepositForBurn and is used to iterate over the raw logs and unpacked data for DepositForBurn events raised by the TokenMessengerEvents contract. type TokenMessengerEventsDepositForBurnIterator struct { Event *TokenMessengerEventsDepositForBurn // 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 *TokenMessengerEventsDepositForBurnIterator) 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(TokenMessengerEventsDepositForBurn) 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(TokenMessengerEventsDepositForBurn) 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 *TokenMessengerEventsDepositForBurnIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *TokenMessengerEventsDepositForBurnIterator) Close() error { it.sub.Unsubscribe() return nil } // TokenMessengerEventsDepositForBurn represents a DepositForBurn event raised by the TokenMessengerEvents contract. type TokenMessengerEventsDepositForBurn struct { Nonce uint64 BurnToken common.Address Amount *big.Int Depositor common.Address MintRecipient [32]byte DestinationDomain uint32 DestinationTokenMessenger [32]byte DestinationCaller [32]byte Raw types.Log // Blockchain specific contextual infos } // FilterDepositForBurn is a free log retrieval operation binding the contract event 0x2fa9ca894982930190727e75500a97d8dc500233a5065e0f3126c48fbe0343c0. // // Solidity: event DepositForBurn(uint64 indexed nonce, address indexed burnToken, uint256 amount, address indexed depositor, bytes32 mintRecipient, uint32 destinationDomain, bytes32 destinationTokenMessenger, bytes32 destinationCaller) func (_TokenMessengerEvents *TokenMessengerEventsFilterer) FilterDepositForBurn(opts *bind.FilterOpts, nonce []uint64, burnToken []common.Address, depositor []common.Address) (*TokenMessengerEventsDepositForBurnIterator, error) { var nonceRule []interface{} for _, nonceItem := range nonce { nonceRule = append(nonceRule, nonceItem) } var burnTokenRule []interface{} for _, burnTokenItem := range burnToken { burnTokenRule = append(burnTokenRule, burnTokenItem) } var depositorRule []interface{} for _, depositorItem := range depositor { depositorRule = append(depositorRule, depositorItem) } logs, sub, err := _TokenMessengerEvents.contract.FilterLogs(opts, "DepositForBurn", nonceRule, burnTokenRule, depositorRule) if err != nil { return nil, err } return &TokenMessengerEventsDepositForBurnIterator{contract: _TokenMessengerEvents.contract, event: "DepositForBurn", logs: logs, sub: sub}, nil } // WatchDepositForBurn is a free log subscription operation binding the contract event 0x2fa9ca894982930190727e75500a97d8dc500233a5065e0f3126c48fbe0343c0. // // Solidity: event DepositForBurn(uint64 indexed nonce, address indexed burnToken, uint256 amount, address indexed depositor, bytes32 mintRecipient, uint32 destinationDomain, bytes32 destinationTokenMessenger, bytes32 destinationCaller) func (_TokenMessengerEvents *TokenMessengerEventsFilterer) WatchDepositForBurn(opts *bind.WatchOpts, sink chan<- *TokenMessengerEventsDepositForBurn, nonce []uint64, burnToken []common.Address, depositor []common.Address) (event.Subscription, error) { var nonceRule []interface{} for _, nonceItem := range nonce { nonceRule = append(nonceRule, nonceItem) } var burnTokenRule []interface{} for _, burnTokenItem := range burnToken { burnTokenRule = append(burnTokenRule, burnTokenItem) } var depositorRule []interface{} for _, depositorItem := range depositor { depositorRule = append(depositorRule, depositorItem) } logs, sub, err := _TokenMessengerEvents.contract.WatchLogs(opts, "DepositForBurn", nonceRule, burnTokenRule, depositorRule) 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(TokenMessengerEventsDepositForBurn) if err := _TokenMessengerEvents.contract.UnpackLog(event, "DepositForBurn", 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 } // ParseDepositForBurn is a log parse operation binding the contract event 0x2fa9ca894982930190727e75500a97d8dc500233a5065e0f3126c48fbe0343c0. // // Solidity: event DepositForBurn(uint64 indexed nonce, address indexed burnToken, uint256 amount, address indexed depositor, bytes32 mintRecipient, uint32 destinationDomain, bytes32 destinationTokenMessenger, bytes32 destinationCaller) func (_TokenMessengerEvents *TokenMessengerEventsFilterer) ParseDepositForBurn(log types.Log) (*TokenMessengerEventsDepositForBurn, error) { event := new(TokenMessengerEventsDepositForBurn) if err := _TokenMessengerEvents.contract.UnpackLog(event, "DepositForBurn", log); err != nil { return nil, err } event.Raw = log return event, nil } // TokenMessengerEventsMintAndWithdrawIterator is returned from FilterMintAndWithdraw and is used to iterate over the raw logs and unpacked data for MintAndWithdraw events raised by the TokenMessengerEvents contract. type TokenMessengerEventsMintAndWithdrawIterator struct { Event *TokenMessengerEventsMintAndWithdraw // 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 *TokenMessengerEventsMintAndWithdrawIterator) 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(TokenMessengerEventsMintAndWithdraw) 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(TokenMessengerEventsMintAndWithdraw) 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 *TokenMessengerEventsMintAndWithdrawIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *TokenMessengerEventsMintAndWithdrawIterator) Close() error { it.sub.Unsubscribe() return nil } // TokenMessengerEventsMintAndWithdraw represents a MintAndWithdraw event raised by the TokenMessengerEvents contract. type TokenMessengerEventsMintAndWithdraw struct { MintRecipient common.Address Amount *big.Int MintToken common.Address Raw types.Log // Blockchain specific contextual infos } // FilterMintAndWithdraw is a free log retrieval operation binding the contract event 0x1b2a7ff080b8cb6ff436ce0372e399692bbfb6d4ae5766fd8d58a7b8cc6142e6. // // Solidity: event MintAndWithdraw(address indexed mintRecipient, uint256 amount, address indexed mintToken) func (_TokenMessengerEvents *TokenMessengerEventsFilterer) FilterMintAndWithdraw(opts *bind.FilterOpts, mintRecipient []common.Address, mintToken []common.Address) (*TokenMessengerEventsMintAndWithdrawIterator, error) { var mintRecipientRule []interface{} for _, mintRecipientItem := range mintRecipient { mintRecipientRule = append(mintRecipientRule, mintRecipientItem) } var mintTokenRule []interface{} for _, mintTokenItem := range mintToken { mintTokenRule = append(mintTokenRule, mintTokenItem) } logs, sub, err := _TokenMessengerEvents.contract.FilterLogs(opts, "MintAndWithdraw", mintRecipientRule, mintTokenRule) if err != nil { return nil, err } return &TokenMessengerEventsMintAndWithdrawIterator{contract: _TokenMessengerEvents.contract, event: "MintAndWithdraw", logs: logs, sub: sub}, nil } // WatchMintAndWithdraw is a free log subscription operation binding the contract event 0x1b2a7ff080b8cb6ff436ce0372e399692bbfb6d4ae5766fd8d58a7b8cc6142e6. // // Solidity: event MintAndWithdraw(address indexed mintRecipient, uint256 amount, address indexed mintToken) func (_TokenMessengerEvents *TokenMessengerEventsFilterer) WatchMintAndWithdraw(opts *bind.WatchOpts, sink chan<- *TokenMessengerEventsMintAndWithdraw, mintRecipient []common.Address, mintToken []common.Address) (event.Subscription, error) { var mintRecipientRule []interface{} for _, mintRecipientItem := range mintRecipient { mintRecipientRule = append(mintRecipientRule, mintRecipientItem) } var mintTokenRule []interface{} for _, mintTokenItem := range mintToken { mintTokenRule = append(mintTokenRule, mintTokenItem) } logs, sub, err := _TokenMessengerEvents.contract.WatchLogs(opts, "MintAndWithdraw", mintRecipientRule, mintTokenRule) 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(TokenMessengerEventsMintAndWithdraw) if err := _TokenMessengerEvents.contract.UnpackLog(event, "MintAndWithdraw", 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 } // ParseMintAndWithdraw is a log parse operation binding the contract event 0x1b2a7ff080b8cb6ff436ce0372e399692bbfb6d4ae5766fd8d58a7b8cc6142e6. // // Solidity: event MintAndWithdraw(address indexed mintRecipient, uint256 amount, address indexed mintToken) func (_TokenMessengerEvents *TokenMessengerEventsFilterer) ParseMintAndWithdraw(log types.Log) (*TokenMessengerEventsMintAndWithdraw, error) { event := new(TokenMessengerEventsMintAndWithdraw) if err := _TokenMessengerEvents.contract.UnpackLog(event, "MintAndWithdraw", log); err != nil { return nil, err } event.Raw = log return event, nil }