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

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

func (*BTCXSetManagerProxyEventIterator) Error

Error returns any retrieval or parsing error occurred during filtering.

func (*BTCXSetManagerProxyEventIterator) Next

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

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

func (*ERC20DetailedApprovalIterator) Error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20DetailedApprovalIterator) Next

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

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

func (*ERC20DetailedTransferIterator) Error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20DetailedTransferIterator) Next

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

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

func (*ERC20ExtendedApprovalIterator) Error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20ExtendedApprovalIterator) Next

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

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

func (*ERC20ExtendedBindAssetHashIterator) Error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20ExtendedBindAssetHashIterator) Next

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

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

func (*ERC20ExtendedSetManagerProxyEventIterator) Error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20ExtendedSetManagerProxyEventIterator) Next

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

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

func (*ERC20ExtendedTransferIterator) Error

Error returns any retrieval or parsing error occurred during filtering.

func (*ERC20ExtendedTransferIterator) Next

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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL