stategen

package
v0.0.0-...-5793453 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 16, 2024 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var DeserializeABI = DeserializeMetaData.ABI

DeserializeABI is the input ABI used to generate the binding from. Deprecated: Use DeserializeMetaData.ABI instead.

View Source 
var DeserializeBin = DeserializeMetaData.Bin

DeserializeBin is the compiled bytecode used for deploying new contracts. Deprecated: Use DeserializeMetaData.Bin instead.

View Source 
var DeserializeMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220e88966e135db00decfb4f77c2660d7324bd86a218f695aa9d32977c369cca2cc64736f6c63430008090033",
}

DeserializeMetaData contains all meta data concerning the Deserialize contract.

View Source 
var GlobalStateLibABI = GlobalStateLibMetaData.ABI

GlobalStateLibABI is the input ABI used to generate the binding from. Deprecated: Use GlobalStateLibMetaData.ABI instead.

View Source 
var GlobalStateLibBin = GlobalStateLibMetaData.Bin

GlobalStateLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use GlobalStateLibMetaData.Bin instead.

View Source 
var GlobalStateLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207ded490160310beecfceda151ee73a0d3df5a2fad07fa5a7aeaa4262acfa43a664736f6c63430008090033",
}

GlobalStateLibMetaData contains all meta data concerning the GlobalStateLib contract.

View Source 
var InstructionsABI = InstructionsMetaData.ABI

InstructionsABI is the input ABI used to generate the binding from. Deprecated: Use InstructionsMetaData.ABI instead.

View Source 
var InstructionsBin = InstructionsMetaData.Bin

InstructionsBin is the compiled bytecode used for deploying new contracts. Deprecated: Use InstructionsMetaData.Bin instead.

View Source 
var InstructionsMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212204e1a0aaf9ac1a72c31b6edb0311ce77fbb77eb72f57902af6d3ab6c9267197c864736f6c63430008090033",
}

InstructionsMetaData contains all meta data concerning the Instructions contract.

View Source 
var MachineLibABI = MachineLibMetaData.ABI

MachineLibABI is the input ABI used to generate the binding from. Deprecated: Use MachineLibMetaData.ABI instead.

View Source 
var MachineLibBin = MachineLibMetaData.Bin

MachineLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use MachineLibMetaData.Bin instead.

View Source 
var MachineLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122079819ce9aaebf7ed50c72c59d0bc0e4750d5ff201bf4e122b6e0964dbda6805c64736f6c63430008090033",
}

MachineLibMetaData contains all meta data concerning the MachineLib contract.

View Source 
var MerkleProofLibABI = MerkleProofLibMetaData.ABI

MerkleProofLibABI is the input ABI used to generate the binding from. Deprecated: Use MerkleProofLibMetaData.ABI instead.

View Source 
var MerkleProofLibBin = MerkleProofLibMetaData.Bin

MerkleProofLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use MerkleProofLibMetaData.Bin instead.

View Source 
var MerkleProofLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212205b97a3d105f69a5bd04d6177ec65ebb59aac972af8e1f061c35617640f8d5eb664736f6c63430008090033",
}

MerkleProofLibMetaData contains all meta data concerning the MerkleProofLib contract.

View Source 
var ModuleLibABI = ModuleLibMetaData.ABI

ModuleLibABI is the input ABI used to generate the binding from. Deprecated: Use ModuleLibMetaData.ABI instead.

View Source 
var ModuleLibBin = ModuleLibMetaData.Bin

ModuleLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use ModuleLibMetaData.Bin instead.

View Source 
var ModuleLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212200fae0a92bfe4dae3c6696d7c15ae2e9e5a14ed529046b187c812f43dfb6f85f964736f6c63430008090033",
}

ModuleLibMetaData contains all meta data concerning the ModuleLib contract.

View Source 
var ModuleMemoryCompactLibABI = ModuleMemoryCompactLibMetaData.ABI

ModuleMemoryCompactLibABI is the input ABI used to generate the binding from. Deprecated: Use ModuleMemoryCompactLibMetaData.ABI instead.

View Source 
var ModuleMemoryCompactLibBin = ModuleMemoryCompactLibMetaData.Bin

ModuleMemoryCompactLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use ModuleMemoryCompactLibMetaData.Bin instead.

View Source 
var ModuleMemoryCompactLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220cdf47d879cd0db948bafc1487ac7d69c690f0282e51c015a724c2232c0b6c8fd64736f6c63430008090033",
}

ModuleMemoryCompactLibMetaData contains all meta data concerning the ModuleMemoryCompactLib contract.

View Source 
var ModuleMemoryLibABI = ModuleMemoryLibMetaData.ABI

ModuleMemoryLibABI is the input ABI used to generate the binding from. Deprecated: Use ModuleMemoryLibMetaData.ABI instead.

View Source 
var ModuleMemoryLibBin = ModuleMemoryLibMetaData.Bin

ModuleMemoryLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use ModuleMemoryLibMetaData.Bin instead.

View Source 
var ModuleMemoryLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212203b15bbe3a93c2b8e546fec9d78a2ff9de280900d7dc883efded143d545b830ea64736f6c63430008090033",
}

ModuleMemoryLibMetaData contains all meta data concerning the ModuleMemoryLib contract.

View Source 
var PcArrayLibABI = PcArrayLibMetaData.ABI

PcArrayLibABI is the input ABI used to generate the binding from. Deprecated: Use PcArrayLibMetaData.ABI instead.

View Source 
var PcArrayLibBin = PcArrayLibMetaData.Bin

PcArrayLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use PcArrayLibMetaData.Bin instead.

View Source 
var PcArrayLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212206eb60fb3338df3afc67b852a92b799c50e9707404e047b72e1e4ee4bc6fedb4064736f6c63430008090033",
}

PcArrayLibMetaData contains all meta data concerning the PcArrayLib contract.

View Source 
var StackFrameLibABI = StackFrameLibMetaData.ABI

StackFrameLibABI is the input ABI used to generate the binding from. Deprecated: Use StackFrameLibMetaData.ABI instead.

View Source 
var StackFrameLibBin = StackFrameLibMetaData.Bin

StackFrameLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use StackFrameLibMetaData.Bin instead.

View Source 
var StackFrameLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122078d479c65c53fcf969220fee3c46b95f40e44b9ee6e2655de0e4cf5b05faf22b64736f6c63430008090033",
}

StackFrameLibMetaData contains all meta data concerning the StackFrameLib contract.

View Source 
var ValueArrayLibABI = ValueArrayLibMetaData.ABI

ValueArrayLibABI is the input ABI used to generate the binding from. Deprecated: Use ValueArrayLibMetaData.ABI instead.

View Source 
var ValueArrayLibBin = ValueArrayLibMetaData.Bin

ValueArrayLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use ValueArrayLibMetaData.Bin instead.

View Source 
var ValueArrayLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220e5cda3355cd36e573acec0c93dd2c102051a3f7b19a4cc72e1d68ef5c3390d5464736f6c63430008090033",
}

ValueArrayLibMetaData contains all meta data concerning the ValueArrayLib contract.

View Source 
var ValueLibABI = ValueLibMetaData.ABI

ValueLibABI is the input ABI used to generate the binding from. Deprecated: Use ValueLibMetaData.ABI instead.

View Source 
var ValueLibBin = ValueLibMetaData.Bin

ValueLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use ValueLibMetaData.Bin instead.

View Source 
var ValueLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220096701f7479169630d3ad05f72d2acf877b0bef33930c5cb28a6b7840e105bab64736f6c63430008090033",
}

ValueLibMetaData contains all meta data concerning the ValueLib contract.

View Source 
var ValueStackLibABI = ValueStackLibMetaData.ABI

ValueStackLibABI is the input ABI used to generate the binding from. Deprecated: Use ValueStackLibMetaData.ABI instead.

View Source 
var ValueStackLibBin = ValueStackLibMetaData.Bin

ValueStackLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use ValueStackLibMetaData.Bin instead.

View Source 
var ValueStackLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220a924f8039777965d76975e6c61be84cc188ea98c021a439fa6d162d727b00bb264736f6c63430008090033",
}

ValueStackLibMetaData contains all meta data concerning the ValueStackLib contract.

Functions

This section is empty.

Types

type Deserialize 

type Deserialize struct {
	DeserializeCaller     // Read-only binding to the contract
	DeserializeTransactor // Write-only binding to the contract
	DeserializeFilterer   // Log filterer for contract events
}

Deserialize is an auto generated Go binding around an Ethereum contract.

func DeployDeserialize 

func DeployDeserialize(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Deserialize, error)

DeployDeserialize deploys a new Ethereum contract, binding an instance of Deserialize to it.

func NewDeserialize 

func NewDeserialize(address common.Address, backend bind.ContractBackend) (*Deserialize, error)

NewDeserialize creates a new instance of Deserialize, bound to a specific deployed contract.

type DeserializeCaller 

type DeserializeCaller struct {
	// contains filtered or unexported fields
}

DeserializeCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewDeserializeCaller 

func NewDeserializeCaller(address common.Address, caller bind.ContractCaller) (*DeserializeCaller, error)

NewDeserializeCaller creates a new read-only instance of Deserialize, bound to a specific deployed contract.

type DeserializeCallerRaw 

type DeserializeCallerRaw struct {
	Contract *DeserializeCaller // Generic read-only contract binding to access the raw methods on
}

DeserializeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*DeserializeCallerRaw) Call 

func (_Deserialize *DeserializeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type DeserializeCallerSession 

type DeserializeCallerSession struct {
	Contract *DeserializeCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts      // Call options to use throughout this session
}

DeserializeCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type DeserializeFilterer 

type DeserializeFilterer struct {
	// contains filtered or unexported fields
}

DeserializeFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewDeserializeFilterer 

func NewDeserializeFilterer(address common.Address, filterer bind.ContractFilterer) (*DeserializeFilterer, error)

NewDeserializeFilterer creates a new log filterer instance of Deserialize, bound to a specific deployed contract.

type DeserializeRaw 

type DeserializeRaw struct {
	Contract *Deserialize // Generic contract binding to access the raw methods on
}

DeserializeRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*DeserializeRaw) Call 

func (_Deserialize *DeserializeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*DeserializeRaw) Transact 

func (_Deserialize *DeserializeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*DeserializeRaw) Transfer 

func (_Deserialize *DeserializeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type DeserializeSession 

type DeserializeSession struct {
	Contract     *Deserialize      // 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
}

DeserializeSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type DeserializeTransactor 

type DeserializeTransactor struct {
	// contains filtered or unexported fields
}

DeserializeTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewDeserializeTransactor 

func NewDeserializeTransactor(address common.Address, transactor bind.ContractTransactor) (*DeserializeTransactor, error)

NewDeserializeTransactor creates a new write-only instance of Deserialize, bound to a specific deployed contract.

type DeserializeTransactorRaw 

type DeserializeTransactorRaw struct {
	Contract *DeserializeTransactor // Generic write-only contract binding to access the raw methods on
}

DeserializeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*DeserializeTransactorRaw) Transact 

func (_Deserialize *DeserializeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*DeserializeTransactorRaw) Transfer 

func (_Deserialize *DeserializeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type DeserializeTransactorSession 

type DeserializeTransactorSession struct {
	Contract     *DeserializeTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
}

DeserializeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type GlobalStateLib 

type GlobalStateLib struct {
	GlobalStateLibCaller     // Read-only binding to the contract
	GlobalStateLibTransactor // Write-only binding to the contract
	GlobalStateLibFilterer   // Log filterer for contract events
}

GlobalStateLib is an auto generated Go binding around an Ethereum contract.

func DeployGlobalStateLib 

func DeployGlobalStateLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GlobalStateLib, error)

DeployGlobalStateLib deploys a new Ethereum contract, binding an instance of GlobalStateLib to it.

func NewGlobalStateLib 

func NewGlobalStateLib(address common.Address, backend bind.ContractBackend) (*GlobalStateLib, error)

NewGlobalStateLib creates a new instance of GlobalStateLib, bound to a specific deployed contract.

type GlobalStateLibCaller 

type GlobalStateLibCaller struct {
	// contains filtered or unexported fields
}

GlobalStateLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewGlobalStateLibCaller 

func NewGlobalStateLibCaller(address common.Address, caller bind.ContractCaller) (*GlobalStateLibCaller, error)

NewGlobalStateLibCaller creates a new read-only instance of GlobalStateLib, bound to a specific deployed contract.

type GlobalStateLibCallerRaw 

type GlobalStateLibCallerRaw struct {
	Contract *GlobalStateLibCaller // Generic read-only contract binding to access the raw methods on
}

GlobalStateLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*GlobalStateLibCallerRaw) Call 

func (_GlobalStateLib *GlobalStateLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type GlobalStateLibCallerSession 

type GlobalStateLibCallerSession struct {
	Contract *GlobalStateLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts         // Call options to use throughout this session
}

GlobalStateLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type GlobalStateLibFilterer 

type GlobalStateLibFilterer struct {
	// contains filtered or unexported fields
}

GlobalStateLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewGlobalStateLibFilterer 

func NewGlobalStateLibFilterer(address common.Address, filterer bind.ContractFilterer) (*GlobalStateLibFilterer, error)

NewGlobalStateLibFilterer creates a new log filterer instance of GlobalStateLib, bound to a specific deployed contract.

type GlobalStateLibRaw 

type GlobalStateLibRaw struct {
	Contract *GlobalStateLib // Generic contract binding to access the raw methods on
}

GlobalStateLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*GlobalStateLibRaw) Call 

