// Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. package snapshotharness 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 ) // GasDataLibMetaData contains all meta data concerning the GasDataLib contract. var GasDataLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220ff5fa1c38ca1908404cb5f612a561dbe5ef17577ddd20f378ceec3715c83ad9664736f6c63430008110033", } // GasDataLibABI is the input ABI used to generate the binding from. // Deprecated: Use GasDataLibMetaData.ABI instead. var GasDataLibABI = GasDataLibMetaData.ABI // GasDataLibBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use GasDataLibMetaData.Bin instead. var GasDataLibBin = GasDataLibMetaData.Bin // DeployGasDataLib deploys a new Ethereum contract, binding an instance of GasDataLib to it. func DeployGasDataLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GasDataLib, error) { parsed, err := GasDataLibMetaData.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(GasDataLibBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &GasDataLib{GasDataLibCaller: GasDataLibCaller{contract: contract}, GasDataLibTransactor: GasDataLibTransactor{contract: contract}, GasDataLibFilterer: GasDataLibFilterer{contract: contract}}, nil } // GasDataLib is an auto generated Go binding around an Ethereum contract. type GasDataLib struct { GasDataLibCaller // Read-only binding to the contract GasDataLibTransactor // Write-only binding to the contract GasDataLibFilterer // Log filterer for contract events } // GasDataLibCaller is an auto generated read-only Go binding around an Ethereum contract. type GasDataLibCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // GasDataLibTransactor is an auto generated write-only Go binding around an Ethereum contract. type GasDataLibTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // GasDataLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type GasDataLibFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // GasDataLibSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type GasDataLibSession struct { Contract *GasDataLib // 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 } // GasDataLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type GasDataLibCallerSession struct { Contract *GasDataLibCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // GasDataLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type GasDataLibTransactorSession struct { Contract *GasDataLibTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // GasDataLibRaw is an auto generated low-level Go binding around an Ethereum contract. type GasDataLibRaw struct { Contract *GasDataLib // Generic contract binding to access the raw methods on } // GasDataLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type GasDataLibCallerRaw struct { Contract *GasDataLibCaller // Generic read-only contract binding to access the raw methods on } // GasDataLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type GasDataLibTransactorRaw struct { Contract *GasDataLibTransactor // Generic write-only contract binding to access the raw methods on } // NewGasDataLib creates a new instance of GasDataLib, bound to a specific deployed contract. func NewGasDataLib(address common.Address, backend bind.ContractBackend) (*GasDataLib, error) { contract, err := bindGasDataLib(address, backend, backend, backend) if err != nil { return nil, err } return &GasDataLib{GasDataLibCaller: GasDataLibCaller{contract: contract}, GasDataLibTransactor: GasDataLibTransactor{contract: contract}, GasDataLibFilterer: GasDataLibFilterer{contract: contract}}, nil } // NewGasDataLibCaller creates a new read-only instance of GasDataLib, bound to a specific deployed contract. func NewGasDataLibCaller(address common.Address, caller bind.ContractCaller) (*GasDataLibCaller, error) { contract, err := bindGasDataLib(address, caller, nil, nil) if err != nil { return nil, err } return &GasDataLibCaller{contract: contract}, nil } // NewGasDataLibTransactor creates a new write-only instance of GasDataLib, bound to a specific deployed contract. func NewGasDataLibTransactor(address common.Address, transactor bind.ContractTransactor) (*GasDataLibTransactor, error) { contract, err := bindGasDataLib(address, nil, transactor, nil) if err != nil { return nil, err } return &GasDataLibTransactor{contract: contract}, nil } // NewGasDataLibFilterer creates a new log filterer instance of GasDataLib, bound to a specific deployed contract. func NewGasDataLibFilterer(address common.Address, filterer bind.ContractFilterer) (*GasDataLibFilterer, error) { contract, err := bindGasDataLib(address, nil, nil, filterer) if err != nil { return nil, err } return &GasDataLibFilterer{contract: contract}, nil } // bindGasDataLib binds a generic wrapper to an already deployed contract. func bindGasDataLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := GasDataLibMetaData.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 (_GasDataLib *GasDataLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _GasDataLib.Contract.GasDataLibCaller.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 (_GasDataLib *GasDataLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _GasDataLib.Contract.GasDataLibTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_GasDataLib *GasDataLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _GasDataLib.Contract.GasDataLibTransactor.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 (_GasDataLib *GasDataLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _GasDataLib.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 (_GasDataLib *GasDataLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _GasDataLib.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_GasDataLib *GasDataLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _GasDataLib.Contract.contract.Transact(opts, method, params...) } // MemViewLibMetaData contains all meta data concerning the MemViewLib contract. var MemViewLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212202a368ed60e495730a527e3929e1f187ef5bf4e4b0ad9c35eddbbfd36bc4dfbe164736f6c63430008110033", } // 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: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220716ad5f5163096e9390a91f676fda1faac3496295aa34699e194af214364f60064736f6c63430008110033", } // 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...) } // NumberLibMetaData contains all meta data concerning the NumberLib contract. var NumberLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220120ceb848adc25aac9dcdd9a58241609071c08b4f5b15bc330a27986b5d0bb9864736f6c63430008110033", } // NumberLibABI is the input ABI used to generate the binding from. // Deprecated: Use NumberLibMetaData.ABI instead. var NumberLibABI = NumberLibMetaData.ABI // NumberLibBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use NumberLibMetaData.Bin instead. var NumberLibBin = NumberLibMetaData.Bin // DeployNumberLib deploys a new Ethereum contract, binding an instance of NumberLib to it. func DeployNumberLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *NumberLib, error) { parsed, err := NumberLibMetaData.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(NumberLibBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &NumberLib{NumberLibCaller: NumberLibCaller{contract: contract}, NumberLibTransactor: NumberLibTransactor{contract: contract}, NumberLibFilterer: NumberLibFilterer{contract: contract}}, nil } // NumberLib is an auto generated Go binding around an Ethereum contract. type NumberLib struct { NumberLibCaller // Read-only binding to the contract NumberLibTransactor // Write-only binding to the contract NumberLibFilterer // Log filterer for contract events } // NumberLibCaller is an auto generated read-only Go binding around an Ethereum contract. type NumberLibCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // NumberLibTransactor is an auto generated write-only Go binding around an Ethereum contract. type NumberLibTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // NumberLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type NumberLibFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // NumberLibSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type NumberLibSession struct { Contract *NumberLib // 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 } // NumberLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type NumberLibCallerSession struct { Contract *NumberLibCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // NumberLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type NumberLibTransactorSession struct { Contract *NumberLibTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // NumberLibRaw is an auto generated low-level Go binding around an Ethereum contract. type NumberLibRaw struct { Contract *NumberLib // Generic contract binding to access the raw methods on } // NumberLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type NumberLibCallerRaw struct { Contract *NumberLibCaller // Generic read-only contract binding to access the raw methods on } // NumberLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type NumberLibTransactorRaw struct { Contract *NumberLibTransactor // Generic write-only contract binding to access the raw methods on } // NewNumberLib creates a new instance of NumberLib, bound to a specific deployed contract. func NewNumberLib(address common.Address, backend bind.ContractBackend) (*NumberLib, error) { contract, err := bindNumberLib(address, backend, backend, backend) if err != nil { return nil, err } return &NumberLib{NumberLibCaller: NumberLibCaller{contract: contract}, NumberLibTransactor: NumberLibTransactor{contract: contract}, NumberLibFilterer: NumberLibFilterer{contract: contract}}, nil } // NewNumberLibCaller creates a new read-only instance of NumberLib, bound to a specific deployed contract. func NewNumberLibCaller(address common.Address, caller bind.ContractCaller) (*NumberLibCaller, error) { contract, err := bindNumberLib(address, caller, nil, nil) if err != nil { return nil, err } return &NumberLibCaller{contract: contract}, nil } // NewNumberLibTransactor creates a new write-only instance of NumberLib, bound to a specific deployed contract. func NewNumberLibTransactor(address common.Address, transactor bind.ContractTransactor) (*NumberLibTransactor, error) { contract, err := bindNumberLib(address, nil, transactor, nil) if err != nil { return nil, err } return &NumberLibTransactor{contract: contract}, nil } // NewNumberLibFilterer creates a new log filterer instance of NumberLib, bound to a specific deployed contract. func NewNumberLibFilterer(address common.Address, filterer bind.ContractFilterer) (*NumberLibFilterer, error) { contract, err := bindNumberLib(address, nil, nil, filterer) if err != nil { return nil, err } return &NumberLibFilterer{contract: contract}, nil } // bindNumberLib binds a generic wrapper to an already deployed contract. func bindNumberLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := NumberLibMetaData.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 (_NumberLib *NumberLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _NumberLib.Contract.NumberLibCaller.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 (_NumberLib *NumberLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _NumberLib.Contract.NumberLibTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_NumberLib *NumberLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _NumberLib.Contract.NumberLibTransactor.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 (_NumberLib *NumberLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _NumberLib.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 (_NumberLib *NumberLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _NumberLib.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_NumberLib *NumberLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _NumberLib.Contract.contract.Transact(opts, method, params...) } // SnapshotHarnessMetaData contains all meta data concerning the SnapshotHarness contract. var SnapshotHarnessMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"IncorrectStatesAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"IndexOutOfRange\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"IndexedTooMuch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OccupiedMemory\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PrecompileOutOfGas\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TreeHeightTooLow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnallocatedMemory\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnformattedSnapshot\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnformattedState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ViewOverrun\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"calculateRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"castToSnapshot\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"statePayloads\",\"type\":\"bytes[]\"}],\"name\":\"formatSnapshot\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"hashValid\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"isSnapshot\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"snapGas\",\"outputs\":[{\"internalType\":\"ChainGas[]\",\"name\":\"\",\"type\":\"uint128[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"},{\"internalType\":\"uint8\",\"name\":\"stateIndex\",\"type\":\"uint8\"}],\"name\":\"state\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"statesAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", Sigs: map[string]string{ "c9b2c4b4": "calculateRoot(bytes)", "925ea687": "castToSnapshot(bytes)", "a641fa33": "formatSnapshot(bytes[])", "730dbf63": "hashValid(bytes)", "8aae3c34": "isSnapshot(bytes)", "493ed1fd": "snapGas(bytes)", "24fc81d8": "state(bytes,uint8)", "450701c5": "statesAmount(bytes)", }, Bin: "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", } // SnapshotHarnessABI is the input ABI used to generate the binding from. // Deprecated: Use SnapshotHarnessMetaData.ABI instead. var SnapshotHarnessABI = SnapshotHarnessMetaData.ABI // Deprecated: Use SnapshotHarnessMetaData.Sigs instead. // SnapshotHarnessFuncSigs maps the 4-byte function signature to its string representation. var SnapshotHarnessFuncSigs = SnapshotHarnessMetaData.Sigs // SnapshotHarnessBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use SnapshotHarnessMetaData.Bin instead. var SnapshotHarnessBin = SnapshotHarnessMetaData.Bin // DeploySnapshotHarness deploys a new Ethereum contract, binding an instance of SnapshotHarness to it. func DeploySnapshotHarness(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SnapshotHarness, error) { parsed, err := SnapshotHarnessMetaData.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(SnapshotHarnessBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &SnapshotHarness{SnapshotHarnessCaller: SnapshotHarnessCaller{contract: contract}, SnapshotHarnessTransactor: SnapshotHarnessTransactor{contract: contract}, SnapshotHarnessFilterer: SnapshotHarnessFilterer{contract: contract}}, nil } // SnapshotHarness is an auto generated Go binding around an Ethereum contract. type SnapshotHarness struct { SnapshotHarnessCaller // Read-only binding to the contract SnapshotHarnessTransactor // Write-only binding to the contract SnapshotHarnessFilterer // Log filterer for contract events } // SnapshotHarnessCaller is an auto generated read-only Go binding around an Ethereum contract. type SnapshotHarnessCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SnapshotHarnessTransactor is an auto generated write-only Go binding around an Ethereum contract. type SnapshotHarnessTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SnapshotHarnessFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type SnapshotHarnessFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SnapshotHarnessSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type SnapshotHarnessSession struct { Contract *SnapshotHarness // 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 } // SnapshotHarnessCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type SnapshotHarnessCallerSession struct { Contract *SnapshotHarnessCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // SnapshotHarnessTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type SnapshotHarnessTransactorSession struct { Contract *SnapshotHarnessTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // SnapshotHarnessRaw is an auto generated low-level Go binding around an Ethereum contract. type SnapshotHarnessRaw struct { Contract *SnapshotHarness // Generic contract binding to access the raw methods on } // SnapshotHarnessCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type SnapshotHarnessCallerRaw struct { Contract *SnapshotHarnessCaller // Generic read-only contract binding to access the raw methods on } // SnapshotHarnessTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type SnapshotHarnessTransactorRaw struct { Contract *SnapshotHarnessTransactor // Generic write-only contract binding to access the raw methods on } // NewSnapshotHarness creates a new instance of SnapshotHarness, bound to a specific deployed contract. func NewSnapshotHarness(address common.Address, backend bind.ContractBackend) (*SnapshotHarness, error) { contract, err := bindSnapshotHarness(address, backend, backend, backend) if err != nil { return nil, err } return &SnapshotHarness{SnapshotHarnessCaller: SnapshotHarnessCaller{contract: contract}, SnapshotHarnessTransactor: SnapshotHarnessTransactor{contract: contract}, SnapshotHarnessFilterer: SnapshotHarnessFilterer{contract: contract}}, nil } // NewSnapshotHarnessCaller creates a new read-only instance of SnapshotHarness, bound to a specific deployed contract. func NewSnapshotHarnessCaller(address common.Address, caller bind.ContractCaller) (*SnapshotHarnessCaller, error) { contract, err := bindSnapshotHarness(address, caller, nil, nil) if err != nil { return nil, err } return &SnapshotHarnessCaller{contract: contract}, nil } // NewSnapshotHarnessTransactor creates a new write-only instance of SnapshotHarness, bound to a specific deployed contract. func NewSnapshotHarnessTransactor(address common.Address, transactor bind.ContractTransactor) (*SnapshotHarnessTransactor, error) { contract, err := bindSnapshotHarness(address, nil, transactor, nil) if err != nil { return nil, err } return &SnapshotHarnessTransactor{contract: contract}, nil } // NewSnapshotHarnessFilterer creates a new log filterer instance of SnapshotHarness, bound to a specific deployed contract. func NewSnapshotHarnessFilterer(address common.Address, filterer bind.ContractFilterer) (*SnapshotHarnessFilterer, error) { contract, err := bindSnapshotHarness(address, nil, nil, filterer) if err != nil { return nil, err } return &SnapshotHarnessFilterer{contract: contract}, nil } // bindSnapshotHarness binds a generic wrapper to an already deployed contract. func bindSnapshotHarness(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := SnapshotHarnessMetaData.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 (_SnapshotHarness *SnapshotHarnessRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _SnapshotHarness.Contract.SnapshotHarnessCaller.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 (_SnapshotHarness *SnapshotHarnessRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _SnapshotHarness.Contract.SnapshotHarnessTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_SnapshotHarness *SnapshotHarnessRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _SnapshotHarness.Contract.SnapshotHarnessTransactor.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 (_SnapshotHarness *SnapshotHarnessCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _SnapshotHarness.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 (_SnapshotHarness *SnapshotHarnessTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _SnapshotHarness.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_SnapshotHarness *SnapshotHarnessTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _SnapshotHarness.Contract.contract.Transact(opts, method, params...) } // CalculateRoot is a free data retrieval call binding the contract method 0xc9b2c4b4. // // Solidity: function calculateRoot(bytes payload) pure returns(bytes32) func (_SnapshotHarness *SnapshotHarnessCaller) CalculateRoot(opts *bind.CallOpts, payload []byte) ([32]byte, error) { var out []interface{} err := _SnapshotHarness.contract.Call(opts, &out, "calculateRoot", payload) if err != nil { return *new([32]byte), err } out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) return out0, err } // CalculateRoot is a free data retrieval call binding the contract method 0xc9b2c4b4. // // Solidity: function calculateRoot(bytes payload) pure returns(bytes32) func (_SnapshotHarness *SnapshotHarnessSession) CalculateRoot(payload []byte) ([32]byte, error) { return _SnapshotHarness.Contract.CalculateRoot(&_SnapshotHarness.CallOpts, payload) } // CalculateRoot is a free data retrieval call binding the contract method 0xc9b2c4b4. // // Solidity: function calculateRoot(bytes payload) pure returns(bytes32) func (_SnapshotHarness *SnapshotHarnessCallerSession) CalculateRoot(payload []byte) ([32]byte, error) { return _SnapshotHarness.Contract.CalculateRoot(&_SnapshotHarness.CallOpts, payload) } // CastToSnapshot is a free data retrieval call binding the contract method 0x925ea687. // // Solidity: function castToSnapshot(bytes payload) view returns(bytes) func (_SnapshotHarness *SnapshotHarnessCaller) CastToSnapshot(opts *bind.CallOpts, payload []byte) ([]byte, error) { var out []interface{} err := _SnapshotHarness.contract.Call(opts, &out, "castToSnapshot", payload) if err != nil { return *new([]byte), err } out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) return out0, err } // CastToSnapshot is a free data retrieval call binding the contract method 0x925ea687. // // Solidity: function castToSnapshot(bytes payload) view returns(bytes) func (_SnapshotHarness *SnapshotHarnessSession) CastToSnapshot(payload []byte) ([]byte, error) { return _SnapshotHarness.Contract.CastToSnapshot(&_SnapshotHarness.CallOpts, payload) } // CastToSnapshot is a free data retrieval call binding the contract method 0x925ea687. // // Solidity: function castToSnapshot(bytes payload) view returns(bytes) func (_SnapshotHarness *SnapshotHarnessCallerSession) CastToSnapshot(payload []byte) ([]byte, error) { return _SnapshotHarness.Contract.CastToSnapshot(&_SnapshotHarness.CallOpts, payload) } // FormatSnapshot is a free data retrieval call binding the contract method 0xa641fa33. // // Solidity: function formatSnapshot(bytes[] statePayloads) view returns(bytes) func (_SnapshotHarness *SnapshotHarnessCaller) FormatSnapshot(opts *bind.CallOpts, statePayloads [][]byte) ([]byte, error) { var out []interface{} err := _SnapshotHarness.contract.Call(opts, &out, "formatSnapshot", statePayloads) if err != nil { return *new([]byte), err } out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) return out0, err } // FormatSnapshot is a free data retrieval call binding the contract method 0xa641fa33. // // Solidity: function formatSnapshot(bytes[] statePayloads) view returns(bytes) func (_SnapshotHarness *SnapshotHarnessSession) FormatSnapshot(statePayloads [][]byte) ([]byte, error) { return _SnapshotHarness.Contract.FormatSnapshot(&_SnapshotHarness.CallOpts, statePayloads) } // FormatSnapshot is a free data retrieval call binding the contract method 0xa641fa33. // // Solidity: function formatSnapshot(bytes[] statePayloads) view returns(bytes) func (_SnapshotHarness *SnapshotHarnessCallerSession) FormatSnapshot(statePayloads [][]byte) ([]byte, error) { return _SnapshotHarness.Contract.FormatSnapshot(&_SnapshotHarness.CallOpts, statePayloads) } // HashValid is a free data retrieval call binding the contract method 0x730dbf63. // // Solidity: function hashValid(bytes payload) pure returns(bytes32) func (_SnapshotHarness *SnapshotHarnessCaller) HashValid(opts *bind.CallOpts, payload []byte) ([32]byte, error) { var out []interface{} err := _SnapshotHarness.contract.Call(opts, &out, "hashValid", payload) if err != nil { return *new([32]byte), err } out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) return out0, err } // HashValid is a free data retrieval call binding the contract method 0x730dbf63. // // Solidity: function hashValid(bytes payload) pure returns(bytes32) func (_SnapshotHarness *SnapshotHarnessSession) HashValid(payload []byte) ([32]byte, error) { return _SnapshotHarness.Contract.HashValid(&_SnapshotHarness.CallOpts, payload) } // HashValid is a free data retrieval call binding the contract method 0x730dbf63. // // Solidity: function hashValid(bytes payload) pure returns(bytes32) func (_SnapshotHarness *SnapshotHarnessCallerSession) HashValid(payload []byte) ([32]byte, error) { return _SnapshotHarness.Contract.HashValid(&_SnapshotHarness.CallOpts, payload) } // IsSnapshot is a free data retrieval call binding the contract method 0x8aae3c34. // // Solidity: function isSnapshot(bytes payload) pure returns(bool) func (_SnapshotHarness *SnapshotHarnessCaller) IsSnapshot(opts *bind.CallOpts, payload []byte) (bool, error) { var out []interface{} err := _SnapshotHarness.contract.Call(opts, &out, "isSnapshot", payload) if err != nil { return *new(bool), err } out0 := *abi.ConvertType(out[0], new(bool)).(*bool) return out0, err } // IsSnapshot is a free data retrieval call binding the contract method 0x8aae3c34. // // Solidity: function isSnapshot(bytes payload) pure returns(bool) func (_SnapshotHarness *SnapshotHarnessSession) IsSnapshot(payload []byte) (bool, error) { return _SnapshotHarness.Contract.IsSnapshot(&_SnapshotHarness.CallOpts, payload) } // IsSnapshot is a free data retrieval call binding the contract method 0x8aae3c34. // // Solidity: function isSnapshot(bytes payload) pure returns(bool) func (_SnapshotHarness *SnapshotHarnessCallerSession) IsSnapshot(payload []byte) (bool, error) { return _SnapshotHarness.Contract.IsSnapshot(&_SnapshotHarness.CallOpts, payload) } // SnapGas is a free data retrieval call binding the contract method 0x493ed1fd. // // Solidity: function snapGas(bytes payload) pure returns(uint128[]) func (_SnapshotHarness *SnapshotHarnessCaller) SnapGas(opts *bind.CallOpts, payload []byte) ([]*big.Int, error) { var out []interface{} err := _SnapshotHarness.contract.Call(opts, &out, "snapGas", payload) if err != nil { return *new([]*big.Int), err } out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) return out0, err } // SnapGas is a free data retrieval call binding the contract method 0x493ed1fd. // // Solidity: function snapGas(bytes payload) pure returns(uint128[]) func (_SnapshotHarness *SnapshotHarnessSession) SnapGas(payload []byte) ([]*big.Int, error) { return _SnapshotHarness.Contract.SnapGas(&_SnapshotHarness.CallOpts, payload) } // SnapGas is a free data retrieval call binding the contract method 0x493ed1fd. // // Solidity: function snapGas(bytes payload) pure returns(uint128[]) func (_SnapshotHarness *SnapshotHarnessCallerSession) SnapGas(payload []byte) ([]*big.Int, error) { return _SnapshotHarness.Contract.SnapGas(&_SnapshotHarness.CallOpts, payload) } // State is a free data retrieval call binding the contract method 0x24fc81d8. // // Solidity: function state(bytes payload, uint8 stateIndex) view returns(bytes) func (_SnapshotHarness *SnapshotHarnessCaller) State(opts *bind.CallOpts, payload []byte, stateIndex uint8) ([]byte, error) { var out []interface{} err := _SnapshotHarness.contract.Call(opts, &out, "state", payload, stateIndex) if err != nil { return *new([]byte), err } out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) return out0, err } // State is a free data retrieval call binding the contract method 0x24fc81d8. // // Solidity: function state(bytes payload, uint8 stateIndex) view returns(bytes) func (_SnapshotHarness *SnapshotHarnessSession) State(payload []byte, stateIndex uint8) ([]byte, error) { return _SnapshotHarness.Contract.State(&_SnapshotHarness.CallOpts, payload, stateIndex) } // State is a free data retrieval call binding the contract method 0x24fc81d8. // // Solidity: function state(bytes payload, uint8 stateIndex) view returns(bytes) func (_SnapshotHarness *SnapshotHarnessCallerSession) State(payload []byte, stateIndex uint8) ([]byte, error) { return _SnapshotHarness.Contract.State(&_SnapshotHarness.CallOpts, payload, stateIndex) } // StatesAmount is a free data retrieval call binding the contract method 0x450701c5. // // Solidity: function statesAmount(bytes payload) pure returns(uint256) func (_SnapshotHarness *SnapshotHarnessCaller) StatesAmount(opts *bind.CallOpts, payload []byte) (*big.Int, error) { var out []interface{} err := _SnapshotHarness.contract.Call(opts, &out, "statesAmount", payload) if err != nil { return *new(*big.Int), err } out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) return out0, err } // StatesAmount is a free data retrieval call binding the contract method 0x450701c5. // // Solidity: function statesAmount(bytes payload) pure returns(uint256) func (_SnapshotHarness *SnapshotHarnessSession) StatesAmount(payload []byte) (*big.Int, error) { return _SnapshotHarness.Contract.StatesAmount(&_SnapshotHarness.CallOpts, payload) } // StatesAmount is a free data retrieval call binding the contract method 0x450701c5. // // Solidity: function statesAmount(bytes payload) pure returns(uint256) func (_SnapshotHarness *SnapshotHarnessCallerSession) StatesAmount(payload []byte) (*big.Int, error) { return _SnapshotHarness.Contract.StatesAmount(&_SnapshotHarness.CallOpts, payload) } // SnapshotLibMetaData contains all meta data concerning the SnapshotLib contract. var SnapshotLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220a8ac39e5532814e8f3fbe19ca3637d2fe94765705855ace7b90b6ed73d946df764736f6c63430008110033", } // SnapshotLibABI is the input ABI used to generate the binding from. // Deprecated: Use SnapshotLibMetaData.ABI instead. var SnapshotLibABI = SnapshotLibMetaData.ABI // SnapshotLibBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use SnapshotLibMetaData.Bin instead. var SnapshotLibBin = SnapshotLibMetaData.Bin // DeploySnapshotLib deploys a new Ethereum contract, binding an instance of SnapshotLib to it. func DeploySnapshotLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SnapshotLib, error) { parsed, err := SnapshotLibMetaData.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(SnapshotLibBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &SnapshotLib{SnapshotLibCaller: SnapshotLibCaller{contract: contract}, SnapshotLibTransactor: SnapshotLibTransactor{contract: contract}, SnapshotLibFilterer: SnapshotLibFilterer{contract: contract}}, nil } // SnapshotLib is an auto generated Go binding around an Ethereum contract. type SnapshotLib struct { SnapshotLibCaller // Read-only binding to the contract SnapshotLibTransactor // Write-only binding to the contract SnapshotLibFilterer // Log filterer for contract events } // SnapshotLibCaller is an auto generated read-only Go binding around an Ethereum contract. type SnapshotLibCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SnapshotLibTransactor is an auto generated write-only Go binding around an Ethereum contract. type SnapshotLibTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SnapshotLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type SnapshotLibFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // SnapshotLibSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type SnapshotLibSession struct { Contract *SnapshotLib // 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 } // SnapshotLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type SnapshotLibCallerSession struct { Contract *SnapshotLibCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // SnapshotLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type SnapshotLibTransactorSession struct { Contract *SnapshotLibTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // SnapshotLibRaw is an auto generated low-level Go binding around an Ethereum contract. type SnapshotLibRaw struct { Contract *SnapshotLib // Generic contract binding to access the raw methods on } // SnapshotLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type SnapshotLibCallerRaw struct { Contract *SnapshotLibCaller // Generic read-only contract binding to access the raw methods on } // SnapshotLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type SnapshotLibTransactorRaw struct { Contract *SnapshotLibTransactor // Generic write-only contract binding to access the raw methods on } // NewSnapshotLib creates a new instance of SnapshotLib, bound to a specific deployed contract. func NewSnapshotLib(address common.Address, backend bind.ContractBackend) (*SnapshotLib, error) { contract, err := bindSnapshotLib(address, backend, backend, backend) if err != nil { return nil, err } return &SnapshotLib{SnapshotLibCaller: SnapshotLibCaller{contract: contract}, SnapshotLibTransactor: SnapshotLibTransactor{contract: contract}, SnapshotLibFilterer: SnapshotLibFilterer{contract: contract}}, nil } // NewSnapshotLibCaller creates a new read-only instance of SnapshotLib, bound to a specific deployed contract. func NewSnapshotLibCaller(address common.Address, caller bind.ContractCaller) (*SnapshotLibCaller, error) { contract, err := bindSnapshotLib(address, caller, nil, nil) if err != nil { return nil, err } return &SnapshotLibCaller{contract: contract}, nil } // NewSnapshotLibTransactor creates a new write-only instance of SnapshotLib, bound to a specific deployed contract. func NewSnapshotLibTransactor(address common.Address, transactor bind.ContractTransactor) (*SnapshotLibTransactor, error) { contract, err := bindSnapshotLib(address, nil, transactor, nil) if err != nil { return nil, err } return &SnapshotLibTransactor{contract: contract}, nil } // NewSnapshotLibFilterer creates a new log filterer instance of SnapshotLib, bound to a specific deployed contract. func NewSnapshotLibFilterer(address common.Address, filterer bind.ContractFilterer) (*SnapshotLibFilterer, error) { contract, err := bindSnapshotLib(address, nil, nil, filterer) if err != nil { return nil, err } return &SnapshotLibFilterer{contract: contract}, nil } // bindSnapshotLib binds a generic wrapper to an already deployed contract. func bindSnapshotLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := SnapshotLibMetaData.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 (_SnapshotLib *SnapshotLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _SnapshotLib.Contract.SnapshotLibCaller.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 (_SnapshotLib *SnapshotLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _SnapshotLib.Contract.SnapshotLibTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_SnapshotLib *SnapshotLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _SnapshotLib.Contract.SnapshotLibTransactor.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 (_SnapshotLib *SnapshotLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _SnapshotLib.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 (_SnapshotLib *SnapshotLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _SnapshotLib.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_SnapshotLib *SnapshotLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _SnapshotLib.Contract.contract.Transact(opts, method, params...) } // StateLibMetaData contains all meta data concerning the StateLib contract. var StateLibMetaData = &bind.MetaData{ ABI: "[]", Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122039b6d8818226a3bb39a6b45fac416a91bd2a8a5d919e16c8e1c657f624fcd70e64736f6c63430008110033", } // StateLibABI is the input ABI used to generate the binding from. // Deprecated: Use StateLibMetaData.ABI instead. var StateLibABI = StateLibMetaData.ABI // StateLibBin is the compiled bytecode used for deploying new contracts. // Deprecated: Use StateLibMetaData.Bin instead. var StateLibBin = StateLibMetaData.Bin // DeployStateLib deploys a new Ethereum contract, binding an instance of StateLib to it. func DeployStateLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StateLib, error) { parsed, err := StateLibMetaData.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(StateLibBin), backend) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &StateLib{StateLibCaller: StateLibCaller{contract: contract}, StateLibTransactor: StateLibTransactor{contract: contract}, StateLibFilterer: StateLibFilterer{contract: contract}}, nil } // StateLib is an auto generated Go binding around an Ethereum contract. type StateLib struct { StateLibCaller // Read-only binding to the contract StateLibTransactor // Write-only binding to the contract StateLibFilterer // Log filterer for contract events } // StateLibCaller is an auto generated read-only Go binding around an Ethereum contract. type StateLibCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // StateLibTransactor is an auto generated write-only Go binding around an Ethereum contract. type StateLibTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // StateLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type StateLibFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // StateLibSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type StateLibSession struct { Contract *StateLib // 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 } // StateLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type StateLibCallerSession struct { Contract *StateLibCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // StateLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type StateLibTransactorSession struct { Contract *StateLibTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // StateLibRaw is an auto generated low-level Go binding around an Ethereum contract. type StateLibRaw struct { Contract *StateLib // Generic contract binding to access the raw methods on } // StateLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type StateLibCallerRaw struct { Contract *StateLibCaller // Generic read-only contract binding to access the raw methods on } // StateLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type StateLibTransactorRaw struct { Contract *StateLibTransactor // Generic write-only contract binding to access the raw methods on } // NewStateLib creates a new instance of StateLib, bound to a specific deployed contract. func NewStateLib(address common.Address, backend bind.ContractBackend) (*StateLib, error) { contract, err := bindStateLib(address, backend, backend, backend) if err != nil { return nil, err } return &StateLib{StateLibCaller: StateLibCaller{contract: contract}, StateLibTransactor: StateLibTransactor{contract: contract}, StateLibFilterer: StateLibFilterer{contract: contract}}, nil } // NewStateLibCaller creates a new read-only instance of StateLib, bound to a specific deployed contract. func NewStateLibCaller(address common.Address, caller bind.ContractCaller) (*StateLibCaller, error) { contract, err := bindStateLib(address, caller, nil, nil) if err != nil { return nil, err } return &StateLibCaller{contract: contract}, nil } // NewStateLibTransactor creates a new write-only instance of StateLib, bound to a specific deployed contract. func NewStateLibTransactor(address common.Address, transactor bind.ContractTransactor) (*StateLibTransactor, error) { contract, err := bindStateLib(address, nil, transactor, nil) if err != nil { return nil, err } return &StateLibTransactor{contract: contract}, nil } // NewStateLibFilterer creates a new log filterer instance of StateLib, bound to a specific deployed contract. func NewStateLibFilterer(address common.Address, filterer bind.ContractFilterer) (*StateLibFilterer, error) { contract, err := bindStateLib(address, nil, nil, filterer) if err != nil { return nil, err } return &StateLibFilterer{contract: contract}, nil } // bindStateLib binds a generic wrapper to an already deployed contract. func bindStateLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := StateLibMetaData.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 (_StateLib *StateLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _StateLib.Contract.StateLibCaller.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 (_StateLib *StateLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _StateLib.Contract.StateLibTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_StateLib *StateLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _StateLib.Contract.StateLibTransactor.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 (_StateLib *StateLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _StateLib.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 (_StateLib *StateLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _StateLib.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_StateLib *StateLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _StateLib.Contract.contract.Transact(opts, method, params...) }