trivialapp

package
v0.9.0 Latest Latest
Warning

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

 Go to latest Published: Feb 25, 2022 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const AppABI = "" /* 2675-byte string literal not displayed */

AppABI is the input ABI used to generate the binding from.

View Source 
const ArrayABI = "[]"

ArrayABI is the input ABI used to generate the binding from.

View Source 
const ChannelABI = "[]"

ChannelABI is the input ABI used to generate the binding from.

View Source 
const ECDSAABI = "[]"

ECDSAABI is the input ABI used to generate the binding from.

View Source 
const SafeMathABI = "[]"

SafeMathABI is the input ABI used to generate the binding from.

View Source 
const SigABI = "[]"

SigABI is the input ABI used to generate the binding from.

View Source 
const TrivialAppABI = "" /* 2675-byte string literal not displayed */

TrivialAppABI is the input ABI used to generate the binding from.

Variables

View Source 
var AppFuncSigs = map[string]string{
	"0d1feb4f": "validTransition((uint256,uint256,address[],address,bool,bool),(bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool),(bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool),uint256)",
}

AppFuncSigs maps the 4-byte function signature to its string representation.

View Source 
var ArrayBin = "" /* 244-byte string literal not displayed */

ArrayBin is the compiled bytecode used for deploying new contracts.

View Source 
var ChannelBin = "" /* 244-byte string literal not displayed */

ChannelBin is the compiled bytecode used for deploying new contracts.

View Source 
var ECDSABin = "" /* 244-byte string literal not displayed */

ECDSABin is the compiled bytecode used for deploying new contracts.

View Source 
var SafeMathBin = "" /* 244-byte string literal not displayed */

SafeMathBin is the compiled bytecode used for deploying new contracts.

View Source 
var SigBin = "" /* 244-byte string literal not displayed */

SigBin is the compiled bytecode used for deploying new contracts.

View Source 
var TrivialAppBin = "" /* 630-byte string literal not displayed */

TrivialAppBin is the compiled bytecode used for deploying new contracts.

View Source 
var TrivialAppBinRuntime = "" /* 564-byte string literal not displayed */

TrivialAppBinRuntime is the runtime part of the compiled bytecode used for deploying new contracts.

View Source 
var TrivialAppFuncSigs = map[string]string{
	"0d1feb4f": "validTransition((uint256,uint256,address[],address,bool,bool),(bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool),(bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool),uint256)",
}

TrivialAppFuncSigs maps the 4-byte function signature to its string representation.

Functions

This section is empty.

Types

type App 

type App struct {
	AppCaller     // Read-only binding to the contract
	AppTransactor // Write-only binding to the contract
	AppFilterer   // Log filterer for contract events
}

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

func NewApp 

func NewApp(address common.Address, backend bind.ContractBackend) (*App, error)

NewApp creates a new instance of App, bound to a specific deployed contract.

type AppCaller 

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

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

func NewAppCaller 

func NewAppCaller(address common.Address, caller bind.ContractCaller) (*AppCaller, error)

NewAppCaller creates a new read-only instance of App, bound to a specific deployed contract.

func (*AppCaller) ValidTransition 

func (_App *AppCaller) ValidTransition(opts *bind.CallOpts, params ChannelParams, from ChannelState, to ChannelState, actorIdx *big.Int) error

ValidTransition is a free data retrieval call binding the contract method 0x0d1feb4f.

Solidity: function validTransition((uint256,uint256,address[],address,bool,bool) params, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) from, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) to, uint256 actorIdx) pure returns()

type AppCallerRaw 

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

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

func (*AppCallerRaw) Call 

func (_App *AppCallerRaw) 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 AppCallerSession 

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

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

func (*AppCallerSession) ValidTransition 

func (_App *AppCallerSession) ValidTransition(params ChannelParams, from ChannelState, to ChannelState, actorIdx *big.Int) error

ValidTransition is a free data retrieval call binding the contract method 0x0d1feb4f.

Solidity: function validTransition((uint256,uint256,address[],address,bool,bool) params, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) from, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) to, uint256 actorIdx) pure returns()

type AppFilterer 

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

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

func NewAppFilterer 

