// Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. package messageharness import ( "errors" "math/big" "strings" ethereum "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/event" ) // Reference imports to suppress errors if they are not otherwise used. var ( _ = errors.New _ = big.NewInt _ = strings.NewReader _ = ethereum.NotFound _ = bind.Bind _ = common.Big1 _ = types.BloomLookup _ = event.NewSubscription _ = abi.ConvertType ) // BaseMessageLibMetaData contains all meta data concerning the BaseMessageLib contract. var BaseMessageLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122041d23836bcd66702e03e2f733dc9c9c2260cbf0de4b30196d604ee0e2d22da7764736f6c63430008110033", } // BaseMessageLibABI is the input ABI used to generate the binding from. // Deprecated: Use BaseMessageLibMetaData.ABI instead. var BaseMessageLibABI = BaseMessageLibMetaData.ABI // BaseMessageLibBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use BaseMessageLibMetaData.Bin instead. var BaseMessageLibBin = BaseMessageLibMetaData.Bin // DeployBaseMessageLib deploys a new Ethereum contract, binding an instance of BaseMessageLib to it. func DeployBaseMessageLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BaseMessageLib, error) { parsed, err := BaseMessageLibMetaData.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(BaseMessageLibBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &BaseMessageLib{BaseMessageLibCaller: BaseMessageLibCaller{contract: contract}, BaseMessageLibTransactor: BaseMessageLibTransactor{contract: contract}, BaseMessageLibFilterer: BaseMessageLibFilterer{contract: contract}}, nil } // BaseMessageLib is an auto generated Go binding around an Ethereum contract. type BaseMessageLib struct { BaseMessageLibCaller // Read-only binding to the contract BaseMessageLibTransactor // Write-only binding to the contract BaseMessageLibFilterer // Log filterer for contract events } // BaseMessageLibCaller is an auto generated read-only Go binding around an Ethereum contract. type BaseMessageLibCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // BaseMessageLibTransactor is an auto generated write-only Go binding around an Ethereum contract. type BaseMessageLibTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // BaseMessageLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type BaseMessageLibFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // BaseMessageLibSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type BaseMessageLibSession struct { Contract *BaseMessageLib // 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 } // BaseMessageLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type BaseMessageLibCallerSession struct { Contract *BaseMessageLibCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // BaseMessageLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type BaseMessageLibTransactorSession struct { Contract *BaseMessageLibTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // BaseMessageLibRaw is an auto generated low-level Go binding around an Ethereum contract. type BaseMessageLibRaw struct { Contract *BaseMessageLib // Generic contract binding to access the raw methods on } // BaseMessageLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type BaseMessageLibCallerRaw struct { Contract *BaseMessageLibCaller // Generic read-only contract binding to access the raw methods on } // BaseMessageLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type BaseMessageLibTransactorRaw struct { Contract *BaseMessageLibTransactor // Generic write-only contract binding to access the raw methods on } // NewBaseMessageLib creates a new instance of BaseMessageLib, bound to a specific deployed contract. func NewBaseMessageLib(address common.Address, backend bind.ContractBackend) (*BaseMessageLib, error) { contract, err := bindBaseMessageLib(address, backend, backend, backend) if err != nil { return nil, err } return &BaseMessageLib{BaseMessageLibCaller: BaseMessageLibCaller{contract: contract}, BaseMessageLibTransactor: BaseMessageLibTransactor{contract: contract}, BaseMessageLibFilterer: BaseMessageLibFilterer{contract: contract}}, nil } // NewBaseMessageLibCaller creates a new read-only instance of BaseMessageLib, bound to a specific deployed contract. func NewBaseMessageLibCaller(address common.Address, caller bind.ContractCaller) (*BaseMessageLibCaller, error) { contract, err := bindBaseMessageLib(address, caller, nil, nil) if err != nil { return nil, err } return &BaseMessageLibCaller{contract: contract}, nil } // NewBaseMessageLibTransactor creates a new write-only instance of BaseMessageLib, bound to a specific deployed contract. func NewBaseMessageLibTransactor(address common.Address, transactor bind.ContractTransactor) (*BaseMessageLibTransactor, error) { contract, err := bindBaseMessageLib(address, nil, transactor, nil) if err != nil { return nil, err } return &BaseMessageLibTransactor{contract: contract}, nil } // NewBaseMessageLibFilterer creates a new log filterer instance of BaseMessageLib, bound to a specific deployed contract. func NewBaseMessageLibFilterer(address common.Address, filterer bind.ContractFilterer) (*BaseMessageLibFilterer, error) { contract, err := bindBaseMessageLib(address, nil, nil, filterer) if err != nil { return nil, err } return &BaseMessageLibFilterer{contract: contract}, nil } // bindBaseMessageLib binds a generic wrapper to an already deployed contract. func bindBaseMessageLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := BaseMessageLibMetaData.GetAbi() if err != nil { return nil, err } return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_BaseMessageLib *BaseMessageLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _BaseMessageLib.Contract.BaseMessageLibCaller.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 (_BaseMessageLib *BaseMessageLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _BaseMessageLib.Contract.BaseMessageLibTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_BaseMessageLib *BaseMessageLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _BaseMessageLib.Contract.BaseMessageLibTransactor.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 (_BaseMessageLib *BaseMessageLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _BaseMessageLib.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 (_BaseMessageLib *BaseMessageLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _BaseMessageLib.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_BaseMessageLib *BaseMessageLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _BaseMessageLib.Contract.contract.Transact(opts, method, params...) } // ByteStringMetaData contains all meta data concerning the ByteString contract. var ByteStringMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220eee135197a617b274c67485f81b0cac474ad60c10294e096bd5ea0b8e607a4b264736f6c63430008110033", } // ByteStringABI is the input ABI used to generate the binding from. // Deprecated: Use ByteStringMetaData.ABI instead. var ByteStringABI = ByteStringMetaData.ABI // ByteStringBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use ByteStringMetaData.Bin instead. var ByteStringBin = ByteStringMetaData.Bin // DeployByteString deploys a new Ethereum contract, binding an instance of ByteString to it. func DeployByteString(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ByteString, error) { parsed, err := ByteStringMetaData.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(ByteStringBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &ByteString{ByteStringCaller: ByteStringCaller{contract: contract}, ByteStringTransactor: ByteStringTransactor{contract: contract}, ByteStringFilterer: ByteStringFilterer{contract: contract}}, nil } // ByteString is an auto generated Go binding around an Ethereum contract. type ByteString struct { ByteStringCaller // Read-only binding to the contract ByteStringTransactor // Write-only binding to the contract ByteStringFilterer // Log filterer for contract events } // ByteStringCaller is an auto generated read-only Go binding around an Ethereum contract. type ByteStringCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // ByteStringTransactor is an auto generated write-only Go binding around an Ethereum contract. type ByteStringTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // ByteStringFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type ByteStringFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // ByteStringSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type ByteStringSession struct { Contract *ByteString // 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 } // ByteStringCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type ByteStringCallerSession struct { Contract *ByteStringCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // ByteStringTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type ByteStringTransactorSession struct { Contract *ByteStringTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // ByteStringRaw is an auto generated low-level Go binding around an Ethereum contract. type ByteStringRaw struct { Contract *ByteString // Generic contract binding to access the raw methods on } // ByteStringCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type ByteStringCallerRaw struct { Contract *ByteStringCaller // Generic read-only contract binding to access the raw methods on } // ByteStringTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type ByteStringTransactorRaw struct { Contract *ByteStringTransactor // Generic write-only contract binding to access the raw methods on } // NewByteString creates a new instance of ByteString, bound to a specific deployed contract. func NewByteString(address common.Address, backend bind.ContractBackend) (*ByteString, error) { contract, err := bindByteString(address, backend, backend, backend) if err != nil { return nil, err } return &ByteString{ByteStringCaller: ByteStringCaller{contract: contract}, ByteStringTransactor: ByteStringTransactor{contract: contract}, ByteStringFilterer: ByteStringFilterer{contract: contract}}, nil } // NewByteStringCaller creates a new read-only instance of ByteString, bound to a specific deployed contract. func NewByteStringCaller(address common.Address, caller bind.ContractCaller) (*ByteStringCaller, error) { contract, err := bindByteString(address, caller, nil, nil) if err != nil { return nil, err } return &ByteStringCaller{contract: contract}, nil } // NewByteStringTransactor creates a new write-only instance of ByteString, bound to a specific deployed contract. func NewByteStringTransactor(address common.Address, transactor bind.ContractTransactor) (*ByteStringTransactor, error) { contract, err := bindByteString(address, nil, transactor, nil) if err != nil { return nil, err } return &ByteStringTransactor{contract: contract}, nil } // NewByteStringFilterer creates a new log filterer instance of ByteString, bound to a specific deployed contract. func NewByteStringFilterer(address common.Address, filterer bind.ContractFilterer) (*ByteStringFilterer, error) { contract, err := bindByteString(address, nil, nil, filterer) if err != nil { return nil, err } return &ByteStringFilterer{contract: contract}, nil } // bindByteString binds a generic wrapper to an already deployed contract. func bindByteString(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := ByteStringMetaData.GetAbi() if err != nil { return nil, err } return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_ByteString *ByteStringRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _ByteString.Contract.ByteStringCaller.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 (_ByteString *ByteStringRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _ByteString.Contract.ByteStringTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_ByteString *ByteStringRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _ByteString.Contract.ByteStringTransactor.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 (_ByteString *ByteStringCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _ByteString.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 (_ByteString *ByteStringTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _ByteString.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_ByteString *ByteStringTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _ByteString.Contract.contract.Transact(opts, method, params...) } // HeaderLibMetaData contains all meta data concerning the HeaderLib contract. var HeaderLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212201062edbb28fdb47e9233927bbf4ae47416821a39c4b7124dd894052f972e5bb764736f6c63430008110033", } // HeaderLibABI is the input ABI used to generate the binding from. // Deprecated: Use HeaderLibMetaData.ABI instead. var HeaderLibABI = HeaderLibMetaData.ABI // HeaderLibBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use HeaderLibMetaData.Bin instead. var HeaderLibBin = HeaderLibMetaData.Bin // DeployHeaderLib deploys a new Ethereum contract, binding an instance of HeaderLib to it. func DeployHeaderLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *HeaderLib, error) { parsed, err := HeaderLibMetaData.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(HeaderLibBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &HeaderLib{HeaderLibCaller: HeaderLibCaller{contract: contract}, HeaderLibTransactor: HeaderLibTransactor{contract: contract}, HeaderLibFilterer: HeaderLibFilterer{contract: contract}}, nil } // HeaderLib is an auto generated Go binding around an Ethereum contract. type HeaderLib struct { HeaderLibCaller // Read-only binding to the contract HeaderLibTransactor // Write-only binding to the contract HeaderLibFilterer // Log filterer for contract events } // HeaderLibCaller is an auto generated read-only Go binding around an Ethereum contract. type HeaderLibCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // HeaderLibTransactor is an auto generated write-only Go binding around an Ethereum contract. type HeaderLibTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // HeaderLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type HeaderLibFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // HeaderLibSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type HeaderLibSession struct { Contract *HeaderLib // 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 } // HeaderLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type HeaderLibCallerSession struct { Contract *HeaderLibCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // HeaderLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type HeaderLibTransactorSession struct { Contract *HeaderLibTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // HeaderLibRaw is an auto generated low-level Go binding around an Ethereum contract. type HeaderLibRaw struct { Contract *HeaderLib // Generic contract binding to access the raw methods on } // HeaderLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type HeaderLibCallerRaw struct { Contract *HeaderLibCaller // Generic read-only contract binding to access the raw methods on } // HeaderLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type HeaderLibTransactorRaw struct { Contract *HeaderLibTransactor // Generic write-only contract binding to access the raw methods on } // NewHeaderLib creates a new instance of HeaderLib, bound to a specific deployed contract. func NewHeaderLib(address common.Address, backend bind.ContractBackend) (*HeaderLib, error) { contract, err := bindHeaderLib(address, backend, backend, backend) if err != nil { return nil, err } return &HeaderLib{HeaderLibCaller: HeaderLibCaller{contract: contract}, HeaderLibTransactor: HeaderLibTransactor{contract: contract}, HeaderLibFilterer: HeaderLibFilterer{contract: contract}}, nil } // NewHeaderLibCaller creates a new read-only instance of HeaderLib, bound to a specific deployed contract. func NewHeaderLibCaller(address common.Address, caller bind.ContractCaller) (*HeaderLibCaller, error) { contract, err := bindHeaderLib(address, caller, nil, nil) if err != nil { return nil, err } return &HeaderLibCaller{contract: contract}, nil } // NewHeaderLibTransactor creates a new write-only instance of HeaderLib, bound to a specific deployed contract. func NewHeaderLibTransactor(address common.Address, transactor bind.ContractTransactor) (*HeaderLibTransactor, error) { contract, err := bindHeaderLib(address, nil, transactor, nil) if err != nil { return nil, err } return &HeaderLibTransactor{contract: contract}, nil } // NewHeaderLibFilterer creates a new log filterer instance of HeaderLib, bound to a specific deployed contract. func NewHeaderLibFilterer(address common.Address, filterer bind.ContractFilterer) (*HeaderLibFilterer, error) { contract, err := bindHeaderLib(address, nil, nil, filterer) if err != nil { return nil, err } return &HeaderLibFilterer{contract: contract}, nil } // bindHeaderLib binds a generic wrapper to an already deployed contract. func bindHeaderLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := HeaderLibMetaData.GetAbi() if err != nil { return nil, err } return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_HeaderLib *HeaderLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _HeaderLib.Contract.HeaderLibCaller.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 (_HeaderLib *HeaderLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _HeaderLib.Contract.HeaderLibTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_HeaderLib *HeaderLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _HeaderLib.Contract.HeaderLibTransactor.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 (_HeaderLib *HeaderLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _HeaderLib.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 (_HeaderLib *HeaderLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _HeaderLib.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_HeaderLib *HeaderLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _HeaderLib.Contract.contract.Transact(opts, method, params...) } // MemViewLibMetaData contains all meta data concerning the MemViewLib contract. var MemViewLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220a59c6874ea406d8f2f9baf552f7356546c590f123132a6eadc166e92a28d6f3764736f6c63430008110033", } // MemViewLibABI is the input ABI used to generate the binding from. // Deprecated: Use MemViewLibMetaData.ABI instead. var MemViewLibABI = MemViewLibMetaData.ABI // MemViewLibBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use MemViewLibMetaData.Bin instead. var MemViewLibBin = MemViewLibMetaData.Bin // DeployMemViewLib deploys a new Ethereum contract, binding an instance of MemViewLib to it. func DeployMemViewLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MemViewLib, error) { parsed, err := MemViewLibMetaData.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(MemViewLibBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &MemViewLib{MemViewLibCaller: MemViewLibCaller{contract: contract}, MemViewLibTransactor: MemViewLibTransactor{contract: contract}, MemViewLibFilterer: MemViewLibFilterer{contract: contract}}, nil } // MemViewLib is an auto generated Go binding around an Ethereum contract. type MemViewLib struct { MemViewLibCaller // Read-only binding to the contract MemViewLibTransactor // Write-only binding to the contract MemViewLibFilterer // Log filterer for contract events } // MemViewLibCaller is an auto generated read-only Go binding around an Ethereum contract. type MemViewLibCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MemViewLibTransactor is an auto generated write-only Go binding around an Ethereum contract. type MemViewLibTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MemViewLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type MemViewLibFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MemViewLibSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type MemViewLibSession struct { Contract *MemViewLib // 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 } // MemViewLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type MemViewLibCallerSession struct { Contract *MemViewLibCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // MemViewLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type MemViewLibTransactorSession struct { Contract *MemViewLibTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // MemViewLibRaw is an auto generated low-level Go binding around an Ethereum contract. type MemViewLibRaw struct { Contract *MemViewLib // Generic contract binding to access the raw methods on } // MemViewLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type MemViewLibCallerRaw struct { Contract *MemViewLibCaller // Generic read-only contract binding to access the raw methods on } // MemViewLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type MemViewLibTransactorRaw struct { Contract *MemViewLibTransactor // Generic write-only contract binding to access the raw methods on } // NewMemViewLib creates a new instance of MemViewLib, bound to a specific deployed contract. func NewMemViewLib(address common.Address, backend bind.ContractBackend) (*MemViewLib, error) { contract, err := bindMemViewLib(address, backend, backend, backend) if err != nil { return nil, err } return &MemViewLib{MemViewLibCaller: MemViewLibCaller{contract: contract}, MemViewLibTransactor: MemViewLibTransactor{contract: contract}, MemViewLibFilterer: MemViewLibFilterer{contract: contract}}, nil } // NewMemViewLibCaller creates a new read-only instance of MemViewLib, bound to a specific deployed contract. func NewMemViewLibCaller(address common.Address, caller bind.ContractCaller) (*MemViewLibCaller, error) { contract, err := bindMemViewLib(address, caller, nil, nil) if err != nil { return nil, err } return &MemViewLibCaller{contract: contract}, nil } // NewMemViewLibTransactor creates a new write-only instance of MemViewLib, bound to a specific deployed contract. func NewMemViewLibTransactor(address common.Address, transactor bind.ContractTransactor) (*MemViewLibTransactor, error) { contract, err := bindMemViewLib(address, nil, transactor, nil) if err != nil { return nil, err } return &MemViewLibTransactor{contract: contract}, nil } // NewMemViewLibFilterer creates a new log filterer instance of MemViewLib, bound to a specific deployed contract. func NewMemViewLibFilterer(address common.Address, filterer bind.ContractFilterer) (*MemViewLibFilterer, error) { contract, err := bindMemViewLib(address, nil, nil, filterer) if err != nil { return nil, err } return &MemViewLibFilterer{contract: contract}, nil } // bindMemViewLib binds a generic wrapper to an already deployed contract. func bindMemViewLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := MemViewLibMetaData.GetAbi() if err != nil { return nil, err } return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_MemViewLib *MemViewLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MemViewLib.Contract.MemViewLibCaller.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 (_MemViewLib *MemViewLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MemViewLib.Contract.MemViewLibTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MemViewLib *MemViewLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MemViewLib.Contract.MemViewLibTransactor.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 (_MemViewLib *MemViewLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MemViewLib.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 (_MemViewLib *MemViewLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MemViewLib.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MemViewLib *MemViewLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MemViewLib.Contract.contract.Transact(opts, method, params...) } // MerkleMathMetaData contains all meta data concerning the MerkleMath contract. var MerkleMathMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220449b0b83bb2c1274fd046212793ef458afe05450a235a0c28c7a280670b4dba664736f6c63430008110033", } // MerkleMathABI is the input ABI used to generate the binding from. // Deprecated: Use MerkleMathMetaData.ABI instead. var MerkleMathABI = MerkleMathMetaData.ABI // MerkleMathBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use MerkleMathMetaData.Bin instead. var MerkleMathBin = MerkleMathMetaData.Bin // DeployMerkleMath deploys a new Ethereum contract, binding an instance of MerkleMath to it. func DeployMerkleMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MerkleMath, error) { parsed, err := MerkleMathMetaData.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(MerkleMathBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &MerkleMath{MerkleMathCaller: MerkleMathCaller{contract: contract}, MerkleMathTransactor: MerkleMathTransactor{contract: contract}, MerkleMathFilterer: MerkleMathFilterer{contract: contract}}, nil } // MerkleMath is an auto generated Go binding around an Ethereum contract. type MerkleMath struct { MerkleMathCaller // Read-only binding to the contract MerkleMathTransactor // Write-only binding to the contract MerkleMathFilterer // Log filterer for contract events } // MerkleMathCaller is an auto generated read-only Go binding around an Ethereum contract. type MerkleMathCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MerkleMathTransactor is an auto generated write-only Go binding around an Ethereum contract. type MerkleMathTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MerkleMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type MerkleMathFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MerkleMathSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type MerkleMathSession struct { Contract *MerkleMath // 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 } // MerkleMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type MerkleMathCallerSession struct { Contract *MerkleMathCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // MerkleMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type MerkleMathTransactorSession struct { Contract *MerkleMathTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // MerkleMathRaw is an auto generated low-level Go binding around an Ethereum contract. type MerkleMathRaw struct { Contract *MerkleMath // Generic contract binding to access the raw methods on } // MerkleMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type MerkleMathCallerRaw struct { Contract *MerkleMathCaller // Generic read-only contract binding to access the raw methods on } // MerkleMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type MerkleMathTransactorRaw struct { Contract *MerkleMathTransactor // Generic write-only contract binding to access the raw methods on } // NewMerkleMath creates a new instance of MerkleMath, bound to a specific deployed contract. func NewMerkleMath(address common.Address, backend bind.ContractBackend) (*MerkleMath, error) { contract, err := bindMerkleMath(address, backend, backend, backend) if err != nil { return nil, err } return &MerkleMath{MerkleMathCaller: MerkleMathCaller{contract: contract}, MerkleMathTransactor: MerkleMathTransactor{contract: contract}, MerkleMathFilterer: MerkleMathFilterer{contract: contract}}, nil } // NewMerkleMathCaller creates a new read-only instance of MerkleMath, bound to a specific deployed contract. func NewMerkleMathCaller(address common.Address, caller bind.ContractCaller) (*MerkleMathCaller, error) { contract, err := bindMerkleMath(address, caller, nil, nil) if err != nil { return nil, err } return &MerkleMathCaller{contract: contract}, nil } // NewMerkleMathTransactor creates a new write-only instance of MerkleMath, bound to a specific deployed contract. func NewMerkleMathTransactor(address common.Address, transactor bind.ContractTransactor) (*MerkleMathTransactor, error) { contract, err := bindMerkleMath(address, nil, transactor, nil) if err != nil { return nil, err } return &MerkleMathTransactor{contract: contract}, nil } // NewMerkleMathFilterer creates a new log filterer instance of MerkleMath, bound to a specific deployed contract. func NewMerkleMathFilterer(address common.Address, filterer bind.ContractFilterer) (*MerkleMathFilterer, error) { contract, err := bindMerkleMath(address, nil, nil, filterer) if err != nil { return nil, err } return &MerkleMathFilterer{contract: contract}, nil } // bindMerkleMath binds a generic wrapper to an already deployed contract. func bindMerkleMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := MerkleMathMetaData.GetAbi() if err != nil { return nil, err } return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_MerkleMath *MerkleMathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MerkleMath.Contract.MerkleMathCaller.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 (_MerkleMath *MerkleMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MerkleMath.Contract.MerkleMathTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MerkleMath *MerkleMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MerkleMath.Contract.MerkleMathTransactor.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 (_MerkleMath *MerkleMathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MerkleMath.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 (_MerkleMath *MerkleMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MerkleMath.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MerkleMath *MerkleMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MerkleMath.Contract.contract.Transact(opts, method, params...) } // MessageHarnessMetaData contains all meta data concerning the MessageHarness contract. var MessageHarnessMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"FlagOutOfRange\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"IndexedTooMuch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OccupiedMemory\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PrecompileOutOfGas\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnallocatedMemory\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnformattedBaseMessage\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnformattedCallData\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnformattedMessage\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ViewOverrun\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"body\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"castToMessage\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"Header\",\"name\":\"header_\",\"type\":\"uint136\"},{\"internalType\":\"bytes\",\"name\":\"body_\",\"type\":\"bytes\"}],\"name\":\"formatMessage\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"header\",\"outputs\":[{\"internalType\":\"Header\",\"name\":\"\",\"type\":\"uint136\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"isMessage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"leaf\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", Sigs: map[string]string{ "c97c703a": "body(bytes)", "c311d359": "castToMessage(bytes)", "00b26cfe": "formatMessage(uint136,bytes)", "801fdbfc": "header(bytes)", "f9893ddd": "isMessage(bytes)", "d7a7a72c": "leaf(bytes)", }, Bin: "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", } // MessageHarnessABI is the input ABI used to generate the binding from. // Deprecated: Use MessageHarnessMetaData.ABI instead. var MessageHarnessABI = MessageHarnessMetaData.ABI // Deprecated: Use MessageHarnessMetaData.Sigs instead. // MessageHarnessFuncSigs maps the 4-byte function signature to its string representation. var MessageHarnessFuncSigs = MessageHarnessMetaData.Sigs // MessageHarnessBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use MessageHarnessMetaData.Bin instead. var MessageHarnessBin = MessageHarnessMetaData.Bin // DeployMessageHarness deploys a new Ethereum contract, binding an instance of MessageHarness to it. func DeployMessageHarness(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MessageHarness, error) { parsed, err := MessageHarnessMetaData.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(MessageHarnessBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &MessageHarness{MessageHarnessCaller: MessageHarnessCaller{contract: contract}, MessageHarnessTransactor: MessageHarnessTransactor{contract: contract}, MessageHarnessFilterer: MessageHarnessFilterer{contract: contract}}, nil } // MessageHarness is an auto generated Go binding around an Ethereum contract. type MessageHarness struct { MessageHarnessCaller // Read-only binding to the contract MessageHarnessTransactor // Write-only binding to the contract MessageHarnessFilterer // Log filterer for contract events } // MessageHarnessCaller is an auto generated read-only Go binding around an Ethereum contract. type MessageHarnessCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MessageHarnessTransactor is an auto generated write-only Go binding around an Ethereum contract. type MessageHarnessTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MessageHarnessFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type MessageHarnessFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MessageHarnessSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type MessageHarnessSession struct { Contract *MessageHarness // 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 } // MessageHarnessCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type MessageHarnessCallerSession struct { Contract *MessageHarnessCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // MessageHarnessTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type MessageHarnessTransactorSession struct { Contract *MessageHarnessTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // MessageHarnessRaw is an auto generated low-level Go binding around an Ethereum contract. type MessageHarnessRaw struct { Contract *MessageHarness // Generic contract binding to access the raw methods on } // MessageHarnessCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type MessageHarnessCallerRaw struct { Contract *MessageHarnessCaller // Generic read-only contract binding to access the raw methods on } // MessageHarnessTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type MessageHarnessTransactorRaw struct { Contract *MessageHarnessTransactor // Generic write-only contract binding to access the raw methods on } // NewMessageHarness creates a new instance of MessageHarness, bound to a specific deployed contract. func NewMessageHarness(address common.Address, backend bind.ContractBackend) (*MessageHarness, error) { contract, err := bindMessageHarness(address, backend, backend, backend) if err != nil { return nil, err } return &MessageHarness{MessageHarnessCaller: MessageHarnessCaller{contract: contract}, MessageHarnessTransactor: MessageHarnessTransactor{contract: contract}, MessageHarnessFilterer: MessageHarnessFilterer{contract: contract}}, nil } // NewMessageHarnessCaller creates a new read-only instance of MessageHarness, bound to a specific deployed contract. func NewMessageHarnessCaller(address common.Address, caller bind.ContractCaller) (*MessageHarnessCaller, error) { contract, err := bindMessageHarness(address, caller, nil, nil) if err != nil { return nil, err } return &MessageHarnessCaller{contract: contract}, nil } // NewMessageHarnessTransactor creates a new write-only instance of MessageHarness, bound to a specific deployed contract. func NewMessageHarnessTransactor(address common.Address, transactor bind.ContractTransactor) (*MessageHarnessTransactor, error) { contract, err := bindMessageHarness(address, nil, transactor, nil) if err != nil { return nil, err } return &MessageHarnessTransactor{contract: contract}, nil } // NewMessageHarnessFilterer creates a new log filterer instance of MessageHarness, bound to a specific deployed contract. func NewMessageHarnessFilterer(address common.Address, filterer bind.ContractFilterer) (*MessageHarnessFilterer, error) { contract, err := bindMessageHarness(address, nil, nil, filterer) if err != nil { return nil, err } return &MessageHarnessFilterer{contract: contract}, nil } // bindMessageHarness binds a generic wrapper to an already deployed contract. func bindMessageHarness(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := MessageHarnessMetaData.GetAbi() if err != nil { return nil, err } return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_MessageHarness *MessageHarnessRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MessageHarness.Contract.MessageHarnessCaller.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 (_MessageHarness *MessageHarnessRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MessageHarness.Contract.MessageHarnessTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MessageHarness *MessageHarnessRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MessageHarness.Contract.MessageHarnessTransactor.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 (_MessageHarness *MessageHarnessCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MessageHarness.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 (_MessageHarness *MessageHarnessTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MessageHarness.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MessageHarness *MessageHarnessTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MessageHarness.Contract.contract.Transact(opts, method, params...) } // Body is a free data retrieval call binding the contract method 0xc97c703a. // // Solidity: function body(bytes payload) view returns(bytes) func (_MessageHarness *MessageHarnessCaller) Body(opts *bind.CallOpts, payload []byte) ([]byte, error) { var out []interface{} err := _MessageHarness.contract.Call(opts, &out, "body", payload) if err != nil { return *new([]byte), err } out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) return out0, err } // Body is a free data retrieval call binding the contract method 0xc97c703a. // // Solidity: function body(bytes payload) view returns(bytes) func (_MessageHarness *MessageHarnessSession) Body(payload []byte) ([]byte, error) { return _MessageHarness.Contract.Body(&_MessageHarness.CallOpts, payload) } // Body is a free data retrieval call binding the contract method 0xc97c703a. // // Solidity: function body(bytes payload) view returns(bytes) func (_MessageHarness *MessageHarnessCallerSession) Body(payload []byte) ([]byte, error) { return _MessageHarness.Contract.Body(&_MessageHarness.CallOpts, payload) } // CastToMessage is a free data retrieval call binding the contract method 0xc311d359. // // Solidity: function castToMessage(bytes payload) view returns(bytes) func (_MessageHarness *MessageHarnessCaller) CastToMessage(opts *bind.CallOpts, payload []byte) ([]byte, error) { var out []interface{} err := _MessageHarness.contract.Call(opts, &out, "castToMessage", payload) if err != nil { return *new([]byte), err } out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) return out0, err } // CastToMessage is a free data retrieval call binding the contract method 0xc311d359. // // Solidity: function castToMessage(bytes payload) view returns(bytes) func (_MessageHarness *MessageHarnessSession) CastToMessage(payload []byte) ([]byte, error) { return _MessageHarness.Contract.CastToMessage(&_MessageHarness.CallOpts, payload) } // CastToMessage is a free data retrieval call binding the contract method 0xc311d359. // // Solidity: function castToMessage(bytes payload) view returns(bytes) func (_MessageHarness *MessageHarnessCallerSession) CastToMessage(payload []byte) ([]byte, error) { return _MessageHarness.Contract.CastToMessage(&_MessageHarness.CallOpts, payload) } // FormatMessage is a free data retrieval call binding the contract method 0x00b26cfe. // // Solidity: function formatMessage(uint136 header_, bytes body_) pure returns(bytes) func (_MessageHarness *MessageHarnessCaller) FormatMessage(opts *bind.CallOpts, header_ *big.Int, body_ []byte) ([]byte, error) { var out []interface{} err := _MessageHarness.contract.Call(opts, &out, "formatMessage", header_, body_) if err != nil { return *new([]byte), err } out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) return out0, err } // FormatMessage is a free data retrieval call binding the contract method 0x00b26cfe. // // Solidity: function formatMessage(uint136 header_, bytes body_) pure returns(bytes) func (_MessageHarness *MessageHarnessSession) FormatMessage(header_ *big.Int, body_ []byte) ([]byte, error) { return _MessageHarness.Contract.FormatMessage(&_MessageHarness.CallOpts, header_, body_) } // FormatMessage is a free data retrieval call binding the contract method 0x00b26cfe. // // Solidity: function formatMessage(uint136 header_, bytes body_) pure returns(bytes) func (_MessageHarness *MessageHarnessCallerSession) FormatMessage(header_ *big.Int, body_ []byte) ([]byte, error) { return _MessageHarness.Contract.FormatMessage(&_MessageHarness.CallOpts, header_, body_) } // Header is a free data retrieval call binding the contract method 0x801fdbfc. // // Solidity: function header(bytes payload) pure returns(uint136) func (_MessageHarness *MessageHarnessCaller) Header(opts *bind.CallOpts, payload []byte) (*big.Int, error) { var out []interface{} err := _MessageHarness.contract.Call(opts, &out, "header", payload) if err != nil { return *new(*big.Int), err } out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) return out0, err } // Header is a free data retrieval call binding the contract method 0x801fdbfc. // // Solidity: function header(bytes payload) pure returns(uint136) func (_MessageHarness *MessageHarnessSession) Header(payload []byte) (*big.Int, error) { return _MessageHarness.Contract.Header(&_MessageHarness.CallOpts, payload) } // Header is a free data retrieval call binding the contract method 0x801fdbfc. // // Solidity: function header(bytes payload) pure returns(uint136) func (_MessageHarness *MessageHarnessCallerSession) Header(payload []byte) (*big.Int, error) { return _MessageHarness.Contract.Header(&_MessageHarness.CallOpts, payload) } // IsMessage is a free data retrieval call binding the contract method 0xf9893ddd. // // Solidity: function isMessage(bytes payload) pure returns(bool) func (_MessageHarness *MessageHarnessCaller) IsMessage(opts *bind.CallOpts, payload []byte) (bool, error) { var out []interface{} err := _MessageHarness.contract.Call(opts, &out, "isMessage", payload) if err != nil { return *new(bool), err } out0 := *abi.ConvertType(out[0], new(bool)).(*bool) return out0, err } // IsMessage is a free data retrieval call binding the contract method 0xf9893ddd. // // Solidity: function isMessage(bytes payload) pure returns(bool) func (_MessageHarness *MessageHarnessSession) IsMessage(payload []byte) (bool, error) { return _MessageHarness.Contract.IsMessage(&_MessageHarness.CallOpts, payload) } // IsMessage is a free data retrieval call binding the contract method 0xf9893ddd. // // Solidity: function isMessage(bytes payload) pure returns(bool) func (_MessageHarness *MessageHarnessCallerSession) IsMessage(payload []byte) (bool, error) { return _MessageHarness.Contract.IsMessage(&_MessageHarness.CallOpts, payload) } // Leaf is a free data retrieval call binding the contract method 0xd7a7a72c. // // Solidity: function leaf(bytes payload) pure returns(bytes32) func (_MessageHarness *MessageHarnessCaller) Leaf(opts *bind.CallOpts, payload []byte) ([32]byte, error) { var out []interface{} err := _MessageHarness.contract.Call(opts, &out, "leaf", payload) if err != nil { return *new([32]byte), err } out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) return out0, err } // Leaf is a free data retrieval call binding the contract method 0xd7a7a72c. // // Solidity: function leaf(bytes payload) pure returns(bytes32) func (_MessageHarness *MessageHarnessSession) Leaf(payload []byte) ([32]byte, error) { return _MessageHarness.Contract.Leaf(&_MessageHarness.CallOpts, payload) } // Leaf is a free data retrieval call binding the contract method 0xd7a7a72c. // // Solidity: function leaf(bytes payload) pure returns(bytes32) func (_MessageHarness *MessageHarnessCallerSession) Leaf(payload []byte) ([32]byte, error) { return _MessageHarness.Contract.Leaf(&_MessageHarness.CallOpts, payload) } // MessageLibMetaData contains all meta data concerning the MessageLib contract. var MessageLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220df70c371d0a7fd51a9b8545b710a16bc546b609ec6588737f100dd787e2a1ef364736f6c63430008110033", } // MessageLibABI is the input ABI used to generate the binding from. // Deprecated: Use MessageLibMetaData.ABI instead. var MessageLibABI = MessageLibMetaData.ABI // MessageLibBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use MessageLibMetaData.Bin instead. var MessageLibBin = MessageLibMetaData.Bin // DeployMessageLib deploys a new Ethereum contract, binding an instance of MessageLib to it. func DeployMessageLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MessageLib, error) { parsed, err := MessageLibMetaData.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(MessageLibBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &MessageLib{MessageLibCaller: MessageLibCaller{contract: contract}, MessageLibTransactor: MessageLibTransactor{contract: contract}, MessageLibFilterer: MessageLibFilterer{contract: contract}}, nil } // MessageLib is an auto generated Go binding around an Ethereum contract. type MessageLib struct { MessageLibCaller // Read-only binding to the contract MessageLibTransactor // Write-only binding to the contract MessageLibFilterer // Log filterer for contract events } // MessageLibCaller is an auto generated read-only Go binding around an Ethereum contract. type MessageLibCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MessageLibTransactor is an auto generated write-only Go binding around an Ethereum contract. type MessageLibTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MessageLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type MessageLibFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MessageLibSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type MessageLibSession struct { Contract *MessageLib // 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 } // MessageLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type MessageLibCallerSession struct { Contract *MessageLibCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // MessageLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type MessageLibTransactorSession struct { Contract *MessageLibTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // MessageLibRaw is an auto generated low-level Go binding around an Ethereum contract. type MessageLibRaw struct { Contract *MessageLib // Generic contract binding to access the raw methods on } // MessageLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type MessageLibCallerRaw struct { Contract *MessageLibCaller // Generic read-only contract binding to access the raw methods on } // MessageLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type MessageLibTransactorRaw struct { Contract *MessageLibTransactor // Generic write-only contract binding to access the raw methods on } // NewMessageLib creates a new instance of MessageLib, bound to a specific deployed contract. func NewMessageLib(address common.Address, backend bind.ContractBackend) (*MessageLib, error) { contract, err := bindMessageLib(address, backend, backend, backend) if err != nil { return nil, err } return &MessageLib{MessageLibCaller: MessageLibCaller{contract: contract}, MessageLibTransactor: MessageLibTransactor{contract: contract}, MessageLibFilterer: MessageLibFilterer{contract: contract}}, nil } // NewMessageLibCaller creates a new read-only instance of MessageLib, bound to a specific deployed contract. func NewMessageLibCaller(address common.Address, caller bind.ContractCaller) (*MessageLibCaller, error) { contract, err := bindMessageLib(address, caller, nil, nil) if err != nil { return nil, err } return &MessageLibCaller{contract: contract}, nil } // NewMessageLibTransactor creates a new write-only instance of MessageLib, bound to a specific deployed contract. func NewMessageLibTransactor(address common.Address, transactor bind.ContractTransactor) (*MessageLibTransactor, error) { contract, err := bindMessageLib(address, nil, transactor, nil) if err != nil { return nil, err } return &MessageLibTransactor{contract: contract}, nil } // NewMessageLibFilterer creates a new log filterer instance of MessageLib, bound to a specific deployed contract. func NewMessageLibFilterer(address common.Address, filterer bind.ContractFilterer) (*MessageLibFilterer, error) { contract, err := bindMessageLib(address, nil, nil, filterer) if err != nil { return nil, err } return &MessageLibFilterer{contract: contract}, nil } // bindMessageLib binds a generic wrapper to an already deployed contract. func bindMessageLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := MessageLibMetaData.GetAbi() if err != nil { return nil, err } return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_MessageLib *MessageLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MessageLib.Contract.MessageLibCaller.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 (_MessageLib *MessageLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MessageLib.Contract.MessageLibTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MessageLib *MessageLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MessageLib.Contract.MessageLibTransactor.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 (_MessageLib *MessageLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MessageLib.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 (_MessageLib *MessageLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MessageLib.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MessageLib *MessageLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MessageLib.Contract.contract.Transact(opts, method, params...) } // RequestLibMetaData contains all meta data concerning the RequestLib contract. var RequestLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220cfa091f03661f3b510584f20c5b5b9aab0f969fb733e4f2b4b9a8f6d9c68a5f464736f6c63430008110033", } // RequestLibABI is the input ABI used to generate the binding from. // Deprecated: Use RequestLibMetaData.ABI instead. var RequestLibABI = RequestLibMetaData.ABI // RequestLibBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use RequestLibMetaData.Bin instead. var RequestLibBin = RequestLibMetaData.Bin // DeployRequestLib deploys a new Ethereum contract, binding an instance of RequestLib to it. func DeployRequestLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *RequestLib, error) { parsed, err := RequestLibMetaData.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(RequestLibBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &RequestLib{RequestLibCaller: RequestLibCaller{contract: contract}, RequestLibTransactor: RequestLibTransactor{contract: contract}, RequestLibFilterer: RequestLibFilterer{contract: contract}}, nil } // RequestLib is an auto generated Go binding around an Ethereum contract. type RequestLib struct { RequestLibCaller // Read-only binding to the contract RequestLibTransactor // Write-only binding to the contract RequestLibFilterer // Log filterer for contract events } // RequestLibCaller is an auto generated read-only Go binding around an Ethereum contract. type RequestLibCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // RequestLibTransactor is an auto generated write-only Go binding around an Ethereum contract. type RequestLibTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // RequestLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type RequestLibFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // RequestLibSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type RequestLibSession struct { Contract *RequestLib // 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 } // RequestLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type RequestLibCallerSession struct { Contract *RequestLibCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // RequestLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type RequestLibTransactorSession struct { Contract *RequestLibTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // RequestLibRaw is an auto generated low-level Go binding around an Ethereum contract. type RequestLibRaw struct { Contract *RequestLib // Generic contract binding to access the raw methods on } // RequestLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type RequestLibCallerRaw struct { Contract *RequestLibCaller // Generic read-only contract binding to access the raw methods on } // RequestLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type RequestLibTransactorRaw struct { Contract *RequestLibTransactor // Generic write-only contract binding to access the raw methods on } // NewRequestLib creates a new instance of RequestLib, bound to a specific deployed contract. func NewRequestLib(address common.Address, backend bind.ContractBackend) (*RequestLib, error) { contract, err := bindRequestLib(address, backend, backend, backend) if err != nil { return nil, err } return &RequestLib{RequestLibCaller: RequestLibCaller{contract: contract}, RequestLibTransactor: RequestLibTransactor{contract: contract}, RequestLibFilterer: RequestLibFilterer{contract: contract}}, nil } // NewRequestLibCaller creates a new read-only instance of RequestLib, bound to a specific deployed contract. func NewRequestLibCaller(address common.Address, caller bind.ContractCaller) (*RequestLibCaller, error) { contract, err := bindRequestLib(address, caller, nil, nil) if err != nil { return nil, err } return &RequestLibCaller{contract: contract}, nil } // NewRequestLibTransactor creates a new write-only instance of RequestLib, bound to a specific deployed contract. func NewRequestLibTransactor(address common.Address, transactor bind.ContractTransactor) (*RequestLibTransactor, error) { contract, err := bindRequestLib(address, nil, transactor, nil) if err != nil { return nil, err } return &RequestLibTransactor{contract: contract}, nil } // NewRequestLibFilterer creates a new log filterer instance of RequestLib, bound to a specific deployed contract. func NewRequestLibFilterer(address common.Address, filterer bind.ContractFilterer) (*RequestLibFilterer, error) { contract, err := bindRequestLib(address, nil, nil, filterer) if err != nil { return nil, err } return &RequestLibFilterer{contract: contract}, nil } // bindRequestLib binds a generic wrapper to an already deployed contract. func bindRequestLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := RequestLibMetaData.GetAbi() if err != nil { return nil, err } return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_RequestLib *RequestLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _RequestLib.Contract.RequestLibCaller.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 (_RequestLib *RequestLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _RequestLib.Contract.RequestLibTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_RequestLib *RequestLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _RequestLib.Contract.RequestLibTransactor.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 (_RequestLib *RequestLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _RequestLib.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 (_RequestLib *RequestLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _RequestLib.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_RequestLib *RequestLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _RequestLib.Contract.contract.Transact(opts, method, params...) } // SafeCastMetaData contains all meta data concerning the SafeCast contract. var SafeCastMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220147775f580af86beda89a6a285fc494588ef8273f7e021ce78ec44e8d0b7a39e64736f6c63430008110033", } // SafeCastABI is the input ABI used to generate the binding from. // Deprecated: Use SafeCastMetaData.ABI instead. var SafeCastABI = SafeCastMetaData.ABI // SafeCastBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use SafeCastMetaData.Bin instead. var SafeCastBin = SafeCastMetaData.Bin // DeploySafeCast deploys a new Ethereum contract, binding an instance of SafeCast to it. func DeploySafeCast(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeCast, error) { parsed, err := SafeCastMetaData.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(SafeCastBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &SafeCast{SafeCastCaller: SafeCastCaller{contract: contract}, SafeCastTransactor: SafeCastTransactor{contract: contract}, SafeCastFilterer: SafeCastFilterer{contract: contract}}, nil } // SafeCast is an auto generated Go binding around an Ethereum contract. type SafeCast struct { SafeCastCaller // Read-only binding to the contract SafeCastTransactor // Write-only binding to the contract SafeCastFilterer // Log filterer for contract events } // SafeCastCaller is an auto generated read-only Go binding around an Ethereum contract. type SafeCastCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SafeCastTransactor is an auto generated write-only Go binding around an Ethereum contract. type SafeCastTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SafeCastFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type SafeCastFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SafeCastSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type SafeCastSession struct { Contract *SafeCast // 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 } // SafeCastCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type SafeCastCallerSession struct { Contract *SafeCastCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // SafeCastTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type SafeCastTransactorSession struct { Contract *SafeCastTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // SafeCastRaw is an auto generated low-level Go binding around an Ethereum contract. type SafeCastRaw struct { Contract *SafeCast // Generic contract binding to access the raw methods on } // SafeCastCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type SafeCastCallerRaw struct { Contract *SafeCastCaller // Generic read-only contract binding to access the raw methods on } // SafeCastTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type SafeCastTransactorRaw struct { Contract *SafeCastTransactor // Generic write-only contract binding to access the raw methods on } // NewSafeCast creates a new instance of SafeCast, bound to a specific deployed contract. func NewSafeCast(address common.Address, backend bind.ContractBackend) (*SafeCast, error) { contract, err := bindSafeCast(address, backend, backend, backend) if err != nil { return nil, err } return &SafeCast{SafeCastCaller: SafeCastCaller{contract: contract}, SafeCastTransactor: SafeCastTransactor{contract: contract}, SafeCastFilterer: SafeCastFilterer{contract: contract}}, nil } // NewSafeCastCaller creates a new read-only instance of SafeCast, bound to a specific deployed contract. func NewSafeCastCaller(address common.Address, caller bind.ContractCaller) (*SafeCastCaller, error) { contract, err := bindSafeCast(address, caller, nil, nil) if err != nil { return nil, err } return &SafeCastCaller{contract: contract}, nil } // NewSafeCastTransactor creates a new write-only instance of SafeCast, bound to a specific deployed contract. func NewSafeCastTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeCastTransactor, error) { contract, err := bindSafeCast(address, nil, transactor, nil) if err != nil { return nil, err } return &SafeCastTransactor{contract: contract}, nil } // NewSafeCastFilterer creates a new log filterer instance of SafeCast, bound to a specific deployed contract. func NewSafeCastFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeCastFilterer, error) { contract, err := bindSafeCast(address, nil, nil, filterer) if err != nil { return nil, err } return &SafeCastFilterer{contract: contract}, nil } // bindSafeCast binds a generic wrapper to an already deployed contract. func bindSafeCast(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := SafeCastMetaData.GetAbi() if err != nil { return nil, err } return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_SafeCast *SafeCastRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _SafeCast.Contract.SafeCastCaller.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 (_SafeCast *SafeCastRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _SafeCast.Contract.SafeCastTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_SafeCast *SafeCastRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _SafeCast.Contract.SafeCastTransactor.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 (_SafeCast *SafeCastCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _SafeCast.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 (_SafeCast *SafeCastTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _SafeCast.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_SafeCast *SafeCastTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _SafeCast.Contract.contract.Transact(opts, method, params...) } // TipsLibMetaData contains all meta data concerning the TipsLib contract. var TipsLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220931454fd6fcf69bbe3b24280fe9050172f456fbbd60ef057e60b9d77829d06a864736f6c63430008110033", } // TipsLibABI is the input ABI used to generate the binding from. // Deprecated: Use TipsLibMetaData.ABI instead. var TipsLibABI = TipsLibMetaData.ABI // TipsLibBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use TipsLibMetaData.Bin instead. var TipsLibBin = TipsLibMetaData.Bin // DeployTipsLib deploys a new Ethereum contract, binding an instance of TipsLib to it. func DeployTipsLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *TipsLib, error) { parsed, err := TipsLibMetaData.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(TipsLibBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &TipsLib{TipsLibCaller: TipsLibCaller{contract: contract}, TipsLibTransactor: TipsLibTransactor{contract: contract}, TipsLibFilterer: TipsLibFilterer{contract: contract}}, nil } // TipsLib is an auto generated Go binding around an Ethereum contract. type TipsLib struct { TipsLibCaller // Read-only binding to the contract TipsLibTransactor // Write-only binding to the contract TipsLibFilterer // Log filterer for contract events } // TipsLibCaller is an auto generated read-only Go binding around an Ethereum contract. type TipsLibCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // TipsLibTransactor is an auto generated write-only Go binding around an Ethereum contract. type TipsLibTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // TipsLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type TipsLibFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // TipsLibSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type TipsLibSession struct { Contract *TipsLib // 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 } // TipsLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type TipsLibCallerSession struct { Contract *TipsLibCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // TipsLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type TipsLibTransactorSession struct { Contract *TipsLibTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // TipsLibRaw is an auto generated low-level Go binding around an Ethereum contract. type TipsLibRaw struct { Contract *TipsLib // Generic contract binding to access the raw methods on } // TipsLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type TipsLibCallerRaw struct { Contract *TipsLibCaller // Generic read-only contract binding to access the raw methods on } // TipsLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type TipsLibTransactorRaw struct { Contract *TipsLibTransactor // Generic write-only contract binding to access the raw methods on } // NewTipsLib creates a new instance of TipsLib, bound to a specific deployed contract. func NewTipsLib(address common.Address, backend bind.ContractBackend) (*TipsLib, error) { contract, err := bindTipsLib(address, backend, backend, backend) if err != nil { return nil, err } return &TipsLib{TipsLibCaller: TipsLibCaller{contract: contract}, TipsLibTransactor: TipsLibTransactor{contract: contract}, TipsLibFilterer: TipsLibFilterer{contract: contract}}, nil } // NewTipsLibCaller creates a new read-only instance of TipsLib, bound to a specific deployed contract. func NewTipsLibCaller(address common.Address, caller bind.ContractCaller) (*TipsLibCaller, error) { contract, err := bindTipsLib(address, caller, nil, nil) if err != nil { return nil, err } return &TipsLibCaller{contract: contract}, nil } // NewTipsLibTransactor creates a new write-only instance of TipsLib, bound to a specific deployed contract. func NewTipsLibTransactor(address common.Address, transactor bind.ContractTransactor) (*TipsLibTransactor, error) { contract, err := bindTipsLib(address, nil, transactor, nil) if err != nil { return nil, err } return &TipsLibTransactor{contract: contract}, nil } // NewTipsLibFilterer creates a new log filterer instance of TipsLib, bound to a specific deployed contract. func NewTipsLibFilterer(address common.Address, filterer bind.ContractFilterer) (*TipsLibFilterer, error) { contract, err := bindTipsLib(address, nil, nil, filterer) if err != nil { return nil, err } return &TipsLibFilterer{contract: contract}, nil } // bindTipsLib binds a generic wrapper to an already deployed contract. func bindTipsLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := TipsLibMetaData.GetAbi() if err != nil { return nil, err } return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_TipsLib *TipsLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _TipsLib.Contract.TipsLibCaller.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 (_TipsLib *TipsLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _TipsLib.Contract.TipsLibTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_TipsLib *TipsLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _TipsLib.Contract.TipsLibTransactor.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 (_TipsLib *TipsLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _TipsLib.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 (_TipsLib *TipsLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _TipsLib.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_TipsLib *TipsLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _TipsLib.Contract.contract.Transact(opts, method, params...) }