lock_proxy_abi

package
v0.0.0-...-e558250 Latest Latest
Warning

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

 Go to latest Published: Dec 8, 2020 License: GPL-3.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const ContextABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]"

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

View Source 
const IERC20ABI = "" /* 2016-byte string literal not displayed */

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

View Source 
const IEthCrossChainManagerABI = "" /* 358-byte string literal not displayed */

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

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

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

View Source 
const LockProxyABI = "" /* 4721-byte string literal not displayed */

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

View Source 
const OwnableABI = "" /* 1013-byte string literal not displayed */

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

View Source 
const SafeERC20ABI = "[]"

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

View Source 
const SafeMathABI = "[]"

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

View Source 
const UtilsABI = "[]"

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

View Source 
const ZeroCopySinkABI = "[]"

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

View Source 
const ZeroCopySourceABI = "[]"

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

Variables

View Source 
var IERC20FuncSigs = map[string]string{
	"852d9213": "allowance(address,address)",
	"1f2d4860": "approve(address,uint256)",
	"cc8be70e": "balanceOf(address)",
	"0256e278": "totalSupply()",
	"6904e965": "transfer(address,uint256)",
	"ad8a9731": "transferFrom(address,address,uint256)",
}

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

View Source 
var IEthCrossChainManagerFuncSigs = map[string]string{
	"1f5045a8": "crossChain(uint64,bytes,bytes,bytes)",
}

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

View Source 
var IEthCrossChainManagerProxyFuncSigs = map[string]string{
	"483bf041": "getEthCrossChainManager()",
}

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

View Source 
var LockProxyBin = "" /* 23918-byte string literal not displayed */

LockProxyBin is the compiled bytecode used for deploying new contracts.

View Source 
var LockProxyFuncSigs = map[string]string{
	"a223c32c": "assetHashMap(address,uint64)",
	"dfe848a5": "bindAssetHash(address,uint64,bytes)",
	"6e5d9c8f": "bindProxyHash(uint64,bytes)",
	"783ca7dc": "getBalanceFor(address)",
	"ede8e529": "isOwner()",
	"514e3836": "lock(address,uint64,bytes,uint256)",
	"ffcaba74": "managerProxyContract()",
	"5089e2c8": "owner()",
	"ead1f21f": "proxyHashMap(uint64)",
	"d86e29e2": "renounceOwnership()",
	"7430f358": "setManagerProxy(address)",
	"16cad12a": "transferOwnership(address)",
	"4d7ee918": "unlock(bytes,bytes,uint64)",
}

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

View Source 
var OwnableFuncSigs = map[string]string{
	"ede8e529": "isOwner()",
	"5089e2c8": "owner()",
	"d86e29e2": "renounceOwnership()",
	"16cad12a": "transferOwnership(address)",
}

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

View Source 
var SafeERC20Bin = "" /* 242-byte string literal not displayed */

SafeERC20Bin is the compiled bytecode used for deploying new contracts.

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

SafeMathBin is the compiled bytecode used for deploying new contracts.

View Source 
var UtilsBin = "" /* 242-byte string literal not displayed */

UtilsBin is the compiled bytecode used for deploying new contracts.

View Source 
var ZeroCopySinkBin = "" /* 242-byte string literal not displayed */

ZeroCopySinkBin is the compiled bytecode used for deploying new contracts.

View Source 
var ZeroCopySourceBin = "" /* 242-byte string literal not displayed */

ZeroCopySourceBin is the compiled bytecode used for deploying new contracts.

Functions

func AsyncDeployLockProxy 

func AsyncDeployLockProxy(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

func AsyncDeploySafeERC20 

func AsyncDeploySafeERC20(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

func AsyncDeploySafeMath 

func AsyncDeploySafeMath(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

func AsyncDeployUtils 

func AsyncDeployUtils(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

func AsyncDeployZeroCopySink 

func AsyncDeployZeroCopySink(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

func AsyncDeployZeroCopySource 

func AsyncDeployZeroCopySource(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

Types

type Context 

type Context struct {
	ContextCaller     // Read-only binding to the contract
	ContextTransactor // Write-only binding to the contract
	ContextFilterer   // Log filterer for contract events
}

Context is an auto generated Go binding around a Solidity contract.

func NewContext 

func NewContext(address common.Address, backend bind.ContractBackend) (*Context, error)

NewContext creates a new instance of Context, bound to a specific deployed contract.

type ContextCaller 

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

ContextCaller is an auto generated read-only Go binding around a Solidity contract.

func NewContextCaller 

func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error)

NewContextCaller creates a new read-only instance of Context, bound to a specific deployed contract.

type ContextCallerRaw 

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

ContextCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*ContextCallerRaw) Call 

func (_Context *ContextCallerRaw) 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 ContextCallerSession 

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

ContextCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type ContextFilterer 

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

ContextFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewContextFilterer 

func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error)

NewContextFilterer creates a new log filterer instance of Context, bound to a specific deployed contract.

type ContextRaw 

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

ContextRaw is an auto generated low-level Go binding around a Solidity contract.

func (*ContextRaw) Call 

func (_Context *ContextRaw) 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 (*ContextRaw) Transact 

func (_Context *ContextRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ContextRaw) Transfer 

func (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ContextSession 

type ContextSession struct {
	Contract     *Context          // 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
}

ContextSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

type ContextTransactor 

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

ContextTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewContextTransactor 

func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error)

NewContextTransactor creates a new write-only instance of Context, bound to a specific deployed contract.

type ContextTransactorRaw 

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

ContextTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*ContextTransactorRaw) Transact 

func (_Context *ContextTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ContextTransactorRaw) Transfer 

func (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ContextTransactorSession 

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

ContextTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

type IERC20 

type IERC20 struct {
	IERC20Caller     // Read-only binding to the contract
	IERC20Transactor // Write-only binding to the contract
	IERC20Filterer   // Log filterer for contract events
}

IERC20 is an auto generated Go binding around a Solidity contract.

func NewIERC20 

func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error)

NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract.

type IERC20Approval 

type IERC20Approval struct {
	Owner   common.Address
	Spender common.Address
	Value   *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

IERC20Approval represents a Approval event raised by the IERC20 contract.

type IERC20ApprovalIterator 

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

IERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC20 contract.

func (*IERC20ApprovalIterator) Close 

func (it *IERC20ApprovalIterator) Close() error

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

func (*IERC20ApprovalIterator) Error 

func (it *IERC20ApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*IERC20ApprovalIterator) Next 

func (it *IERC20ApprovalIterator) 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 IERC20Caller 

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

IERC20Caller is an auto generated read-only Go binding around a Solidity contract.

func NewIERC20Caller 

func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error)

NewIERC20Caller creates a new read-only instance of IERC20, bound to a specific deployed contract.

func (*IERC20Caller) Allowance 

func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error)

Allowance is a free data retrieval call binding the contract method 0x852d9213.

Solidity: function allowance(address owner, address spender) constant returns(uint256)

func (*IERC20Caller) BalanceOf 

func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error)

BalanceOf is a free data retrieval call binding the contract method 0xcc8be70e.

Solidity: function balanceOf(address account) constant returns(uint256)

func (*IERC20Caller) TotalSupply 

func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

TotalSupply is a free data retrieval call binding the contract method 0x0256e278.

Solidity: function totalSupply() constant returns(uint256)

type IERC20CallerRaw 

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

IERC20CallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*IERC20CallerRaw) Call 

func (_IERC20 *IERC20CallerRaw) 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 IERC20CallerSession 

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

IERC20CallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*IERC20CallerSession) Allowance 

func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

Allowance is a free data retrieval call binding the contract method 0x852d9213.

Solidity: function allowance(address owner, address spender) constant returns(uint256)

func (*IERC20CallerSession) BalanceOf 

func (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error)

BalanceOf is a free data retrieval call binding the contract method 0xcc8be70e.

Solidity: function balanceOf(address account) constant returns(uint256)

func (*IERC20CallerSession) TotalSupply 

func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error)

TotalSupply is a free data retrieval call binding the contract method 0x0256e278.

Solidity: function totalSupply() constant returns(uint256)

type IERC20Filterer 

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

IERC20Filterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewIERC20Filterer 

func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error)

NewIERC20Filterer creates a new log filterer instance of IERC20, bound to a specific deployed contract.

func (*IERC20Filterer) FilterApproval 

func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error)

FilterApproval is a free log retrieval operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000d1e45707.

Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)

func (*IERC20Filterer) FilterTransfer 

func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error)

FilterTransfer is a free log retrieval operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000018f84334.

Solidity: event Transfer(address indexed from, address indexed to, uint256 value)

func (*IERC20Filterer) ParseApproval 

func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error)

ParseApproval is a log parse operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000d1e45707.

Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)

func (*IERC20Filterer) ParseTransfer 

func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error)

ParseTransfer is a log parse operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000018f84334.

Solidity: event Transfer(address indexed from, address indexed to, uint256 value)

func (*IERC20Filterer) WatchApproval 

func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error)

WatchApproval is a free log subscription operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000d1e45707.

Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)

func (*IERC20Filterer) WatchTransfer 

func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error)