func NewAppFilterer(address common.Address, filterer bind.ContractFilterer) (*AppFilterer, error)

NewAppFilterer creates a new log filterer instance of App, bound to a specific deployed contract.

type AppRaw 

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

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

func (*AppRaw) Call 

func (_App *AppRaw) 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 (*AppRaw) Transact 

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

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

func (*AppRaw) Transfer 

func (_App *AppRaw) 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 AppSession 

type AppSession struct {
	Contract     *App              // 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
}

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

func (*AppSession) ValidTransition 

func (_App *AppSession) ValidTransition(params ChannelParams, from ChannelState, to ChannelState, actorIdx *big.Int) error

ValidTransition is a free data retrieval call binding the contract method 0x0d1feb4f.

Solidity: function validTransition((uint256,uint256,address[],address,bool,bool) params, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) from, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) to, uint256 actorIdx) pure returns()

type AppTransactor 

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

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

func NewAppTransactor 

func NewAppTransactor(address common.Address, transactor bind.ContractTransactor) (*AppTransactor, error)

NewAppTransactor creates a new write-only instance of App, bound to a specific deployed contract.

type AppTransactorRaw 

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

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

func (*AppTransactorRaw) Transact 

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

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

func (*AppTransactorRaw) Transfer 

func (_App *AppTransactorRaw) 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 AppTransactorSession 

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

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

type Array added in v0.7.0 

type Array struct {
	ArrayCaller     // Read-only binding to the contract
	ArrayTransactor // Write-only binding to the contract
	ArrayFilterer   // Log filterer for contract events
}

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

func DeployArray added in v0.7.0 

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

DeployArray deploys a new Ethereum contract, binding an instance of Array to it.

func NewArray added in v0.7.0 

func NewArray(address common.Address, backend bind.ContractBackend) (*Array, error)

NewArray creates a new instance of Array, bound to a specific deployed contract.

type ArrayCaller added in v0.7.0 

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

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

func NewArrayCaller added in v0.7.0 

func NewArrayCaller(address common.Address, caller bind.ContractCaller) (*ArrayCaller, error)

NewArrayCaller creates a new read-only instance of Array, bound to a specific deployed contract.

type ArrayCallerRaw added in v0.7.0 

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

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

func (*ArrayCallerRaw) Call added in v0.7.0 

func (_Array *ArrayCallerRaw) 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 ArrayCallerSession added in v0.7.0 

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

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

type ArrayFilterer added in v0.7.0 

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

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

func NewArrayFilterer added in v0.7.0 

func NewArrayFilterer(address common.Address, filterer bind.ContractFilterer) (*ArrayFilterer, error)

NewArrayFilterer creates a new log filterer instance of Array, bound to a specific deployed contract.

type ArrayRaw added in v0.7.0 

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

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

func (*ArrayRaw) Call added in v0.7.0 

func (_Array *ArrayRaw) 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 (*ArrayRaw) Transact added in v0.7.0 

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

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

func (*ArrayRaw) Transfer added in v0.7.0 

func (_Array *ArrayRaw) 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 ArraySession added in v0.7.0 

type ArraySession struct {
	Contract     *Array            // 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
}

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

type ArrayTransactor added in v0.7.0 

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

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

func NewArrayTransactor added in v0.7.0 

func NewArrayTransactor(address common.Address, transactor bind.ContractTransactor) (*ArrayTransactor, error)

NewArrayTransactor creates a new write-only instance of Array, bound to a specific deployed contract.

type ArrayTransactorRaw added in v0.7.0 

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

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

func (*ArrayTransactorRaw) Transact added in v0.7.0 

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

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

func (*ArrayTransactorRaw) Transfer added in v0.7.0 

func (_Array *ArrayTransactorRaw) 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 ArrayTransactorSession added in v0.7.0 

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

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

type Channel 

type Channel struct {
	ChannelCaller     // Read-only binding to the contract
	ChannelTransactor // Write-only binding to the contract
	ChannelFilterer   // Log filterer for contract events
}

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

func DeployChannel 

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

DeployChannel deploys a new Ethereum contract, binding an instance of Channel to it.

func NewChannel 

func NewChannel(address common.Address, backend bind.ContractBackend) (*Channel, error)

