app

package
v0.0.0-...-6d19cb1 Latest Latest
Warning

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

 Go to latest Published: Jan 11, 2022 License: Apache-2.0 Imports: 17 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 (
	AssetIdx = 0
)
View Source 
const ChannelABI = "[]"

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

View Source 
const CredentialSwapABI = "" /* 2667-byte string literal not displayed */

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

View Source 
const DecodeABI = "[]"

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

Variables

View Source 
var (
	ErrInvalidInitData     = errors.New("invalid init data")
	ErrInvalidNextData     = errors.New("invalid next data")
	ErrExpectedOffer       = errors.New("expected offer")
	ErrUnequalAllocation   = errors.New("unequal allocation")
	ErrInsufficientBalance = errors.New("insufficient balance")
	ErrInvalidSigner       = errors.New("invalid signer")
)
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 CredentialSwapBin = "" /* 8536-byte string literal not displayed */

CredentialSwapBin is the compiled bytecode used for deploying new contracts.

View Source 
var CredentialSwapFuncSigs = 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)",
}

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

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

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

Functions

func SignHash 

func SignHash(acc *simple.Account, h [data.HashLen]byte) ([data.SigLen]byte, error)

func VerifySig 

func VerifySig(sig [data.SigLen]byte, h [data.HashLen]byte, addr common.Address) error

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 

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 

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 

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 

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

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

func NewArrayCaller 

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 

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 

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 

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 

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

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

func NewArrayFilterer 

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 

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 

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 

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 

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 

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 

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

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

func NewArrayTransactor 

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 

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 

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 

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 

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 Credential 

type Credential struct {
	Document  []byte
	Signature []byte
}

func (*Credential) String 

func (c *Credential) String() string

type CredentialSwap 

type CredentialSwap struct {
	CredentialSwapCaller     // Read-only binding to the contract
	CredentialSwapTransactor // Write-only binding to the contract
	CredentialSwapFilterer   // Log filterer for contract events
}

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

func DeployCredentialSwap 

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

DeployCredentialSwap deploys a new Ethereum contract, binding an instance of CredentialSwap to it.

func NewCredentialSwap 

func NewCredentialSwap(address common.Address, backend bind.ContractBackend) (*CredentialSwap, error)

NewCredentialSwap creates a new instance of CredentialSwap, bound to a specific deployed contract.

type CredentialSwapApp 

type CredentialSwapApp struct {
	Addr wallet.Address
}

CredentialSwapApp is a channel app for atomically trading a credential against a payment.

func NewCredentialSwapApp 

func NewCredentialSwapApp(addr wallet.Address) *CredentialSwapApp

func (*CredentialSwapApp) DecodeData 

func (a *CredentialSwapApp) DecodeData(r io.Reader) (channel.Data, error)

DecodeData decodes the channel data.

func (*CredentialSwapApp) Def 

func (a *CredentialSwapApp) Def() wallet.Address

Def returns the app address.

func (*CredentialSwapApp) InitData 

func (a *CredentialSwapApp) InitData() channel.Data

func (*CredentialSwapApp) ValidInit 

func (a *CredentialSwapApp) ValidInit(p *channel.Params, s *channel.State) error

ValidInit checks that the initial state is valid.

func (*CredentialSwapApp) ValidTransition 

func (a *CredentialSwapApp) ValidTransition(params *channel.Params, cur, next *channel.State, actorIdx channel.Index) error

ValidTransition is called whenever the channel state transitions.

type CredentialSwapCaller 

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

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

func NewCredentialSwapCaller 

func NewCredentialSwapCaller(address common.Address, caller bind.ContractCaller) (*CredentialSwapCaller, error)

NewCredentialSwapCaller creates a new read-only instance of CredentialSwap, bound to a specific deployed contract.

func (*CredentialSwapCaller) ValidTransition 

func (_CredentialSwap *CredentialSwapCaller) ValidTransition(opts *bind.CallOpts, arg0 ChannelParams, cur ChannelState, next ChannelState, actor *big.Int) error

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

Solidity: function validTransition((uint256,uint256,address[],address,bool,bool) , (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) cur, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) next, uint256 actor) pure returns()

type CredentialSwapCallerRaw 

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

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

func (*CredentialSwapCallerRaw) Call 

func (_CredentialSwap *CredentialSwapCallerRaw) 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 CredentialSwapCallerSession 

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

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

func (*CredentialSwapCallerSession) ValidTransition 

func (_CredentialSwap *CredentialSwapCallerSession) ValidTransition(arg0 ChannelParams, cur ChannelState, next ChannelState, actor *big.Int) error

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