func (_GlobalStateLib *GlobalStateLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*GlobalStateLibRaw) Transact 

func (_GlobalStateLib *GlobalStateLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*GlobalStateLibRaw) Transfer 

func (_GlobalStateLib *GlobalStateLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type GlobalStateLibSession 

type GlobalStateLibSession struct {
	Contract     *GlobalStateLib   // 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
}

GlobalStateLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type GlobalStateLibTransactor 

type GlobalStateLibTransactor struct {
	// contains filtered or unexported fields
}

GlobalStateLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewGlobalStateLibTransactor 

func NewGlobalStateLibTransactor(address common.Address, transactor bind.ContractTransactor) (*GlobalStateLibTransactor, error)

NewGlobalStateLibTransactor creates a new write-only instance of GlobalStateLib, bound to a specific deployed contract.

type GlobalStateLibTransactorRaw 

type GlobalStateLibTransactorRaw struct {
	Contract *GlobalStateLibTransactor // Generic write-only contract binding to access the raw methods on
}

GlobalStateLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*GlobalStateLibTransactorRaw) Transact 

func (_GlobalStateLib *GlobalStateLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*GlobalStateLibTransactorRaw) Transfer 

func (_GlobalStateLib *GlobalStateLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type GlobalStateLibTransactorSession 

type GlobalStateLibTransactorSession struct {
	Contract     *GlobalStateLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
}

GlobalStateLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type Instructions 

type Instructions struct {
	InstructionsCaller     // Read-only binding to the contract
	InstructionsTransactor // Write-only binding to the contract
	InstructionsFilterer   // Log filterer for contract events
}

Instructions is an auto generated Go binding around an Ethereum contract.

func DeployInstructions 

func DeployInstructions(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Instructions, error)

DeployInstructions deploys a new Ethereum contract, binding an instance of Instructions to it.

func NewInstructions 

func NewInstructions(address common.Address, backend bind.ContractBackend) (*Instructions, error)

NewInstructions creates a new instance of Instructions, bound to a specific deployed contract.

type InstructionsCaller 

type InstructionsCaller struct {
	// contains filtered or unexported fields
}

InstructionsCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewInstructionsCaller 

func NewInstructionsCaller(address common.Address, caller bind.ContractCaller) (*InstructionsCaller, error)

NewInstructionsCaller creates a new read-only instance of Instructions, bound to a specific deployed contract.

type InstructionsCallerRaw 

type InstructionsCallerRaw struct {
	Contract *InstructionsCaller // Generic read-only contract binding to access the raw methods on
}

InstructionsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*InstructionsCallerRaw) Call 

func (_Instructions *InstructionsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type InstructionsCallerSession 

type InstructionsCallerSession struct {
	Contract *InstructionsCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts       // Call options to use throughout this session
}

InstructionsCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type InstructionsFilterer 

type InstructionsFilterer struct {
	// contains filtered or unexported fields
}

InstructionsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewInstructionsFilterer 

func NewInstructionsFilterer(address common.Address, filterer bind.ContractFilterer) (*InstructionsFilterer, error)

NewInstructionsFilterer creates a new log filterer instance of Instructions, bound to a specific deployed contract.

type InstructionsRaw 

type InstructionsRaw struct {
	Contract *Instructions // Generic contract binding to access the raw methods on
}

InstructionsRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*InstructionsRaw) Call 

func (_Instructions *InstructionsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*InstructionsRaw) Transact 

func (_Instructions *InstructionsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*InstructionsRaw) Transfer 

func (_Instructions *InstructionsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type InstructionsSession 

type InstructionsSession struct {
	Contract     *Instructions     // 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
}

InstructionsSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type InstructionsTransactor 

type InstructionsTransactor struct {
	// contains filtered or unexported fields
}

InstructionsTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewInstructionsTransactor 

func NewInstructionsTransactor(address common.Address, transactor bind.ContractTransactor) (*InstructionsTransactor, error)

NewInstructionsTransactor creates a new write-only instance of Instructions, bound to a specific deployed contract.

type InstructionsTransactorRaw 

type InstructionsTransactorRaw struct {
	Contract *InstructionsTransactor // Generic write-only contract binding to access the raw methods on
}

InstructionsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*InstructionsTransactorRaw) Transact 

func (_Instructions *InstructionsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*InstructionsTransactorRaw) Transfer 

func (_Instructions *InstructionsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type InstructionsTransactorSession 

type InstructionsTransactorSession struct {
	Contract     *InstructionsTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
}

InstructionsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type MachineLib 

type MachineLib struct {
	MachineLibCaller     // Read-only binding to the contract
	MachineLibTransactor // Write-only binding to the contract
	MachineLibFilterer   // Log filterer for contract events
}

MachineLib is an auto generated Go binding around an Ethereum contract.

func DeployMachineLib 

func DeployMachineLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MachineLib, error)

DeployMachineLib deploys a new Ethereum contract, binding an instance of MachineLib to it.

func NewMachineLib 

func NewMachineLib(address common.Address, backend bind.ContractBackend) (*MachineLib, error)

NewMachineLib creates a new instance of MachineLib, bound to a specific deployed contract.

type MachineLibCaller 

type MachineLibCaller struct {
	// contains filtered or unexported fields
}

MachineLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewMachineLibCaller 

func NewMachineLibCaller(address common.Address, caller bind.ContractCaller) (*MachineLibCaller, error)

NewMachineLibCaller creates a new read-only instance of MachineLib, bound to a specific deployed contract.

type MachineLibCallerRaw 

type MachineLibCallerRaw struct {
	Contract *MachineLibCaller // Generic read-only contract binding to access the raw methods on
}

MachineLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*MachineLibCallerRaw) Call 

func (_MachineLib *MachineLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type MachineLibCallerSession 

type MachineLibCallerSession struct {
	Contract *MachineLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts     // Call options to use throughout this session
}

MachineLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type MachineLibFilterer 

type MachineLibFilterer struct {
	// contains filtered or unexported fields
}

MachineLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewMachineLibFilterer 

func NewMachineLibFilterer(address common.Address, filterer bind.ContractFilterer) (*MachineLibFilterer, error)

NewMachineLibFilterer creates a new log filterer instance of MachineLib, bound to a specific deployed contract.

type MachineLibRaw 

type MachineLibRaw struct {
	Contract *MachineLib // Generic contract binding to access the raw methods on
}

MachineLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*MachineLibRaw) Call 

func (_MachineLib *MachineLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*MachineLibRaw) Transact 

func (_MachineLib *MachineLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*MachineLibRaw) Transfer 