WatchTransfer is a free log subscription operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000018f84334.

Solidity: event Transfer(address indexed from, address indexed to, uint256 value)

type IERC20Raw 

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

IERC20Raw is an auto generated low-level Go binding around a Solidity contract.

func (*IERC20Raw) Call 

func (_IERC20 *IERC20Raw) 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 (*IERC20Raw) Transact 

func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IERC20Raw) Transfer 

func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IERC20Session 

type IERC20Session struct {
	Contract     *IERC20           // 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
}

IERC20Session is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*IERC20Session) Allowance 

func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

Allowance is a free data retrieval call binding the contract method 0x852d9213.

Solidity: function allowance(address owner, address spender) constant returns(uint256)

func (*IERC20Session) Approve 

func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Approve is a paid mutator transaction binding the contract method 0x1f2d4860.

Solidity: function approve(address spender, uint256 amount) returns(bool)

func (*IERC20Session) AsyncApprove 

func (_IERC20 *IERC20Session) AsyncApprove(handler func(*types.Receipt, error), spender common.Address, amount *big.Int) (*types.Transaction, error)

func (*IERC20Session) AsyncTransfer 

func (_IERC20 *IERC20Session) AsyncTransfer(handler func(*types.Receipt, error), recipient common.Address, amount *big.Int) (*types.Transaction, error)

func (*IERC20Session) AsyncTransferFrom 

func (_IERC20 *IERC20Session) AsyncTransferFrom(handler func(*types.Receipt, error), sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

func (*IERC20Session) BalanceOf 

func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error)

BalanceOf is a free data retrieval call binding the contract method 0xcc8be70e.

Solidity: function balanceOf(address account) constant returns(uint256)

func (*IERC20Session) TotalSupply 

func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error)

TotalSupply is a free data retrieval call binding the contract method 0x0256e278.

Solidity: function totalSupply() constant returns(uint256)

func (*IERC20Session) Transfer 

func (_IERC20 *IERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Transfer is a paid mutator transaction binding the contract method 0x6904e965.

Solidity: function transfer(address recipient, uint256 amount) returns(bool)

func (*IERC20Session) TransferFrom 

func (_IERC20 *IERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

TransferFrom is a paid mutator transaction binding the contract method 0xad8a9731.

Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)

type IERC20Transactor 

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

IERC20Transactor is an auto generated write-only Go binding around a Solidity contract.

func NewIERC20Transactor 

func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error)

NewIERC20Transactor creates a new write-only instance of IERC20, bound to a specific deployed contract.

func (*IERC20Transactor) Approve 

func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Approve is a paid mutator transaction binding the contract method 0x1f2d4860.

Solidity: function approve(address spender, uint256 amount) returns(bool)

func (*IERC20Transactor) AsyncApprove 

func (_IERC20 *IERC20Transactor) AsyncApprove(handler func(*types.Receipt, error), opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error)

func (*IERC20Transactor) AsyncTransfer 

func (_IERC20 *IERC20Transactor) AsyncTransfer(handler func(*types.Receipt, error), opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

func (*IERC20Transactor) AsyncTransferFrom 

func (_IERC20 *IERC20Transactor) AsyncTransferFrom(handler func(*types.Receipt, error), opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

func (*IERC20Transactor) Transfer 

func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Transfer is a paid mutator transaction binding the contract method 0x6904e965.

Solidity: function transfer(address recipient, uint256 amount) returns(bool)

func (*IERC20Transactor) TransferFrom 

func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

TransferFrom is a paid mutator transaction binding the contract method 0xad8a9731.

Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)

type IERC20TransactorRaw 

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

IERC20TransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*IERC20TransactorRaw) Transact 

func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IERC20TransactorRaw) Transfer 

func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IERC20TransactorSession 

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

IERC20TransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*IERC20TransactorSession) Approve 

func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Approve is a paid mutator transaction binding the contract method 0x1f2d4860.

Solidity: function approve(address spender, uint256 amount) returns(bool)

func (*IERC20TransactorSession) AsyncApprove 

func (_IERC20 *IERC20TransactorSession) AsyncApprove(handler func(*types.Receipt, error), spender common.Address, amount *big.Int) (*types.Transaction, error)

func (*IERC20TransactorSession) AsyncTransfer 

func (_IERC20 *IERC20TransactorSession) AsyncTransfer(handler func(*types.Receipt, error), recipient common.Address, amount *big.Int) (*types.Transaction, error)

func (*IERC20TransactorSession) AsyncTransferFrom 

func (_IERC20 *IERC20TransactorSession) AsyncTransferFrom(handler func(*types.Receipt, error), sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

func (*IERC20TransactorSession) Transfer 

func (_IERC20 *IERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Transfer is a paid mutator transaction binding the contract method 0x6904e965.

Solidity: function transfer(address recipient, uint256 amount) returns(bool)

func (*IERC20TransactorSession) TransferFrom 

func (_IERC20 *IERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

TransferFrom is a paid mutator transaction binding the contract method 0xad8a9731.

Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)

type IERC20Transfer 

type IERC20Transfer struct {
	From  common.Address
	To    common.Address
	Value *big.Int
	Raw   types.Log // Blockchain specific contextual infos
}

IERC20Transfer represents a Transfer event raised by the IERC20 contract.

type IERC20TransferIterator 

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

IERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC20 contract.

func (*IERC20TransferIterator) Close 

func (it *IERC20TransferIterator) Close() error

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

func (*IERC20TransferIterator) Error 

func (it *IERC20TransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*IERC20TransferIterator) Next 

func (it *IERC20TransferIterator) 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 IEthCrossChainManager 

type IEthCrossChainManager struct {
	IEthCrossChainManagerCaller     // Read-only binding to the contract
	IEthCrossChainManagerTransactor // Write-only binding to the contract
	IEthCrossChainManagerFilterer   // Log filterer for contract events
}

IEthCrossChainManager is an auto generated Go binding around a Solidity contract.

func NewIEthCrossChainManager 

func NewIEthCrossChainManager(address common.Address, backend bind.ContractBackend) (*IEthCrossChainManager, error)

NewIEthCrossChainManager creates a new instance of IEthCrossChainManager, bound to a specific deployed contract.

type IEthCrossChainManagerCaller 

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

IEthCrossChainManagerCaller is an auto generated read-only Go binding around a Solidity contract.

func NewIEthCrossChainManagerCaller 

func NewIEthCrossChainManagerCaller(address common.Address, caller bind.ContractCaller) (*IEthCrossChainManagerCaller, error)

NewIEthCrossChainManagerCaller creates a new read-only instance of IEthCrossChainManager, bound to a specific deployed contract.

type IEthCrossChainManagerCallerRaw 

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

IEthCrossChainManagerCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*IEthCrossChainManagerCallerRaw) Call 

func (_IEthCrossChainManager *IEthCrossChainManagerCallerRaw) 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 IEthCrossChainManagerCallerSession 

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

IEthCrossChainManagerCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type IEthCrossChainManagerFilterer 

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

IEthCrossChainManagerFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewIEthCrossChainManagerFilterer 

func NewIEthCrossChainManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*IEthCrossChainManagerFilterer, error)

NewIEthCrossChainManagerFilterer creates a new log filterer instance of IEthCrossChainManager, bound to a specific deployed contract.

type IEthCrossChainManagerProxy 

type IEthCrossChainManagerProxy struct {
	IEthCrossChainManagerProxyCaller     // Read-only binding to the contract
	IEthCrossChainManagerProxyTransactor // Write-only binding to the contract
	IEthCrossChainManagerProxyFilterer   // Log filterer for contract events
}

IEthCrossChainManagerProxy is an auto generated Go binding around a Solidity contract.

func NewIEthCrossChainManagerProxy 

func NewIEthCrossChainManagerProxy(address common.Address, backend bind.ContractBackend) (*IEthCrossChainManagerProxy, error)

NewIEthCrossChainManagerProxy creates a new instance of IEthCrossChainManagerProxy, bound to a specific deployed contract.

type IEthCrossChainManagerProxyCaller 

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

IEthCrossChainManagerProxyCaller is an auto generated read-only Go binding around a Solidity contract.

func NewIEthCrossChainManagerProxyCaller 

func NewIEthCrossChainManagerProxyCaller(address common.Address, caller bind.ContractCaller) (*IEthCrossChainManagerProxyCaller, error)

NewIEthCrossChainManagerProxyCaller creates a new read-only instance of IEthCrossChainManagerProxy, bound to a specific deployed contract.

func (*IEthCrossChainManagerProxyCaller) GetEthCrossChainManager 

func (_IEthCrossChainManagerProxy *IEthCrossChainManagerProxyCaller) GetEthCrossChainManager(opts *bind.CallOpts) (common.Address, error)

GetEthCrossChainManager is a free data retrieval call binding the contract method 0x483bf041.

Solidity: function getEthCrossChainManager() constant returns(address)

type IEthCrossChainManagerProxyCallerRaw 

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

IEthCrossChainManagerProxyCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*IEthCrossChainManagerProxyCallerRaw) Call 

func (_IEthCrossChainManagerProxy *IEthCrossChainManagerProxyCallerRaw) 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 IEthCrossChainManagerProxyCallerSession 

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

IEthCrossChainManagerProxyCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*IEthCrossChainManagerProxyCallerSession) GetEthCrossChainManager 

func (_IEthCrossChainManagerProxy *IEthCrossChainManagerProxyCallerSession) GetEthCrossChainManager() (common.Address, error)

GetEthCrossChainManager is a free data retrieval call binding the contract method 0x483bf041.

Solidity: function getEthCrossChainManager() constant returns(address)

type IEthCrossChainManagerProxyFilterer 

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

IEthCrossChainManagerProxyFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewIEthCrossChainManagerProxyFilterer 

func NewIEthCrossChainManagerProxyFilterer(address common.Address, filterer bind.ContractFilterer) (*IEthCrossChainManagerProxyFilterer, error)

NewIEthCrossChainManagerProxyFilterer creates a new log filterer instance of IEthCrossChainManagerProxy, bound to a specific deployed contract.

type IEthCrossChainManagerProxyRaw 

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

IEthCrossChainManagerProxyRaw is an auto generated low-level Go binding around a Solidity contract.

func (*IEthCrossChainManagerProxyRaw) Call 

func (_IEthCrossChainManagerProxy *IEthCrossChainManagerProxyRaw) 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 (*IEthCrossChainManagerProxyRaw) Transact 

func (_IEthCrossChainManagerProxy *IEthCrossChainManagerProxyRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IEthCrossChainManagerProxyRaw) Transfer 

func (_IEthCrossChainManagerProxy *IEthCrossChainManagerProxyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IEthCrossChainManagerProxySession 

type IEthCrossChainManagerProxySession struct {
	Contract     *IEthCrossChainManagerProxy // 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
}

IEthCrossChainManagerProxySession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*IEthCrossChainManagerProxySession) GetEthCrossChainManager 

func (_IEthCrossChainManagerProxy *IEthCrossChainManagerProxySession) GetEthCrossChainManager() (common.Address, error)

GetEthCrossChainManager is a free data retrieval call binding the contract method 0x483bf041.

Solidity: function getEthCrossChainManager() constant returns(address)

type IEthCrossChainManagerProxyTransactor 

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

IEthCrossChainManagerProxyTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewIEthCrossChainManagerProxyTransactor 

func NewIEthCrossChainManagerProxyTransactor(address common.Address, transactor bind.ContractTransactor) (*IEthCrossChainManagerProxyTransactor, error)

NewIEthCrossChainManagerProxyTransactor creates a new write-only instance of IEthCrossChainManagerProxy, bound to a specific deployed contract.

type IEthCrossChainManagerProxyTransactorRaw 

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

IEthCrossChainManagerProxyTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*IEthCrossChainManagerProxyTransactorRaw) Transact 

func (_IEthCrossChainManagerProxy *IEthCrossChainManagerProxyTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IEthCrossChainManagerProxyTransactorRaw) Transfer 

func (_IEthCrossChainManagerProxy *IEthCrossChainManagerProxyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IEthCrossChainManagerProxyTransactorSession 

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

IEthCrossChainManagerProxyTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

type IEthCrossChainManagerRaw 

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

IEthCrossChainManagerRaw is an auto generated low-level Go binding around a Solidity contract.

func (*IEthCrossChainManagerRaw) Call 

func (_IEthCrossChainManager *IEthCrossChainManagerRaw) 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 (*IEthCrossChainManagerRaw) Transact 

func (_IEthCrossChainManager *IEthCrossChainManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IEthCrossChainManagerRaw) Transfer 

func (_IEthCrossChainManager *IEthCrossChainManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IEthCrossChainManagerSession 

type IEthCrossChainManagerSession struct {
	Contract     *IEthCrossChainManager // 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
}

IEthCrossChainManagerSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*IEthCrossChainManagerSession) AsyncCrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerSession) AsyncCrossChain(handler func(*types.Receipt, error), _toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, error)

func (*IEthCrossChainManagerSession) CrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerSession) CrossChain(_toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, *types.Receipt, error)

CrossChain is a paid mutator transaction binding the contract method 0x1f5045a8.

Solidity: function crossChain(uint64 _toChainId, bytes _toContract, bytes _method, bytes _txData) returns(bool)

type IEthCrossChainManagerTransactor 

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

IEthCrossChainManagerTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewIEthCrossChainManagerTransactor 

func NewIEthCrossChainManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*IEthCrossChainManagerTransactor, error)

NewIEthCrossChainManagerTransactor creates a new write-only instance of IEthCrossChainManager, bound to a specific deployed contract.

func (*IEthCrossChainManagerTransactor) AsyncCrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactor) AsyncCrossChain(handler func(*types.Receipt, error), opts *bind.TransactOpts, _toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, error)

func (*IEthCrossChainManagerTransactor) CrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactor) CrossChain(opts *bind.TransactOpts, _toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, *types.Receipt, error)

CrossChain is a paid mutator transaction binding the contract method 0x1f5045a8.

Solidity: function crossChain(uint64 _toChainId, bytes _toContract, bytes _method, bytes _txData) returns(bool)

type IEthCrossChainManagerTransactorRaw 

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

IEthCrossChainManagerTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*IEthCrossChainManagerTransactorRaw) Transact 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IEthCrossChainManagerTransactorRaw) Transfer 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IEthCrossChainManagerTransactorSession 

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

IEthCrossChainManagerTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*IEthCrossChainManagerTransactorSession) AsyncCrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactorSession) AsyncCrossChain(handler func(*types.Receipt, error), _toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, error)

func (*IEthCrossChainManagerTransactorSession) CrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactorSession) CrossChain(_toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, *types.Receipt, error)

CrossChain is a paid mutator transaction binding the contract method 0x1f5045a8.

Solidity: function crossChain(uint64 _toChainId, bytes _toContract, bytes _method, bytes _txData) returns(bool)

type LockProxy 

type LockProxy struct {
	LockProxyCaller     // Read-only binding to the contract
	LockProxyTransactor // Write-only binding to the contract
	LockProxyFilterer   // Log filterer for contract events
}

LockProxy is an auto generated Go binding around a Solidity contract.

func DeployLockProxy 

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

DeployLockProxy deploys a new contract, binding an instance of LockProxy to it.

func NewLockProxy 

func NewLockProxy(address common.Address, backend bind.ContractBackend) (*LockProxy, error)

NewLockProxy creates a new instance of LockProxy, bound to a specific deployed contract.

type LockProxyBindAssetEvent 

type LockProxyBindAssetEvent struct {
	FromAssetHash   common.Address
	ToChainId       uint64
	TargetProxyHash []byte
	InitialAmount   *big.Int
	Raw             types.Log // Blockchain specific contextual infos
}

LockProxyBindAssetEvent represents a BindAssetEvent event raised by the LockProxy contract.

type LockProxyBindAssetEventIterator 

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

LockProxyBindAssetEventIterator is returned from FilterBindAssetEvent and is used to iterate over the raw logs and unpacked data for BindAssetEvent events raised by the LockProxy contract.

func (*LockProxyBindAssetEventIterator) Close 

func (it *LockProxyBindAssetEventIterator) Close() error

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

func (*LockProxyBindAssetEventIterator) Error 

func (it *LockProxyBindAssetEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*LockProxyBindAssetEventIterator) Next 

func (it *LockProxyBindAssetEventIterator) 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 LockProxyBindProxyEvent 

type LockProxyBindProxyEvent struct {
	ToChainId       uint64
	TargetProxyHash []byte
	Raw             types.Log // Blockchain specific contextual infos
}

LockProxyBindProxyEvent represents a BindProxyEvent event raised by the LockProxy contract.

type LockProxyBindProxyEventIterator 

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

LockProxyBindProxyEventIterator is returned from FilterBindProxyEvent and is used to iterate over the raw logs and unpacked data for BindProxyEvent events raised by the LockProxy contract.

func (*LockProxyBindProxyEventIterator) Close 

func (it *LockProxyBindProxyEventIterator) Close() error

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

func (*LockProxyBindProxyEventIterator) Error 

func (it *LockProxyBindProxyEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*LockProxyBindProxyEventIterator) Next 

func (it *LockProxyBindProxyEventIterator) 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 LockProxyCaller 

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

LockProxyCaller is an auto generated read-only Go binding around a Solidity contract.

func NewLockProxyCaller 

func NewLockProxyCaller(address common.Address, caller bind.ContractCaller) (*LockProxyCaller, error)

NewLockProxyCaller creates a new read-only instance of LockProxy, bound to a specific deployed contract.

func (*LockProxyCaller) AssetHashMap 

func (_LockProxy *LockProxyCaller) AssetHashMap(opts *bind.CallOpts, arg0 common.Address, arg1 uint64) ([]byte, error)

AssetHashMap is a free data retrieval call binding the contract method 0xa223c32c.

Solidity: function assetHashMap(address , uint64 ) constant returns(bytes)

func (*LockProxyCaller) GetBalanceFor 

func (_LockProxy *LockProxyCaller) GetBalanceFor(opts *bind.CallOpts, fromAssetHash common.Address) (*big.Int, error)

GetBalanceFor is a free data retrieval call binding the contract method 0x783ca7dc.

Solidity: function getBalanceFor(address fromAssetHash) constant returns(uint256)

func (*LockProxyCaller) IsOwner 

func (_LockProxy *LockProxyCaller) IsOwner(opts *bind.CallOpts) (bool, error)

IsOwner is a free data retrieval call binding the contract method 0xede8e529.

Solidity: function isOwner() constant returns(bool)

func (*LockProxyCaller) ManagerProxyContract 

func (_LockProxy *LockProxyCaller) ManagerProxyContract(opts *bind.CallOpts) (common.Address, error)

ManagerProxyContract is a free data retrieval call binding the contract method 0xffcaba74.

Solidity: function managerProxyContract() constant returns(address)

func (*LockProxyCaller) Owner 

func (_LockProxy *LockProxyCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x5089e2c8.

Solidity: function owner() constant returns(address)

func (*LockProxyCaller) ProxyHashMap 

func (_LockProxy *LockProxyCaller) ProxyHashMap(opts *bind.CallOpts, arg0 uint64) ([]byte, error)

ProxyHashMap is a free data retrieval call binding the contract method 0xead1f21f.

Solidity: function proxyHashMap(uint64 ) constant returns(bytes)

type LockProxyCallerRaw 

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

LockProxyCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*LockProxyCallerRaw) Call 

func (_LockProxy *LockProxyCallerRaw) 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 LockProxyCallerSession 

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

LockProxyCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*LockProxyCallerSession) AssetHashMap 

func (_LockProxy *LockProxyCallerSession) AssetHashMap(arg0 common.Address, arg1 uint64) ([]byte, error)

AssetHashMap is a free data retrieval call binding the contract method 0xa223c32c.

Solidity: function assetHashMap(address , uint64 ) constant returns(bytes)

func (*LockProxyCallerSession) GetBalanceFor 

func (_LockProxy *LockProxyCallerSession) GetBalanceFor(fromAssetHash common.Address) (*big.Int, error)

GetBalanceFor is a free data retrieval call binding the contract method 0x783ca7dc.

Solidity: function getBalanceFor(address fromAssetHash) constant returns(uint256)

func (*LockProxyCallerSession) IsOwner 

func (_LockProxy *LockProxyCallerSession) IsOwner() (bool, error)

IsOwner is a free data retrieval call binding the contract method 0xede8e529.

Solidity: function isOwner() constant returns(bool)

func (*LockProxyCallerSession) ManagerProxyContract 

func (_LockProxy *LockProxyCallerSession) ManagerProxyContract() (common.Address, error)

ManagerProxyContract is a free data retrieval call binding the contract method 0xffcaba74.

Solidity: function managerProxyContract() constant returns(address)

func (*LockProxyCallerSession) Owner 

func (_LockProxy *LockProxyCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x5089e2c8.

Solidity: function owner() constant returns(address)

func (*LockProxyCallerSession) ProxyHashMap 

func (_LockProxy *LockProxyCallerSession) ProxyHashMap(arg0 uint64) ([]byte, error)

ProxyHashMap is a free data retrieval call binding the contract method 0xead1f21f.

Solidity: function proxyHashMap(uint64 ) constant returns(bytes)

type LockProxyFilterer 

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

LockProxyFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewLockProxyFilterer 

func NewLockProxyFilterer(address common.Address, filterer bind.ContractFilterer) (*LockProxyFilterer, error)

NewLockProxyFilterer creates a new log filterer instance of LockProxy, bound to a specific deployed contract.

func (*LockProxyFilterer) FilterBindAssetEvent 

func (_LockProxy *LockProxyFilterer) FilterBindAssetEvent(opts *bind.FilterOpts) (*LockProxyBindAssetEventIterator, error)

FilterBindAssetEvent is a free log retrieval operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000e3a41ce6.

Solidity: event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint256 initialAmount)

func (*LockProxyFilterer) FilterBindProxyEvent 

func (_LockProxy *LockProxyFilterer) FilterBindProxyEvent(opts *bind.FilterOpts) (*LockProxyBindProxyEventIterator, error)

FilterBindProxyEvent is a free log retrieval operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000031c20b3e.

Solidity: event BindProxyEvent(uint64 toChainId, bytes targetProxyHash)

func (*LockProxyFilterer) FilterLockEvent 

func (_LockProxy *LockProxyFilterer) FilterLockEvent(opts *bind.FilterOpts) (*LockProxyLockEventIterator, error)

FilterLockEvent is a free log retrieval operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000fb8999b3.

Solidity: event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount)

func (*LockProxyFilterer) FilterOwnershipTransferred 

func (_LockProxy *LockProxyFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*LockProxyOwnershipTransferredIterator, error)

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x000000000000000000000000000000000000000000000000000000005c7c30d4.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*LockProxyFilterer) FilterSetManagerProxyEvent 

func (_LockProxy *LockProxyFilterer) FilterSetManagerProxyEvent(opts *bind.FilterOpts) (*LockProxySetManagerProxyEventIterator, error)

FilterSetManagerProxyEvent is a free log retrieval operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000ecc5d052.

Solidity: event SetManagerProxyEvent(address manager)

func (*LockProxyFilterer) FilterUnlockEvent 

func (_LockProxy *LockProxyFilterer) FilterUnlockEvent(opts *bind.FilterOpts) (*LockProxyUnlockEventIterator, error)

FilterUnlockEvent is a free log retrieval operation binding the contract event 0x000000000000000000000000000000000000000000000000000000004cf264bf.

Solidity: event UnlockEvent(address toAssetHash, address toAddress, uint256 amount)

func (*LockProxyFilterer) ParseBindAssetEvent 

func (_LockProxy *LockProxyFilterer) ParseBindAssetEvent(log types.Log) (*LockProxyBindAssetEvent, error)

ParseBindAssetEvent is a log parse operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000e3a41ce6.

Solidity: event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint256 initialAmount)

func (*LockProxyFilterer) ParseBindProxyEvent 

func (_LockProxy *LockProxyFilterer) ParseBindProxyEvent(log types.Log) (*LockProxyBindProxyEvent, error)

ParseBindProxyEvent is a log parse operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000031c20b3e.

Solidity: event BindProxyEvent(uint64 toChainId, bytes targetProxyHash)

func (*LockProxyFilterer) ParseLockEvent 

func (_LockProxy *LockProxyFilterer) ParseLockEvent(log types.Log) (*LockProxyLockEvent, error)

ParseLockEvent is a log parse operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000fb8999b3.

Solidity: event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount)

func (*LockProxyFilterer) ParseOwnershipTransferred 

func (_LockProxy *LockProxyFilterer) ParseOwnershipTransferred(log types.Log) (*LockProxyOwnershipTransferred, error)

ParseOwnershipTransferred is a log parse operation binding the contract event 0x000000000000000000000000000000000000000000000000000000005c7c30d4.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*LockProxyFilterer) ParseSetManagerProxyEvent 

func (_LockProxy *LockProxyFilterer) ParseSetManagerProxyEvent(log types.Log) (*LockProxySetManagerProxyEvent, error)

ParseSetManagerProxyEvent is a log parse operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000ecc5d052.

Solidity: event SetManagerProxyEvent(address manager)

func (*LockProxyFilterer) ParseUnlockEvent 

func (_LockProxy *LockProxyFilterer) ParseUnlockEvent(log types.Log) (*LockProxyUnlockEvent, error)

ParseUnlockEvent is a log parse operation binding the contract event 0x000000000000000000000000000000000000000000000000000000004cf264bf.

Solidity: event UnlockEvent(address toAssetHash, address toAddress, uint256 amount)

func (*LockProxyFilterer) WatchBindAssetEvent 

func (_LockProxy *LockProxyFilterer) WatchBindAssetEvent(opts *bind.WatchOpts, sink chan<- *LockProxyBindAssetEvent) (event.Subscription, error)

WatchBindAssetEvent is a free log subscription operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000e3a41ce6.

Solidity: event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint256 initialAmount)

func (*LockProxyFilterer) WatchBindProxyEvent 

func (_LockProxy *LockProxyFilterer) WatchBindProxyEvent(opts *bind.WatchOpts, sink chan<- *LockProxyBindProxyEvent) (event.Subscription, error)

WatchBindProxyEvent is a free log subscription operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000031c20b3e.

Solidity: event BindProxyEvent(uint64 toChainId, bytes targetProxyHash)

func (*LockProxyFilterer) WatchLockEvent 

func (_LockProxy *LockProxyFilterer) WatchLockEvent(opts *bind.WatchOpts, sink chan<- *LockProxyLockEvent) (event.Subscription, error)

WatchLockEvent is a free log subscription operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000fb8999b3.

Solidity: event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount)

func (*LockProxyFilterer) WatchOwnershipTransferred 

func (_LockProxy *LockProxyFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *LockProxyOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x000000000000000000000000000000000000000000000000000000005c7c30d4.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*LockProxyFilterer) WatchSetManagerProxyEvent 

func (_LockProxy *LockProxyFilterer) WatchSetManagerProxyEvent(opts *bind.WatchOpts, sink chan<- *LockProxySetManagerProxyEvent) (event.Subscription, error)

