btcx_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 BTCXABI = "" /* 7074-byte string literal not displayed */

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

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 ERC20ABI = "" /* 2579-byte string literal not displayed */

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

View Source 
const ERC20DetailedABI = "" /* 2752-byte string literal not displayed */

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

View Source 
const ERC20ExtendedABI = "" /* 4982-byte string literal not displayed */

ERC20ExtendedABI 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 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 BTCXBin = "" /* 24456-byte string literal not displayed */

BTCXBin is the compiled bytecode used for deploying new contracts.

View Source 
var BTCXFuncSigs = map[string]string{
	"852d9213": "allowance(address,address)",
	"1f2d4860": "approve(address,uint256)",
	"cc8be70e": "balanceOf(address)",
	"9ac51a96": "bindAssetHash(uint64,bytes)",
	"1f260fb3": "bondAssetHashes(uint64)",
	"391edc16": "burn(uint256)",
	"46b13615": "decimals()",
	"13a1aa5c": "decreaseAllowance(address,uint256)",
	"4d2e8120": "increaseAllowance(address,uint256)",
	"bb39e9b1": "lock(uint64,bytes,uint64)",
	"ffcaba74": "managerProxyContract()",
	"c573baf5": "minimumLimit()",
	"4f5e00c7": "mint(address,uint256)",
	"b11b6883": "name()",
	"3ba17b05": "operator()",
	"3f7d0ff8": "redeemScript()",
	"7430f358": "setManagerProxy(address)",
	"0458b76d": "setMinimumLimit(uint64)",
	"5bfa2796": "symbol()",
	"0256e278": "totalSupply()",
	"6904e965": "transfer(address,uint256)",
	"ad8a9731": "transferFrom(address,address,uint256)",
	"4d7ee918": "unlock(bytes,bytes,uint64)",
}

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

View Source 
var ERC20Bin = "" /* 4546-byte string literal not displayed */

ERC20Bin is the compiled bytecode used for deploying new contracts.

View Source 
var ERC20DetailedFuncSigs = map[string]string{
	"852d9213": "allowance(address,address)",
	"1f2d4860": "approve(address,uint256)",
	"cc8be70e": "balanceOf(address)",
	"46b13615": "decimals()",
	"b11b6883": "name()",
	"5bfa2796": "symbol()",
	"0256e278": "totalSupply()",
	"6904e965": "transfer(address,uint256)",
	"ad8a9731": "transferFrom(address,address,uint256)",
}

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

View Source 
var ERC20ExtendedFuncSigs = map[string]string{
	"852d9213": "allowance(address,address)",
	"1f2d4860": "approve(address,uint256)",
	"cc8be70e": "balanceOf(address)",
	"9ac51a96": "bindAssetHash(uint64,bytes)",
	"1f260fb3": "bondAssetHashes(uint64)",
	"391edc16": "burn(uint256)",
	"46b13615": "decimals()",
	"13a1aa5c": "decreaseAllowance(address,uint256)",
	"4d2e8120": "increaseAllowance(address,uint256)",
	"ffcaba74": "managerProxyContract()",
	"4f5e00c7": "mint(address,uint256)",
	"b11b6883": "name()",
	"3ba17b05": "operator()",
	"7430f358": "setManagerProxy(address)",
	"5bfa2796": "symbol()",
	"0256e278": "totalSupply()",
	"6904e965": "transfer(address,uint256)",
	"ad8a9731": "transferFrom(address,address,uint256)",
}

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

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

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

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 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 AsyncDeployBTCX 

func AsyncDeployBTCX(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend, _redeemScript []byte) (*types.Transaction, error)

func AsyncDeployERC20 