func (_MachineLib *MachineLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type MachineLibSession 

type MachineLibSession struct {
	Contract     *MachineLib       // 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
}

MachineLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type MachineLibTransactor 

type MachineLibTransactor struct {
	// contains filtered or unexported fields
}

MachineLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewMachineLibTransactor 

func NewMachineLibTransactor(address common.Address, transactor bind.ContractTransactor) (*MachineLibTransactor, error)

NewMachineLibTransactor creates a new write-only instance of MachineLib, bound to a specific deployed contract.

type MachineLibTransactorRaw 

type MachineLibTransactorRaw struct {
	Contract *MachineLibTransactor // Generic write-only contract binding to access the raw methods on
}

MachineLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*MachineLibTransactorRaw) Transact 

func (_MachineLib *MachineLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*MachineLibTransactorRaw) Transfer 

func (_MachineLib *MachineLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type MachineLibTransactorSession 

type MachineLibTransactorSession struct {
	Contract     *MachineLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
}

MachineLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type MerkleProofLib 

type MerkleProofLib struct {
	MerkleProofLibCaller     // Read-only binding to the contract
	MerkleProofLibTransactor // Write-only binding to the contract
	MerkleProofLibFilterer   // Log filterer for contract events
}

MerkleProofLib is an auto generated Go binding around an Ethereum contract.

func DeployMerkleProofLib 

func DeployMerkleProofLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MerkleProofLib, error)

DeployMerkleProofLib deploys a new Ethereum contract, binding an instance of MerkleProofLib to it.

func NewMerkleProofLib 

func NewMerkleProofLib(address common.Address, backend bind.ContractBackend) (*MerkleProofLib, error)

NewMerkleProofLib creates a new instance of MerkleProofLib, bound to a specific deployed contract.

type MerkleProofLibCaller 

type MerkleProofLibCaller struct {
	// contains filtered or unexported fields
}

MerkleProofLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewMerkleProofLibCaller 

func NewMerkleProofLibCaller(address common.Address, caller bind.ContractCaller) (*MerkleProofLibCaller, error)

NewMerkleProofLibCaller creates a new read-only instance of MerkleProofLib, bound to a specific deployed contract.

type MerkleProofLibCallerRaw 

type MerkleProofLibCallerRaw struct {
	Contract *MerkleProofLibCaller // Generic read-only contract binding to access the raw methods on
}

MerkleProofLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*MerkleProofLibCallerRaw) Call 

func (_MerkleProofLib *MerkleProofLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type MerkleProofLibCallerSession 

type MerkleProofLibCallerSession struct {
	Contract *MerkleProofLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts         // Call options to use throughout this session
}

MerkleProofLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type MerkleProofLibFilterer 

type MerkleProofLibFilterer struct {
	// contains filtered or unexported fields
}

MerkleProofLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewMerkleProofLibFilterer 

func NewMerkleProofLibFilterer(address common.Address, filterer bind.ContractFilterer) (*MerkleProofLibFilterer, error)

NewMerkleProofLibFilterer creates a new log filterer instance of MerkleProofLib, bound to a specific deployed contract.

type MerkleProofLibRaw 

type MerkleProofLibRaw struct {
	Contract *MerkleProofLib // Generic contract binding to access the raw methods on
}

MerkleProofLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*MerkleProofLibRaw) Call 

func (_MerkleProofLib *MerkleProofLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*MerkleProofLibRaw) Transact 

func (_MerkleProofLib *MerkleProofLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*MerkleProofLibRaw) Transfer 

func (_MerkleProofLib *MerkleProofLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type MerkleProofLibSession 

type MerkleProofLibSession struct {
	Contract     *MerkleProofLib   // 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
}

MerkleProofLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type MerkleProofLibTransactor 

type MerkleProofLibTransactor struct {
	// contains filtered or unexported fields
}

MerkleProofLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewMerkleProofLibTransactor 

func NewMerkleProofLibTransactor(address common.Address, transactor bind.ContractTransactor) (*MerkleProofLibTransactor, error)

NewMerkleProofLibTransactor creates a new write-only instance of MerkleProofLib, bound to a specific deployed contract.

type MerkleProofLibTransactorRaw 

type MerkleProofLibTransactorRaw struct {
	Contract *MerkleProofLibTransactor // Generic write-only contract binding to access the raw methods on
}

MerkleProofLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*MerkleProofLibTransactorRaw) Transact 

func (_MerkleProofLib *MerkleProofLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*MerkleProofLibTransactorRaw) Transfer 

func (_MerkleProofLib *MerkleProofLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type MerkleProofLibTransactorSession 

type MerkleProofLibTransactorSession struct {
	Contract     *MerkleProofLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
}

MerkleProofLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ModuleLib 

type ModuleLib struct {
	ModuleLibCaller     // Read-only binding to the contract
	ModuleLibTransactor // Write-only binding to the contract
	ModuleLibFilterer   // Log filterer for contract events
}

ModuleLib is an auto generated Go binding around an Ethereum contract.

func DeployModuleLib 

func DeployModuleLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ModuleLib, error)

DeployModuleLib deploys a new Ethereum contract, binding an instance of ModuleLib to it.

func NewModuleLib 

func NewModuleLib(address common.Address, backend bind.ContractBackend) (*ModuleLib, error)

NewModuleLib creates a new instance of ModuleLib, bound to a specific deployed contract.

type ModuleLibCaller 

type ModuleLibCaller struct {
	// contains filtered or unexported fields
}

ModuleLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewModuleLibCaller 

func NewModuleLibCaller(address common.Address, caller bind.ContractCaller) (*ModuleLibCaller, error)

NewModuleLibCaller creates a new read-only instance of ModuleLib, bound to a specific deployed contract.

type ModuleLibCallerRaw 

type ModuleLibCallerRaw struct {
	Contract *ModuleLibCaller // Generic read-only contract binding to access the raw methods on
}

ModuleLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ModuleLibCallerRaw) Call 

func (_ModuleLib *ModuleLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type ModuleLibCallerSession 

type ModuleLibCallerSession struct {
	Contract *ModuleLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts    // Call options to use throughout this session
}

ModuleLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ModuleLibFilterer 

type ModuleLibFilterer struct {
	// contains filtered or unexported fields
}

ModuleLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewModuleLibFilterer 

func NewModuleLibFilterer(address common.Address, filterer bind.ContractFilterer) (*ModuleLibFilterer, error)

NewModuleLibFilterer creates a new log filterer instance of ModuleLib, bound to a specific deployed contract.

type ModuleLibRaw 

type ModuleLibRaw struct {
	Contract *ModuleLib // Generic contract binding to access the raw methods on
}

ModuleLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ModuleLibRaw) Call 

func (_ModuleLib *ModuleLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*ModuleLibRaw) Transact 