WatchSetManagerProxyEvent is a free log subscription operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000ecc5d052.

Solidity: event SetManagerProxyEvent(address manager)

func (*LockProxyFilterer) WatchUnlockEvent 

func (_LockProxy *LockProxyFilterer) WatchUnlockEvent(opts *bind.WatchOpts, sink chan<- *LockProxyUnlockEvent) (event.Subscription, error)

WatchUnlockEvent is a free log subscription operation binding the contract event 0x000000000000000000000000000000000000000000000000000000004cf264bf.

Solidity: event UnlockEvent(address toAssetHash, address toAddress, uint256 amount)

type LockProxyLockEvent 

type LockProxyLockEvent struct {
	FromAssetHash common.Address
	FromAddress   common.Address
	ToChainId     uint64
	ToAssetHash   []byte
	ToAddress     []byte
	Amount        *big.Int
	Raw           types.Log // Blockchain specific contextual infos
}

LockProxyLockEvent represents a LockEvent event raised by the LockProxy contract.

type LockProxyLockEventIterator 

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

LockProxyLockEventIterator is returned from FilterLockEvent and is used to iterate over the raw logs and unpacked data for LockEvent events raised by the LockProxy contract.

func (*LockProxyLockEventIterator) Close 

func (it *LockProxyLockEventIterator) Close() error

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

func (*LockProxyLockEventIterator) Error 

func (it *LockProxyLockEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*LockProxyLockEventIterator) Next 

func (it *LockProxyLockEventIterator) 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 LockProxyOwnershipTransferred 

type LockProxyOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

LockProxyOwnershipTransferred represents a OwnershipTransferred event raised by the LockProxy contract.

type LockProxyOwnershipTransferredIterator 

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

LockProxyOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the LockProxy contract.

func (*LockProxyOwnershipTransferredIterator) Close 

func (it *LockProxyOwnershipTransferredIterator) Close() error

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

func (*LockProxyOwnershipTransferredIterator) Error 

func (it *LockProxyOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*LockProxyOwnershipTransferredIterator) Next 

func (it *LockProxyOwnershipTransferredIterator) 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 LockProxyRaw 

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

LockProxyRaw is an auto generated low-level Go binding around a Solidity contract.

func (*LockProxyRaw) Call 

func (_LockProxy *LockProxyRaw) 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 (*LockProxyRaw) Transact 

func (_LockProxy *LockProxyRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*LockProxyRaw) Transfer 

func (_LockProxy *LockProxyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type LockProxySession 

type LockProxySession struct {
	Contract     *LockProxy        // 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
}

LockProxySession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*LockProxySession) AssetHashMap 

func (_LockProxy *LockProxySession) AssetHashMap(arg0 common.Address, arg1 uint64) ([]byte, error)

AssetHashMap is a free data retrieval call binding the contract method 0xa223c32c.

Solidity: function assetHashMap(address , uint64 ) constant returns(bytes)

func (*LockProxySession) AsyncBindAssetHash 

func (_LockProxy *LockProxySession) AsyncBindAssetHash(handler func(*types.Receipt, error), fromAssetHash common.Address, toChainId uint64, toAssetHash []byte) (*types.Transaction, error)

func (*LockProxySession) AsyncBindProxyHash 

func (_LockProxy *LockProxySession) AsyncBindProxyHash(handler func(*types.Receipt, error), toChainId uint64, targetProxyHash []byte) (*types.Transaction, error)

func (*LockProxySession) AsyncLock 

func (_LockProxy *LockProxySession) AsyncLock(handler func(*types.Receipt, error), fromAssetHash common.Address, toChainId uint64, toAddress []byte, amount *big.Int) (*types.Transaction, error)

func (*LockProxySession) AsyncRenounceOwnership 

func (_LockProxy *LockProxySession) AsyncRenounceOwnership(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*LockProxySession) AsyncSetManagerProxy 

func (_LockProxy *LockProxySession) AsyncSetManagerProxy(handler func(*types.Receipt, error), ethCCMProxyAddr common.Address) (*types.Transaction, error)

func (*LockProxySession) AsyncTransferOwnership 

func (_LockProxy *LockProxySession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*LockProxySession) AsyncUnlock 

func (_LockProxy *LockProxySession) AsyncUnlock(handler func(*types.Receipt, error), argsBs []byte, fromContractAddr []byte, fromChainId uint64) (*types.Transaction, error)

func (*LockProxySession) BindAssetHash 

func (_LockProxy *LockProxySession) BindAssetHash(fromAssetHash common.Address, toChainId uint64, toAssetHash []byte) (*types.Transaction, *types.Receipt, error)

BindAssetHash is a paid mutator transaction binding the contract method 0xdfe848a5.

Solidity: function bindAssetHash(address fromAssetHash, uint64 toChainId, bytes toAssetHash) returns(bool)

func (*LockProxySession) BindProxyHash 

func (_LockProxy *LockProxySession) BindProxyHash(toChainId uint64, targetProxyHash []byte) (*types.Transaction, *types.Receipt, error)

BindProxyHash is a paid mutator transaction binding the contract method 0x6e5d9c8f.

Solidity: function bindProxyHash(uint64 toChainId, bytes targetProxyHash) returns(bool)

func (*LockProxySession) GetBalanceFor 

func (_LockProxy *LockProxySession) GetBalanceFor(fromAssetHash common.Address) (*big.Int, error)

GetBalanceFor is a free data retrieval call binding the contract method 0x783ca7dc.

Solidity: function getBalanceFor(address fromAssetHash) constant returns(uint256)

func (*LockProxySession) IsOwner 

func (_LockProxy *LockProxySession) IsOwner() (bool, error)

IsOwner is a free data retrieval call binding the contract method 0xede8e529.

Solidity: function isOwner() constant returns(bool)

func (*LockProxySession) Lock 