NewChannel creates a new instance of Channel, bound to a specific deployed contract.

type ChannelAllocation 

type ChannelAllocation struct {
	Assets   []common.Address
	Balances [][]*big.Int
	Locked   []ChannelSubAlloc
}

ChannelAllocation is an auto generated low-level Go binding around an user-defined struct.

type ChannelCaller 

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

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

func NewChannelCaller 

func NewChannelCaller(address common.Address, caller bind.ContractCaller) (*ChannelCaller, error)

NewChannelCaller creates a new read-only instance of Channel, bound to a specific deployed contract.

type ChannelCallerRaw 

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

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

func (*ChannelCallerRaw) Call 

func (_Channel *ChannelCallerRaw) 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 ChannelCallerSession 

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

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

type ChannelFilterer 

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

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

func NewChannelFilterer 

func NewChannelFilterer(address common.Address, filterer bind.ContractFilterer) (*ChannelFilterer, error)

NewChannelFilterer creates a new log filterer instance of Channel, bound to a specific deployed contract.

type ChannelParams 

type ChannelParams struct {
	ChallengeDuration *big.Int
	Nonce             *big.Int
	Participants      []common.Address
	App               common.Address
	LedgerChannel     bool
	VirtualChannel    bool
}

ChannelParams is an auto generated low-level Go binding around an user-defined struct.

type ChannelRaw 

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

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

func (*ChannelRaw) Call 

func (_Channel *ChannelRaw) 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 (*ChannelRaw) Transact 

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

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

func (*ChannelRaw) Transfer 

func (_Channel *ChannelRaw) 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 ChannelSession 

type ChannelSession struct {
	Contract     *Channel          // 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
}

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

type ChannelState 

type ChannelState struct {
	ChannelID [32]byte
	Version   uint64
	Outcome   ChannelAllocation
	AppData   []byte
	IsFinal   bool
}

ChannelState is an auto generated low-level Go binding around an user-defined struct.

type ChannelSubAlloc 

type ChannelSubAlloc struct {
	ID       [32]byte
	Balances []*big.Int
	IndexMap []uint16
}

ChannelSubAlloc is an auto generated low-level Go binding around an user-defined struct.

type ChannelTransactor 

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

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

func NewChannelTransactor 

func NewChannelTransactor(address common.Address, transactor bind.ContractTransactor) (*ChannelTransactor, error)

NewChannelTransactor creates a new write-only instance of Channel, bound to a specific deployed contract.

type ChannelTransactorRaw 

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

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

func (*ChannelTransactorRaw) Transact 

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

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

func (*ChannelTransactorRaw) Transfer 

func (_Channel *ChannelTransactorRaw) 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 ChannelTransactorSession 

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

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

type ECDSA 

type ECDSA struct {
	ECDSACaller     // Read-only binding to the contract
	ECDSATransactor // Write-only binding to the contract
	ECDSAFilterer   // Log filterer for contract events
}

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

func DeployECDSA 

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

DeployECDSA deploys a new Ethereum contract, binding an instance of ECDSA to it.

func NewECDSA 

func NewECDSA(address common.Address, backend bind.ContractBackend) (*ECDSA, error)

NewECDSA creates a new instance of ECDSA, bound to a specific deployed contract.

type ECDSACaller 

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

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

func NewECDSACaller 

func NewECDSACaller(address common.Address, caller bind.ContractCaller) (*ECDSACaller, error)

NewECDSACaller creates a new read-only instance of ECDSA, bound to a specific deployed contract.

type ECDSACallerRaw 

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

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

func (*ECDSACallerRaw) Call 

func (_ECDSA *ECDSACallerRaw) 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 ECDSACallerSession 

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

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

type ECDSAFilterer 

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

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

func NewECDSAFilterer 

func NewECDSAFilterer(address common.Address, filterer bind.ContractFilterer) (*ECDSAFilterer, error)

NewECDSAFilterer creates a new log filterer instance of ECDSA, bound to a specific deployed contract.

type ECDSARaw 

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

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

func (*ECDSARaw) Call 

func (_ECDSA *ECDSARaw) 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 (*ECDSARaw) Transact 

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

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