func (_ModuleLib *ModuleLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ModuleLibRaw) Transfer 

func (_ModuleLib *ModuleLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ModuleLibSession 

type ModuleLibSession struct {
	Contract     *ModuleLib        // 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
}

ModuleLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type ModuleLibTransactor 

type ModuleLibTransactor struct {
	// contains filtered or unexported fields
}

ModuleLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewModuleLibTransactor 

func NewModuleLibTransactor(address common.Address, transactor bind.ContractTransactor) (*ModuleLibTransactor, error)

NewModuleLibTransactor creates a new write-only instance of ModuleLib, bound to a specific deployed contract.

type ModuleLibTransactorRaw 

type ModuleLibTransactorRaw struct {
	Contract *ModuleLibTransactor // Generic write-only contract binding to access the raw methods on
}

ModuleLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ModuleLibTransactorRaw) Transact 

func (_ModuleLib *ModuleLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ModuleLibTransactorRaw) Transfer 

func (_ModuleLib *ModuleLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ModuleLibTransactorSession 

type ModuleLibTransactorSession struct {
	Contract     *ModuleLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
}

ModuleLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ModuleMemoryCompactLib 

type ModuleMemoryCompactLib struct {
	ModuleMemoryCompactLibCaller     // Read-only binding to the contract
	ModuleMemoryCompactLibTransactor // Write-only binding to the contract
	ModuleMemoryCompactLibFilterer   // Log filterer for contract events
}

ModuleMemoryCompactLib is an auto generated Go binding around an Ethereum contract.

func DeployModuleMemoryCompactLib 

func DeployModuleMemoryCompactLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ModuleMemoryCompactLib, error)

DeployModuleMemoryCompactLib deploys a new Ethereum contract, binding an instance of ModuleMemoryCompactLib to it.

func NewModuleMemoryCompactLib 

func NewModuleMemoryCompactLib(address common.Address, backend bind.ContractBackend) (*ModuleMemoryCompactLib, error)

NewModuleMemoryCompactLib creates a new instance of ModuleMemoryCompactLib, bound to a specific deployed contract.

type ModuleMemoryCompactLibCaller 

type ModuleMemoryCompactLibCaller struct {
	// contains filtered or unexported fields
}

ModuleMemoryCompactLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewModuleMemoryCompactLibCaller 

func NewModuleMemoryCompactLibCaller(address common.Address, caller bind.ContractCaller) (*ModuleMemoryCompactLibCaller, error)

NewModuleMemoryCompactLibCaller creates a new read-only instance of ModuleMemoryCompactLib, bound to a specific deployed contract.

type ModuleMemoryCompactLibCallerRaw 

type ModuleMemoryCompactLibCallerRaw struct {
	Contract *ModuleMemoryCompactLibCaller // Generic read-only contract binding to access the raw methods on
}

ModuleMemoryCompactLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ModuleMemoryCompactLibCallerRaw) Call 

func (_ModuleMemoryCompactLib *ModuleMemoryCompactLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type ModuleMemoryCompactLibCallerSession 

type ModuleMemoryCompactLibCallerSession struct {
	Contract *ModuleMemoryCompactLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts                 // Call options to use throughout this session
}

ModuleMemoryCompactLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ModuleMemoryCompactLibFilterer 

type ModuleMemoryCompactLibFilterer struct {
	// contains filtered or unexported fields
}

ModuleMemoryCompactLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewModuleMemoryCompactLibFilterer 

func NewModuleMemoryCompactLibFilterer(address common.Address, filterer bind.ContractFilterer) (*ModuleMemoryCompactLibFilterer, error)

NewModuleMemoryCompactLibFilterer creates a new log filterer instance of ModuleMemoryCompactLib, bound to a specific deployed contract.

type ModuleMemoryCompactLibRaw 

type ModuleMemoryCompactLibRaw struct {
	Contract *ModuleMemoryCompactLib // Generic contract binding to access the raw methods on
}

ModuleMemoryCompactLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ModuleMemoryCompactLibRaw) Call 

func (_ModuleMemoryCompactLib *ModuleMemoryCompactLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*ModuleMemoryCompactLibRaw) Transact 

func (_ModuleMemoryCompactLib *ModuleMemoryCompactLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ModuleMemoryCompactLibRaw) Transfer 

func (_ModuleMemoryCompactLib *ModuleMemoryCompactLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ModuleMemoryCompactLibSession 

type ModuleMemoryCompactLibSession struct {
	Contract     *ModuleMemoryCompactLib // 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
}

ModuleMemoryCompactLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type ModuleMemoryCompactLibTransactor 

type ModuleMemoryCompactLibTransactor struct {
	// contains filtered or unexported fields
}

ModuleMemoryCompactLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewModuleMemoryCompactLibTransactor 

func NewModuleMemoryCompactLibTransactor(address common.Address, transactor bind.ContractTransactor) (*ModuleMemoryCompactLibTransactor, error)

NewModuleMemoryCompactLibTransactor creates a new write-only instance of ModuleMemoryCompactLib, bound to a specific deployed contract.

type ModuleMemoryCompactLibTransactorRaw 

type ModuleMemoryCompactLibTransactorRaw struct {
	Contract *ModuleMemoryCompactLibTransactor // Generic write-only contract binding to access the raw methods on
}

ModuleMemoryCompactLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ModuleMemoryCompactLibTransactorRaw) Transact 

func (_ModuleMemoryCompactLib *ModuleMemoryCompactLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ModuleMemoryCompactLibTransactorRaw) Transfer 

func (_ModuleMemoryCompactLib *ModuleMemoryCompactLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ModuleMemoryCompactLibTransactorSession 

type ModuleMemoryCompactLibTransactorSession struct {
	Contract     *ModuleMemoryCompactLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts                 // Transaction auth options to use throughout this session
}

ModuleMemoryCompactLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ModuleMemoryLib 

type ModuleMemoryLib struct {
	ModuleMemoryLibCaller     // Read-only binding to the contract
	ModuleMemoryLibTransactor // Write-only binding to the contract
	ModuleMemoryLibFilterer   // Log filterer for contract events
}

ModuleMemoryLib is an auto generated Go binding around an Ethereum contract.

func DeployModuleMemoryLib 

func DeployModuleMemoryLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ModuleMemoryLib, error)

DeployModuleMemoryLib deploys a new Ethereum contract, binding an instance of ModuleMemoryLib to it.

func NewModuleMemoryLib 

func NewModuleMemoryLib(address common.Address, backend bind.ContractBackend) (*ModuleMemoryLib, error)

NewModuleMemoryLib creates a new instance of ModuleMemoryLib, bound to a specific deployed contract.

type ModuleMemoryLibCaller 