func (_LockProxy *LockProxySession) Lock(fromAssetHash common.Address, toChainId uint64, toAddress []byte, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Lock is a paid mutator transaction binding the contract method 0x514e3836.

Solidity: function lock(address fromAssetHash, uint64 toChainId, bytes toAddress, uint256 amount) returns(bool)

func (*LockProxySession) ManagerProxyContract 

func (_LockProxy *LockProxySession) ManagerProxyContract() (common.Address, error)

ManagerProxyContract is a free data retrieval call binding the contract method 0xffcaba74.

Solidity: function managerProxyContract() constant returns(address)

func (*LockProxySession) Owner 

func (_LockProxy *LockProxySession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x5089e2c8.

Solidity: function owner() constant returns(address)

func (*LockProxySession) ProxyHashMap 

func (_LockProxy *LockProxySession) ProxyHashMap(arg0 uint64) ([]byte, error)

ProxyHashMap is a free data retrieval call binding the contract method 0xead1f21f.

Solidity: function proxyHashMap(uint64 ) constant returns(bytes)

func (*LockProxySession) RenounceOwnership 

func (_LockProxy *LockProxySession) RenounceOwnership() (*types.Transaction, *types.Receipt, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0xd86e29e2.

Solidity: function renounceOwnership() returns()

func (*LockProxySession) SetManagerProxy 

func (_LockProxy *LockProxySession) SetManagerProxy(ethCCMProxyAddr common.Address) (*types.Transaction, *types.Receipt, error)

SetManagerProxy is a paid mutator transaction binding the contract method 0x7430f358.

Solidity: function setManagerProxy(address ethCCMProxyAddr) returns()

func (*LockProxySession) TransferOwnership 

func (_LockProxy *LockProxySession) TransferOwnership(newOwner common.Address) (*types.Transaction, *types.Receipt, error)

TransferOwnership is a paid mutator transaction binding the contract method 0x16cad12a.

Solidity: function transferOwnership(address newOwner) returns()

func (*LockProxySession) Unlock 

func (_LockProxy *LockProxySession) Unlock(argsBs []byte, fromContractAddr []byte, fromChainId uint64) (*types.Transaction, *types.Receipt, error)

Unlock is a paid mutator transaction binding the contract method 0x4d7ee918.

Solidity: function unlock(bytes argsBs, bytes fromContractAddr, uint64 fromChainId) returns(bool)

type LockProxySetManagerProxyEvent 

type LockProxySetManagerProxyEvent struct {
	Manager common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

LockProxySetManagerProxyEvent represents a SetManagerProxyEvent event raised by the LockProxy contract.

type LockProxySetManagerProxyEventIterator 

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

LockProxySetManagerProxyEventIterator is returned from FilterSetManagerProxyEvent and is used to iterate over the raw logs and unpacked data for SetManagerProxyEvent events raised by the LockProxy contract.

func (*LockProxySetManagerProxyEventIterator) Close 

func (it *LockProxySetManagerProxyEventIterator) Close() error

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

func (*LockProxySetManagerProxyEventIterator) Error 

func (it *LockProxySetManagerProxyEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*LockProxySetManagerProxyEventIterator) Next 

func (it *LockProxySetManagerProxyEventIterator) 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 LockProxyTransactor 

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

LockProxyTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewLockProxyTransactor 

func NewLockProxyTransactor(address common.Address, transactor bind.ContractTransactor) (*LockProxyTransactor, error)

NewLockProxyTransactor creates a new write-only instance of LockProxy, bound to a specific deployed contract.

func (*LockProxyTransactor) AsyncBindAssetHash 

func (_LockProxy *LockProxyTransactor) AsyncBindAssetHash(handler func(*types.Receipt, error), opts *bind.TransactOpts, fromAssetHash common.Address, toChainId uint64, toAssetHash []byte) (*types.Transaction, error)

func (*LockProxyTransactor) AsyncBindProxyHash 

func (_LockProxy *LockProxyTransactor) AsyncBindProxyHash(handler func(*types.Receipt, error), opts *bind.TransactOpts, toChainId uint64, targetProxyHash []byte) (*types.Transaction, error)

func (*LockProxyTransactor) AsyncLock 

func (_LockProxy *LockProxyTransactor) AsyncLock(handler func(*types.Receipt, error), opts *bind.TransactOpts, fromAssetHash common.Address, toChainId uint64, toAddress []byte, amount *big.Int) (*types.Transaction, error)

func (*LockProxyTransactor) AsyncRenounceOwnership 

func (_LockProxy *LockProxyTransactor) AsyncRenounceOwnership(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*LockProxyTransactor) AsyncSetManagerProxy 

func (_LockProxy *LockProxyTransactor) AsyncSetManagerProxy(handler func(*types.Receipt, error), opts *bind.TransactOpts, ethCCMProxyAddr common.Address) (*types.Transaction, error)

func (*LockProxyTransactor) AsyncTransferOwnership 

func (_LockProxy *LockProxyTransactor) AsyncTransferOwnership(handler func(*types.Receipt, error), opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

func (*LockProxyTransactor) AsyncUnlock 

func (_LockProxy *LockProxyTransactor) AsyncUnlock(handler func(*types.Receipt, error), opts *bind.TransactOpts, argsBs []byte, fromContractAddr []byte, fromChainId uint64) (*types.Transaction, error)

func (*LockProxyTransactor) BindAssetHash 

func (_LockProxy *LockProxyTransactor) BindAssetHash(opts *bind.TransactOpts, fromAssetHash common.Address, toChainId uint64, toAssetHash []byte) (*types.Transaction, *types.Receipt, error)

BindAssetHash is a paid mutator transaction binding the contract method 0xdfe848a5.

Solidity: function bindAssetHash(address fromAssetHash, uint64 toChainId, bytes toAssetHash) returns(bool)

func (*LockProxyTransactor) BindProxyHash 

func (_LockProxy *LockProxyTransactor) BindProxyHash(opts *bind.TransactOpts, toChainId uint64, targetProxyHash []byte) (*types.Transaction, *types.Receipt, error)

BindProxyHash is a paid mutator transaction binding the contract method 0x6e5d9c8f.

Solidity: function bindProxyHash(uint64 toChainId, bytes targetProxyHash) returns(bool)

func (*LockProxyTransactor) Lock 

func (_LockProxy *LockProxyTransactor) Lock(opts *bind.TransactOpts, fromAssetHash common.Address, toChainId uint64, toAddress []byte, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Lock is a paid mutator transaction binding the contract method 0x514e3836.

Solidity: function lock(address fromAssetHash, uint64 toChainId, bytes toAddress, uint256 amount) returns(bool)

func (*LockProxyTransactor) RenounceOwnership 

func (_LockProxy *LockProxyTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0xd86e29e2.

Solidity: function renounceOwnership() returns()

func (*LockProxyTransactor) SetManagerProxy 

func (_LockProxy *LockProxyTransactor) SetManagerProxy(opts *bind.TransactOpts, ethCCMProxyAddr common.Address) (*types.Transaction, *types.Receipt, error)

SetManagerProxy is a paid mutator transaction binding the contract method 0x7430f358.

Solidity: function setManagerProxy(address ethCCMProxyAddr) returns()

func (*LockProxyTransactor) TransferOwnership 

func (_LockProxy *LockProxyTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, *types.Receipt, error)

TransferOwnership is a paid mutator transaction binding the contract method 0x16cad12a.

Solidity: function transferOwnership(address newOwner) returns()

func (*LockProxyTransactor) Unlock 

func (_LockProxy *LockProxyTransactor) Unlock(opts *bind.TransactOpts, argsBs []byte, fromContractAddr []byte, fromChainId uint64) (*types.Transaction, *types.Receipt, error)

Unlock is a paid mutator transaction binding the contract method 0x4d7ee918.

Solidity: function unlock(bytes argsBs, bytes fromContractAddr, uint64 fromChainId) returns(bool)

type LockProxyTransactorRaw 

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

LockProxyTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*LockProxyTransactorRaw) Transact 

func (_LockProxy *LockProxyTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*LockProxyTransactorRaw) Transfer 

func (_LockProxy *LockProxyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type LockProxyTransactorSession 

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

LockProxyTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*LockProxyTransactorSession) AsyncBindAssetHash 

func (_LockProxy *LockProxyTransactorSession) AsyncBindAssetHash(handler func(*types.Receipt, error), fromAssetHash common.Address, toChainId uint64, toAssetHash []byte) (*types.Transaction, error)

func (*LockProxyTransactorSession) AsyncBindProxyHash 

func (_LockProxy *LockProxyTransactorSession) AsyncBindProxyHash(handler func(*types.Receipt, error), toChainId uint64, targetProxyHash []byte) (*types.Transaction, error)

func (*LockProxyTransactorSession) AsyncLock 

func (_LockProxy *LockProxyTransactorSession) AsyncLock(handler func(*types.Receipt, error), fromAssetHash common.Address, toChainId uint64, toAddress []byte, amount *big.Int) (*types.Transaction, error)

func (*LockProxyTransactorSession) AsyncRenounceOwnership 

func (_LockProxy *LockProxyTransactorSession) AsyncRenounceOwnership(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*LockProxyTransactorSession) AsyncSetManagerProxy 

func (_LockProxy *LockProxyTransactorSession) AsyncSetManagerProxy(handler func(*types.Receipt, error), ethCCMProxyAddr common.Address) (*types.Transaction, error)

func (*LockProxyTransactorSession) AsyncTransferOwnership 

func (_LockProxy *LockProxyTransactorSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*LockProxyTransactorSession) AsyncUnlock 

func (_LockProxy *LockProxyTransactorSession) AsyncUnlock(handler func(*types.Receipt, error), argsBs []byte, fromContractAddr []byte, fromChainId uint64) (*types.Transaction, error)

func (*LockProxyTransactorSession) BindAssetHash 

func (_LockProxy *LockProxyTransactorSession) BindAssetHash(fromAssetHash common.Address, toChainId uint64, toAssetHash []byte) (*types.Transaction, *types.Receipt, error)

BindAssetHash is a paid mutator transaction binding the contract method 0xdfe848a5.

Solidity: function bindAssetHash(address fromAssetHash, uint64 toChainId, bytes toAssetHash) returns(bool)

func (*LockProxyTransactorSession) BindProxyHash 

func (_LockProxy *LockProxyTransactorSession) BindProxyHash(toChainId uint64, targetProxyHash []byte) (*types.Transaction, *types.Receipt, error)

BindProxyHash is a paid mutator transaction binding the contract method 0x6e5d9c8f.

Solidity: function bindProxyHash(uint64 toChainId, bytes targetProxyHash) returns(bool)

func (*LockProxyTransactorSession) Lock 

func (_LockProxy *LockProxyTransactorSession) Lock(fromAssetHash common.Address, toChainId uint64, toAddress []byte, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Lock is a paid mutator transaction binding the contract method 0x514e3836.

Solidity: function lock(address fromAssetHash, uint64 toChainId, bytes toAddress, uint256 amount) returns(bool)

func (*LockProxyTransactorSession) RenounceOwnership 

func (_LockProxy *LockProxyTransactorSession) RenounceOwnership() (*types.Transaction, *types.Receipt, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0xd86e29e2.

Solidity: function renounceOwnership() returns()

func (*LockProxyTransactorSession) SetManagerProxy 

func (_LockProxy *LockProxyTransactorSession) SetManagerProxy(ethCCMProxyAddr common.Address) (*types.Transaction, *types.Receipt, error)

SetManagerProxy is a paid mutator transaction binding the contract method 0x7430f358.

Solidity: function setManagerProxy(address ethCCMProxyAddr) returns()

func (*LockProxyTransactorSession) TransferOwnership 

func (_LockProxy *LockProxyTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, *types.Receipt, error)

TransferOwnership is a paid mutator transaction binding the contract method 0x16cad12a.

Solidity: function transferOwnership(address newOwner) returns()

func (*LockProxyTransactorSession) Unlock 

func (_LockProxy *LockProxyTransactorSession) Unlock(argsBs []byte, fromContractAddr []byte, fromChainId uint64) (*types.Transaction, *types.Receipt, error)

Unlock is a paid mutator transaction binding the contract method 0x4d7ee918.

Solidity: function unlock(bytes argsBs, bytes fromContractAddr, uint64 fromChainId) returns(bool)

type LockProxyUnlockEvent 

type LockProxyUnlockEvent struct {
	ToAssetHash common.Address
	ToAddress   common.Address
	Amount      *big.Int
	Raw         types.Log // Blockchain specific contextual infos
}

LockProxyUnlockEvent represents a UnlockEvent event raised by the LockProxy contract.

type LockProxyUnlockEventIterator 

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

LockProxyUnlockEventIterator is returned from FilterUnlockEvent and is used to iterate over the raw logs and unpacked data for UnlockEvent events raised by the LockProxy contract.

func (*LockProxyUnlockEventIterator) Close 

func (it *LockProxyUnlockEventIterator) Close() error

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

func (*LockProxyUnlockEventIterator) Error 

func (it *LockProxyUnlockEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*LockProxyUnlockEventIterator) Next 

func (it *LockProxyUnlockEventIterator) 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 Ownable 

type Ownable struct {
	OwnableCaller     // Read-only binding to the contract
	OwnableTransactor // Write-only binding to the contract
	OwnableFilterer   // Log filterer for contract events
}

Ownable is an auto generated Go binding around a Solidity contract.

func NewOwnable 

func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error)

NewOwnable creates a new instance of Ownable, bound to a specific deployed contract.

type OwnableCaller 

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

OwnableCaller is an auto generated read-only Go binding around a Solidity contract.

func NewOwnableCaller 

func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error)

NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract.

func (*OwnableCaller) IsOwner 

func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error)

IsOwner is a free data retrieval call binding the contract method 0xede8e529.

Solidity: function isOwner() constant returns(bool)

func (*OwnableCaller) Owner 

func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x5089e2c8.

Solidity: function owner() constant returns(address)

type OwnableCallerRaw 

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

OwnableCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*OwnableCallerRaw) Call 

func (_Ownable *OwnableCallerRaw) 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 OwnableCallerSession 

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

OwnableCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*OwnableCallerSession) IsOwner 

func (_Ownable *OwnableCallerSession) IsOwner() (bool, error)

IsOwner is a free data retrieval call binding the contract method 0xede8e529.

Solidity: function isOwner() constant returns(bool)

func (*OwnableCallerSession) Owner 

func (_Ownable *OwnableCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x5089e2c8.

Solidity: function owner() constant returns(address)

type OwnableFilterer 

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

OwnableFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewOwnableFilterer 

func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error)

NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract.

func (*OwnableFilterer) FilterOwnershipTransferred 

func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, error)

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x000000000000000000000000000000000000000000000000000000005c7c30d4.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*OwnableFilterer) ParseOwnershipTransferred 

func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error)

