arbostestcontracts

package
v0.8.0 Latest Latest
Warning

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

 Go to latest Published: Mar 30, 2021 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const CloneFactoryABI = "" /* 490-byte string literal not displayed */

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

View Source 
const FailedERC20ABI = "" /* 256-byte string literal not displayed */

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

View Source 
const FailedERC721ABI = "" /* 257-byte string literal not displayed */

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

View Source 
const FailedSendABI = "" /* 447-byte string literal not displayed */

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

View Source 
const FibonacciABI = "" /* 577-byte string literal not displayed */

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

View Source 
const GasUsedABI = "" /* 288-byte string literal not displayed */

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

View Source 
const IFailedSendABI = "" /* 192-byte string literal not displayed */

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

View Source 
const OpCodesABI = "" /* 1032-byte string literal not displayed */

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

View Source 
const Receiver2ABI = "" /* 271-byte string literal not displayed */

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

View Source 
const ReceiverABI = "" /* 600-byte string literal not displayed */

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

View Source 
const SimpleABI = "" /* 747-byte string literal not displayed */

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

View Source 
const StorageABI = "" /* 258-byte string literal not displayed */

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

View Source 
const Sys2ABI = "" /* 317-byte string literal not displayed */

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

View Source 
const SysABI = "" /* 180-byte string literal not displayed */

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

View Source 
const TransferABI = "" /* 421-byte string literal not displayed */

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

Variables

View Source 
var CloneFactoryBin = "" /* 712-byte string literal not displayed */

CloneFactoryBin is the compiled bytecode used for deploying new contracts.

View Source 
var CloneFactoryFuncSigs = map[string]string{
	"c91091c3": "create2Clone(address,uint256)",
}

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

View Source 
var FailedERC20Bin = "" /* 476-byte string literal not displayed */

FailedERC20Bin is the compiled bytecode used for deploying new contracts.

View Source 
var FailedERC20FuncSigs = map[string]string{
	"e58306f9": "adminMint(address,uint256)",
}

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

View Source 
var FailedERC721Bin = "" /* 476-byte string literal not displayed */

FailedERC721Bin is the compiled bytecode used for deploying new contracts.

View Source 
var FailedERC721FuncSigs = map[string]string{
	"e58306f9": "adminMint(address,uint256)",
}

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

View Source 
var FailedSendBin = "" /* 976-byte string literal not displayed */

FailedSendBin is the compiled bytecode used for deploying new contracts.

View Source 
var FailedSendFuncSigs = map[string]string{
	"3e58c58c": "send(address)",
	"68742da6": "withdrawFunds(address)",
}

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

View Source 
var FibonacciBin = "" /* 946-byte string literal not displayed */

FibonacciBin is the compiled bytecode used for deploying new contracts.

View Source 
var FibonacciFuncSigs = map[string]string{
	"2ddec39b": "generateFib(uint256)",
	"90a3e3de": "getFib(uint256)",
}

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

View Source 
var GasUsedBin = "" /* 308-byte string literal not displayed */

GasUsedBin is the compiled bytecode used for deploying new contracts.

View Source 
var GasUsedFuncSigs = map[string]string{
	"5dfc2e4a": "noop()",
	"703c2d1a": "sstore()",
}

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

View Source 
var IFailedSendFuncSigs = map[string]string{
	"68742da6": "withdrawFunds(address)",
}

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

View Source 
var OpCodesBin = "" /* 1028-byte string literal not displayed */

OpCodesBin is the compiled bytecode used for deploying new contracts.

View Source 
var OpCodesFuncSigs = map[string]string{
	"9663f88f": "getBlockHash()",
	"03dd3df4": "getNestedOrigin(address)",
	"84e58c86": "getNestedSend(address)",
	"df1f29ee": "getOrigin()",
	"5e01eb5a": "getSender()",
}

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

View Source 
var Receiver2Bin = "" /* 380-byte string literal not displayed */

Receiver2Bin is the compiled bytecode used for deploying new contracts.

View Source 
var Receiver2FuncSigs = map[string]string{
	"7795b5fc": "mutate()",
	"f8a8fd6d": "test()",
}

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

View Source 
var ReceiverBin = "" /* 864-byte string literal not displayed */

ReceiverBin is the compiled bytecode used for deploying new contracts.

View Source 
var ReceiverFuncSigs = map[string]string{
	"7795b5fc": "mutate()",
	"85295877": "other()",
	"f8a8fd6d": "test()",
}

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

View Source 
var SimpleBin = "" /* 1022-byte string literal not displayed */

SimpleBin is the compiled bytecode used for deploying new contracts.

View Source 
var SimpleFuncSigs = map[string]string{
	"ae0aba8c": "acceptPayment()",
	"267c4ae4": "exists()",
	"9b7c9da3": "nestedCall(uint256)",
	"9436bc1f": "rejectPayment()",
	"3bccbbc9": "reverts()",
}

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

View Source 
var StorageBin = "" /* 560-byte string literal not displayed */

StorageBin is the compiled bytecode used for deploying new contracts.

View Source 
var StorageFuncSigs = map[string]string{
	"188f9139": "failGetStorage()",
}

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

View Source 
var Sys2FuncSigs = map[string]string{
	"a169625f": "getStorageAt(address,uint256)",
}

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

View Source 
var SysFuncSigs = map[string]string{
	"25e16063": "withdrawEth(address)",
}

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

View Source 
var TransferBin = "" /* 640-byte string literal not displayed */

TransferBin is the compiled bytecode used for deploying new contracts.

View Source 
var TransferFuncSigs = map[string]string{
	"b46300ec": "send()",
	"3386b1a2": "send2(address)",
}

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

Functions

This section is empty.

Types

type CloneFactory 

type CloneFactory struct {
	CloneFactoryCaller     // Read-only binding to the contract
	CloneFactoryTransactor // Write-only binding to the contract
	CloneFactoryFilterer   // Log filterer for contract events
}

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

func DeployCloneFactory 

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

DeployCloneFactory deploys a new Ethereum contract, binding an instance of CloneFactory to it.

func NewCloneFactory 

func NewCloneFactory(address common.Address, backend bind.ContractBackend) (*CloneFactory, error)

NewCloneFactory creates a new instance of CloneFactory, bound to a specific deployed contract.

type CloneFactoryCaller 

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

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

func NewCloneFactoryCaller 

func NewCloneFactoryCaller(address common.Address, caller bind.ContractCaller) (*CloneFactoryCaller, error)

NewCloneFactoryCaller creates a new read-only instance of CloneFactory, bound to a specific deployed contract.

type CloneFactoryCallerRaw 

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

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

func (*CloneFactoryCallerRaw) Call 

func (_CloneFactory *CloneFactoryCallerRaw) 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 CloneFactoryCallerSession 

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

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

type CloneFactoryCreatedClone 