type ModuleMemoryLibCaller struct {
	// contains filtered or unexported fields
}

ModuleMemoryLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewModuleMemoryLibCaller 

func NewModuleMemoryLibCaller(address common.Address, caller bind.ContractCaller) (*ModuleMemoryLibCaller, error)

NewModuleMemoryLibCaller creates a new read-only instance of ModuleMemoryLib, bound to a specific deployed contract.

type ModuleMemoryLibCallerRaw 

type ModuleMemoryLibCallerRaw struct {
	Contract *ModuleMemoryLibCaller // Generic read-only contract binding to access the raw methods on
}

ModuleMemoryLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ModuleMemoryLibCallerRaw) Call 

func (_ModuleMemoryLib *ModuleMemoryLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type ModuleMemoryLibCallerSession 

type ModuleMemoryLibCallerSession struct {
	Contract *ModuleMemoryLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts          // Call options to use throughout this session
}

ModuleMemoryLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ModuleMemoryLibFilterer 

type ModuleMemoryLibFilterer struct {
	// contains filtered or unexported fields
}

ModuleMemoryLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewModuleMemoryLibFilterer 

func NewModuleMemoryLibFilterer(address common.Address, filterer bind.ContractFilterer) (*ModuleMemoryLibFilterer, error)

NewModuleMemoryLibFilterer creates a new log filterer instance of ModuleMemoryLib, bound to a specific deployed contract.

type ModuleMemoryLibRaw 

type ModuleMemoryLibRaw struct {
	Contract *ModuleMemoryLib // Generic contract binding to access the raw methods on
}

ModuleMemoryLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ModuleMemoryLibRaw) Call 

func (_ModuleMemoryLib *ModuleMemoryLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*ModuleMemoryLibRaw) Transact 

func (_ModuleMemoryLib *ModuleMemoryLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ModuleMemoryLibRaw) Transfer 

func (_ModuleMemoryLib *ModuleMemoryLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ModuleMemoryLibSession 

type ModuleMemoryLibSession struct {
	Contract     *ModuleMemoryLib  // 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
}

ModuleMemoryLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type ModuleMemoryLibTransactor 

type ModuleMemoryLibTransactor struct {
	// contains filtered or unexported fields
}

ModuleMemoryLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewModuleMemoryLibTransactor 

func NewModuleMemoryLibTransactor(address common.Address, transactor bind.ContractTransactor) (*ModuleMemoryLibTransactor, error)

NewModuleMemoryLibTransactor creates a new write-only instance of ModuleMemoryLib, bound to a specific deployed contract.

type ModuleMemoryLibTransactorRaw 

type ModuleMemoryLibTransactorRaw struct {
	Contract *ModuleMemoryLibTransactor // Generic write-only contract binding to access the raw methods on
}

ModuleMemoryLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ModuleMemoryLibTransactorRaw) Transact 

func (_ModuleMemoryLib *ModuleMemoryLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ModuleMemoryLibTransactorRaw) Transfer 

func (_ModuleMemoryLib *ModuleMemoryLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ModuleMemoryLibTransactorSession 

type ModuleMemoryLibTransactorSession struct {
	Contract     *ModuleMemoryLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts          // Transaction auth options to use throughout this session
}

ModuleMemoryLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type PcArrayLib 

type PcArrayLib struct {
	PcArrayLibCaller     // Read-only binding to the contract
	PcArrayLibTransactor // Write-only binding to the contract
	PcArrayLibFilterer   // Log filterer for contract events
}

PcArrayLib is an auto generated Go binding around an Ethereum contract.

func DeployPcArrayLib 

func DeployPcArrayLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *PcArrayLib, error)

DeployPcArrayLib deploys a new Ethereum contract, binding an instance of PcArrayLib to it.

func NewPcArrayLib 

func NewPcArrayLib(address common.Address, backend bind.ContractBackend) (*PcArrayLib, error)

NewPcArrayLib creates a new instance of PcArrayLib, bound to a specific deployed contract.

type PcArrayLibCaller 

type PcArrayLibCaller struct {
	// contains filtered or unexported fields
}

PcArrayLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewPcArrayLibCaller 

func NewPcArrayLibCaller(address common.Address, caller bind.ContractCaller) (*PcArrayLibCaller, error)

NewPcArrayLibCaller creates a new read-only instance of PcArrayLib, bound to a specific deployed contract.

type PcArrayLibCallerRaw 

type PcArrayLibCallerRaw struct {
	Contract *PcArrayLibCaller // Generic read-only contract binding to access the raw methods on
}

PcArrayLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*PcArrayLibCallerRaw) Call 

func (_PcArrayLib *PcArrayLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type PcArrayLibCallerSession 

type PcArrayLibCallerSession struct {
	Contract *PcArrayLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts     // Call options to use throughout this session
}

PcArrayLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type PcArrayLibFilterer 

type PcArrayLibFilterer struct {
	// contains filtered or unexported fields
}

PcArrayLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewPcArrayLibFilterer 

func NewPcArrayLibFilterer(address common.Address, filterer bind.ContractFilterer) (*PcArrayLibFilterer, error)

NewPcArrayLibFilterer creates a new log filterer instance of PcArrayLib, bound to a specific deployed contract.

type PcArrayLibRaw 

type PcArrayLibRaw struct {
	Contract *PcArrayLib // Generic contract binding to access the raw methods on
}

PcArrayLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*PcArrayLibRaw) Call 

func (_PcArrayLib *PcArrayLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*PcArrayLibRaw) Transact 

func (_PcArrayLib *PcArrayLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*PcArrayLibRaw) Transfer 

func (_PcArrayLib *PcArrayLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type PcArrayLibSession 

type PcArrayLibSession struct {
	Contract     *PcArrayLib       // 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
}

PcArrayLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type PcArrayLibTransactor 

type PcArrayLibTransactor struct {
	// contains filtered or unexported fields
}

PcArrayLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewPcArrayLibTransactor 

func NewPcArrayLibTransactor(address common.Address, transactor bind.ContractTransactor) (*PcArrayLibTransactor, error)

NewPcArrayLibTransactor creates a new write-only instance of PcArrayLib, bound to a specific deployed contract.

type PcArrayLibTransactorRaw 

type PcArrayLibTransactorRaw struct {
	Contract *PcArrayLibTransactor // Generic write-only contract binding to access the raw methods on
}

PcArrayLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*PcArrayLibTransactorRaw) Transact 

func (_PcArrayLib *PcArrayLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*PcArrayLibTransactorRaw) Transfer 