ParseOwnershipTransferred is a log parse operation binding the contract event 0x000000000000000000000000000000000000000000000000000000005c7c30d4.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*OwnableFilterer) WatchOwnershipTransferred 

func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x000000000000000000000000000000000000000000000000000000005c7c30d4.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

type OwnableOwnershipTransferred 

type OwnableOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract.

type OwnableOwnershipTransferredIterator 

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

OwnableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Ownable contract.

func (*OwnableOwnershipTransferredIterator) Close 

func (it *OwnableOwnershipTransferredIterator) Close() error

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

func (*OwnableOwnershipTransferredIterator) Error 

func (it *OwnableOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OwnableOwnershipTransferredIterator) Next 

func (it *OwnableOwnershipTransferredIterator) 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 OwnableRaw 

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

OwnableRaw is an auto generated low-level Go binding around a Solidity contract.

func (*OwnableRaw) Call 

func (_Ownable *OwnableRaw) 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 (*OwnableRaw) Transact 

func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*OwnableRaw) Transfer 

func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type OwnableSession 

type OwnableSession struct {
	Contract     *Ownable          // 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
}

OwnableSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*OwnableSession) AsyncRenounceOwnership 

func (_Ownable *OwnableSession) AsyncRenounceOwnership(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*OwnableSession) AsyncTransferOwnership 

func (_Ownable *OwnableSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*OwnableSession) IsOwner 

func (_Ownable *OwnableSession) IsOwner() (bool, error)

IsOwner is a free data retrieval call binding the contract method 0xede8e529.

Solidity: function isOwner() constant returns(bool)

func (*OwnableSession) Owner 

func (_Ownable *OwnableSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x5089e2c8.

Solidity: function owner() constant returns(address)

func (*OwnableSession) RenounceOwnership 

func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, *types.Receipt, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0xd86e29e2.

Solidity: function renounceOwnership() returns()

func (*OwnableSession) TransferOwnership 

func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, *types.Receipt, error)

TransferOwnership is a paid mutator transaction binding the contract method 0x16cad12a.

Solidity: function transferOwnership(address newOwner) returns()

type OwnableTransactor 

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

OwnableTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewOwnableTransactor 

func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error)

NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract.

func (*OwnableTransactor) AsyncRenounceOwnership 

func (_Ownable *OwnableTransactor) AsyncRenounceOwnership(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*OwnableTransactor) AsyncTransferOwnership 

func (_Ownable *OwnableTransactor) AsyncTransferOwnership(handler func(*types.Receipt, error), opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

func (*OwnableTransactor) RenounceOwnership 

func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0xd86e29e2.

Solidity: function renounceOwnership() returns()

func (*OwnableTransactor) TransferOwnership 

func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, *types.Receipt, error)

TransferOwnership is a paid mutator transaction binding the contract method 0x16cad12a.

Solidity: function transferOwnership(address newOwner) returns()

type OwnableTransactorRaw 

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

OwnableTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*OwnableTransactorRaw) Transact 

func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*OwnableTransactorRaw) Transfer 

func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type OwnableTransactorSession 

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

OwnableTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*OwnableTransactorSession) AsyncRenounceOwnership 

func (_Ownable *OwnableTransactorSession) AsyncRenounceOwnership(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*OwnableTransactorSession) AsyncTransferOwnership 

func (_Ownable *OwnableTransactorSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*OwnableTransactorSession) RenounceOwnership 

func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, *types.Receipt, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0xd86e29e2.

Solidity: function renounceOwnership() returns()

func (*OwnableTransactorSession) TransferOwnership 

func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, *types.Receipt, error)

TransferOwnership is a paid mutator transaction binding the contract method 0x16cad12a.

Solidity: function transferOwnership(address newOwner) returns()

type SafeERC20 

type SafeERC20 struct {
	SafeERC20Caller     // Read-only binding to the contract
	SafeERC20Transactor // Write-only binding to the contract
	SafeERC20Filterer   // Log filterer for contract events
}

SafeERC20 is an auto generated Go binding around a Solidity contract.

func DeploySafeERC20 

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

DeploySafeERC20 deploys a new contract, binding an instance of SafeERC20 to it.

func NewSafeERC20 

func NewSafeERC20(address common.Address, backend bind.ContractBackend) (*SafeERC20, error)

NewSafeERC20 creates a new instance of SafeERC20, bound to a specific deployed contract.

type SafeERC20Caller 

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

SafeERC20Caller is an auto generated read-only Go binding around a Solidity contract.

func NewSafeERC20Caller 

func NewSafeERC20Caller(address common.Address, caller bind.ContractCaller) (*SafeERC20Caller, error)

NewSafeERC20Caller creates a new read-only instance of SafeERC20, bound to a specific deployed contract.

type SafeERC20CallerRaw 

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

SafeERC20CallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*SafeERC20CallerRaw) Call 

func (_SafeERC20 *SafeERC20CallerRaw) 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 SafeERC20CallerSession 

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

SafeERC20CallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type SafeERC20Filterer 

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

SafeERC20Filterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewSafeERC20Filterer 

func NewSafeERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*SafeERC20Filterer, error)

NewSafeERC20Filterer creates a new log filterer instance of SafeERC20, bound to a specific deployed contract.

type SafeERC20Raw 

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

SafeERC20Raw is an auto generated low-level Go binding around a Solidity contract.

func (*SafeERC20Raw) Call 

func (_SafeERC20 *SafeERC20Raw) 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 (*SafeERC20Raw) Transact 

func (_SafeERC20 *SafeERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*SafeERC20Raw) Transfer 

func (_SafeERC20 *SafeERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type SafeERC20Session 

type SafeERC20Session struct {
	Contract     *SafeERC20        // 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
}

SafeERC20Session is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

type SafeERC20Transactor 

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

SafeERC20Transactor is an auto generated write-only Go binding around a Solidity contract.

func NewSafeERC20Transactor 

func NewSafeERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*SafeERC20Transactor, error)

NewSafeERC20Transactor creates a new write-only instance of SafeERC20, bound to a specific deployed contract.

type SafeERC20TransactorRaw 

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

SafeERC20TransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*SafeERC20TransactorRaw) Transact 

func (_SafeERC20 *SafeERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*SafeERC20TransactorRaw) Transfer 

func (_SafeERC20 *SafeERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type SafeERC20TransactorSession 

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

SafeERC20TransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

type SafeMath 

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

SafeMath is an auto generated Go binding around a Solidity contract.

func DeploySafeMath 

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

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

func NewSafeMath 

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

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

type SafeMathCaller 

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

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

func NewSafeMathCaller 

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

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

type SafeMathCallerRaw 

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

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

func (*SafeMathCallerRaw) Call 

func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type SafeMathCallerSession 

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

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

type SafeMathFilterer 

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

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

func NewSafeMathFilterer 

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

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

type SafeMathRaw 

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

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

func (*SafeMathRaw) Call 

func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*SafeMathRaw) Transact 

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

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