func (*ECDSARaw) Transfer 

func (_ECDSA *ECDSARaw) 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 ECDSASession 

type ECDSASession struct {
	Contract     *ECDSA            // 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
}

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

type ECDSATransactor 

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

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

func NewECDSATransactor 

func NewECDSATransactor(address common.Address, transactor bind.ContractTransactor) (*ECDSATransactor, error)

NewECDSATransactor creates a new write-only instance of ECDSA, bound to a specific deployed contract.

type ECDSATransactorRaw 

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

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

func (*ECDSATransactorRaw) Transact 

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

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

func (*ECDSATransactorRaw) Transfer 

func (_ECDSA *ECDSATransactorRaw) 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 ECDSATransactorSession 

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

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

type SafeMath added in v0.7.0 

type SafeMath struct {
	SafeMathCaller     // Read-only binding to the contract
	SafeMathTransactor // Write-only binding to the contract
	SafeMathFilterer   // Log filterer for contract events
}

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

func DeploySafeMath added in v0.7.0 

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

DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it.

func NewSafeMath added in v0.7.0 

func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error)

NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract.

type SafeMathCaller added in v0.7.0 

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

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

func NewSafeMathCaller added in v0.7.0 

func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error)

NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract.

type SafeMathCallerRaw added in v0.7.0 

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

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

func (*SafeMathCallerRaw) Call added in v0.7.0 

func (_SafeMath *SafeMathCallerRaw) 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 SafeMathCallerSession added in v0.7.0 

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

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

type SafeMathFilterer added in v0.7.0 

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

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

func NewSafeMathFilterer added in v0.7.0 

func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error)

NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract.

type SafeMathRaw added in v0.7.0 

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

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

func (*SafeMathRaw) Call added in v0.7.0 

func (_SafeMath *SafeMathRaw) 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 (*SafeMathRaw) Transact added in v0.7.0 

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

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

func (*SafeMathRaw) Transfer added in v0.7.0 

func (_SafeMath *SafeMathRaw) 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 SafeMathSession added in v0.7.0 

type SafeMathSession struct {
	Contract     *SafeMath         // 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
}

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

type SafeMathTransactor added in v0.7.0 

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

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

func NewSafeMathTransactor added in v0.7.0 

func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error)

NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract.

type SafeMathTransactorRaw added in v0.7.0 

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

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

func (*SafeMathTransactorRaw) Transact added in v0.7.0 

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

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

func (*SafeMathTransactorRaw) Transfer added in v0.7.0 

func (_SafeMath *SafeMathTransactorRaw) 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 SafeMathTransactorSession added in v0.7.0 

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

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

type Sig 

type Sig struct {
	SigCaller     // Read-only binding to the contract
	SigTransactor // Write-only binding to the contract
	SigFilterer   // Log filterer for contract events
}

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

func DeploySig 

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

DeploySig deploys a new Ethereum contract, binding an instance of Sig to it.

func NewSig 

func NewSig(address common.Address, backend bind.ContractBackend) (*Sig, error)

NewSig creates a new instance of Sig, bound to a specific deployed contract.

type SigCaller 

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

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

func NewSigCaller 

func NewSigCaller(address common.Address, caller bind.ContractCaller) (*SigCaller, error)

NewSigCaller creates a new read-only instance of Sig, bound to a specific deployed contract.

type SigCallerRaw 

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

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

func (*SigCallerRaw) Call 

func (_Sig *SigCallerRaw) 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 SigCallerSession 

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

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

type SigFilterer 

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

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

func NewSigFilterer 

func NewSigFilterer(address common.Address, filterer bind.ContractFilterer) (*SigFilterer, error)

NewSigFilterer creates a new log filterer instance of Sig, bound to a specific deployed contract.

type SigRaw 

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

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

func (*SigRaw) Call 

func (_Sig *SigRaw) 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 (*SigRaw) Transact 

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

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

func (*SigRaw) Transfer 

func (_Sig *SigRaw) 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 SigSession 

type SigSession struct {
	Contract     *Sig              // 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
}

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

type SigTransactor 

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

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

func NewSigTransactor 