type CloneFactoryCreatedClone struct {
	Clone common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

CloneFactoryCreatedClone represents a CreatedClone event raised by the CloneFactory contract.

type CloneFactoryCreatedCloneIterator 

type CloneFactoryCreatedCloneIterator struct {
	Event *CloneFactoryCreatedClone // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

CloneFactoryCreatedCloneIterator is returned from FilterCreatedClone and is used to iterate over the raw logs and unpacked data for CreatedClone events raised by the CloneFactory contract.

func (*CloneFactoryCreatedCloneIterator) Close 

func (it *CloneFactoryCreatedCloneIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*CloneFactoryCreatedCloneIterator) Error 

func (it *CloneFactoryCreatedCloneIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*CloneFactoryCreatedCloneIterator) Next 

func (it *CloneFactoryCreatedCloneIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type CloneFactoryFilterer 

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

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

func NewCloneFactoryFilterer 

func NewCloneFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*CloneFactoryFilterer, error)

NewCloneFactoryFilterer creates a new log filterer instance of CloneFactory, bound to a specific deployed contract.

func (*CloneFactoryFilterer) FilterCreatedClone 

func (_CloneFactory *CloneFactoryFilterer) FilterCreatedClone(opts *bind.FilterOpts) (*CloneFactoryCreatedCloneIterator, error)

FilterCreatedClone is a free log retrieval operation binding the contract event 0x8bbdbba0e10077e3bdd81d5076242c5eca7c410250c1bf0ff4a0d8e40a6a8b31.

Solidity: event CreatedClone(address clone)

func (*CloneFactoryFilterer) ParseCreatedClone 

func (_CloneFactory *CloneFactoryFilterer) ParseCreatedClone(log types.Log) (*CloneFactoryCreatedClone, error)

ParseCreatedClone is a log parse operation binding the contract event 0x8bbdbba0e10077e3bdd81d5076242c5eca7c410250c1bf0ff4a0d8e40a6a8b31.

Solidity: event CreatedClone(address clone)

func (*CloneFactoryFilterer) WatchCreatedClone 

func (_CloneFactory *CloneFactoryFilterer) WatchCreatedClone(opts *bind.WatchOpts, sink chan<- *CloneFactoryCreatedClone) (event.Subscription, error)

WatchCreatedClone is a free log subscription operation binding the contract event 0x8bbdbba0e10077e3bdd81d5076242c5eca7c410250c1bf0ff4a0d8e40a6a8b31.

Solidity: event CreatedClone(address clone)

type CloneFactoryRaw 

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

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

func (*CloneFactoryRaw) Call 

func (_CloneFactory *CloneFactoryRaw) 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 (*CloneFactoryRaw) Transact 

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

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

func (*CloneFactoryRaw) Transfer 

func (_CloneFactory *CloneFactoryRaw) 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 CloneFactorySession 

type CloneFactorySession struct {
	Contract     *CloneFactory     // 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
}

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

func (*CloneFactorySession) Create2Clone 

func (_CloneFactory *CloneFactorySession) Create2Clone(target common.Address, salt *big.Int) (*types.Transaction, error)

Create2Clone is a paid mutator transaction binding the contract method 0xc91091c3.

Solidity: function create2Clone(address target, uint256 salt) returns(address)

type CloneFactoryTransactor 

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

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

func NewCloneFactoryTransactor 

func NewCloneFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*CloneFactoryTransactor, error)

NewCloneFactoryTransactor creates a new write-only instance of CloneFactory, bound to a specific deployed contract.

func (*CloneFactoryTransactor) Create2Clone 

func (_CloneFactory *CloneFactoryTransactor) Create2Clone(opts *bind.TransactOpts, target common.Address, salt *big.Int) (*types.Transaction, error)

Create2Clone is a paid mutator transaction binding the contract method 0xc91091c3.

Solidity: function create2Clone(address target, uint256 salt) returns(address)

type CloneFactoryTransactorRaw 

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

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

func (*CloneFactoryTransactorRaw) Transact 

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

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

func (*CloneFactoryTransactorRaw) Transfer 

func (_CloneFactory *CloneFactoryTransactorRaw) 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 CloneFactoryTransactorSession 

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

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

func (*CloneFactoryTransactorSession) Create2Clone 

func (_CloneFactory *CloneFactoryTransactorSession) Create2Clone(target common.Address, salt *big.Int) (*types.Transaction, error)

Create2Clone is a paid mutator transaction binding the contract method 0xc91091c3.

Solidity: function create2Clone(address target, uint256 salt) returns(address)

type FailedERC20 

type FailedERC20 struct {
	FailedERC20Caller     // Read-only binding to the contract
	FailedERC20Transactor // Write-only binding to the contract
	FailedERC20Filterer   // Log filterer for contract events
}

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

func DeployFailedERC20 

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

DeployFailedERC20 deploys a new Ethereum contract, binding an instance of FailedERC20 to it.

func NewFailedERC20 

func NewFailedERC20(address common.Address, backend bind.ContractBackend) (*FailedERC20, error)

NewFailedERC20 creates a new instance of FailedERC20, bound to a specific deployed contract.

type FailedERC20Caller 

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

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

func NewFailedERC20Caller 

func NewFailedERC20Caller(address common.Address, caller bind.ContractCaller) (*FailedERC20Caller, error)

NewFailedERC20Caller creates a new read-only instance of FailedERC20, bound to a specific deployed contract.

type FailedERC20CallerRaw 

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

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

func (*FailedERC20CallerRaw) Call 

func (_FailedERC20 *FailedERC20CallerRaw) 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 FailedERC20CallerSession 

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

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

type FailedERC20Filterer 

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

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

func NewFailedERC20Filterer 

func NewFailedERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*FailedERC20Filterer, error)

NewFailedERC20Filterer creates a new log filterer instance of FailedERC20, bound to a specific deployed contract.

type FailedERC20Raw 

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

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

func (*FailedERC20Raw) Call 

func (_FailedERC20 *FailedERC20Raw) 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 (*FailedERC20Raw) Transact 

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

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

func (*FailedERC20Raw) Transfer 

func (_FailedERC20 *FailedERC20Raw) 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 FailedERC20Session 

type FailedERC20Session struct {
	Contract     *FailedERC20      // 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
}

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

func (*FailedERC20Session) AdminMint 

func (_FailedERC20 *FailedERC20Session) AdminMint(account common.Address, amount *big.Int) (*types.Transaction, error)

AdminMint is a paid mutator transaction binding the contract method 0xe58306f9.

Solidity: function adminMint(address account, uint256 amount) returns()

type FailedERC20Transactor 

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

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

func NewFailedERC20Transactor 

func NewFailedERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*FailedERC20Transactor, error)

NewFailedERC20Transactor creates a new write-only instance of FailedERC20, bound to a specific deployed contract.

func (*FailedERC20Transactor) AdminMint 

func (_FailedERC20 *FailedERC20Transactor) AdminMint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error)

AdminMint is a paid mutator transaction binding the contract method 0xe58306f9.

Solidity: function adminMint(address account, uint256 amount) returns()

type FailedERC20TransactorRaw 

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

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

func (*FailedERC20TransactorRaw) Transact 

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

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

func (*FailedERC20TransactorRaw) Transfer 

func (_FailedERC20 *FailedERC20TransactorRaw) 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 FailedERC20TransactorSession 

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

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

func (*FailedERC20TransactorSession) AdminMint 

func (_FailedERC20 *FailedERC20TransactorSession) AdminMint(account common.Address, amount *big.Int) (*types.Transaction, error)

AdminMint is a paid mutator transaction binding the contract method 0xe58306f9.

Solidity: function adminMint(address account, uint256 amount) returns()

type FailedERC721 

type FailedERC721 struct {
	FailedERC721Caller     // Read-only binding to the contract
	FailedERC721Transactor // Write-only binding to the contract
	FailedERC721Filterer   // Log filterer for contract events
}

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

func DeployFailedERC721 

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

DeployFailedERC721 deploys a new Ethereum contract, binding an instance of FailedERC721 to it.

func NewFailedERC721 

func NewFailedERC721(address common.Address, backend bind.ContractBackend) (*FailedERC721, error)

NewFailedERC721 creates a new instance of FailedERC721, bound to a specific deployed contract.

type FailedERC721Caller 

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

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

func NewFailedERC721Caller 

func NewFailedERC721Caller(address common.Address, caller bind.ContractCaller) (*FailedERC721Caller, error)

NewFailedERC721Caller creates a new read-only instance of FailedERC721, bound to a specific deployed contract.

type FailedERC721CallerRaw 

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

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

func (*FailedERC721CallerRaw) Call 

func (_FailedERC721 *FailedERC721CallerRaw) 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 FailedERC721CallerSession 

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

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

type FailedERC721Filterer 

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

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

func NewFailedERC721Filterer 

func NewFailedERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*FailedERC721Filterer, error)

NewFailedERC721Filterer creates a new log filterer instance of FailedERC721, bound to a specific deployed contract.

type FailedERC721Raw 

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

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

func (*FailedERC721Raw) Call 

func (_FailedERC721 *FailedERC721Raw) 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 (*FailedERC721Raw) Transact 

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

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

func (*FailedERC721Raw) Transfer 

func (_FailedERC721 *FailedERC721Raw) 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 FailedERC721Session 

type FailedERC721Session struct {
	Contract     *FailedERC721     // 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
}

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

func (*FailedERC721Session) AdminMint 

func (_FailedERC721 *FailedERC721Session) AdminMint(account common.Address, tokenId *big.Int) (*types.Transaction, error)

AdminMint is a paid mutator transaction binding the contract method 0xe58306f9.

Solidity: function adminMint(address account, uint256 tokenId) returns()

type FailedERC721Transactor 

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

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

func NewFailedERC721Transactor 

func NewFailedERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*FailedERC721Transactor, error)

NewFailedERC721Transactor creates a new write-only instance of FailedERC721, bound to a specific deployed contract.

func (*FailedERC721Transactor) AdminMint 

func (_FailedERC721 *FailedERC721Transactor) AdminMint(opts *bind.TransactOpts, account common.Address, tokenId *big.Int) (*types.Transaction, error)

AdminMint is a paid mutator transaction binding the contract method 0xe58306f9.

Solidity: function adminMint(address account, uint256 tokenId) returns()