func AsyncDeployERC20(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 BTCX 

type BTCX struct {
	BTCXCaller     // Read-only binding to the contract
	BTCXTransactor // Write-only binding to the contract
	BTCXFilterer   // Log filterer for contract events
}

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

func DeployBTCX 

func DeployBTCX(auth *bind.TransactOpts, backend bind.ContractBackend, _redeemScript []byte) (common.Address, *types.Transaction, *BTCX, error)

DeployBTCX deploys a new contract, binding an instance of BTCX to it.

func NewBTCX 

func NewBTCX(address common.Address, backend bind.ContractBackend) (*BTCX, error)

NewBTCX creates a new instance of BTCX, bound to a specific deployed contract.

type BTCXApproval 

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

BTCXApproval represents a Approval event raised by the BTCX contract.

type BTCXApprovalIterator 

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

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

func (*BTCXApprovalIterator) Close 

func (it *BTCXApprovalIterator) Close() error

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

func (*BTCXApprovalIterator) Error 

func (it *BTCXApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*BTCXApprovalIterator) Next 

func (it *BTCXApprovalIterator) 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 BTCXBindAssetHash 

type BTCXBindAssetHash struct {
	ChainId      uint64
	ContractAddr []byte
	Raw          types.Log // Blockchain specific contextual infos
}

BTCXBindAssetHash represents a BindAssetHash event raised by the BTCX contract.

type BTCXBindAssetHashIterator 

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

BTCXBindAssetHashIterator is returned from FilterBindAssetHash and is used to iterate over the raw logs and unpacked data for BindAssetHash events raised by the BTCX contract.

func (*BTCXBindAssetHashIterator) Close 

func (it *BTCXBindAssetHashIterator) Close() error

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

func (*BTCXBindAssetHashIterator) Error 

func (it *BTCXBindAssetHashIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*BTCXBindAssetHashIterator) Next 

func (it *BTCXBindAssetHashIterator) 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 BTCXCaller 

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

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

func NewBTCXCaller 

func NewBTCXCaller(address common.Address, caller bind.ContractCaller) (*BTCXCaller, error)

NewBTCXCaller creates a new read-only instance of BTCX, bound to a specific deployed contract.

func (*BTCXCaller) Allowance 

func (_BTCX *BTCXCaller) 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 (*BTCXCaller) BalanceOf 

func (_BTCX *BTCXCaller) 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 (*BTCXCaller) BondAssetHashes 

func (_BTCX *BTCXCaller) BondAssetHashes(opts *bind.CallOpts, arg0 uint64) ([]byte, error)

BondAssetHashes is a free data retrieval call binding the contract method 0x1f260fb3.

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

func (*BTCXCaller) Decimals 

func (_BTCX *BTCXCaller) Decimals(opts *bind.CallOpts) (uint8, error)

Decimals is a free data retrieval call binding the contract method 0x46b13615.

Solidity: function decimals() constant returns(uint8)

func (*BTCXCaller) ManagerProxyContract 

func (_BTCX *BTCXCaller) 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 (*BTCXCaller) MinimumLimit 

func (_BTCX *BTCXCaller) MinimumLimit(opts *bind.CallOpts) (uint64, error)

MinimumLimit is a free data retrieval call binding the contract method 0xc573baf5.

Solidity: function minimumLimit() constant returns(uint64)

func (*BTCXCaller) Name 

func (_BTCX *BTCXCaller) Name(opts *bind.CallOpts) (string, error)

Name is a free data retrieval call binding the contract method 0xb11b6883.

Solidity: function name() constant returns(string)

func (*BTCXCaller) Operator 

func (_BTCX *BTCXCaller) Operator(opts *bind.CallOpts) (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x3ba17b05.

Solidity: function operator() constant returns(address)

func (*BTCXCaller) RedeemScript 

func (_BTCX *BTCXCaller) RedeemScript(opts *bind.CallOpts) ([]byte, error)

RedeemScript is a free data retrieval call binding the contract method 0x3f7d0ff8.

Solidity: function redeemScript() constant returns(bytes)

func (*BTCXCaller) Symbol 

func (_BTCX *BTCXCaller) Symbol(opts *bind.CallOpts) (string, error)

Symbol is a free data retrieval call binding the contract method 0x5bfa2796.

Solidity: function symbol() constant returns(string)

func (*BTCXCaller) TotalSupply 

func (_BTCX *BTCXCaller) 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 BTCXCallerRaw 

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

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

func (*BTCXCallerRaw) Call 

func (_BTCX *BTCXCallerRaw) 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 BTCXCallerSession 

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

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

func (*BTCXCallerSession) Allowance 

func (_BTCX *BTCXCallerSession) 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 (*BTCXCallerSession) BalanceOf 

func (_BTCX *BTCXCallerSession) 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 (*BTCXCallerSession) BondAssetHashes 

func (_BTCX *BTCXCallerSession) BondAssetHashes(arg0 uint64) ([]byte, error)

BondAssetHashes is a free data retrieval call binding the contract method 0x1f260fb3.

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

func (*BTCXCallerSession) Decimals 

func (_BTCX *BTCXCallerSession) Decimals() (uint8, error)

Decimals is a free data retrieval call binding the contract method 0x46b13615.

Solidity: function decimals() constant returns(uint8)

func (*BTCXCallerSession) ManagerProxyContract 

func (_BTCX *BTCXCallerSession) ManagerProxyContract() (common.Address, error)

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

Solidity: function managerProxyContract() constant returns(address)

func (*BTCXCallerSession) MinimumLimit 

func (_BTCX *BTCXCallerSession) MinimumLimit() (uint64, error)

MinimumLimit is a free data retrieval call binding the contract method 0xc573baf5.

Solidity: function minimumLimit() constant returns(uint64)

func (*BTCXCallerSession) Name 

func (_BTCX *BTCXCallerSession) Name() (string, error)

Name is a free data retrieval call binding the contract method 0xb11b6883.

Solidity: function name() constant returns(string)

func (*BTCXCallerSession) Operator 

func (_BTCX *BTCXCallerSession) Operator() (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x3ba17b05.

Solidity: function operator() constant returns(address)

func (*BTCXCallerSession) RedeemScript 

func (_BTCX *BTCXCallerSession) RedeemScript() ([]byte, error)

RedeemScript is a free data retrieval call binding the contract method 0x3f7d0ff8.

Solidity: function redeemScript() constant returns(bytes)

func (*BTCXCallerSession) Symbol 

func (_BTCX *BTCXCallerSession) Symbol() (string, error)

Symbol is a free data retrieval call binding the contract method 0x5bfa2796.

Solidity: function symbol() constant returns(string)

func (*BTCXCallerSession) TotalSupply 

func (_BTCX *BTCXCallerSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

type BTCXFilterer 

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

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

func NewBTCXFilterer 

func NewBTCXFilterer(address common.Address, filterer bind.ContractFilterer) (*BTCXFilterer, error)

NewBTCXFilterer creates a new log filterer instance of BTCX, bound to a specific deployed contract.

func (*BTCXFilterer) FilterApproval 

func (_BTCX *BTCXFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*BTCXApprovalIterator, 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 (*BTCXFilterer) FilterBindAssetHash 

func (_BTCX *BTCXFilterer) FilterBindAssetHash(opts *bind.FilterOpts) (*BTCXBindAssetHashIterator, error)

FilterBindAssetHash is a free log retrieval operation binding the contract event 0x000000000000000000000000000000000000000000000000000000009581fc60.

Solidity: event BindAssetHash(uint64 chainId, bytes contractAddr)

func (*BTCXFilterer) FilterLockEvent 

func (_BTCX *BTCXFilterer) FilterLockEvent(opts *bind.FilterOpts) (*BTCXLockEventIterator, error)

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

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

func (*BTCXFilterer) FilterSetManagerProxyEvent 

func (_BTCX *BTCXFilterer) FilterSetManagerProxyEvent(opts *bind.FilterOpts) (*BTCXSetManagerProxyEventIterator, error)

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

Solidity: event SetManagerProxyEvent(address managerContract)

func (*BTCXFilterer) FilterTransfer 

func (_BTCX *BTCXFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*BTCXTransferIterator, 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 (*BTCXFilterer) FilterUnlockEvent 

func (_BTCX *BTCXFilterer) FilterUnlockEvent(opts *bind.FilterOpts) (*BTCXUnlockEventIterator, error)

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

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

func (*BTCXFilterer) ParseApproval 

func (_BTCX *BTCXFilterer) ParseApproval(log types.Log) (*BTCXApproval, error)

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

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

func (*BTCXFilterer) ParseBindAssetHash 

func (_BTCX *BTCXFilterer) ParseBindAssetHash(log types.Log) (*BTCXBindAssetHash, error)

ParseBindAssetHash is a log parse operation binding the contract event 0x000000000000000000000000000000000000000000000000000000009581fc60.

Solidity: event BindAssetHash(uint64 chainId, bytes contractAddr)

func (*BTCXFilterer) ParseLockEvent 

func (_BTCX *BTCXFilterer) ParseLockEvent(log types.Log) (*BTCXLockEvent, error)

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

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

func (*BTCXFilterer) ParseSetManagerProxyEvent 

func (_BTCX *BTCXFilterer) ParseSetManagerProxyEvent(log types.Log) (*BTCXSetManagerProxyEvent, error)

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

Solidity: event SetManagerProxyEvent(address managerContract)

func (*BTCXFilterer) ParseTransfer 

func (_BTCX *BTCXFilterer) ParseTransfer(log types.Log) (*BTCXTransfer, error)

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

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

func (*BTCXFilterer) ParseUnlockEvent 

func (_BTCX *BTCXFilterer) ParseUnlockEvent(log types.Log) (*BTCXUnlockEvent, error)

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

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

func (*BTCXFilterer) WatchApproval 

func (_BTCX *BTCXFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *BTCXApproval, 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 (*BTCXFilterer) WatchBindAssetHash 

func (_BTCX *BTCXFilterer) WatchBindAssetHash(opts *bind.WatchOpts, sink chan<- *BTCXBindAssetHash) (event.Subscription, error)

WatchBindAssetHash is a free log subscription operation binding the contract event 0x000000000000000000000000000000000000000000000000000000009581fc60.

Solidity: event BindAssetHash(uint64 chainId, bytes contractAddr)

func (*BTCXFilterer) WatchLockEvent 

func (_BTCX *BTCXFilterer) WatchLockEvent(opts *bind.WatchOpts, sink chan<- *BTCXLockEvent) (event.Subscription, error)

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

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

func (*BTCXFilterer) WatchSetManagerProxyEvent 

func (_BTCX *BTCXFilterer) WatchSetManagerProxyEvent(opts *bind.WatchOpts, sink chan<- *BTCXSetManagerProxyEvent) (event.Subscription, error)

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

Solidity: event SetManagerProxyEvent(address managerContract)

func (*BTCXFilterer) WatchTransfer 

func (_BTCX *BTCXFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *BTCXTransfer, 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)

func (*BTCXFilterer) WatchUnlockEvent 

func (_BTCX *BTCXFilterer) WatchUnlockEvent(opts *bind.WatchOpts, sink chan<- *BTCXUnlockEvent) (event.Subscription, error)

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

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

type BTCXLockEvent 

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

BTCXLockEvent represents a LockEvent event raised by the BTCX contract.

type BTCXLockEventIterator 

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

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

func (*BTCXLockEventIterator) Close 

func (it *BTCXLockEventIterator) Close() error

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

func (*BTCXLockEventIterator) Error 

func (it *BTCXLockEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*BTCXLockEventIterator) Next 

func (it *BTCXLockEventIterator) 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 BTCXRaw 

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

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

func (*BTCXRaw) Call 

func (_BTCX *BTCXRaw) 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 (*BTCXRaw) Transact 

func (_BTCX *BTCXRaw) 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 (*BTCXRaw) Transfer 

func (_BTCX *BTCXRaw) 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 BTCXSession 

type BTCXSession struct {
	Contract     *BTCX             // 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
}

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

func (*BTCXSession) Allowance 

func (_BTCX *BTCXSession) 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 (*BTCXSession) Approve 

func (_BTCX *BTCXSession) 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 (*BTCXSession) AsyncApprove 

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

func (*BTCXSession) AsyncBindAssetHash 

func (_BTCX *BTCXSession) AsyncBindAssetHash(handler func(*types.Receipt, error), chainId uint64, contractAddr []byte) (*types.Transaction, error)

func (*BTCXSession) AsyncBurn 

func (_BTCX *BTCXSession) AsyncBurn(handler func(*types.Receipt, error), amount *big.Int) (*types.Transaction, error)

func (*BTCXSession) AsyncDecreaseAllowance 

func (_BTCX *BTCXSession) AsyncDecreaseAllowance(handler func(*types.Receipt, error), spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

func (*BTCXSession) AsyncIncreaseAllowance 

func (_BTCX *BTCXSession) AsyncIncreaseAllowance(handler func(*types.Receipt, error), spender common.Address, addedValue *big.Int) (*types.Transaction, error)

func (*BTCXSession) AsyncLock 

func (_BTCX *BTCXSession) AsyncLock(handler func(*types.Receipt, error), toChainId uint64, toUserAddr []byte, amount uint64) (*types.Transaction, error)

func (*BTCXSession) AsyncMint 

func (_BTCX *BTCXSession) AsyncMint(handler func(*types.Receipt, error), account common.Address, amount *big.Int) (*types.Transaction, error)

func (*BTCXSession) AsyncSetManagerProxy 

func (_BTCX *BTCXSession) AsyncSetManagerProxy(handler func(*types.Receipt, error), ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, error)

func (*BTCXSession) AsyncSetMinimumLimit 

func (_BTCX *BTCXSession) AsyncSetMinimumLimit(handler func(*types.Receipt, error), minimumTransferLimit uint64) (*types.Transaction, error)

func (*BTCXSession) AsyncTransfer 

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

func (*BTCXSession) AsyncTransferFrom 

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

func (*BTCXSession) AsyncUnlock 

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

func (*BTCXSession) BalanceOf 

func (_BTCX *BTCXSession) 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 (*BTCXSession) BindAssetHash 

func (_BTCX *BTCXSession) BindAssetHash(chainId uint64, contractAddr []byte) (*types.Transaction, *types.Receipt, error)

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

Solidity: function bindAssetHash(uint64 chainId, bytes contractAddr) returns()

func (*BTCXSession) BondAssetHashes 

func (_BTCX *BTCXSession) BondAssetHashes(arg0 uint64) ([]byte, error)

BondAssetHashes is a free data retrieval call binding the contract method 0x1f260fb3.

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

func (*BTCXSession) Burn 

func (_BTCX *BTCXSession) Burn(amount *big.Int) (*types.Transaction, *types.Receipt, error)

Burn is a paid mutator transaction binding the contract method 0x391edc16.

Solidity: function burn(uint256 amount) returns(bool)

func (*BTCXSession) Decimals 

func (_BTCX *BTCXSession) Decimals() (uint8, error)

Decimals is a free data retrieval call binding the contract method 0x46b13615.

Solidity: function decimals() constant returns(uint8)

func (*BTCXSession) DecreaseAllowance 

func (_BTCX *BTCXSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, *types.Receipt, error)

DecreaseAllowance is a paid mutator transaction binding the contract method 0x13a1aa5c.

Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)

func (*BTCXSession) IncreaseAllowance 

func (_BTCX *BTCXSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, *types.Receipt, error)

IncreaseAllowance is a paid mutator transaction binding the contract method 0x4d2e8120.

Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)

func (*BTCXSession) Lock 

func (_BTCX *BTCXSession) Lock(toChainId uint64, toUserAddr []byte, amount uint64) (*types.Transaction, *types.Receipt, error)

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

Solidity: function lock(uint64 toChainId, bytes toUserAddr, uint64 amount) returns(bool)

func (*BTCXSession) ManagerProxyContract 

func (_BTCX *BTCXSession) ManagerProxyContract() (common.Address, error)

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

Solidity: function managerProxyContract() constant returns(address)

func (*BTCXSession) MinimumLimit 

func (_BTCX *BTCXSession) MinimumLimit() (uint64, error)

MinimumLimit is a free data retrieval call binding the contract method 0xc573baf5.

Solidity: function minimumLimit() constant returns(uint64)

func (*BTCXSession) Mint 

func (_BTCX *BTCXSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Mint is a paid mutator transaction binding the contract method 0x4f5e00c7.

Solidity: function mint(address account, uint256 amount) returns(bool)

func (*BTCXSession) Name 

func (_BTCX *BTCXSession) Name() (string, error)

Name is a free data retrieval call binding the contract method 0xb11b6883.

Solidity: function name() constant returns(string)

func (*BTCXSession) Operator 

func (_BTCX *BTCXSession) Operator() (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x3ba17b05.

Solidity: function operator() constant returns(address)

func (*BTCXSession) RedeemScript 

func (_BTCX *BTCXSession) RedeemScript() ([]byte, error)

RedeemScript is a free data retrieval call binding the contract method 0x3f7d0ff8.

Solidity: function redeemScript() constant returns(bytes)

func (*BTCXSession) SetManagerProxy 

func (_BTCX *BTCXSession) SetManagerProxy(ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function setManagerProxy(address ethCrossChainManagerProxyAddr) returns()

func (*BTCXSession) SetMinimumLimit 

func (_BTCX *BTCXSession) SetMinimumLimit(minimumTransferLimit uint64) (*types.Transaction, *types.Receipt, error)

SetMinimumLimit is a paid mutator transaction binding the contract method 0x0458b76d.

Solidity: function setMinimumLimit(uint64 minimumTransferLimit) returns(bool)

func (*BTCXSession) Symbol 

func (_BTCX *BTCXSession) Symbol() (string, error)

Symbol is a free data retrieval call binding the contract method 0x5bfa2796.

Solidity: function symbol() constant returns(string)

func (*BTCXSession) TotalSupply 

func (_BTCX *BTCXSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

func (*BTCXSession) Transfer 

func (_BTCX *BTCXSession) 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 (*BTCXSession) TransferFrom 

func (_BTCX *BTCXSession) 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)

func (*BTCXSession) Unlock 

func (_BTCX *BTCXSession) 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 BTCXSetManagerProxyEvent 

type BTCXSetManagerProxyEvent struct {
	ManagerContract common.Address
	Raw             types.Log // Blockchain specific contextual infos
}

BTCXSetManagerProxyEvent represents a SetManagerProxyEvent event raised by the BTCX contract.

type BTCXSetManagerProxyEventIterator 

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

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

func (*BTCXSetManagerProxyEventIterator) Close 

func (it *BTCXSetManagerProxyEventIterator) Close() error

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

func (*BTCXSetManagerProxyEventIterator) Error 

func (it *BTCXSetManagerProxyEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*BTCXSetManagerProxyEventIterator) Next 

func (it *BTCXSetManagerProxyEventIterator) 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 BTCXTransactor 

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

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

func NewBTCXTransactor 

func NewBTCXTransactor(address common.Address, transactor bind.ContractTransactor) (*BTCXTransactor, error)

NewBTCXTransactor creates a new write-only instance of BTCX, bound to a specific deployed contract.

func (*BTCXTransactor) Approve 

func (_BTCX *BTCXTransactor) 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 (*BTCXTransactor) AsyncApprove 

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

func (*BTCXTransactor) AsyncBindAssetHash 

func (_BTCX *BTCXTransactor) AsyncBindAssetHash(handler func(*types.Receipt, error), opts *bind.TransactOpts, chainId uint64, contractAddr []byte) (*types.Transaction, error)

func (*BTCXTransactor) AsyncBurn 

func (_BTCX *BTCXTransactor) AsyncBurn(handler func(*types.Receipt, error), opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error)

func (*BTCXTransactor) AsyncDecreaseAllowance 

func (_BTCX *BTCXTransactor) AsyncDecreaseAllowance(handler func(*types.Receipt, error), opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

func (*BTCXTransactor) AsyncIncreaseAllowance 

func (_BTCX *BTCXTransactor) AsyncIncreaseAllowance(handler func(*types.Receipt, error), opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

func (*BTCXTransactor) AsyncLock 

func (_BTCX *BTCXTransactor) AsyncLock(handler func(*types.Receipt, error), opts *bind.TransactOpts, toChainId uint64, toUserAddr []byte, amount uint64) (*types.Transaction, error)

func (*BTCXTransactor) AsyncMint 

func (_BTCX *BTCXTransactor) AsyncMint(handler func(*types.Receipt, error), opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error)

func (*BTCXTransactor) AsyncSetManagerProxy 

func (_BTCX *BTCXTransactor) AsyncSetManagerProxy(handler func(*types.Receipt, error), opts *bind.TransactOpts, ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, error)

func (*BTCXTransactor) AsyncSetMinimumLimit 

func (_BTCX *BTCXTransactor) AsyncSetMinimumLimit(handler func(*types.Receipt, error), opts *bind.TransactOpts, minimumTransferLimit uint64) (*types.Transaction, error)

func (*BTCXTransactor) AsyncTransfer 

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

func (*BTCXTransactor) AsyncTransferFrom 

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

func (*BTCXTransactor) AsyncUnlock 

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

func (*BTCXTransactor) BindAssetHash 

func (_BTCX *BTCXTransactor) BindAssetHash(opts *bind.TransactOpts, chainId uint64, contractAddr []byte) (*types.Transaction, *types.Receipt, error)

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

Solidity: function bindAssetHash(uint64 chainId, bytes contractAddr) returns()

func (*BTCXTransactor) Burn 

func (_BTCX *BTCXTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Burn is a paid mutator transaction binding the contract method 0x391edc16.

Solidity: function burn(uint256 amount) returns(bool)

func (*BTCXTransactor) DecreaseAllowance 

func (_BTCX *BTCXTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, *types.Receipt, error)

DecreaseAllowance is a paid mutator transaction binding the contract method 0x13a1aa5c.

Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)

func (*BTCXTransactor) IncreaseAllowance 

func (_BTCX *BTCXTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, *types.Receipt, error)

IncreaseAllowance is a paid mutator transaction binding the contract method 0x4d2e8120.

Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)

func (*BTCXTransactor) Lock 

func (_BTCX *BTCXTransactor) Lock(opts *bind.TransactOpts, toChainId uint64, toUserAddr []byte, amount uint64) (*types.Transaction, *types.Receipt, error)

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

Solidity: function lock(uint64 toChainId, bytes toUserAddr, uint64 amount) returns(bool)

func (*BTCXTransactor) Mint 

func (_BTCX *BTCXTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Mint is a paid mutator transaction binding the contract method 0x4f5e00c7.

Solidity: function mint(address account, uint256 amount) returns(bool)

func (*BTCXTransactor) SetManagerProxy 

func (_BTCX *BTCXTransactor) SetManagerProxy(opts *bind.TransactOpts, ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function setManagerProxy(address ethCrossChainManagerProxyAddr) returns()

func (*BTCXTransactor) SetMinimumLimit 

func (_BTCX *BTCXTransactor) SetMinimumLimit(opts *bind.TransactOpts, minimumTransferLimit uint64) (*types.Transaction, *types.Receipt, error)

SetMinimumLimit is a paid mutator transaction binding the contract method 0x0458b76d.

Solidity: function setMinimumLimit(uint64 minimumTransferLimit) returns(bool)

func (*BTCXTransactor) Transfer 

func (_BTCX *BTCXTransactor) 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 (*BTCXTransactor) TransferFrom 

func (_BTCX *BTCXTransactor) 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)

func (*BTCXTransactor) Unlock 

func (_BTCX *BTCXTransactor) 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 BTCXTransactorRaw 

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

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

func (*BTCXTransactorRaw) Transact 

func (_BTCX *BTCXTransactorRaw) 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 (*BTCXTransactorRaw) Transfer 

func (_BTCX *BTCXTransactorRaw) 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 BTCXTransactorSession 

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

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

func (*BTCXTransactorSession) Approve 

func (_BTCX *BTCXTransactorSession) 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 (*BTCXTransactorSession) AsyncApprove 

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

func (*BTCXTransactorSession) AsyncBindAssetHash 

func (_BTCX *BTCXTransactorSession) AsyncBindAssetHash(handler func(*types.Receipt, error), chainId uint64, contractAddr []byte) (*types.Transaction, error)

func (*BTCXTransactorSession) AsyncBurn 

func (_BTCX *BTCXTransactorSession) AsyncBurn(handler func(*types.Receipt, error), amount *big.Int) (*types.Transaction, error)

func (*BTCXTransactorSession) AsyncDecreaseAllowance 

func (_BTCX *BTCXTransactorSession) AsyncDecreaseAllowance(handler func(*types.Receipt, error), spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

func (*BTCXTransactorSession) AsyncIncreaseAllowance 

func (_BTCX *BTCXTransactorSession) AsyncIncreaseAllowance(handler func(*types.Receipt, error), spender common.Address, addedValue *big.Int) (*types.Transaction, error)

func (*BTCXTransactorSession) AsyncLock 

func (_BTCX *BTCXTransactorSession) AsyncLock(handler func(*types.Receipt, error), toChainId uint64, toUserAddr []byte, amount uint64) (*types.Transaction, error)

func (*BTCXTransactorSession) AsyncMint 

func (_BTCX *BTCXTransactorSession) AsyncMint(handler func(*types.Receipt, error), account common.Address, amount *big.Int) (*types.Transaction, error)

func (*BTCXTransactorSession) AsyncSetManagerProxy 

func (_BTCX *BTCXTransactorSession) AsyncSetManagerProxy(handler func(*types.Receipt, error), ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, error)

func (*BTCXTransactorSession) AsyncSetMinimumLimit 

func (_BTCX *BTCXTransactorSession) AsyncSetMinimumLimit(handler func(*types.Receipt, error), minimumTransferLimit uint64) (*types.Transaction, error)

func (*BTCXTransactorSession) AsyncTransfer 

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

func (*BTCXTransactorSession) AsyncTransferFrom 

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

func (*BTCXTransactorSession) AsyncUnlock 

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

func (*BTCXTransactorSession) BindAssetHash 

func (_BTCX *BTCXTransactorSession) BindAssetHash(chainId uint64, contractAddr []byte) (*types.Transaction, *types.Receipt, error)

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

Solidity: function bindAssetHash(uint64 chainId, bytes contractAddr) returns()

func (*BTCXTransactorSession) Burn 

func (_BTCX *BTCXTransactorSession) Burn(amount *big.Int) (*types.Transaction, *types.Receipt, error)

Burn is a paid mutator transaction binding the contract method 0x391edc16.

Solidity: function burn(uint256 amount) returns(bool)

func (*BTCXTransactorSession) DecreaseAllowance 

func (_BTCX *BTCXTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, *types.Receipt, error)

DecreaseAllowance is a paid mutator transaction binding the contract method 0x13a1aa5c.

Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)

func (*BTCXTransactorSession) IncreaseAllowance 

func (_BTCX *BTCXTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, *types.Receipt, error)

IncreaseAllowance is a paid mutator transaction binding the contract method 0x4d2e8120.

Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)

func (*BTCXTransactorSession) Lock 

func (_BTCX *BTCXTransactorSession) Lock(toChainId uint64, toUserAddr []byte, amount uint64) (*types.Transaction, *types.Receipt, error)

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

Solidity: function lock(uint64 toChainId, bytes toUserAddr, uint64 amount) returns(bool)

func (*BTCXTransactorSession) Mint 

func (_BTCX *BTCXTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Mint is a paid mutator transaction binding the contract method 0x4f5e00c7.

Solidity: function mint(address account, uint256 amount) returns(bool)

func (*BTCXTransactorSession) SetManagerProxy 

func (_BTCX *BTCXTransactorSession) SetManagerProxy(ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function setManagerProxy(address ethCrossChainManagerProxyAddr) returns()

func (*BTCXTransactorSession) SetMinimumLimit 

func (_BTCX *BTCXTransactorSession) SetMinimumLimit(minimumTransferLimit uint64) (*types.Transaction, *types.Receipt, error)

SetMinimumLimit is a paid mutator transaction binding the contract method 0x0458b76d.

Solidity: function setMinimumLimit(uint64 minimumTransferLimit) returns(bool)

func (*BTCXTransactorSession) Transfer 

func (_BTCX *BTCXTransactorSession) 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 (*BTCXTransactorSession) TransferFrom 

func (_BTCX *BTCXTransactorSession) 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)

func (*BTCXTransactorSession) Unlock 

func (_BTCX *BTCXTransactorSession) 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 BTCXTransfer 

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

BTCXTransfer represents a Transfer event raised by the BTCX contract.

type BTCXTransferIterator 

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

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

func (*BTCXTransferIterator) Close 

func (it *BTCXTransferIterator) Close() error

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

func (*BTCXTransferIterator) Error 

func (it *BTCXTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*BTCXTransferIterator) Next 

func (it *BTCXTransferIterator) 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 BTCXUnlockEvent 

type BTCXUnlockEvent struct {
	ToAssetHash common.Address
	ToAddress   common.Address
	Amount      uint64
	Raw         types.Log // Blockchain specific contextual infos
}

BTCXUnlockEvent represents a UnlockEvent event raised by the BTCX contract.

type BTCXUnlockEventIterator 

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

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

func (*BTCXUnlockEventIterator) Close 

func (it *BTCXUnlockEventIterator) Close() error

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

func (*BTCXUnlockEventIterator) Error 

func (it *BTCXUnlockEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*BTCXUnlockEventIterator) Next 

func (it *BTCXUnlockEventIterator) 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 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 ERC20 

type ERC20 struct {
	ERC20Caller     // Read-only binding to the contract
	ERC20Transactor // Write-only binding to the contract
	ERC20Filterer   // Log filterer for contract events
}

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

func DeployERC20 

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

DeployERC20 deploys a new contract, binding an instance of ERC20 to it.

func NewERC20 

func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error)

NewERC20 creates a new instance of ERC20, bound to a specific deployed contract.

type ERC20Approval 

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

ERC20Approval represents a Approval event raised by the ERC20 contract.

type ERC20ApprovalIterator 

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

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

func (*ERC20ApprovalIterator) Close 

func (it *ERC20ApprovalIterator) Close() error

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

func (*ERC20ApprovalIterator) Error 

func (it *ERC20ApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20ApprovalIterator) Next 

func (it *ERC20ApprovalIterator) 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 ERC20Caller 

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

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

func NewERC20Caller 

func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error)

NewERC20Caller creates a new read-only instance of ERC20, bound to a specific deployed contract.

func (*ERC20Caller) Allowance 

func (_ERC20 *ERC20Caller) 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 (*ERC20Caller) BalanceOf 

func (_ERC20 *ERC20Caller) 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 (*ERC20Caller) TotalSupply 

func (_ERC20 *ERC20Caller) 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 ERC20CallerRaw 

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

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

func (*ERC20CallerRaw) Call 

func (_ERC20 *ERC20CallerRaw) 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 ERC20CallerSession 

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

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

func (*ERC20CallerSession) Allowance 

func (_ERC20 *ERC20CallerSession) 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 (*ERC20CallerSession) BalanceOf 

func (_ERC20 *ERC20CallerSession) 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 (*ERC20CallerSession) TotalSupply 

func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

type ERC20Detailed 

type ERC20Detailed struct {
	ERC20DetailedCaller     // Read-only binding to the contract
	ERC20DetailedTransactor // Write-only binding to the contract
	ERC20DetailedFilterer   // Log filterer for contract events
}

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

func NewERC20Detailed 

func NewERC20Detailed(address common.Address, backend bind.ContractBackend) (*ERC20Detailed, error)

NewERC20Detailed creates a new instance of ERC20Detailed, bound to a specific deployed contract.

type ERC20DetailedApproval 

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

ERC20DetailedApproval represents a Approval event raised by the ERC20Detailed contract.

type ERC20DetailedApprovalIterator 

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

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

func (*ERC20DetailedApprovalIterator) Close 

func (it *ERC20DetailedApprovalIterator) Close() error

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

func (*ERC20DetailedApprovalIterator) Error 

func (it *ERC20DetailedApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20DetailedApprovalIterator) Next 

func (it *ERC20DetailedApprovalIterator) 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 ERC20DetailedCaller 

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

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

func NewERC20DetailedCaller 

func NewERC20DetailedCaller(address common.Address, caller bind.ContractCaller) (*ERC20DetailedCaller, error)

NewERC20DetailedCaller creates a new read-only instance of ERC20Detailed, bound to a specific deployed contract.

func (*ERC20DetailedCaller) Allowance 

func (_ERC20Detailed *ERC20DetailedCaller) 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 (*ERC20DetailedCaller) BalanceOf 

func (_ERC20Detailed *ERC20DetailedCaller) 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 (*ERC20DetailedCaller) Decimals 

func (_ERC20Detailed *ERC20DetailedCaller) Decimals(opts *bind.CallOpts) (uint8, error)

Decimals is a free data retrieval call binding the contract method 0x46b13615.

Solidity: function decimals() constant returns(uint8)

func (*ERC20DetailedCaller) Name 

func (_ERC20Detailed *ERC20DetailedCaller) Name(opts *bind.CallOpts) (string, error)

Name is a free data retrieval call binding the contract method 0xb11b6883.

Solidity: function name() constant returns(string)

func (*ERC20DetailedCaller) Symbol 

func (_ERC20Detailed *ERC20DetailedCaller) Symbol(opts *bind.CallOpts) (string, error)

Symbol is a free data retrieval call binding the contract method 0x5bfa2796.

Solidity: function symbol() constant returns(string)

func (*ERC20DetailedCaller) TotalSupply 

func (_ERC20Detailed *ERC20DetailedCaller) 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 ERC20DetailedCallerRaw 

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

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

func (*ERC20DetailedCallerRaw) Call 

func (_ERC20Detailed *ERC20DetailedCallerRaw) 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 ERC20DetailedCallerSession 

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

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

func (*ERC20DetailedCallerSession) Allowance 

func (_ERC20Detailed *ERC20DetailedCallerSession) 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 (*ERC20DetailedCallerSession) BalanceOf 

func (_ERC20Detailed *ERC20DetailedCallerSession) 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 (*ERC20DetailedCallerSession) Decimals 

func (_ERC20Detailed *ERC20DetailedCallerSession) Decimals() (uint8, error)

Decimals is a free data retrieval call binding the contract method 0x46b13615.

Solidity: function decimals() constant returns(uint8)

func (*ERC20DetailedCallerSession) Name 

func (_ERC20Detailed *ERC20DetailedCallerSession) Name() (string, error)

Name is a free data retrieval call binding the contract method 0xb11b6883.

Solidity: function name() constant returns(string)

func (*ERC20DetailedCallerSession) Symbol 

func (_ERC20Detailed *ERC20DetailedCallerSession) Symbol() (string, error)

Symbol is a free data retrieval call binding the contract method 0x5bfa2796.

Solidity: function symbol() constant returns(string)

func (*ERC20DetailedCallerSession) TotalSupply 

func (_ERC20Detailed *ERC20DetailedCallerSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

type ERC20DetailedFilterer 

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

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

func NewERC20DetailedFilterer 

func NewERC20DetailedFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20DetailedFilterer, error)

NewERC20DetailedFilterer creates a new log filterer instance of ERC20Detailed, bound to a specific deployed contract.

func (*ERC20DetailedFilterer) FilterApproval 

func (_ERC20Detailed *ERC20DetailedFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20DetailedApprovalIterator, 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 (*ERC20DetailedFilterer) FilterTransfer 

func (_ERC20Detailed *ERC20DetailedFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20DetailedTransferIterator, 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 (*ERC20DetailedFilterer) ParseApproval 

func (_ERC20Detailed *ERC20DetailedFilterer) ParseApproval(log types.Log) (*ERC20DetailedApproval, error)

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

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

func (*ERC20DetailedFilterer) ParseTransfer 

func (_ERC20Detailed *ERC20DetailedFilterer) ParseTransfer(log types.Log) (*ERC20DetailedTransfer, error)

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

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

func (*ERC20DetailedFilterer) WatchApproval 

func (_ERC20Detailed *ERC20DetailedFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20DetailedApproval, 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 (*ERC20DetailedFilterer) WatchTransfer 

func (_ERC20Detailed *ERC20DetailedFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20DetailedTransfer, 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 ERC20DetailedRaw 

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

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

func (*ERC20DetailedRaw) Call 

func (_ERC20Detailed *ERC20DetailedRaw) 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 (*ERC20DetailedRaw) Transact 

func (_ERC20Detailed *ERC20DetailedRaw) 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 (*ERC20DetailedRaw) Transfer 

func (_ERC20Detailed *ERC20DetailedRaw) 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 ERC20DetailedSession 

type ERC20DetailedSession struct {
	Contract     *ERC20Detailed    // 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
}

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

func (*ERC20DetailedSession) Allowance 

func (_ERC20Detailed *ERC20DetailedSession) 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 (*ERC20DetailedSession) Approve 

func (_ERC20Detailed *ERC20DetailedSession) 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 (*ERC20DetailedSession) AsyncApprove 

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

func (*ERC20DetailedSession) AsyncTransfer 

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

func (*ERC20DetailedSession) AsyncTransferFrom 

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

func (*ERC20DetailedSession) BalanceOf 

func (_ERC20Detailed *ERC20DetailedSession) 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 (*ERC20DetailedSession) Decimals 

func (_ERC20Detailed *ERC20DetailedSession) Decimals() (uint8, error)

Decimals is a free data retrieval call binding the contract method 0x46b13615.

Solidity: function decimals() constant returns(uint8)

func (*ERC20DetailedSession) Name 

func (_ERC20Detailed *ERC20DetailedSession) Name() (string, error)

Name is a free data retrieval call binding the contract method 0xb11b6883.

Solidity: function name() constant returns(string)

func (*ERC20DetailedSession) Symbol 

func (_ERC20Detailed *ERC20DetailedSession) Symbol() (string, error)

Symbol is a free data retrieval call binding the contract method 0x5bfa2796.

Solidity: function symbol() constant returns(string)

func (*ERC20DetailedSession) TotalSupply 

func (_ERC20Detailed *ERC20DetailedSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

func (*ERC20DetailedSession) Transfer 

func (_ERC20Detailed *ERC20DetailedSession) 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 (*ERC20DetailedSession) TransferFrom 

func (_ERC20Detailed *ERC20DetailedSession) 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 ERC20DetailedTransactor 

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

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

func NewERC20DetailedTransactor 

func NewERC20DetailedTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20DetailedTransactor, error)

NewERC20DetailedTransactor creates a new write-only instance of ERC20Detailed, bound to a specific deployed contract.

func (*ERC20DetailedTransactor) Approve 

func (_ERC20Detailed *ERC20DetailedTransactor) 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 (*ERC20DetailedTransactor) AsyncApprove 

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

func (*ERC20DetailedTransactor) AsyncTransfer 

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

func (*ERC20DetailedTransactor) AsyncTransferFrom 

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

func (*ERC20DetailedTransactor) Transfer 

func (_ERC20Detailed *ERC20DetailedTransactor) 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 (*ERC20DetailedTransactor) TransferFrom 

func (_ERC20Detailed *ERC20DetailedTransactor) 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 ERC20DetailedTransactorRaw 

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

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

func (*ERC20DetailedTransactorRaw) Transact 

func (_ERC20Detailed *ERC20DetailedTransactorRaw) 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 (*ERC20DetailedTransactorRaw) Transfer 

func (_ERC20Detailed *ERC20DetailedTransactorRaw) 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 ERC20DetailedTransactorSession 

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

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

func (*ERC20DetailedTransactorSession) Approve 

func (_ERC20Detailed *ERC20DetailedTransactorSession) 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 (*ERC20DetailedTransactorSession) AsyncApprove 

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

func (*ERC20DetailedTransactorSession) AsyncTransfer 

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

func (*ERC20DetailedTransactorSession) AsyncTransferFrom 

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

func (*ERC20DetailedTransactorSession) Transfer 

func (_ERC20Detailed *ERC20DetailedTransactorSession) 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 (*ERC20DetailedTransactorSession) TransferFrom 

func (_ERC20Detailed *ERC20DetailedTransactorSession) 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 ERC20DetailedTransfer 

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

ERC20DetailedTransfer represents a Transfer event raised by the ERC20Detailed contract.

type ERC20DetailedTransferIterator 

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

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

func (*ERC20DetailedTransferIterator) Close 

func (it *ERC20DetailedTransferIterator) Close() error

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

func (*ERC20DetailedTransferIterator) Error 

func (it *ERC20DetailedTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20DetailedTransferIterator) Next 

func (it *ERC20DetailedTransferIterator) 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 ERC20Extended 

type ERC20Extended struct {
	ERC20ExtendedCaller     // Read-only binding to the contract
	ERC20ExtendedTransactor // Write-only binding to the contract
	ERC20ExtendedFilterer   // Log filterer for contract events
}

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

func NewERC20Extended 

func NewERC20Extended(address common.Address, backend bind.ContractBackend) (*ERC20Extended, error)

NewERC20Extended creates a new instance of ERC20Extended, bound to a specific deployed contract.

type ERC20ExtendedApproval 

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

ERC20ExtendedApproval represents a Approval event raised by the ERC20Extended contract.

type ERC20ExtendedApprovalIterator 

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

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

func (*ERC20ExtendedApprovalIterator) Close 

func (it *ERC20ExtendedApprovalIterator) Close() error

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

func (*ERC20ExtendedApprovalIterator) Error 

func (it *ERC20ExtendedApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20ExtendedApprovalIterator) Next 

func (it *ERC20ExtendedApprovalIterator) 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 ERC20ExtendedBindAssetHash 

type ERC20ExtendedBindAssetHash struct {
	ChainId      uint64
	ContractAddr []byte
	Raw          types.Log // Blockchain specific contextual infos
}

ERC20ExtendedBindAssetHash represents a BindAssetHash event raised by the ERC20Extended contract.

type ERC20ExtendedBindAssetHashIterator 

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

ERC20ExtendedBindAssetHashIterator is returned from FilterBindAssetHash and is used to iterate over the raw logs and unpacked data for BindAssetHash events raised by the ERC20Extended contract.

func (*ERC20ExtendedBindAssetHashIterator) Close 

func (it *ERC20ExtendedBindAssetHashIterator) Close() error

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

func (*ERC20ExtendedBindAssetHashIterator) Error 

func (it *ERC20ExtendedBindAssetHashIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20ExtendedBindAssetHashIterator) Next 

func (it *ERC20ExtendedBindAssetHashIterator) 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 ERC20ExtendedCaller 

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

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

func NewERC20ExtendedCaller 

func NewERC20ExtendedCaller(address common.Address, caller bind.ContractCaller) (*ERC20ExtendedCaller, error)

NewERC20ExtendedCaller creates a new read-only instance of ERC20Extended, bound to a specific deployed contract.

func (*ERC20ExtendedCaller) Allowance 

func (_ERC20Extended *ERC20ExtendedCaller) 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 (*ERC20ExtendedCaller) BalanceOf 

func (_ERC20Extended *ERC20ExtendedCaller) 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 (*ERC20ExtendedCaller) BondAssetHashes 

func (_ERC20Extended *ERC20ExtendedCaller) BondAssetHashes(opts *bind.CallOpts, arg0 uint64) ([]byte, error)

BondAssetHashes is a free data retrieval call binding the contract method 0x1f260fb3.

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

func (*ERC20ExtendedCaller) Decimals 

func (_ERC20Extended *ERC20ExtendedCaller) Decimals(opts *bind.CallOpts) (uint8, error)

Decimals is a free data retrieval call binding the contract method 0x46b13615.

Solidity: function decimals() constant returns(uint8)

func (*ERC20ExtendedCaller) ManagerProxyContract 

func (_ERC20Extended *ERC20ExtendedCaller) 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 (*ERC20ExtendedCaller) Name 

func (_ERC20Extended *ERC20ExtendedCaller) Name(opts *bind.CallOpts) (string, error)

Name is a free data retrieval call binding the contract method 0xb11b6883.

Solidity: function name() constant returns(string)

func (*ERC20ExtendedCaller) Operator 

func (_ERC20Extended *ERC20ExtendedCaller) Operator(opts *bind.CallOpts) (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x3ba17b05.

Solidity: function operator() constant returns(address)

func (*ERC20ExtendedCaller) Symbol 

func (_ERC20Extended *ERC20ExtendedCaller) Symbol(opts *bind.CallOpts) (string, error)

Symbol is a free data retrieval call binding the contract method 0x5bfa2796.

Solidity: function symbol() constant returns(string)

func (*ERC20ExtendedCaller) TotalSupply 

func (_ERC20Extended *ERC20ExtendedCaller) 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 ERC20ExtendedCallerRaw 

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

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

func (*ERC20ExtendedCallerRaw) Call 

func (_ERC20Extended *ERC20ExtendedCallerRaw) 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 ERC20ExtendedCallerSession 

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

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

func (*ERC20ExtendedCallerSession) Allowance 

func (_ERC20Extended *ERC20ExtendedCallerSession) 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 (*ERC20ExtendedCallerSession) BalanceOf 

func (_ERC20Extended *ERC20ExtendedCallerSession) 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 (*ERC20ExtendedCallerSession) BondAssetHashes 

func (_ERC20Extended *ERC20ExtendedCallerSession) BondAssetHashes(arg0 uint64) ([]byte, error)

BondAssetHashes is a free data retrieval call binding the contract method 0x1f260fb3.

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

func (*ERC20ExtendedCallerSession) Decimals 

func (_ERC20Extended *ERC20ExtendedCallerSession) Decimals() (uint8, error)

Decimals is a free data retrieval call binding the contract method 0x46b13615.

Solidity: function decimals() constant returns(uint8)

func (*ERC20ExtendedCallerSession) ManagerProxyContract 

func (_ERC20Extended *ERC20ExtendedCallerSession) ManagerProxyContract() (common.Address, error)

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

Solidity: function managerProxyContract() constant returns(address)

func (*ERC20ExtendedCallerSession) Name 

func (_ERC20Extended *ERC20ExtendedCallerSession) Name() (string, error)

Name is a free data retrieval call binding the contract method 0xb11b6883.

Solidity: function name() constant returns(string)

func (*ERC20ExtendedCallerSession) Operator 

func (_ERC20Extended *ERC20ExtendedCallerSession) Operator() (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x3ba17b05.

Solidity: function operator() constant returns(address)

func (*ERC20ExtendedCallerSession) Symbol 

func (_ERC20Extended *ERC20ExtendedCallerSession) Symbol() (string, error)

Symbol is a free data retrieval call binding the contract method 0x5bfa2796.

Solidity: function symbol() constant returns(string)

func (*ERC20ExtendedCallerSession) TotalSupply 

func (_ERC20Extended *ERC20ExtendedCallerSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

type ERC20ExtendedFilterer 

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

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

func NewERC20ExtendedFilterer 

func NewERC20ExtendedFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20ExtendedFilterer, error)

NewERC20ExtendedFilterer creates a new log filterer instance of ERC20Extended, bound to a specific deployed contract.

func (*ERC20ExtendedFilterer) FilterApproval 

func (_ERC20Extended *ERC20ExtendedFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ExtendedApprovalIterator, 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 (*ERC20ExtendedFilterer) FilterBindAssetHash 

func (_ERC20Extended *ERC20ExtendedFilterer) FilterBindAssetHash(opts *bind.FilterOpts) (*ERC20ExtendedBindAssetHashIterator, error)

FilterBindAssetHash is a free log retrieval operation binding the contract event 0x000000000000000000000000000000000000000000000000000000009581fc60.

Solidity: event BindAssetHash(uint64 chainId, bytes contractAddr)

func (*ERC20ExtendedFilterer) FilterSetManagerProxyEvent 

func (_ERC20Extended *ERC20ExtendedFilterer) FilterSetManagerProxyEvent(opts *bind.FilterOpts) (*ERC20ExtendedSetManagerProxyEventIterator, error)

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

Solidity: event SetManagerProxyEvent(address managerContract)

func (*ERC20ExtendedFilterer) FilterTransfer 

func (_ERC20Extended *ERC20ExtendedFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20ExtendedTransferIterator, 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 (*ERC20ExtendedFilterer) ParseApproval 

func (_ERC20Extended *ERC20ExtendedFilterer) ParseApproval(log types.Log) (*ERC20ExtendedApproval, error)

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

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

func (*ERC20ExtendedFilterer) ParseBindAssetHash 

func (_ERC20Extended *ERC20ExtendedFilterer) ParseBindAssetHash(log types.Log) (*ERC20ExtendedBindAssetHash, error)

ParseBindAssetHash is a log parse operation binding the contract event 0x000000000000000000000000000000000000000000000000000000009581fc60.

Solidity: event BindAssetHash(uint64 chainId, bytes contractAddr)

func (*ERC20ExtendedFilterer) ParseSetManagerProxyEvent 

func (_ERC20Extended *ERC20ExtendedFilterer) ParseSetManagerProxyEvent(log types.Log) (*ERC20ExtendedSetManagerProxyEvent, error)

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

Solidity: event SetManagerProxyEvent(address managerContract)

func (*ERC20ExtendedFilterer) ParseTransfer 

func (_ERC20Extended *ERC20ExtendedFilterer) ParseTransfer(log types.Log) (*ERC20ExtendedTransfer, error)

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

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

func (*ERC20ExtendedFilterer) WatchApproval 

func (_ERC20Extended *ERC20ExtendedFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20ExtendedApproval, 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 (*ERC20ExtendedFilterer) WatchBindAssetHash 

func (_ERC20Extended *ERC20ExtendedFilterer) WatchBindAssetHash(opts *bind.WatchOpts, sink chan<- *ERC20ExtendedBindAssetHash) (event.Subscription, error)

WatchBindAssetHash is a free log subscription operation binding the contract event 0x000000000000000000000000000000000000000000000000000000009581fc60.

Solidity: event BindAssetHash(uint64 chainId, bytes contractAddr)

func (*ERC20ExtendedFilterer) WatchSetManagerProxyEvent 

func (_ERC20Extended *ERC20ExtendedFilterer) WatchSetManagerProxyEvent(opts *bind.WatchOpts, sink chan<- *ERC20ExtendedSetManagerProxyEvent) (event.Subscription, error)

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

Solidity: event SetManagerProxyEvent(address managerContract)

func (*ERC20ExtendedFilterer) WatchTransfer 

func (_ERC20Extended *ERC20ExtendedFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20ExtendedTransfer, 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 ERC20ExtendedRaw 

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

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

func (*ERC20ExtendedRaw) Call 

func (_ERC20Extended *ERC20ExtendedRaw) 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 (*ERC20ExtendedRaw) Transact 

func (_ERC20Extended *ERC20ExtendedRaw) 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 (*ERC20ExtendedRaw) Transfer 

func (_ERC20Extended *ERC20ExtendedRaw) 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 ERC20ExtendedSession 

type ERC20ExtendedSession struct {
	Contract     *ERC20Extended    // 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
}

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

func (*ERC20ExtendedSession) Allowance 

func (_ERC20Extended *ERC20ExtendedSession) 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 (*ERC20ExtendedSession) Approve 

func (_ERC20Extended *ERC20ExtendedSession) 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 (*ERC20ExtendedSession) AsyncApprove 

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

func (*ERC20ExtendedSession) AsyncBindAssetHash 

func (_ERC20Extended *ERC20ExtendedSession) AsyncBindAssetHash(handler func(*types.Receipt, error), chainId uint64, contractAddr []byte) (*types.Transaction, error)

func (*ERC20ExtendedSession) AsyncBurn 

func (_ERC20Extended *ERC20ExtendedSession) AsyncBurn(handler func(*types.Receipt, error), amount *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedSession) AsyncDecreaseAllowance 

func (_ERC20Extended *ERC20ExtendedSession) AsyncDecreaseAllowance(handler func(*types.Receipt, error), spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedSession) AsyncIncreaseAllowance 

func (_ERC20Extended *ERC20ExtendedSession) AsyncIncreaseAllowance(handler func(*types.Receipt, error), spender common.Address, addedValue *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedSession) AsyncMint 

func (_ERC20Extended *ERC20ExtendedSession) AsyncMint(handler func(*types.Receipt, error), account common.Address, amount *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedSession) AsyncSetManagerProxy 

func (_ERC20Extended *ERC20ExtendedSession) AsyncSetManagerProxy(handler func(*types.Receipt, error), ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, error)

func (*ERC20ExtendedSession) AsyncTransfer 

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

func (*ERC20ExtendedSession) AsyncTransferFrom 

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

func (*ERC20ExtendedSession) BalanceOf 

func (_ERC20Extended *ERC20ExtendedSession) 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 (*ERC20ExtendedSession) BindAssetHash 

func (_ERC20Extended *ERC20ExtendedSession) BindAssetHash(chainId uint64, contractAddr []byte) (*types.Transaction, *types.Receipt, error)

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

Solidity: function bindAssetHash(uint64 chainId, bytes contractAddr) returns()

func (*ERC20ExtendedSession) BondAssetHashes 

func (_ERC20Extended *ERC20ExtendedSession) BondAssetHashes(arg0 uint64) ([]byte, error)

BondAssetHashes is a free data retrieval call binding the contract method 0x1f260fb3.

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

func (*ERC20ExtendedSession) Burn 

func (_ERC20Extended *ERC20ExtendedSession) Burn(amount *big.Int) (*types.Transaction, *types.Receipt, error)

Burn is a paid mutator transaction binding the contract method 0x391edc16.

Solidity: function burn(uint256 amount) returns(bool)

func (*ERC20ExtendedSession) Decimals 

func (_ERC20Extended *ERC20ExtendedSession) Decimals() (uint8, error)

Decimals is a free data retrieval call binding the contract method 0x46b13615.

Solidity: function decimals() constant returns(uint8)

func (*ERC20ExtendedSession) DecreaseAllowance 

func (_ERC20Extended *ERC20ExtendedSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, *types.Receipt, error)

DecreaseAllowance is a paid mutator transaction binding the contract method 0x13a1aa5c.

Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)

func (*ERC20ExtendedSession) IncreaseAllowance 

func (_ERC20Extended *ERC20ExtendedSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, *types.Receipt, error)

IncreaseAllowance is a paid mutator transaction binding the contract method 0x4d2e8120.

Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)

func (*ERC20ExtendedSession) ManagerProxyContract 

func (_ERC20Extended *ERC20ExtendedSession) ManagerProxyContract() (common.Address, error)

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

Solidity: function managerProxyContract() constant returns(address)

func (*ERC20ExtendedSession) Mint 

func (_ERC20Extended *ERC20ExtendedSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Mint is a paid mutator transaction binding the contract method 0x4f5e00c7.

Solidity: function mint(address account, uint256 amount) returns(bool)

func (*ERC20ExtendedSession) Name 

func (_ERC20Extended *ERC20ExtendedSession) Name() (string, error)

Name is a free data retrieval call binding the contract method 0xb11b6883.

Solidity: function name() constant returns(string)

func (*ERC20ExtendedSession) Operator 

func (_ERC20Extended *ERC20ExtendedSession) Operator() (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x3ba17b05.

Solidity: function operator() constant returns(address)

func (*ERC20ExtendedSession) SetManagerProxy 

func (_ERC20Extended *ERC20ExtendedSession) SetManagerProxy(ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function setManagerProxy(address ethCrossChainManagerProxyAddr) returns()

func (*ERC20ExtendedSession) Symbol 

func (_ERC20Extended *ERC20ExtendedSession) Symbol() (string, error)

Symbol is a free data retrieval call binding the contract method 0x5bfa2796.

Solidity: function symbol() constant returns(string)

func (*ERC20ExtendedSession) TotalSupply 

func (_ERC20Extended *ERC20ExtendedSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

func (*ERC20ExtendedSession) Transfer 

func (_ERC20Extended *ERC20ExtendedSession) 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 (*ERC20ExtendedSession) TransferFrom 

func (_ERC20Extended *ERC20ExtendedSession) 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 ERC20ExtendedSetManagerProxyEvent 

type ERC20ExtendedSetManagerProxyEvent struct {
	ManagerContract common.Address
	Raw             types.Log // Blockchain specific contextual infos
}

ERC20ExtendedSetManagerProxyEvent represents a SetManagerProxyEvent event raised by the ERC20Extended contract.

type ERC20ExtendedSetManagerProxyEventIterator 

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

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

func (*ERC20ExtendedSetManagerProxyEventIterator) Close 

func (it *ERC20ExtendedSetManagerProxyEventIterator) Close() error

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

func (*ERC20ExtendedSetManagerProxyEventIterator) Error 

func (it *ERC20ExtendedSetManagerProxyEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20ExtendedSetManagerProxyEventIterator) Next 

func (it *ERC20ExtendedSetManagerProxyEventIterator) 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 ERC20ExtendedTransactor 

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

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

func NewERC20ExtendedTransactor 

func NewERC20ExtendedTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20ExtendedTransactor, error)

NewERC20ExtendedTransactor creates a new write-only instance of ERC20Extended, bound to a specific deployed contract.

func (*ERC20ExtendedTransactor) Approve 

func (_ERC20Extended *ERC20ExtendedTransactor) 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 (*ERC20ExtendedTransactor) AsyncApprove 

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

func (*ERC20ExtendedTransactor) AsyncBindAssetHash 

func (_ERC20Extended *ERC20ExtendedTransactor) AsyncBindAssetHash(handler func(*types.Receipt, error), opts *bind.TransactOpts, chainId uint64, contractAddr []byte) (*types.Transaction, error)

func (*ERC20ExtendedTransactor) AsyncBurn 

func (_ERC20Extended *ERC20ExtendedTransactor) AsyncBurn(handler func(*types.Receipt, error), opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedTransactor) AsyncDecreaseAllowance 

func (_ERC20Extended *ERC20ExtendedTransactor) AsyncDecreaseAllowance(handler func(*types.Receipt, error), opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedTransactor) AsyncIncreaseAllowance 

func (_ERC20Extended *ERC20ExtendedTransactor) AsyncIncreaseAllowance(handler func(*types.Receipt, error), opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedTransactor) AsyncMint 

func (_ERC20Extended *ERC20ExtendedTransactor) AsyncMint(handler func(*types.Receipt, error), opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedTransactor) AsyncSetManagerProxy 

func (_ERC20Extended *ERC20ExtendedTransactor) AsyncSetManagerProxy(handler func(*types.Receipt, error), opts *bind.TransactOpts, ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, error)

func (*ERC20ExtendedTransactor) AsyncTransfer 

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

func (*ERC20ExtendedTransactor) AsyncTransferFrom 

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

func (*ERC20ExtendedTransactor) BindAssetHash 

func (_ERC20Extended *ERC20ExtendedTransactor) BindAssetHash(opts *bind.TransactOpts, chainId uint64, contractAddr []byte) (*types.Transaction, *types.Receipt, error)

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

Solidity: function bindAssetHash(uint64 chainId, bytes contractAddr) returns()

func (*ERC20ExtendedTransactor) Burn 

func (_ERC20Extended *ERC20ExtendedTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Burn is a paid mutator transaction binding the contract method 0x391edc16.

Solidity: function burn(uint256 amount) returns(bool)

func (*ERC20ExtendedTransactor) DecreaseAllowance 

func (_ERC20Extended *ERC20ExtendedTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, *types.Receipt, error)

DecreaseAllowance is a paid mutator transaction binding the contract method 0x13a1aa5c.

Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)

func (*ERC20ExtendedTransactor) IncreaseAllowance 

func (_ERC20Extended *ERC20ExtendedTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, *types.Receipt, error)

IncreaseAllowance is a paid mutator transaction binding the contract method 0x4d2e8120.

Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)

func (*ERC20ExtendedTransactor) Mint 

func (_ERC20Extended *ERC20ExtendedTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Mint is a paid mutator transaction binding the contract method 0x4f5e00c7.

Solidity: function mint(address account, uint256 amount) returns(bool)

func (*ERC20ExtendedTransactor) SetManagerProxy 

func (_ERC20Extended *ERC20ExtendedTransactor) SetManagerProxy(opts *bind.TransactOpts, ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function setManagerProxy(address ethCrossChainManagerProxyAddr) returns()

func (*ERC20ExtendedTransactor) Transfer 

func (_ERC20Extended *ERC20ExtendedTransactor) 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 (*ERC20ExtendedTransactor) TransferFrom 

func (_ERC20Extended *ERC20ExtendedTransactor) 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 ERC20ExtendedTransactorRaw 

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

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

func (*ERC20ExtendedTransactorRaw) Transact 

func (_ERC20Extended *ERC20ExtendedTransactorRaw) 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 (*ERC20ExtendedTransactorRaw) Transfer 

func (_ERC20Extended *ERC20ExtendedTransactorRaw) 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 ERC20ExtendedTransactorSession 

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

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

func (*ERC20ExtendedTransactorSession) Approve 

func (_ERC20Extended *ERC20ExtendedTransactorSession) 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 (*ERC20ExtendedTransactorSession) AsyncApprove 

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

func (*ERC20ExtendedTransactorSession) AsyncBindAssetHash 

func (_ERC20Extended *ERC20ExtendedTransactorSession) AsyncBindAssetHash(handler func(*types.Receipt, error), chainId uint64, contractAddr []byte) (*types.Transaction, error)

func (*ERC20ExtendedTransactorSession) AsyncBurn 

func (_ERC20Extended *ERC20ExtendedTransactorSession) AsyncBurn(handler func(*types.Receipt, error), amount *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedTransactorSession) AsyncDecreaseAllowance 

func (_ERC20Extended *ERC20ExtendedTransactorSession) AsyncDecreaseAllowance(handler func(*types.Receipt, error), spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedTransactorSession) AsyncIncreaseAllowance 

func (_ERC20Extended *ERC20ExtendedTransactorSession) AsyncIncreaseAllowance(handler func(*types.Receipt, error), spender common.Address, addedValue *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedTransactorSession) AsyncMint 

func (_ERC20Extended *ERC20ExtendedTransactorSession) AsyncMint(handler func(*types.Receipt, error), account common.Address, amount *big.Int) (*types.Transaction, error)

func (*ERC20ExtendedTransactorSession) AsyncSetManagerProxy 

func (_ERC20Extended *ERC20ExtendedTransactorSession) AsyncSetManagerProxy(handler func(*types.Receipt, error), ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, error)

func (*ERC20ExtendedTransactorSession) AsyncTransfer 

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

func (*ERC20ExtendedTransactorSession) AsyncTransferFrom 

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

func (*ERC20ExtendedTransactorSession) BindAssetHash 

func (_ERC20Extended *ERC20ExtendedTransactorSession) BindAssetHash(chainId uint64, contractAddr []byte) (*types.Transaction, *types.Receipt, error)

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

Solidity: function bindAssetHash(uint64 chainId, bytes contractAddr) returns()

func (*ERC20ExtendedTransactorSession) Burn 

func (_ERC20Extended *ERC20ExtendedTransactorSession) Burn(amount *big.Int) (*types.Transaction, *types.Receipt, error)

Burn is a paid mutator transaction binding the contract method 0x391edc16.

Solidity: function burn(uint256 amount) returns(bool)

func (*ERC20ExtendedTransactorSession) DecreaseAllowance 

func (_ERC20Extended *ERC20ExtendedTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, *types.Receipt, error)

DecreaseAllowance is a paid mutator transaction binding the contract method 0x13a1aa5c.

Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)

func (*ERC20ExtendedTransactorSession) IncreaseAllowance 

func (_ERC20Extended *ERC20ExtendedTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, *types.Receipt, error)

IncreaseAllowance is a paid mutator transaction binding the contract method 0x4d2e8120.

Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)

func (*ERC20ExtendedTransactorSession) Mint 

func (_ERC20Extended *ERC20ExtendedTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, *types.Receipt, error)

Mint is a paid mutator transaction binding the contract method 0x4f5e00c7.

Solidity: function mint(address account, uint256 amount) returns(bool)

func (*ERC20ExtendedTransactorSession) SetManagerProxy 

func (_ERC20Extended *ERC20ExtendedTransactorSession) SetManagerProxy(ethCrossChainManagerProxyAddr common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function setManagerProxy(address ethCrossChainManagerProxyAddr) returns()

func (*ERC20ExtendedTransactorSession) Transfer 

func (_ERC20Extended *ERC20ExtendedTransactorSession) 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 (*ERC20ExtendedTransactorSession) TransferFrom 

func (_ERC20Extended *ERC20ExtendedTransactorSession) 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 ERC20ExtendedTransfer 

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

ERC20ExtendedTransfer represents a Transfer event raised by the ERC20Extended contract.

type ERC20ExtendedTransferIterator 

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

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

func (*ERC20ExtendedTransferIterator) Close 

func (it *ERC20ExtendedTransferIterator) Close() error

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

func (*ERC20ExtendedTransferIterator) Error 

func (it *ERC20ExtendedTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20ExtendedTransferIterator) Next 

func (it *ERC20ExtendedTransferIterator) 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 ERC20Filterer 

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

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

func NewERC20Filterer 

func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error)

NewERC20Filterer creates a new log filterer instance of ERC20, bound to a specific deployed contract.

func (*ERC20Filterer) FilterApproval 

func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, 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 (*ERC20Filterer) FilterTransfer 

func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, 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 (*ERC20Filterer) ParseApproval 

func (_ERC20 *ERC20Filterer) ParseApproval(log types.Log) (*ERC20Approval, error)

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

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

func (*ERC20Filterer) ParseTransfer 

func (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, error)

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

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

func (*ERC20Filterer) WatchApproval 

func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, 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 (*ERC20Filterer) WatchTransfer 

func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, 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 ERC20Raw 

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

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

func (*ERC20Raw) Call 

func (_ERC20 *ERC20Raw) 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 (*ERC20Raw) Transact 

func (_ERC20 *ERC20Raw) 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 (*ERC20Raw) Transfer 

func (_ERC20 *ERC20Raw) 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 ERC20Session 

type ERC20Session struct {
	Contract     *ERC20            // 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
}

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

func (*ERC20Session) Allowance 

func (_ERC20 *ERC20Session) 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 (*ERC20Session) Approve 

func (_ERC20 *ERC20Session) 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 (*ERC20Session) AsyncApprove 

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

func (*ERC20Session) AsyncDecreaseAllowance 

func (_ERC20 *ERC20Session) AsyncDecreaseAllowance(handler func(*types.Receipt, error), spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

func (*ERC20Session) AsyncIncreaseAllowance 

func (_ERC20 *ERC20Session) AsyncIncreaseAllowance(handler func(*types.Receipt, error), spender common.Address, addedValue *big.Int) (*types.Transaction, error)

func (*ERC20Session) AsyncTransfer 

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

func (*ERC20Session) AsyncTransferFrom 

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

func (*ERC20Session) BalanceOf 

func (_ERC20 *ERC20Session) 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 (*ERC20Session) DecreaseAllowance 

func (_ERC20 *ERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, *types.Receipt, error)

DecreaseAllowance is a paid mutator transaction binding the contract method 0x13a1aa5c.

Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)

func (*ERC20Session) IncreaseAllowance 

func (_ERC20 *ERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, *types.Receipt, error)

IncreaseAllowance is a paid mutator transaction binding the contract method 0x4d2e8120.

Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)

func (*ERC20Session) TotalSupply 

func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

func (*ERC20Session) Transfer 

func (_ERC20 *ERC20Session) 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 (*ERC20Session) TransferFrom 

func (_ERC20 *ERC20Session) 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 ERC20Transactor 

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

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

func NewERC20Transactor 

func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error)

NewERC20Transactor creates a new write-only instance of ERC20, bound to a specific deployed contract.

func (*ERC20Transactor) Approve 

func (_ERC20 *ERC20Transactor) 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 (*ERC20Transactor) AsyncApprove 

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

func (*ERC20Transactor) AsyncDecreaseAllowance 

func (_ERC20 *ERC20Transactor) AsyncDecreaseAllowance(handler func(*types.Receipt, error), opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

func (*ERC20Transactor) AsyncIncreaseAllowance 

func (_ERC20 *ERC20Transactor) AsyncIncreaseAllowance(handler func(*types.Receipt, error), opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

func (*ERC20Transactor) AsyncTransfer 

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

func (*ERC20Transactor) AsyncTransferFrom 

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

func (*ERC20Transactor) DecreaseAllowance 

func (_ERC20 *ERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, *types.Receipt, error)

DecreaseAllowance is a paid mutator transaction binding the contract method 0x13a1aa5c.

Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)

func (*ERC20Transactor) IncreaseAllowance 

func (_ERC20 *ERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, *types.Receipt, error)

IncreaseAllowance is a paid mutator transaction binding the contract method 0x4d2e8120.

Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)

func (*ERC20Transactor) Transfer 

func (_ERC20 *ERC20Transactor) 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 (*ERC20Transactor) TransferFrom 

func (_ERC20 *ERC20Transactor) 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 ERC20TransactorRaw 

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

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

func (*ERC20TransactorRaw) Transact 

func (_ERC20 *ERC20TransactorRaw) 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 (*ERC20TransactorRaw) Transfer 

func (_ERC20 *ERC20TransactorRaw) 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 ERC20TransactorSession 

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

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

func (*ERC20TransactorSession) Approve 

func (_ERC20 *ERC20TransactorSession) 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 (*ERC20TransactorSession) AsyncApprove 

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

func (*ERC20TransactorSession) AsyncDecreaseAllowance 

func (_ERC20 *ERC20TransactorSession) AsyncDecreaseAllowance(handler func(*types.Receipt, error), spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

func (*ERC20TransactorSession) AsyncIncreaseAllowance 

func (_ERC20 *ERC20TransactorSession) AsyncIncreaseAllowance(handler func(*types.Receipt, error), spender common.Address, addedValue *big.Int) (*types.Transaction, error)

func (*ERC20TransactorSession) AsyncTransfer 

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

func (*ERC20TransactorSession) AsyncTransferFrom 

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

func (*ERC20TransactorSession) DecreaseAllowance 

func (_ERC20 *ERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, *types.Receipt, error)

DecreaseAllowance is a paid mutator transaction binding the contract method 0x13a1aa5c.

Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)

func (*ERC20TransactorSession) IncreaseAllowance 

func (_ERC20 *ERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, *types.Receipt, error)

IncreaseAllowance is a paid mutator transaction binding the contract method 0x4d2e8120.

Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)

func (*ERC20TransactorSession) Transfer 

func (_ERC20 *ERC20TransactorSession) 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 (*ERC20TransactorSession) TransferFrom 

func (_ERC20 *ERC20TransactorSession) 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 ERC20Transfer 

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

ERC20Transfer represents a Transfer event raised by the ERC20 contract.

type ERC20TransferIterator 

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

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

func (*ERC20TransferIterator) Close 

func (it *ERC20TransferIterator) Close() error

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

func (*ERC20TransferIterator) Error 

func (it *ERC20TransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20TransferIterator) Next 

func (it *ERC20TransferIterator) 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 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 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.