func (_PcArrayLib *PcArrayLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type PcArrayLibTransactorSession 

type PcArrayLibTransactorSession struct {
	Contract     *PcArrayLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
}

PcArrayLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type StackFrameLib 

type StackFrameLib struct {
	StackFrameLibCaller     // Read-only binding to the contract
	StackFrameLibTransactor // Write-only binding to the contract
	StackFrameLibFilterer   // Log filterer for contract events
}

StackFrameLib is an auto generated Go binding around an Ethereum contract.

func DeployStackFrameLib 

func DeployStackFrameLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StackFrameLib, error)

DeployStackFrameLib deploys a new Ethereum contract, binding an instance of StackFrameLib to it.

func NewStackFrameLib 

func NewStackFrameLib(address common.Address, backend bind.ContractBackend) (*StackFrameLib, error)

NewStackFrameLib creates a new instance of StackFrameLib, bound to a specific deployed contract.

type StackFrameLibCaller 

type StackFrameLibCaller struct {
	// contains filtered or unexported fields
}

StackFrameLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewStackFrameLibCaller 

func NewStackFrameLibCaller(address common.Address, caller bind.ContractCaller) (*StackFrameLibCaller, error)

NewStackFrameLibCaller creates a new read-only instance of StackFrameLib, bound to a specific deployed contract.

type StackFrameLibCallerRaw 

type StackFrameLibCallerRaw struct {
	Contract *StackFrameLibCaller // Generic read-only contract binding to access the raw methods on
}

StackFrameLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*StackFrameLibCallerRaw) Call 

func (_StackFrameLib *StackFrameLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type StackFrameLibCallerSession 

type StackFrameLibCallerSession struct {
	Contract *StackFrameLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts        // Call options to use throughout this session
}

StackFrameLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type StackFrameLibFilterer 

type StackFrameLibFilterer struct {
	// contains filtered or unexported fields
}

StackFrameLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewStackFrameLibFilterer 

func NewStackFrameLibFilterer(address common.Address, filterer bind.ContractFilterer) (*StackFrameLibFilterer, error)

NewStackFrameLibFilterer creates a new log filterer instance of StackFrameLib, bound to a specific deployed contract.

type StackFrameLibRaw 

type StackFrameLibRaw struct {
	Contract *StackFrameLib // Generic contract binding to access the raw methods on
}

StackFrameLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*StackFrameLibRaw) Call 

func (_StackFrameLib *StackFrameLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*StackFrameLibRaw) Transact 

func (_StackFrameLib *StackFrameLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*StackFrameLibRaw) Transfer 

func (_StackFrameLib *StackFrameLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type StackFrameLibSession 

type StackFrameLibSession struct {
	Contract     *StackFrameLib    // 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
}

StackFrameLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type StackFrameLibTransactor 

type StackFrameLibTransactor struct {
	// contains filtered or unexported fields
}

StackFrameLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewStackFrameLibTransactor 

func NewStackFrameLibTransactor(address common.Address, transactor bind.ContractTransactor) (*StackFrameLibTransactor, error)

NewStackFrameLibTransactor creates a new write-only instance of StackFrameLib, bound to a specific deployed contract.

type StackFrameLibTransactorRaw 

type StackFrameLibTransactorRaw struct {
	Contract *StackFrameLibTransactor // Generic write-only contract binding to access the raw methods on
}

StackFrameLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*StackFrameLibTransactorRaw) Transact 

func (_StackFrameLib *StackFrameLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*StackFrameLibTransactorRaw) Transfer 

func (_StackFrameLib *StackFrameLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type StackFrameLibTransactorSession 

type StackFrameLibTransactorSession struct {
	Contract     *StackFrameLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
}

StackFrameLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ValueArrayLib 

type ValueArrayLib struct {
	ValueArrayLibCaller     // Read-only binding to the contract
	ValueArrayLibTransactor // Write-only binding to the contract
	ValueArrayLibFilterer   // Log filterer for contract events
}

ValueArrayLib is an auto generated Go binding around an Ethereum contract.

func DeployValueArrayLib 

func DeployValueArrayLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ValueArrayLib, error)

DeployValueArrayLib deploys a new Ethereum contract, binding an instance of ValueArrayLib to it.

func NewValueArrayLib 

func NewValueArrayLib(address common.Address, backend bind.ContractBackend) (*ValueArrayLib, error)

NewValueArrayLib creates a new instance of ValueArrayLib, bound to a specific deployed contract.

type ValueArrayLibCaller 

type ValueArrayLibCaller struct {
	// contains filtered or unexported fields
}

ValueArrayLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewValueArrayLibCaller 

func NewValueArrayLibCaller(address common.Address, caller bind.ContractCaller) (*ValueArrayLibCaller, error)

NewValueArrayLibCaller creates a new read-only instance of ValueArrayLib, bound to a specific deployed contract.

type ValueArrayLibCallerRaw 

type ValueArrayLibCallerRaw struct {
	Contract *ValueArrayLibCaller // Generic read-only contract binding to access the raw methods on
}

ValueArrayLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ValueArrayLibCallerRaw) Call 

func (_ValueArrayLib *ValueArrayLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type ValueArrayLibCallerSession 

type ValueArrayLibCallerSession struct {
	Contract *ValueArrayLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts        // Call options to use throughout this session
}

ValueArrayLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ValueArrayLibFilterer 

type ValueArrayLibFilterer struct {
	// contains filtered or unexported fields
}

ValueArrayLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewValueArrayLibFilterer 

func NewValueArrayLibFilterer(address common.Address, filterer bind.ContractFilterer) (*ValueArrayLibFilterer, error)

NewValueArrayLibFilterer creates a new log filterer instance of ValueArrayLib, bound to a specific deployed contract.

type ValueArrayLibRaw 

type ValueArrayLibRaw struct {
	Contract *ValueArrayLib // Generic contract binding to access the raw methods on
}

ValueArrayLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ValueArrayLibRaw) Call 

func (_ValueArrayLib *ValueArrayLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*ValueArrayLibRaw) Transact 

func (_ValueArrayLib *ValueArrayLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ValueArrayLibRaw) Transfer 

func (_ValueArrayLib *ValueArrayLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ValueArrayLibSession 

type ValueArrayLibSession struct {
	Contract     *ValueArrayLib    // 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
}

ValueArrayLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type ValueArrayLibTransactor 

type ValueArrayLibTransactor struct {
	// contains filtered or unexported fields
}

ValueArrayLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewValueArrayLibTransactor 

func NewValueArrayLibTransactor(address common.Address, transactor bind.ContractTransactor) (*ValueArrayLibTransactor, error)

NewValueArrayLibTransactor creates a new write-only instance of ValueArrayLib, bound to a specific deployed contract.

type ValueArrayLibTransactorRaw 

type ValueArrayLibTransactorRaw struct {
	Contract *ValueArrayLibTransactor // Generic write-only contract binding to access the raw methods on
}

ValueArrayLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ValueArrayLibTransactorRaw) Transact 