type FailedERC721TransactorRaw 

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

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

func (*FailedERC721TransactorRaw) Transact 

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

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

func (*FailedERC721TransactorRaw) Transfer 

func (_FailedERC721 *FailedERC721TransactorRaw) 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 FailedERC721TransactorSession 

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

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

func (*FailedERC721TransactorSession) AdminMint 

func (_FailedERC721 *FailedERC721TransactorSession) AdminMint(account common.Address, tokenId *big.Int) (*types.Transaction, error)

AdminMint is a paid mutator transaction binding the contract method 0xe58306f9.

Solidity: function adminMint(address account, uint256 tokenId) returns()

type FailedSend 

type FailedSend struct {
	FailedSendCaller     // Read-only binding to the contract
	FailedSendTransactor // Write-only binding to the contract
	FailedSendFilterer   // Log filterer for contract events
}

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

func DeployFailedSend 

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

DeployFailedSend deploys a new Ethereum contract, binding an instance of FailedSend to it.

func NewFailedSend 

func NewFailedSend(address common.Address, backend bind.ContractBackend) (*FailedSend, error)

NewFailedSend creates a new instance of FailedSend, bound to a specific deployed contract.

type FailedSendCaller 

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

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

func NewFailedSendCaller 

func NewFailedSendCaller(address common.Address, caller bind.ContractCaller) (*FailedSendCaller, error)

NewFailedSendCaller creates a new read-only instance of FailedSend, bound to a specific deployed contract.

type FailedSendCallerRaw 

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

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

func (*FailedSendCallerRaw) Call 

func (_FailedSend *FailedSendCallerRaw) 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 FailedSendCallerSession 

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

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

type FailedSendFilterer 

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

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

func NewFailedSendFilterer 

func NewFailedSendFilterer(address common.Address, filterer bind.ContractFilterer) (*FailedSendFilterer, error)

NewFailedSendFilterer creates a new log filterer instance of FailedSend, bound to a specific deployed contract.

type FailedSendRaw 

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

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

func (*FailedSendRaw) Call 

func (_FailedSend *FailedSendRaw) 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 (*FailedSendRaw) Transact 

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

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

func (*FailedSendRaw) Transfer 

func (_FailedSend *FailedSendRaw) 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 FailedSendSession 

type FailedSendSession struct {
	Contract     *FailedSend       // 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
}

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

func (*FailedSendSession) Send 

func (_FailedSend *FailedSendSession) Send(dest common.Address) (*types.Transaction, error)

Send is a paid mutator transaction binding the contract method 0x3e58c58c.

Solidity: function send(address dest) payable returns()

func (*FailedSendSession) WithdrawFunds 

func (_FailedSend *FailedSendSession) WithdrawFunds(dest common.Address) (*types.Transaction, error)

WithdrawFunds is a paid mutator transaction binding the contract method 0x68742da6.

Solidity: function withdrawFunds(address dest) returns()

type FailedSendTransactor 

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

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

func NewFailedSendTransactor 

func NewFailedSendTransactor(address common.Address, transactor bind.ContractTransactor) (*FailedSendTransactor, error)

NewFailedSendTransactor creates a new write-only instance of FailedSend, bound to a specific deployed contract.

func (*FailedSendTransactor) Send 

func (_FailedSend *FailedSendTransactor) Send(opts *bind.TransactOpts, dest common.Address) (*types.Transaction, error)

Send is a paid mutator transaction binding the contract method 0x3e58c58c.

Solidity: function send(address dest) payable returns()

func (*FailedSendTransactor) WithdrawFunds 

func (_FailedSend *FailedSendTransactor) WithdrawFunds(opts *bind.TransactOpts, dest common.Address) (*types.Transaction, error)

WithdrawFunds is a paid mutator transaction binding the contract method 0x68742da6.

Solidity: function withdrawFunds(address dest) returns()

type FailedSendTransactorRaw 

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

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

func (*FailedSendTransactorRaw) Transact 

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

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

func (*FailedSendTransactorRaw) Transfer 

func (_FailedSend *FailedSendTransactorRaw) 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 FailedSendTransactorSession 

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

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

func (*FailedSendTransactorSession) Send 

func (_FailedSend *FailedSendTransactorSession) Send(dest common.Address) (*types.Transaction, error)

Send is a paid mutator transaction binding the contract method 0x3e58c58c.

Solidity: function send(address dest) payable returns()

func (*FailedSendTransactorSession) WithdrawFunds 

func (_FailedSend *FailedSendTransactorSession) WithdrawFunds(dest common.Address) (*types.Transaction, error)

WithdrawFunds is a paid mutator transaction binding the contract method 0x68742da6.

Solidity: function withdrawFunds(address dest) returns()

type Fibonacci 

type Fibonacci struct {
	FibonacciCaller     // Read-only binding to the contract
	FibonacciTransactor // Write-only binding to the contract
	FibonacciFilterer   // Log filterer for contract events
}

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

func DeployFibonacci 

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

DeployFibonacci deploys a new Ethereum contract, binding an instance of Fibonacci to it.

func NewFibonacci 

func NewFibonacci(address common.Address, backend bind.ContractBackend) (*Fibonacci, error)

NewFibonacci creates a new instance of Fibonacci, bound to a specific deployed contract.

type FibonacciCaller 

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

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

func NewFibonacciCaller 

func NewFibonacciCaller(address common.Address, caller bind.ContractCaller) (*FibonacciCaller, error)

NewFibonacciCaller creates a new read-only instance of Fibonacci, bound to a specific deployed contract.

func (*FibonacciCaller) GetFib 

func (_Fibonacci *FibonacciCaller) GetFib(opts *bind.CallOpts, n *big.Int) (*big.Int, error)

GetFib is a free data retrieval call binding the contract method 0x90a3e3de.

Solidity: function getFib(uint256 n) view returns(uint256)

type FibonacciCallerRaw 

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

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

func (*FibonacciCallerRaw) Call 

func (_Fibonacci *FibonacciCallerRaw) 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 FibonacciCallerSession 

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

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

func (*FibonacciCallerSession) GetFib 

func (_Fibonacci *FibonacciCallerSession) GetFib(n *big.Int) (*big.Int, error)

GetFib is a free data retrieval call binding the contract method 0x90a3e3de.

Solidity: function getFib(uint256 n) view returns(uint256)

type FibonacciFilterer 

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

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

func NewFibonacciFilterer 

func NewFibonacciFilterer(address common.Address, filterer bind.ContractFilterer) (*FibonacciFilterer, error)

NewFibonacciFilterer creates a new log filterer instance of Fibonacci, bound to a specific deployed contract.

func (*FibonacciFilterer) FilterTestEvent 

func (_Fibonacci *FibonacciFilterer) FilterTestEvent(opts *bind.FilterOpts) (*FibonacciTestEventIterator, error)

FilterTestEvent is a free log retrieval operation binding the contract event 0x1440c4dd67b4344ea1905ec0318995133b550f168b4ee959a0da6b503d7d2414.

Solidity: event TestEvent(uint256 number)

func (*FibonacciFilterer) ParseTestEvent 

func (_Fibonacci *FibonacciFilterer) ParseTestEvent(log types.Log) (*FibonacciTestEvent, error)

ParseTestEvent is a log parse operation binding the contract event 0x1440c4dd67b4344ea1905ec0318995133b550f168b4ee959a0da6b503d7d2414.

Solidity: event TestEvent(uint256 number)

func (*FibonacciFilterer) WatchTestEvent 

func (_Fibonacci *FibonacciFilterer) WatchTestEvent(opts *bind.WatchOpts, sink chan<- *FibonacciTestEvent) (event.Subscription, error)

WatchTestEvent is a free log subscription operation binding the contract event 0x1440c4dd67b4344ea1905ec0318995133b550f168b4ee959a0da6b503d7d2414.

Solidity: event TestEvent(uint256 number)

type FibonacciRaw 

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

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

func (*FibonacciRaw) Call 

func (_Fibonacci *FibonacciRaw) 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 (*FibonacciRaw) Transact 

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

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

func (*FibonacciRaw) Transfer 

func (_Fibonacci *FibonacciRaw) 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 FibonacciSession 

type FibonacciSession struct {
	Contract     *Fibonacci        // 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
}

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

func (*FibonacciSession) GenerateFib 

func (_Fibonacci *FibonacciSession) GenerateFib(n *big.Int) (*types.Transaction, error)

GenerateFib is a paid mutator transaction binding the contract method 0x2ddec39b.

Solidity: function generateFib(uint256 n) payable returns()

func (*FibonacciSession) GetFib 