func (*SafeMathRaw) Transfer 

func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type SafeMathSession 

type SafeMathSession struct {
	Contract     *SafeMath         // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

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

type SafeMathTransactor 

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

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

func NewSafeMathTransactor 

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

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

type SafeMathTransactorRaw 

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

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

func (*SafeMathTransactorRaw) Transact 

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

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

func (*SafeMathTransactorRaw) Transfer 

func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type SafeMathTransactorSession 

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

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

type Utils 

type Utils struct {
	UtilsCaller     // Read-only binding to the contract
	UtilsTransactor // Write-only binding to the contract
	UtilsFilterer   // Log filterer for contract events
}

Utils is an auto generated Go binding around a Solidity contract.

func DeployUtils 

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

DeployUtils deploys a new contract, binding an instance of Utils to it.

func NewUtils 

func NewUtils(address common.Address, backend bind.ContractBackend) (*Utils, error)

NewUtils creates a new instance of Utils, bound to a specific deployed contract.

type UtilsCaller 

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

UtilsCaller is an auto generated read-only Go binding around a Solidity contract.

func NewUtilsCaller 

func NewUtilsCaller(address common.Address, caller bind.ContractCaller) (*UtilsCaller, error)

NewUtilsCaller creates a new read-only instance of Utils, bound to a specific deployed contract.

type UtilsCallerRaw 

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

UtilsCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*UtilsCallerRaw) Call 

func (_Utils *UtilsCallerRaw) 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 UtilsCallerSession 

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

UtilsCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type UtilsFilterer 

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

UtilsFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewUtilsFilterer 

func NewUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*UtilsFilterer, error)

NewUtilsFilterer creates a new log filterer instance of Utils, bound to a specific deployed contract.

type UtilsRaw 

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

UtilsRaw is an auto generated low-level Go binding around a Solidity contract.

func (*UtilsRaw) Call 

func (_Utils *UtilsRaw) 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 (*UtilsRaw) Transact 

func (_Utils *UtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*UtilsRaw) Transfer 

func (_Utils *UtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type UtilsSession 

type UtilsSession struct {
	Contract     *Utils            // 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
}

UtilsSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

type UtilsTransactor 

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

UtilsTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewUtilsTransactor 

func NewUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*UtilsTransactor, error)

NewUtilsTransactor creates a new write-only instance of Utils, bound to a specific deployed contract.

type UtilsTransactorRaw 

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

UtilsTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*UtilsTransactorRaw) Transact 

func (_Utils *UtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*UtilsTransactorRaw) Transfer 

func (_Utils *UtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type UtilsTransactorSession 

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

UtilsTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

type ZeroCopySink 

type ZeroCopySink struct {
	ZeroCopySinkCaller     // Read-only binding to the contract
	ZeroCopySinkTransactor // Write-only binding to the contract
	ZeroCopySinkFilterer   // Log filterer for contract events
}

ZeroCopySink is an auto generated Go binding around a Solidity contract.

func DeployZeroCopySink 

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

DeployZeroCopySink deploys a new contract, binding an instance of ZeroCopySink to it.

func NewZeroCopySink 

func NewZeroCopySink(address common.Address, backend bind.ContractBackend) (*ZeroCopySink, error)

NewZeroCopySink creates a new instance of ZeroCopySink, bound to a specific deployed contract.

type ZeroCopySinkCaller 

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

ZeroCopySinkCaller is an auto generated read-only Go binding around a Solidity contract.

func NewZeroCopySinkCaller 

func NewZeroCopySinkCaller(address common.Address, caller bind.ContractCaller) (*ZeroCopySinkCaller, error)

NewZeroCopySinkCaller creates a new read-only instance of ZeroCopySink, bound to a specific deployed contract.

type ZeroCopySinkCallerRaw 

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

ZeroCopySinkCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*ZeroCopySinkCallerRaw) Call 

func (_ZeroCopySink *ZeroCopySinkCallerRaw) 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 ZeroCopySinkCallerSession 

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

ZeroCopySinkCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type ZeroCopySinkFilterer 

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

ZeroCopySinkFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewZeroCopySinkFilterer 

func NewZeroCopySinkFilterer(address common.Address, filterer bind.ContractFilterer) (*ZeroCopySinkFilterer, error)

NewZeroCopySinkFilterer creates a new log filterer instance of ZeroCopySink, bound to a specific deployed contract.

type ZeroCopySinkRaw 

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

ZeroCopySinkRaw is an auto generated low-level Go binding around a Solidity contract.

func (*ZeroCopySinkRaw) Call 

func (_ZeroCopySink *ZeroCopySinkRaw) 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 (*ZeroCopySinkRaw) Transact 

func (_ZeroCopySink *ZeroCopySinkRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ZeroCopySinkRaw) Transfer 

func (_ZeroCopySink *ZeroCopySinkRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ZeroCopySinkSession 

type ZeroCopySinkSession struct {
	Contract     *ZeroCopySink     // 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
}

ZeroCopySinkSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

type ZeroCopySinkTransactor 

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

ZeroCopySinkTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewZeroCopySinkTransactor 

func NewZeroCopySinkTransactor(address common.Address, transactor bind.ContractTransactor) (*ZeroCopySinkTransactor, error)

NewZeroCopySinkTransactor creates a new write-only instance of ZeroCopySink, bound to a specific deployed contract.

type ZeroCopySinkTransactorRaw 

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

ZeroCopySinkTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*ZeroCopySinkTransactorRaw) Transact 

func (_ZeroCopySink *ZeroCopySinkTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ZeroCopySinkTransactorRaw) Transfer 

func (_ZeroCopySink *ZeroCopySinkTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ZeroCopySinkTransactorSession 

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

ZeroCopySinkTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

type ZeroCopySource 

type ZeroCopySource struct {
	ZeroCopySourceCaller     // Read-only binding to the contract
	ZeroCopySourceTransactor // Write-only binding to the contract
	ZeroCopySourceFilterer   // Log filterer for contract events
}

ZeroCopySource is an auto generated Go binding around a Solidity contract.

func DeployZeroCopySource 

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

DeployZeroCopySource deploys a new contract, binding an instance of ZeroCopySource to it.

func NewZeroCopySource 

func NewZeroCopySource(address common.Address, backend bind.ContractBackend) (*ZeroCopySource, error)

NewZeroCopySource creates a new instance of ZeroCopySource, bound to a specific deployed contract.

type ZeroCopySourceCaller 

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

ZeroCopySourceCaller is an auto generated read-only Go binding around a Solidity contract.

func NewZeroCopySourceCaller 

func NewZeroCopySourceCaller(address common.Address, caller bind.ContractCaller) (*ZeroCopySourceCaller, error)

NewZeroCopySourceCaller creates a new read-only instance of ZeroCopySource, bound to a specific deployed contract.

type ZeroCopySourceCallerRaw 

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

ZeroCopySourceCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*ZeroCopySourceCallerRaw) Call 

func (_ZeroCopySource *ZeroCopySourceCallerRaw) 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 ZeroCopySourceCallerSession 

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

ZeroCopySourceCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type ZeroCopySourceFilterer 

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

ZeroCopySourceFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewZeroCopySourceFilterer 

func NewZeroCopySourceFilterer(address common.Address, filterer bind.ContractFilterer) (*ZeroCopySourceFilterer, error)

NewZeroCopySourceFilterer creates a new log filterer instance of ZeroCopySource, bound to a specific deployed contract.

type ZeroCopySourceRaw 

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

ZeroCopySourceRaw is an auto generated low-level Go binding around a Solidity contract.

func (*ZeroCopySourceRaw) Call 

func (_ZeroCopySource *ZeroCopySourceRaw) 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 (*ZeroCopySourceRaw) Transact 

func (_ZeroCopySource *ZeroCopySourceRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ZeroCopySourceRaw) Transfer 

func (_ZeroCopySource *ZeroCopySourceRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ZeroCopySourceSession 

type ZeroCopySourceSession struct {
	Contract     *ZeroCopySource   // 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
}

ZeroCopySourceSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

type ZeroCopySourceTransactor 

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

ZeroCopySourceTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewZeroCopySourceTransactor 

func NewZeroCopySourceTransactor(address common.Address, transactor bind.ContractTransactor) (*ZeroCopySourceTransactor, error)

NewZeroCopySourceTransactor creates a new write-only instance of ZeroCopySource, bound to a specific deployed contract.

type ZeroCopySourceTransactorRaw 

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

ZeroCopySourceTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*ZeroCopySourceTransactorRaw) Transact 

func (_ZeroCopySource *ZeroCopySourceTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ZeroCopySourceTransactorRaw) Transfer 

func (_ZeroCopySource *ZeroCopySourceTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ZeroCopySourceTransactorSession 

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

ZeroCopySourceTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

Source Files

View all Source files

Jump to

Keyboard shortcuts

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