func (_ValueArrayLib *ValueArrayLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ValueArrayLibTransactorRaw) Transfer 

func (_ValueArrayLib *ValueArrayLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ValueArrayLibTransactorSession 

type ValueArrayLibTransactorSession struct {
	Contract     *ValueArrayLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
}

ValueArrayLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ValueLib 

type ValueLib struct {
	ValueLibCaller     // Read-only binding to the contract
	ValueLibTransactor // Write-only binding to the contract
	ValueLibFilterer   // Log filterer for contract events
}

ValueLib is an auto generated Go binding around an Ethereum contract.

func DeployValueLib 

func DeployValueLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ValueLib, error)

DeployValueLib deploys a new Ethereum contract, binding an instance of ValueLib to it.

func NewValueLib 

func NewValueLib(address common.Address, backend bind.ContractBackend) (*ValueLib, error)

NewValueLib creates a new instance of ValueLib, bound to a specific deployed contract.

type ValueLibCaller 

type ValueLibCaller struct {
	// contains filtered or unexported fields
}

ValueLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewValueLibCaller 

func NewValueLibCaller(address common.Address, caller bind.ContractCaller) (*ValueLibCaller, error)

NewValueLibCaller creates a new read-only instance of ValueLib, bound to a specific deployed contract.

type ValueLibCallerRaw 

type ValueLibCallerRaw struct {
	Contract *ValueLibCaller // Generic read-only contract binding to access the raw methods on
}

ValueLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ValueLibCallerRaw) Call 

func (_ValueLib *ValueLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type ValueLibCallerSession 

type ValueLibCallerSession struct {
	Contract *ValueLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts   // Call options to use throughout this session
}

ValueLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ValueLibFilterer 

type ValueLibFilterer struct {
	// contains filtered or unexported fields
}

ValueLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewValueLibFilterer 

func NewValueLibFilterer(address common.Address, filterer bind.ContractFilterer) (*ValueLibFilterer, error)

NewValueLibFilterer creates a new log filterer instance of ValueLib, bound to a specific deployed contract.

type ValueLibRaw 

type ValueLibRaw struct {
	Contract *ValueLib // Generic contract binding to access the raw methods on
}

ValueLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ValueLibRaw) Call 

func (_ValueLib *ValueLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*ValueLibRaw) Transact 

func (_ValueLib *ValueLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ValueLibRaw) Transfer 

func (_ValueLib *ValueLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ValueLibSession 

type ValueLibSession struct {
	Contract     *ValueLib         // 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
}

ValueLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type ValueLibTransactor 

type ValueLibTransactor struct {
	// contains filtered or unexported fields
}

ValueLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewValueLibTransactor 

func NewValueLibTransactor(address common.Address, transactor bind.ContractTransactor) (*ValueLibTransactor, error)

NewValueLibTransactor creates a new write-only instance of ValueLib, bound to a specific deployed contract.

type ValueLibTransactorRaw 

type ValueLibTransactorRaw struct {
	Contract *ValueLibTransactor // Generic write-only contract binding to access the raw methods on
}

ValueLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ValueLibTransactorRaw) Transact 

func (_ValueLib *ValueLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ValueLibTransactorRaw) Transfer 

func (_ValueLib *ValueLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ValueLibTransactorSession 

type ValueLibTransactorSession struct {
	Contract     *ValueLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

ValueLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ValueStackLib 

type ValueStackLib struct {
	ValueStackLibCaller     // Read-only binding to the contract
	ValueStackLibTransactor // Write-only binding to the contract
	ValueStackLibFilterer   // Log filterer for contract events
}

ValueStackLib is an auto generated Go binding around an Ethereum contract.

func DeployValueStackLib 

func DeployValueStackLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ValueStackLib, error)

DeployValueStackLib deploys a new Ethereum contract, binding an instance of ValueStackLib to it.

func NewValueStackLib 

func NewValueStackLib(address common.Address, backend bind.ContractBackend) (*ValueStackLib, error)

NewValueStackLib creates a new instance of ValueStackLib, bound to a specific deployed contract.

type ValueStackLibCaller 

type ValueStackLibCaller struct {
	// contains filtered or unexported fields
}

ValueStackLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewValueStackLibCaller 

func NewValueStackLibCaller(address common.Address, caller bind.ContractCaller) (*ValueStackLibCaller, error)

NewValueStackLibCaller creates a new read-only instance of ValueStackLib, bound to a specific deployed contract.

type ValueStackLibCallerRaw 

type ValueStackLibCallerRaw struct {
	Contract *ValueStackLibCaller // Generic read-only contract binding to access the raw methods on
}

ValueStackLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ValueStackLibCallerRaw) Call 

func (_ValueStackLib *ValueStackLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type ValueStackLibCallerSession 

type ValueStackLibCallerSession struct {
	Contract *ValueStackLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts        // Call options to use throughout this session
}

ValueStackLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ValueStackLibFilterer 

type ValueStackLibFilterer struct {
	// contains filtered or unexported fields
}

ValueStackLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewValueStackLibFilterer 

func NewValueStackLibFilterer(address common.Address, filterer bind.ContractFilterer) (*ValueStackLibFilterer, error)

NewValueStackLibFilterer creates a new log filterer instance of ValueStackLib, bound to a specific deployed contract.

type ValueStackLibRaw 

type ValueStackLibRaw struct {
	Contract *ValueStackLib // Generic contract binding to access the raw methods on
}

ValueStackLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ValueStackLibRaw) Call 

func (_ValueStackLib *ValueStackLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*ValueStackLibRaw) Transact 

func (_ValueStackLib *ValueStackLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ValueStackLibRaw) Transfer 

func (_ValueStackLib *ValueStackLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ValueStackLibSession 

type ValueStackLibSession struct {
	Contract     *ValueStackLib    // 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
}

ValueStackLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type ValueStackLibTransactor 

type ValueStackLibTransactor struct {
	// contains filtered or unexported fields
}

ValueStackLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewValueStackLibTransactor 

func NewValueStackLibTransactor(address common.Address, transactor bind.ContractTransactor) (*ValueStackLibTransactor, error)

NewValueStackLibTransactor creates a new write-only instance of ValueStackLib, bound to a specific deployed contract.

type ValueStackLibTransactorRaw 

type ValueStackLibTransactorRaw struct {
	Contract *ValueStackLibTransactor // Generic write-only contract binding to access the raw methods on
}

ValueStackLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ValueStackLibTransactorRaw) Transact 

func (_ValueStackLib *ValueStackLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ValueStackLibTransactorRaw) Transfer 

func (_ValueStackLib *ValueStackLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ValueStackLibTransactorSession 

type ValueStackLibTransactorSession struct {
	Contract     *ValueStackLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
}

ValueStackLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.