func NewSigTransactor(address common.Address, transactor bind.ContractTransactor) (*SigTransactor, error)

NewSigTransactor creates a new write-only instance of Sig, bound to a specific deployed contract.

type SigTransactorRaw 

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

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

func (*SigTransactorRaw) Transact 

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

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

func (*SigTransactorRaw) Transfer 

func (_Sig *SigTransactorRaw) 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 SigTransactorSession 

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

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

type TrivialApp 

type TrivialApp struct {
	TrivialAppCaller     // Read-only binding to the contract
	TrivialAppTransactor // Write-only binding to the contract
	TrivialAppFilterer   // Log filterer for contract events
}

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

func DeployTrivialApp 

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

DeployTrivialApp deploys a new Ethereum contract, binding an instance of TrivialApp to it.

func NewTrivialApp 

func NewTrivialApp(address common.Address, backend bind.ContractBackend) (*TrivialApp, error)

NewTrivialApp creates a new instance of TrivialApp, bound to a specific deployed contract.

type TrivialAppCaller 

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

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

func NewTrivialAppCaller 

func NewTrivialAppCaller(address common.Address, caller bind.ContractCaller) (*TrivialAppCaller, error)

NewTrivialAppCaller creates a new read-only instance of TrivialApp, bound to a specific deployed contract.

func (*TrivialAppCaller) ValidTransition 

func (_TrivialApp *TrivialAppCaller) ValidTransition(opts *bind.CallOpts, params ChannelParams, from ChannelState, to ChannelState, actorIdx *big.Int) error

ValidTransition is a free data retrieval call binding the contract method 0x0d1feb4f.

Solidity: function validTransition((uint256,uint256,address[],address,bool,bool) params, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) from, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) to, uint256 actorIdx) pure returns()

type TrivialAppCallerRaw 

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

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

func (*TrivialAppCallerRaw) Call 

func (_TrivialApp *TrivialAppCallerRaw) 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 TrivialAppCallerSession 

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

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

func (*TrivialAppCallerSession) ValidTransition 

func (_TrivialApp *TrivialAppCallerSession) ValidTransition(params ChannelParams, from ChannelState, to ChannelState, actorIdx *big.Int) error

ValidTransition is a free data retrieval call binding the contract method 0x0d1feb4f.

Solidity: function validTransition((uint256,uint256,address[],address,bool,bool) params, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) from, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) to, uint256 actorIdx) pure returns()

type TrivialAppFilterer 

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

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

func NewTrivialAppFilterer 

func NewTrivialAppFilterer(address common.Address, filterer bind.ContractFilterer) (*TrivialAppFilterer, error)

NewTrivialAppFilterer creates a new log filterer instance of TrivialApp, bound to a specific deployed contract.

type TrivialAppRaw 

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

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

func (*TrivialAppRaw) Call 

func (_TrivialApp *TrivialAppRaw) 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 (*TrivialAppRaw) Transact 

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

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

func (*TrivialAppRaw) Transfer 

func (_TrivialApp *TrivialAppRaw) 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 TrivialAppSession 

type TrivialAppSession struct {
	Contract     *TrivialApp       // 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
}

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

func (*TrivialAppSession) ValidTransition 

func (_TrivialApp *TrivialAppSession) ValidTransition(params ChannelParams, from ChannelState, to ChannelState, actorIdx *big.Int) error

ValidTransition is a free data retrieval call binding the contract method 0x0d1feb4f.

Solidity: function validTransition((uint256,uint256,address[],address,bool,bool) params, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) from, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) to, uint256 actorIdx) pure returns()

type TrivialAppTransactor 

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

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

func NewTrivialAppTransactor 

func NewTrivialAppTransactor(address common.Address, transactor bind.ContractTransactor) (*TrivialAppTransactor, error)

NewTrivialAppTransactor creates a new write-only instance of TrivialApp, bound to a specific deployed contract.

type TrivialAppTransactorRaw 

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

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

func (*TrivialAppTransactorRaw) Transact 

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

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

func (*TrivialAppTransactorRaw) Transfer 

func (_TrivialApp *TrivialAppTransactorRaw) 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 TrivialAppTransactorSession 

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

TrivialAppTransactorSession 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.