Solidity: function validTransition((uint256,uint256,address[],address,bool,bool) , (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) cur, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) next, uint256 actor) pure returns()

type CredentialSwapFilterer 

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

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

func NewCredentialSwapFilterer 

func NewCredentialSwapFilterer(address common.Address, filterer bind.ContractFilterer) (*CredentialSwapFilterer, error)

NewCredentialSwapFilterer creates a new log filterer instance of CredentialSwap, bound to a specific deployed contract.

type CredentialSwapRaw 

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

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

func (*CredentialSwapRaw) Call 

func (_CredentialSwap *CredentialSwapRaw) 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 (*CredentialSwapRaw) Transact 

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

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

func (*CredentialSwapRaw) Transfer 

func (_CredentialSwap *CredentialSwapRaw) 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 CredentialSwapSession 

type CredentialSwapSession struct {
	Contract     *CredentialSwap   // 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
}

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

func (*CredentialSwapSession) ValidTransition 

func (_CredentialSwap *CredentialSwapSession) ValidTransition(arg0 ChannelParams, cur ChannelState, next ChannelState, actor *big.Int) error

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

Solidity: function validTransition((uint256,uint256,address[],address,bool,bool) , (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) cur, (bytes32,uint64,(address[],uint256[][],(bytes32,uint256[],uint16[])[]),bytes,bool) next, uint256 actor) pure returns()

type CredentialSwapTransactor 

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

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

func NewCredentialSwapTransactor 

func NewCredentialSwapTransactor(address common.Address, transactor bind.ContractTransactor) (*CredentialSwapTransactor, error)

NewCredentialSwapTransactor creates a new write-only instance of CredentialSwap, bound to a specific deployed contract.

type CredentialSwapTransactorRaw 

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

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

func (*CredentialSwapTransactorRaw) Transact 

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

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

func (*CredentialSwapTransactorRaw) Transfer 

func (_CredentialSwap *CredentialSwapTransactorRaw) 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 CredentialSwapTransactorSession 

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

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

type Decode 

type Decode struct {
	DecodeCaller     // Read-only binding to the contract
	DecodeTransactor // Write-only binding to the contract
	DecodeFilterer   // Log filterer for contract events
}

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

func DeployDecode 

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

DeployDecode deploys a new Ethereum contract, binding an instance of Decode to it.

func NewDecode 

func NewDecode(address common.Address, backend bind.ContractBackend) (*Decode, error)

NewDecode creates a new instance of Decode, bound to a specific deployed contract.

type DecodeCaller 

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

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

func NewDecodeCaller 

func NewDecodeCaller(address common.Address, caller bind.ContractCaller) (*DecodeCaller, error)

NewDecodeCaller creates a new read-only instance of Decode, bound to a specific deployed contract.

type DecodeCallerRaw 

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

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

func (*DecodeCallerRaw) Call 

func (_Decode *DecodeCallerRaw) 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 DecodeCallerSession 

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

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

type DecodeFilterer 

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

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

func NewDecodeFilterer 

func NewDecodeFilterer(address common.Address, filterer bind.ContractFilterer) (*DecodeFilterer, error)

NewDecodeFilterer creates a new log filterer instance of Decode, bound to a specific deployed contract.

type DecodeRaw 

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

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

func (*DecodeRaw) Call 

func (_Decode *DecodeRaw) 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 (*DecodeRaw) Transact 

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

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

func (*DecodeRaw) Transfer 

func (_Decode *DecodeRaw) 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 DecodeSession 

type DecodeSession struct {
	Contract     *Decode           // 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
}

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

type DecodeTransactor 

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

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

func NewDecodeTransactor 

func NewDecodeTransactor(address common.Address, transactor bind.ContractTransactor) (*DecodeTransactor, error)

NewDecodeTransactor creates a new write-only instance of Decode, bound to a specific deployed contract.

type DecodeTransactorRaw 

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

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

func (*DecodeTransactorRaw) Transact 

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

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

func (*DecodeTransactorRaw) Transfer 

func (_Decode *DecodeTransactorRaw) 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 DecodeTransactorSession 

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

DecodeTransactorSession 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 Hash 

type Hash = [data.HashLen]byte

func ComputeDocumentHash 

func ComputeDocumentHash(doc []byte) Hash

type SafeMath 

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 

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 

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 

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

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

func NewSafeMathCaller 

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 

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 

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 

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 

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

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

func NewSafeMathFilterer 

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 

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 

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 

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 

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 

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 

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

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

func NewSafeMathTransactor 

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 

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 

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 

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 

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 Signature 

type Signature = []byte

Source Files

View all Source files

Directories

Path Synopsis

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.