func (_Fibonacci *FibonacciSession) GetFib(n *big.Int) (*big.Int, error)

GetFib is a free data retrieval call binding the contract method 0x90a3e3de.

Solidity: function getFib(uint256 n) view returns(uint256)

type FibonacciTestEvent 

type FibonacciTestEvent struct {
	Number *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

FibonacciTestEvent represents a TestEvent event raised by the Fibonacci contract.

type FibonacciTestEventIterator 

type FibonacciTestEventIterator struct {
	Event *FibonacciTestEvent // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

FibonacciTestEventIterator is returned from FilterTestEvent and is used to iterate over the raw logs and unpacked data for TestEvent events raised by the Fibonacci contract.

func (*FibonacciTestEventIterator) Close 

func (it *FibonacciTestEventIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*FibonacciTestEventIterator) Error 

func (it *FibonacciTestEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*FibonacciTestEventIterator) Next 

func (it *FibonacciTestEventIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type FibonacciTransactor 

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

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

func NewFibonacciTransactor 

func NewFibonacciTransactor(address common.Address, transactor bind.ContractTransactor) (*FibonacciTransactor, error)

NewFibonacciTransactor creates a new write-only instance of Fibonacci, bound to a specific deployed contract.

func (*FibonacciTransactor) GenerateFib 

func (_Fibonacci *FibonacciTransactor) GenerateFib(opts *bind.TransactOpts, n *big.Int) (*types.Transaction, error)

GenerateFib is a paid mutator transaction binding the contract method 0x2ddec39b.

Solidity: function generateFib(uint256 n) payable returns()

type FibonacciTransactorRaw 

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

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

func (*FibonacciTransactorRaw) Transact 

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

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

func (*FibonacciTransactorRaw) Transfer 

func (_Fibonacci *FibonacciTransactorRaw) 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 FibonacciTransactorSession 

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

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

func (*FibonacciTransactorSession) GenerateFib 

func (_Fibonacci *FibonacciTransactorSession) GenerateFib(n *big.Int) (*types.Transaction, error)

GenerateFib is a paid mutator transaction binding the contract method 0x2ddec39b.

Solidity: function generateFib(uint256 n) payable returns()

type GasUsed 

type GasUsed struct {
	GasUsedCaller     // Read-only binding to the contract
	GasUsedTransactor // Write-only binding to the contract
	GasUsedFilterer   // Log filterer for contract events
}

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

func DeployGasUsed 

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

DeployGasUsed deploys a new Ethereum contract, binding an instance of GasUsed to it.

func NewGasUsed 

func NewGasUsed(address common.Address, backend bind.ContractBackend) (*GasUsed, error)

NewGasUsed creates a new instance of GasUsed, bound to a specific deployed contract.

type GasUsedCaller 

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

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

func NewGasUsedCaller 

func NewGasUsedCaller(address common.Address, caller bind.ContractCaller) (*GasUsedCaller, error)

NewGasUsedCaller creates a new read-only instance of GasUsed, bound to a specific deployed contract.

type GasUsedCallerRaw 

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

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

func (*GasUsedCallerRaw) Call 

func (_GasUsed *GasUsedCallerRaw) 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 GasUsedCallerSession 

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

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

type GasUsedFilterer 

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

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

func NewGasUsedFilterer 

func NewGasUsedFilterer(address common.Address, filterer bind.ContractFilterer) (*GasUsedFilterer, error)

NewGasUsedFilterer creates a new log filterer instance of GasUsed, bound to a specific deployed contract.

type GasUsedRaw 

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

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

func (*GasUsedRaw) Call 

func (_GasUsed *GasUsedRaw) 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 (*GasUsedRaw) Transact 

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

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

func (*GasUsedRaw) Transfer 

func (_GasUsed *GasUsedRaw) 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 GasUsedSession 

type GasUsedSession struct {
	Contract     *GasUsed          // 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
}

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

func (*GasUsedSession) Noop 

func (_GasUsed *GasUsedSession) Noop() (*types.Transaction, error)

Noop is a paid mutator transaction binding the contract method 0x5dfc2e4a.

Solidity: function noop() returns()

func (*GasUsedSession) Sstore 

func (_GasUsed *GasUsedSession) Sstore() (*types.Transaction, error)

Sstore is a paid mutator transaction binding the contract method 0x703c2d1a.

Solidity: function sstore() returns()

type GasUsedTransactor 

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

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

func NewGasUsedTransactor 

func NewGasUsedTransactor(address common.Address, transactor bind.ContractTransactor) (*GasUsedTransactor, error)

NewGasUsedTransactor creates a new write-only instance of GasUsed, bound to a specific deployed contract.

func (*GasUsedTransactor) Noop 

func (_GasUsed *GasUsedTransactor) Noop(opts *bind.TransactOpts) (*types.Transaction, error)

Noop is a paid mutator transaction binding the contract method 0x5dfc2e4a.

Solidity: function noop() returns()

func (*GasUsedTransactor) Sstore 

func (_GasUsed *GasUsedTransactor) Sstore(opts *bind.TransactOpts) (*types.Transaction, error)

Sstore is a paid mutator transaction binding the contract method 0x703c2d1a.

Solidity: function sstore() returns()

type GasUsedTransactorRaw 

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

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

func (*GasUsedTransactorRaw) Transact 

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

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

func (*GasUsedTransactorRaw) Transfer 

func (_GasUsed *GasUsedTransactorRaw) 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 GasUsedTransactorSession 

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

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

func (*GasUsedTransactorSession) Noop 

func (_GasUsed *GasUsedTransactorSession) Noop() (*types.Transaction, error)

Noop is a paid mutator transaction binding the contract method 0x5dfc2e4a.

Solidity: function noop() returns()

func (*GasUsedTransactorSession) Sstore 

func (_GasUsed *GasUsedTransactorSession) Sstore() (*types.Transaction, error)

Sstore is a paid mutator transaction binding the contract method 0x703c2d1a.

Solidity: function sstore() returns()

type IFailedSend 

type IFailedSend struct {
	IFailedSendCaller     // Read-only binding to the contract
	IFailedSendTransactor // Write-only binding to the contract
	IFailedSendFilterer   // Log filterer for contract events
}

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

func NewIFailedSend 

func NewIFailedSend(address common.Address, backend bind.ContractBackend) (*IFailedSend, error)

NewIFailedSend creates a new instance of IFailedSend, bound to a specific deployed contract.

type IFailedSendCaller 

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

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

func NewIFailedSendCaller 

func NewIFailedSendCaller(address common.Address, caller bind.ContractCaller) (*IFailedSendCaller, error)

NewIFailedSendCaller creates a new read-only instance of IFailedSend, bound to a specific deployed contract.

type IFailedSendCallerRaw 

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

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

func (*IFailedSendCallerRaw) Call 

func (_IFailedSend *IFailedSendCallerRaw) 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 IFailedSendCallerSession 

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

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

type IFailedSendFilterer 

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

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

func NewIFailedSendFilterer 

func NewIFailedSendFilterer(address common.Address, filterer bind.ContractFilterer) (*IFailedSendFilterer, error)

NewIFailedSendFilterer creates a new log filterer instance of IFailedSend, bound to a specific deployed contract.

type IFailedSendRaw 

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

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

func (*IFailedSendRaw) Call 

func (_IFailedSend *IFailedSendRaw) 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 (*IFailedSendRaw) Transact 

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

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

func (*IFailedSendRaw) Transfer 

func (_IFailedSend *IFailedSendRaw) 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 IFailedSendSession 

type IFailedSendSession struct {
	Contract     *IFailedSend      // 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
}

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

func (*IFailedSendSession) WithdrawFunds 

func (_IFailedSend *IFailedSendSession) WithdrawFunds(dest common.Address) (*types.Transaction, error)

WithdrawFunds is a paid mutator transaction binding the contract method 0x68742da6.

Solidity: function withdrawFunds(address dest) returns()

type IFailedSendTransactor 

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

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

func NewIFailedSendTransactor 

func NewIFailedSendTransactor(address common.Address, transactor bind.ContractTransactor) (*IFailedSendTransactor, error)

NewIFailedSendTransactor creates a new write-only instance of IFailedSend, bound to a specific deployed contract.

func (*IFailedSendTransactor) WithdrawFunds 

func (_IFailedSend *IFailedSendTransactor) WithdrawFunds(opts *bind.TransactOpts, dest common.Address) (*types.Transaction, error)

WithdrawFunds is a paid mutator transaction binding the contract method 0x68742da6.

Solidity: function withdrawFunds(address dest) returns()

type IFailedSendTransactorRaw 

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

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

func (*IFailedSendTransactorRaw) Transact 

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

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

func (*IFailedSendTransactorRaw) Transfer 

func (_IFailedSend *IFailedSendTransactorRaw) 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 IFailedSendTransactorSession 

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

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

func (*IFailedSendTransactorSession) WithdrawFunds 

func (_IFailedSend *IFailedSendTransactorSession) WithdrawFunds(dest common.Address) (*types.Transaction, error)

WithdrawFunds is a paid mutator transaction binding the contract method 0x68742da6.

Solidity: function withdrawFunds(address dest) returns()

type OpCodes 

type OpCodes struct {
	OpCodesCaller     // Read-only binding to the contract
	OpCodesTransactor // Write-only binding to the contract
	OpCodesFilterer   // Log filterer for contract events
}

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

func DeployOpCodes 

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

DeployOpCodes deploys a new Ethereum contract, binding an instance of OpCodes to it.

func NewOpCodes 

func NewOpCodes(address common.Address, backend bind.ContractBackend) (*OpCodes, error)

NewOpCodes creates a new instance of OpCodes, bound to a specific deployed contract.

type OpCodesCaller 

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

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

func NewOpCodesCaller 

func NewOpCodesCaller(address common.Address, caller bind.ContractCaller) (*OpCodesCaller, error)

NewOpCodesCaller creates a new read-only instance of OpCodes, bound to a specific deployed contract.

type OpCodesCallerRaw 

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

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

func (*OpCodesCallerRaw) Call 

func (_OpCodes *OpCodesCallerRaw) 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 OpCodesCallerSession 

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

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

type OpCodesFilterer 

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

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

func NewOpCodesFilterer 

func NewOpCodesFilterer(address common.Address, filterer bind.ContractFilterer) (*OpCodesFilterer, error)

NewOpCodesFilterer creates a new log filterer instance of OpCodes, bound to a specific deployed contract.

type OpCodesRaw 

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

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

func (*OpCodesRaw) Call 

func (_OpCodes *OpCodesRaw) 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 (*OpCodesRaw) Transact 

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

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

func (*OpCodesRaw) Transfer 

func (_OpCodes *OpCodesRaw) 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 OpCodesSession 

type OpCodesSession struct {
	Contract     *OpCodes          // 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
}

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

func (*OpCodesSession) GetBlockHash 

func (_OpCodes *OpCodesSession) GetBlockHash() (*types.Transaction, error)

GetBlockHash is a paid mutator transaction binding the contract method 0x9663f88f.

Solidity: function getBlockHash() returns(bytes32)

func (*OpCodesSession) GetNestedOrigin 

func (_OpCodes *OpCodesSession) GetNestedOrigin(conn common.Address) (*types.Transaction, error)

GetNestedOrigin is a paid mutator transaction binding the contract method 0x03dd3df4.

Solidity: function getNestedOrigin(address conn) returns(address)

func (*OpCodesSession) GetNestedSend 

func (_OpCodes *OpCodesSession) GetNestedSend(conn common.Address) (*types.Transaction, error)

GetNestedSend is a paid mutator transaction binding the contract method 0x84e58c86.

Solidity: function getNestedSend(address conn) returns(address)

func (*OpCodesSession) GetOrigin 

func (_OpCodes *OpCodesSession) GetOrigin() (*types.Transaction, error)

GetOrigin is a paid mutator transaction binding the contract method 0xdf1f29ee.

Solidity: function getOrigin() returns(address)

func (*OpCodesSession) GetSender 

func (_OpCodes *OpCodesSession) GetSender() (*types.Transaction, error)

GetSender is a paid mutator transaction binding the contract method 0x5e01eb5a.

Solidity: function getSender() returns(address)

type OpCodesTransactor 

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

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

func NewOpCodesTransactor 

func NewOpCodesTransactor(address common.Address, transactor bind.ContractTransactor) (*OpCodesTransactor, error)

NewOpCodesTransactor creates a new write-only instance of OpCodes, bound to a specific deployed contract.

func (*OpCodesTransactor) GetBlockHash 

func (_OpCodes *OpCodesTransactor) GetBlockHash(opts *bind.TransactOpts) (*types.Transaction, error)

GetBlockHash is a paid mutator transaction binding the contract method 0x9663f88f.

Solidity: function getBlockHash() returns(bytes32)

func (*OpCodesTransactor) GetNestedOrigin 

func (_OpCodes *OpCodesTransactor) GetNestedOrigin(opts *bind.TransactOpts, conn common.Address) (*types.Transaction, error)

GetNestedOrigin is a paid mutator transaction binding the contract method 0x03dd3df4.

Solidity: function getNestedOrigin(address conn) returns(address)

func (*OpCodesTransactor) GetNestedSend 

func (_OpCodes *OpCodesTransactor) GetNestedSend(opts *bind.TransactOpts, conn common.Address) (*types.Transaction, error)

GetNestedSend is a paid mutator transaction binding the contract method 0x84e58c86.

Solidity: function getNestedSend(address conn) returns(address)

func (*OpCodesTransactor) GetOrigin 

func (_OpCodes *OpCodesTransactor) GetOrigin(opts *bind.TransactOpts) (*types.Transaction, error)

GetOrigin is a paid mutator transaction binding the contract method 0xdf1f29ee.

Solidity: function getOrigin() returns(address)

func (*OpCodesTransactor) GetSender 

func (_OpCodes *OpCodesTransactor) GetSender(opts *bind.TransactOpts) (*types.Transaction, error)

GetSender is a paid mutator transaction binding the contract method 0x5e01eb5a.

Solidity: function getSender() returns(address)

type OpCodesTransactorRaw 

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

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

func (*OpCodesTransactorRaw) Transact 

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

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

func (*OpCodesTransactorRaw) Transfer 

func (_OpCodes *OpCodesTransactorRaw) 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 OpCodesTransactorSession 

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

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

func (*OpCodesTransactorSession) GetBlockHash 

func (_OpCodes *OpCodesTransactorSession) GetBlockHash() (*types.Transaction, error)

GetBlockHash is a paid mutator transaction binding the contract method 0x9663f88f.

Solidity: function getBlockHash() returns(bytes32)

func (*OpCodesTransactorSession) GetNestedOrigin 

func (_OpCodes *OpCodesTransactorSession) GetNestedOrigin(conn common.Address) (*types.Transaction, error)

GetNestedOrigin is a paid mutator transaction binding the contract method 0x03dd3df4.

Solidity: function getNestedOrigin(address conn) returns(address)

func (*OpCodesTransactorSession) GetNestedSend 

func (_OpCodes *OpCodesTransactorSession) GetNestedSend(conn common.Address) (*types.Transaction, error)

GetNestedSend is a paid mutator transaction binding the contract method 0x84e58c86.

Solidity: function getNestedSend(address conn) returns(address)

func (*OpCodesTransactorSession) GetOrigin 

func (_OpCodes *OpCodesTransactorSession) GetOrigin() (*types.Transaction, error)

GetOrigin is a paid mutator transaction binding the contract method 0xdf1f29ee.

Solidity: function getOrigin() returns(address)

func (*OpCodesTransactorSession) GetSender 

func (_OpCodes *OpCodesTransactorSession) GetSender() (*types.Transaction, error)

GetSender is a paid mutator transaction binding the contract method 0x5e01eb5a.

Solidity: function getSender() returns(address)

type Receiver 

type Receiver struct {
	ReceiverCaller     // Read-only binding to the contract
	ReceiverTransactor // Write-only binding to the contract
	ReceiverFilterer   // Log filterer for contract events
}

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

func DeployReceiver 

func DeployReceiver(auth *bind.TransactOpts, backend bind.ContractBackend, otherReciver common.Address) (common.Address, *types.Transaction, *Receiver, error)

DeployReceiver deploys a new Ethereum contract, binding an instance of Receiver to it.

func NewReceiver 

func NewReceiver(address common.Address, backend bind.ContractBackend) (*Receiver, error)

NewReceiver creates a new instance of Receiver, bound to a specific deployed contract.

type Receiver2 

type Receiver2 struct {
	Receiver2Caller     // Read-only binding to the contract
	Receiver2Transactor // Write-only binding to the contract
	Receiver2Filterer   // Log filterer for contract events
}

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

func DeployReceiver2 

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

DeployReceiver2 deploys a new Ethereum contract, binding an instance of Receiver2 to it.

func NewReceiver2 

func NewReceiver2(address common.Address, backend bind.ContractBackend) (*Receiver2, error)

NewReceiver2 creates a new instance of Receiver2, bound to a specific deployed contract.

type Receiver2Caller 

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

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

func NewReceiver2Caller 

func NewReceiver2Caller(address common.Address, caller bind.ContractCaller) (*Receiver2Caller, error)

NewReceiver2Caller creates a new read-only instance of Receiver2, bound to a specific deployed contract.

func (*Receiver2Caller) Test 

func (_Receiver2 *Receiver2Caller) Test(opts *bind.CallOpts) (*big.Int, error)

Test is a free data retrieval call binding the contract method 0xf8a8fd6d.

Solidity: function test() view returns(uint256)

type Receiver2CallerRaw 

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

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

func (*Receiver2CallerRaw) Call 

func (_Receiver2 *Receiver2CallerRaw) 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 Receiver2CallerSession 

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

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

func (*Receiver2CallerSession) Test 

func (_Receiver2 *Receiver2CallerSession) Test() (*big.Int, error)

Test is a free data retrieval call binding the contract method 0xf8a8fd6d.

Solidity: function test() view returns(uint256)

type Receiver2Filterer 

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

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

func NewReceiver2Filterer 

func NewReceiver2Filterer(address common.Address, filterer bind.ContractFilterer) (*Receiver2Filterer, error)

NewReceiver2Filterer creates a new log filterer instance of Receiver2, bound to a specific deployed contract.

type Receiver2Raw 

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

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

func (*Receiver2Raw) Call 

func (_Receiver2 *Receiver2Raw) 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 (*Receiver2Raw) Transact 

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

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

func (*Receiver2Raw) Transfer 

func (_Receiver2 *Receiver2Raw) 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 Receiver2Session 

type Receiver2Session struct {
	Contract     *Receiver2        // 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
}

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

func (*Receiver2Session) Mutate 

func (_Receiver2 *Receiver2Session) Mutate() (*types.Transaction, error)

Mutate is a paid mutator transaction binding the contract method 0x7795b5fc.

Solidity: function mutate() payable returns()

func (*Receiver2Session) Test 

func (_Receiver2 *Receiver2Session) Test() (*big.Int, error)

Test is a free data retrieval call binding the contract method 0xf8a8fd6d.

Solidity: function test() view returns(uint256)

type Receiver2Transactor 

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

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

func NewReceiver2Transactor 

func NewReceiver2Transactor(address common.Address, transactor bind.ContractTransactor) (*Receiver2Transactor, error)

NewReceiver2Transactor creates a new write-only instance of Receiver2, bound to a specific deployed contract.

func (*Receiver2Transactor) Mutate 

func (_Receiver2 *Receiver2Transactor) Mutate(opts *bind.TransactOpts) (*types.Transaction, error)

Mutate is a paid mutator transaction binding the contract method 0x7795b5fc.

Solidity: function mutate() payable returns()

type Receiver2TransactorRaw 

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

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

func (*Receiver2TransactorRaw) Transact 

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

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

func (*Receiver2TransactorRaw) Transfer 

func (_Receiver2 *Receiver2TransactorRaw) 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 Receiver2TransactorSession 

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

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

func (*Receiver2TransactorSession) Mutate 

func (_Receiver2 *Receiver2TransactorSession) Mutate() (*types.Transaction, error)

Mutate is a paid mutator transaction binding the contract method 0x7795b5fc.

Solidity: function mutate() payable returns()

type ReceiverCaller 

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

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

func NewReceiverCaller 

func NewReceiverCaller(address common.Address, caller bind.ContractCaller) (*ReceiverCaller, error)

NewReceiverCaller creates a new read-only instance of Receiver, bound to a specific deployed contract.

func (*ReceiverCaller) Other 

func (_Receiver *ReceiverCaller) Other(opts *bind.CallOpts) (common.Address, error)

Other is a free data retrieval call binding the contract method 0x85295877.

Solidity: function other() view returns(address)

func (*ReceiverCaller) Test 

func (_Receiver *ReceiverCaller) Test(opts *bind.CallOpts) (*big.Int, error)

Test is a free data retrieval call binding the contract method 0xf8a8fd6d.

Solidity: function test() view returns(uint256)

type ReceiverCallerRaw 

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

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

func (*ReceiverCallerRaw) Call 

func (_Receiver *ReceiverCallerRaw) 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 ReceiverCallerSession 

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

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

func (*ReceiverCallerSession) Other 

func (_Receiver *ReceiverCallerSession) Other() (common.Address, error)

Other is a free data retrieval call binding the contract method 0x85295877.

Solidity: function other() view returns(address)

func (*ReceiverCallerSession) Test 

func (_Receiver *ReceiverCallerSession) Test() (*big.Int, error)

Test is a free data retrieval call binding the contract method 0xf8a8fd6d.

Solidity: function test() view returns(uint256)

type ReceiverFilterer 

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

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

func NewReceiverFilterer 

func NewReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*ReceiverFilterer, error)

NewReceiverFilterer creates a new log filterer instance of Receiver, bound to a specific deployed contract.

type ReceiverRaw 

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

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

func (*ReceiverRaw) Call 

func (_Receiver *ReceiverRaw) 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 (*ReceiverRaw) Transact 

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

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

func (*ReceiverRaw) Transfer 

func (_Receiver *ReceiverRaw) 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 ReceiverSession 

type ReceiverSession struct {
	Contract     *Receiver         // 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
}

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

func (*ReceiverSession) Mutate 

func (_Receiver *ReceiverSession) Mutate() (*types.Transaction, error)

Mutate is a paid mutator transaction binding the contract method 0x7795b5fc.

Solidity: function mutate() payable returns()

func (*ReceiverSession) Other 

func (_Receiver *ReceiverSession) Other() (common.Address, error)

Other is a free data retrieval call binding the contract method 0x85295877.

Solidity: function other() view returns(address)

func (*ReceiverSession) Test 

func (_Receiver *ReceiverSession) Test() (*big.Int, error)

Test is a free data retrieval call binding the contract method 0xf8a8fd6d.

Solidity: function test() view returns(uint256)

type ReceiverTransactor 

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

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

func NewReceiverTransactor 

func NewReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*ReceiverTransactor, error)

NewReceiverTransactor creates a new write-only instance of Receiver, bound to a specific deployed contract.

func (*ReceiverTransactor) Mutate 

func (_Receiver *ReceiverTransactor) Mutate(opts *bind.TransactOpts) (*types.Transaction, error)

Mutate is a paid mutator transaction binding the contract method 0x7795b5fc.

Solidity: function mutate() payable returns()

type ReceiverTransactorRaw 

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

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

func (*ReceiverTransactorRaw) Transact 

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

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

func (*ReceiverTransactorRaw) Transfer 

func (_Receiver *ReceiverTransactorRaw) 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 ReceiverTransactorSession 

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

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

func (*ReceiverTransactorSession) Mutate 

func (_Receiver *ReceiverTransactorSession) Mutate() (*types.Transaction, error)

Mutate is a paid mutator transaction binding the contract method 0x7795b5fc.

Solidity: function mutate() payable returns()

type Simple 

type Simple struct {
	SimpleCaller     // Read-only binding to the contract
	SimpleTransactor // Write-only binding to the contract
	SimpleFilterer   // Log filterer for contract events
}

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

func DeploySimple 

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

DeploySimple deploys a new Ethereum contract, binding an instance of Simple to it.

func NewSimple 

func NewSimple(address common.Address, backend bind.ContractBackend) (*Simple, error)

NewSimple creates a new instance of Simple, bound to a specific deployed contract.

type SimpleCaller 

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

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

func NewSimpleCaller 

func NewSimpleCaller(address common.Address, caller bind.ContractCaller) (*SimpleCaller, error)

NewSimpleCaller creates a new read-only instance of Simple, bound to a specific deployed contract.

type SimpleCallerRaw 

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

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

func (*SimpleCallerRaw) Call 

func (_Simple *SimpleCallerRaw) 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 SimpleCallerSession 

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

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

type SimpleFilterer 

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

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

func NewSimpleFilterer 

func NewSimpleFilterer(address common.Address, filterer bind.ContractFilterer) (*SimpleFilterer, error)

NewSimpleFilterer creates a new log filterer instance of Simple, bound to a specific deployed contract.

type SimpleRaw 

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

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

func (*SimpleRaw) Call 

func (_Simple *SimpleRaw) 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 (*SimpleRaw) Transact 

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

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

func (*SimpleRaw) Transfer 

func (_Simple *SimpleRaw) 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 SimpleSession 

type SimpleSession struct {
	Contract     *Simple           // 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
}

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

func (*SimpleSession) AcceptPayment 

func (_Simple *SimpleSession) AcceptPayment() (*types.Transaction, error)

AcceptPayment is a paid mutator transaction binding the contract method 0xae0aba8c.

Solidity: function acceptPayment() payable returns()

func (*SimpleSession) Exists 

func (_Simple *SimpleSession) Exists() (*types.Transaction, error)

Exists is a paid mutator transaction binding the contract method 0x267c4ae4.

Solidity: function exists() returns(uint256)

func (*SimpleSession) NestedCall 

func (_Simple *SimpleSession) NestedCall(value *big.Int) (*types.Transaction, error)

NestedCall is a paid mutator transaction binding the contract method 0x9b7c9da3.

Solidity: function nestedCall(uint256 value) returns()

func (*SimpleSession) Receive 

func (_Simple *SimpleSession) Receive() (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*SimpleSession) RejectPayment 

func (_Simple *SimpleSession) RejectPayment() (*types.Transaction, error)

RejectPayment is a paid mutator transaction binding the contract method 0x9436bc1f.

Solidity: function rejectPayment() returns()

func (*SimpleSession) Reverts 

func (_Simple *SimpleSession) Reverts() (*types.Transaction, error)

Reverts is a paid mutator transaction binding the contract method 0x3bccbbc9.

Solidity: function reverts() returns()

type SimpleTransactor 

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

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

func NewSimpleTransactor 

func NewSimpleTransactor(address common.Address, transactor bind.ContractTransactor) (*SimpleTransactor, error)

NewSimpleTransactor creates a new write-only instance of Simple, bound to a specific deployed contract.

func (*SimpleTransactor) AcceptPayment 

func (_Simple *SimpleTransactor) AcceptPayment(opts *bind.TransactOpts) (*types.Transaction, error)

AcceptPayment is a paid mutator transaction binding the contract method 0xae0aba8c.

Solidity: function acceptPayment() payable returns()

func (*SimpleTransactor) Exists 

func (_Simple *SimpleTransactor) Exists(opts *bind.TransactOpts) (*types.Transaction, error)

Exists is a paid mutator transaction binding the contract method 0x267c4ae4.

Solidity: function exists() returns(uint256)

func (*SimpleTransactor) NestedCall 

func (_Simple *SimpleTransactor) NestedCall(opts *bind.TransactOpts, value *big.Int) (*types.Transaction, error)

NestedCall is a paid mutator transaction binding the contract method 0x9b7c9da3.

Solidity: function nestedCall(uint256 value) returns()

func (*SimpleTransactor) Receive 

func (_Simple *SimpleTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*SimpleTransactor) RejectPayment 

func (_Simple *SimpleTransactor) RejectPayment(opts *bind.TransactOpts) (*types.Transaction, error)

RejectPayment is a paid mutator transaction binding the contract method 0x9436bc1f.

Solidity: function rejectPayment() returns()

func (*SimpleTransactor) Reverts 

func (_Simple *SimpleTransactor) Reverts(opts *bind.TransactOpts) (*types.Transaction, error)

Reverts is a paid mutator transaction binding the contract method 0x3bccbbc9.

Solidity: function reverts() returns()

type SimpleTransactorRaw 

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

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

func (*SimpleTransactorRaw) Transact 

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

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

func (*SimpleTransactorRaw) Transfer 

func (_Simple *SimpleTransactorRaw) 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 SimpleTransactorSession 

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

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

func (*SimpleTransactorSession) AcceptPayment 

func (_Simple *SimpleTransactorSession) AcceptPayment() (*types.Transaction, error)

AcceptPayment is a paid mutator transaction binding the contract method 0xae0aba8c.

Solidity: function acceptPayment() payable returns()

func (*SimpleTransactorSession) Exists 

func (_Simple *SimpleTransactorSession) Exists() (*types.Transaction, error)

Exists is a paid mutator transaction binding the contract method 0x267c4ae4.

Solidity: function exists() returns(uint256)

func (*SimpleTransactorSession) NestedCall 

func (_Simple *SimpleTransactorSession) NestedCall(value *big.Int) (*types.Transaction, error)

NestedCall is a paid mutator transaction binding the contract method 0x9b7c9da3.

Solidity: function nestedCall(uint256 value) returns()

func (*SimpleTransactorSession) Receive 

func (_Simple *SimpleTransactorSession) Receive() (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*SimpleTransactorSession) RejectPayment 

func (_Simple *SimpleTransactorSession) RejectPayment() (*types.Transaction, error)

RejectPayment is a paid mutator transaction binding the contract method 0x9436bc1f.

Solidity: function rejectPayment() returns()

func (*SimpleTransactorSession) Reverts 

func (_Simple *SimpleTransactorSession) Reverts() (*types.Transaction, error)

Reverts is a paid mutator transaction binding the contract method 0x3bccbbc9.

Solidity: function reverts() returns()

type Storage 

type Storage struct {
	StorageCaller     // Read-only binding to the contract
	StorageTransactor // Write-only binding to the contract
	StorageFilterer   // Log filterer for contract events
}

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

func DeployStorage 

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

DeployStorage deploys a new Ethereum contract, binding an instance of Storage to it.

func NewStorage 

func NewStorage(address common.Address, backend bind.ContractBackend) (*Storage, error)

NewStorage creates a new instance of Storage, bound to a specific deployed contract.

type StorageCaller 

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

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

func NewStorageCaller 

func NewStorageCaller(address common.Address, caller bind.ContractCaller) (*StorageCaller, error)

NewStorageCaller creates a new read-only instance of Storage, bound to a specific deployed contract.

type StorageCallerRaw 

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

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

func (*StorageCallerRaw) Call 

func (_Storage *StorageCallerRaw) 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 StorageCallerSession 

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

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

type StorageFilterer 

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

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

func NewStorageFilterer 

func NewStorageFilterer(address common.Address, filterer bind.ContractFilterer) (*StorageFilterer, error)

NewStorageFilterer creates a new log filterer instance of Storage, bound to a specific deployed contract.

type StorageRaw 

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

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

func (*StorageRaw) Call 

func (_Storage *StorageRaw) 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 (*StorageRaw) Transact 

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

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

func (*StorageRaw) Transfer 

func (_Storage *StorageRaw) 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 StorageSession 

type StorageSession struct {
	Contract     *Storage          // 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
}

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

func (*StorageSession) FailGetStorage 

func (_Storage *StorageSession) FailGetStorage() (*types.Transaction, error)

FailGetStorage is a paid mutator transaction binding the contract method 0x188f9139.

Solidity: function failGetStorage() returns(uint256)

type StorageTransactor 

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

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

func NewStorageTransactor 

func NewStorageTransactor(address common.Address, transactor bind.ContractTransactor) (*StorageTransactor, error)

NewStorageTransactor creates a new write-only instance of Storage, bound to a specific deployed contract.

func (*StorageTransactor) FailGetStorage 

func (_Storage *StorageTransactor) FailGetStorage(opts *bind.TransactOpts) (*types.Transaction, error)

FailGetStorage is a paid mutator transaction binding the contract method 0x188f9139.

Solidity: function failGetStorage() returns(uint256)

type StorageTransactorRaw 

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

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

func (*StorageTransactorRaw) Transact 

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

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

func (*StorageTransactorRaw) Transfer 

func (_Storage *StorageTransactorRaw) 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 StorageTransactorSession 

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

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

func (*StorageTransactorSession) FailGetStorage 

func (_Storage *StorageTransactorSession) FailGetStorage() (*types.Transaction, error)

FailGetStorage is a paid mutator transaction binding the contract method 0x188f9139.

Solidity: function failGetStorage() returns(uint256)

type Sys 

type Sys struct {
	SysCaller     // Read-only binding to the contract
	SysTransactor // Write-only binding to the contract
	SysFilterer   // Log filterer for contract events
}

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

func NewSys 

func NewSys(address common.Address, backend bind.ContractBackend) (*Sys, error)

NewSys creates a new instance of Sys, bound to a specific deployed contract.

type Sys2 

type Sys2 struct {
	Sys2Caller     // Read-only binding to the contract
	Sys2Transactor // Write-only binding to the contract
	Sys2Filterer   // Log filterer for contract events
}

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

func NewSys2 

func NewSys2(address common.Address, backend bind.ContractBackend) (*Sys2, error)

NewSys2 creates a new instance of Sys2, bound to a specific deployed contract.

type Sys2Caller 

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

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

func NewSys2Caller 

func NewSys2Caller(address common.Address, caller bind.ContractCaller) (*Sys2Caller, error)

NewSys2Caller creates a new read-only instance of Sys2, bound to a specific deployed contract.

func (*Sys2Caller) GetStorageAt 

func (_Sys2 *Sys2Caller) GetStorageAt(opts *bind.CallOpts, account common.Address, index *big.Int) (*big.Int, error)

GetStorageAt is a free data retrieval call binding the contract method 0xa169625f.

Solidity: function getStorageAt(address account, uint256 index) view returns(uint256)

type Sys2CallerRaw 

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

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

func (*Sys2CallerRaw) Call 

func (_Sys2 *Sys2CallerRaw) 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 Sys2CallerSession 

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

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

func (*Sys2CallerSession) GetStorageAt 

func (_Sys2 *Sys2CallerSession) GetStorageAt(account common.Address, index *big.Int) (*big.Int, error)

GetStorageAt is a free data retrieval call binding the contract method 0xa169625f.

Solidity: function getStorageAt(address account, uint256 index) view returns(uint256)

type Sys2Filterer 

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

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

func NewSys2Filterer 

func NewSys2Filterer(address common.Address, filterer bind.ContractFilterer) (*Sys2Filterer, error)

NewSys2Filterer creates a new log filterer instance of Sys2, bound to a specific deployed contract.

type Sys2Raw 

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

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

func (*Sys2Raw) Call 

func (_Sys2 *Sys2Raw) 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 (*Sys2Raw) Transact 

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

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

func (*Sys2Raw) Transfer 

func (_Sys2 *Sys2Raw) 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 Sys2Session 

type Sys2Session struct {
	Contract     *Sys2             // 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
}

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

func (*Sys2Session) GetStorageAt 

func (_Sys2 *Sys2Session) GetStorageAt(account common.Address, index *big.Int) (*big.Int, error)

GetStorageAt is a free data retrieval call binding the contract method 0xa169625f.

Solidity: function getStorageAt(address account, uint256 index) view returns(uint256)

type Sys2Transactor 

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

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

func NewSys2Transactor 

func NewSys2Transactor(address common.Address, transactor bind.ContractTransactor) (*Sys2Transactor, error)

NewSys2Transactor creates a new write-only instance of Sys2, bound to a specific deployed contract.

type Sys2TransactorRaw 

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

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

func (*Sys2TransactorRaw) Transact 

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

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

func (*Sys2TransactorRaw) Transfer 

func (_Sys2 *Sys2TransactorRaw) 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 Sys2TransactorSession 

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

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

type SysCaller 

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

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

func NewSysCaller 

func NewSysCaller(address common.Address, caller bind.ContractCaller) (*SysCaller, error)

NewSysCaller creates a new read-only instance of Sys, bound to a specific deployed contract.

type SysCallerRaw 

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

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

func (*SysCallerRaw) Call 

func (_Sys *SysCallerRaw) 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 SysCallerSession 

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

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

type SysFilterer 

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

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

func NewSysFilterer 

func NewSysFilterer(address common.Address, filterer bind.ContractFilterer) (*SysFilterer, error)

NewSysFilterer creates a new log filterer instance of Sys, bound to a specific deployed contract.

type SysRaw 

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

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

func (*SysRaw) Call 

func (_Sys *SysRaw) 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 (*SysRaw) Transact 

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

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

func (*SysRaw) Transfer 

func (_Sys *SysRaw) 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 SysSession 

type SysSession struct {
	Contract     *Sys              // 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
}

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

func (*SysSession) WithdrawEth 

func (_Sys *SysSession) WithdrawEth(dest common.Address) (*types.Transaction, error)

WithdrawEth is a paid mutator transaction binding the contract method 0x25e16063.

Solidity: function withdrawEth(address dest) payable returns()

type SysTransactor 

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

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

func NewSysTransactor 

func NewSysTransactor(address common.Address, transactor bind.ContractTransactor) (*SysTransactor, error)

NewSysTransactor creates a new write-only instance of Sys, bound to a specific deployed contract.

func (*SysTransactor) WithdrawEth 

func (_Sys *SysTransactor) WithdrawEth(opts *bind.TransactOpts, dest common.Address) (*types.Transaction, error)

WithdrawEth is a paid mutator transaction binding the contract method 0x25e16063.

Solidity: function withdrawEth(address dest) payable returns()

type SysTransactorRaw 

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

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

func (*SysTransactorRaw) Transact 

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

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

func (*SysTransactorRaw) Transfer 

func (_Sys *SysTransactorRaw) 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 SysTransactorSession 

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

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

func (*SysTransactorSession) WithdrawEth 

func (_Sys *SysTransactorSession) WithdrawEth(dest common.Address) (*types.Transaction, error)

WithdrawEth is a paid mutator transaction binding the contract method 0x25e16063.

Solidity: function withdrawEth(address dest) payable returns()

type Transfer 

type Transfer struct {
	TransferCaller     // Read-only binding to the contract
	TransferTransactor // Write-only binding to the contract
	TransferFilterer   // Log filterer for contract events
}

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

func DeployTransfer 

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

DeployTransfer deploys a new Ethereum contract, binding an instance of Transfer to it.

func NewTransfer 

func NewTransfer(address common.Address, backend bind.ContractBackend) (*Transfer, error)

NewTransfer creates a new instance of Transfer, bound to a specific deployed contract.

type TransferCaller 

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

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

func NewTransferCaller 

func NewTransferCaller(address common.Address, caller bind.ContractCaller) (*TransferCaller, error)

NewTransferCaller creates a new read-only instance of Transfer, bound to a specific deployed contract.

type TransferCallerRaw 

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

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

func (*TransferCallerRaw) Call 

func (_Transfer *TransferCallerRaw) 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 TransferCallerSession 

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

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

type TransferFilterer 

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

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

func NewTransferFilterer 

func NewTransferFilterer(address common.Address, filterer bind.ContractFilterer) (*TransferFilterer, error)

NewTransferFilterer creates a new log filterer instance of Transfer, bound to a specific deployed contract.

type TransferRaw 

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

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

func (*TransferRaw) Call 

func (_Transfer *TransferRaw) 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 (*TransferRaw) Transact 

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

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

func (*TransferRaw) Transfer 

func (_Transfer *TransferRaw) 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 TransferSession 

type TransferSession struct {
	Contract     *Transfer         // 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
}

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

func (*TransferSession) Receive 

func (_Transfer *TransferSession) Receive() (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*TransferSession) Send 

func (_Transfer *TransferSession) Send() (*types.Transaction, error)

Send is a paid mutator transaction binding the contract method 0xb46300ec.

Solidity: function send() returns()

func (*TransferSession) Send2 

func (_Transfer *TransferSession) Send2(wrapped common.Address) (*types.Transaction, error)

Send2 is a paid mutator transaction binding the contract method 0x3386b1a2.

Solidity: function send2(address wrapped) returns()

type TransferTransactor 

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

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

func NewTransferTransactor 

func NewTransferTransactor(address common.Address, transactor bind.ContractTransactor) (*TransferTransactor, error)

NewTransferTransactor creates a new write-only instance of Transfer, bound to a specific deployed contract.

func (*TransferTransactor) Receive 

func (_Transfer *TransferTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*TransferTransactor) Send 

func (_Transfer *TransferTransactor) Send(opts *bind.TransactOpts) (*types.Transaction, error)

Send is a paid mutator transaction binding the contract method 0xb46300ec.

Solidity: function send() returns()

func (*TransferTransactor) Send2 

func (_Transfer *TransferTransactor) Send2(opts *bind.TransactOpts, wrapped common.Address) (*types.Transaction, error)

Send2 is a paid mutator transaction binding the contract method 0x3386b1a2.

Solidity: function send2(address wrapped) returns()

type TransferTransactorRaw 

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

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

func (*TransferTransactorRaw) Transact 

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

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

func (*TransferTransactorRaw) Transfer 

func (_Transfer *TransferTransactorRaw) 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 TransferTransactorSession 

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

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

func (*TransferTransactorSession) Receive 

func (_Transfer *TransferTransactorSession) Receive() (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*TransferTransactorSession) Send 

func (_Transfer *TransferTransactorSession) Send() (*types.Transaction, error)

Send is a paid mutator transaction binding the contract method 0xb46300ec.

Solidity: function send() returns()

func (*TransferTransactorSession) Send2 

func (_Transfer *TransferTransactorSession) Send2(wrapped common.Address) (*types.Transaction, error)

Send2 is a paid mutator transaction binding the contract method 0x3386b1a2.

Solidity: function send2(address wrapped) returns()

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.