erc20

package
v0.0.0 Latest Latest
Warning

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

 Go to latest Published: Nov 5, 2018 License: GPL-3.0 Imports: 15 Imported by: 2

Documentation

Index

Constants

View Source 
const CompatibleERC20ABI = "" /* 1894-byte string literal not displayed */

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

View Source 
const CompatibleERC20Bin = `0x`

CompatibleERC20Bin is the compiled bytecode used for deploying new contracts.

View Source 
const CompatibleERC20FunctionsABI = "[]"

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

View Source 
const CompatibleERC20FunctionsBin = `` /* 242-byte string literal not displayed */

CompatibleERC20FunctionsBin is the compiled bytecode used for deploying new contracts.

View Source 
const MathABI = "[]"

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

View Source 
const MathBin = `` /* 242-byte string literal not displayed */

MathBin is the compiled bytecode used for deploying new contracts.

View Source 
const RenExAtomicSwapperABI = "" /* 3721-byte string literal not displayed */

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

View Source 
const RenExAtomicSwapperBin = `` /* 6952-byte string literal not displayed */

RenExAtomicSwapperBin is the compiled bytecode used for deploying new contracts.

View Source 
const SafeMathABI = "[]"

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

View Source 
const SafeMathBin = `` /* 242-byte string literal not displayed */

SafeMathBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

func NewERC20SwapContractBinder 

func NewERC20SwapContractBinder(account beth.Account, swap foundation.Swap, logger swapper.Logger) (swapper.Contract, error)

NewERC20SwapContractBinder returns a new ERC20 Atom instance

Types

type CompatibleERC20 

type CompatibleERC20 struct {
	CompatibleERC20Caller     // Read-only binding to the contract
	CompatibleERC20Transactor // Write-only binding to the contract
	CompatibleERC20Filterer   // Log filterer for contract events
}

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

func DeployCompatibleERC20 

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

DeployCompatibleERC20 deploys a new Ethereum contract, binding an instance of CompatibleERC20 to it.

func NewCompatibleERC20 

func NewCompatibleERC20(address common.Address, backend bind.ContractBackend) (*CompatibleERC20, error)

NewCompatibleERC20 creates a new instance of CompatibleERC20, bound to a specific deployed contract.

type CompatibleERC20Approval 

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

CompatibleERC20Approval represents a Approval event raised by the CompatibleERC20 contract.

type CompatibleERC20ApprovalIterator 

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

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

func (*CompatibleERC20ApprovalIterator) Close 

func (it *CompatibleERC20ApprovalIterator) Close() error

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

func (*CompatibleERC20ApprovalIterator) Error 

func (it *CompatibleERC20ApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*CompatibleERC20ApprovalIterator) Next 

func (it *CompatibleERC20ApprovalIterator) 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 CompatibleERC20Caller 

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

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

func NewCompatibleERC20Caller 

func NewCompatibleERC20Caller(address common.Address, caller bind.ContractCaller) (*CompatibleERC20Caller, error)

NewCompatibleERC20Caller creates a new read-only instance of CompatibleERC20, bound to a specific deployed contract.

func (*CompatibleERC20Caller) Allowance 

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

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

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

func (*CompatibleERC20Caller) BalanceOf 

func (_CompatibleERC20 *CompatibleERC20Caller) BalanceOf(opts *bind.CallOpts, who common.Address) (*big.Int, error)

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

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

func (*CompatibleERC20Caller) TotalSupply 

func (_CompatibleERC20 *CompatibleERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

type CompatibleERC20CallerRaw 

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

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

func (*CompatibleERC20CallerRaw) Call 

func (_CompatibleERC20 *CompatibleERC20CallerRaw) 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 CompatibleERC20CallerSession 

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

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

func (*CompatibleERC20CallerSession) Allowance 

func (_CompatibleERC20 *CompatibleERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

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

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

func (*CompatibleERC20CallerSession) BalanceOf 

func (_CompatibleERC20 *CompatibleERC20CallerSession) BalanceOf(who common.Address) (*big.Int, error)

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

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

func (*CompatibleERC20CallerSession) TotalSupply 

func (_CompatibleERC20 *CompatibleERC20CallerSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

type CompatibleERC20Filterer 

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

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

func NewCompatibleERC20Filterer 

func NewCompatibleERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*CompatibleERC20Filterer, error)

NewCompatibleERC20Filterer creates a new log filterer instance of CompatibleERC20, bound to a specific deployed contract.

func (*CompatibleERC20Filterer) FilterApproval 

func (_CompatibleERC20 *CompatibleERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*CompatibleERC20ApprovalIterator, error)

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

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

func (*CompatibleERC20Filterer) FilterTransfer 

func (_CompatibleERC20 *CompatibleERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*CompatibleERC20TransferIterator, error)

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

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

func (*CompatibleERC20Filterer) WatchApproval 

func (_CompatibleERC20 *CompatibleERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *CompatibleERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error)

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

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

func (*CompatibleERC20Filterer) WatchTransfer 

func (_CompatibleERC20 *CompatibleERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *CompatibleERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error)

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

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

type CompatibleERC20Functions 

type CompatibleERC20Functions struct {
	CompatibleERC20FunctionsCaller     // Read-only binding to the contract
	CompatibleERC20FunctionsTransactor // Write-only binding to the contract
	CompatibleERC20FunctionsFilterer   // Log filterer for contract events
}

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

func DeployCompatibleERC20Functions 

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

DeployCompatibleERC20Functions deploys a new Ethereum contract, binding an instance of CompatibleERC20Functions to it.

func NewCompatibleERC20Functions 

func NewCompatibleERC20Functions(address common.Address, backend bind.ContractBackend) (*CompatibleERC20Functions, error)

NewCompatibleERC20Functions creates a new instance of CompatibleERC20Functions, bound to a specific deployed contract.

type CompatibleERC20FunctionsCaller 

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

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

func NewCompatibleERC20FunctionsCaller 

func NewCompatibleERC20FunctionsCaller(address common.Address, caller bind.ContractCaller) (*CompatibleERC20FunctionsCaller, error)

NewCompatibleERC20FunctionsCaller creates a new read-only instance of CompatibleERC20Functions, bound to a specific deployed contract.

type CompatibleERC20FunctionsCallerRaw 

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

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

func (*CompatibleERC20FunctionsCallerRaw) Call 

func (_CompatibleERC20Functions *CompatibleERC20FunctionsCallerRaw) 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 CompatibleERC20FunctionsCallerSession 

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

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

type CompatibleERC20FunctionsFilterer 

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

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

func NewCompatibleERC20FunctionsFilterer 

func NewCompatibleERC20FunctionsFilterer(address common.Address, filterer bind.ContractFilterer) (*CompatibleERC20FunctionsFilterer, error)

NewCompatibleERC20FunctionsFilterer creates a new log filterer instance of CompatibleERC20Functions, bound to a specific deployed contract.

type CompatibleERC20FunctionsRaw 

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

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

func (*CompatibleERC20FunctionsRaw) Call 

func (_CompatibleERC20Functions *CompatibleERC20FunctionsRaw) 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 (*CompatibleERC20FunctionsRaw) Transact 

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

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

func (*CompatibleERC20FunctionsRaw) Transfer 

func (_CompatibleERC20Functions *CompatibleERC20FunctionsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type CompatibleERC20FunctionsSession 

type CompatibleERC20FunctionsSession struct {
	Contract     *CompatibleERC20Functions // 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
}

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

type CompatibleERC20FunctionsTransactor 

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

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

func NewCompatibleERC20FunctionsTransactor 

func NewCompatibleERC20FunctionsTransactor(address common.Address, transactor bind.ContractTransactor) (*CompatibleERC20FunctionsTransactor, error)

NewCompatibleERC20FunctionsTransactor creates a new write-only instance of CompatibleERC20Functions, bound to a specific deployed contract.

type CompatibleERC20FunctionsTransactorRaw 

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

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

func (*CompatibleERC20FunctionsTransactorRaw) Transact 

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

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

func (*CompatibleERC20FunctionsTransactorRaw) Transfer 

func (_CompatibleERC20Functions *CompatibleERC20FunctionsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type CompatibleERC20FunctionsTransactorSession 

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

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

type CompatibleERC20Raw 

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

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

func (*CompatibleERC20Raw) Call 

func (_CompatibleERC20 *CompatibleERC20Raw) 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 (*CompatibleERC20Raw) Transact 

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

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

func (*CompatibleERC20Raw) Transfer 

func (_CompatibleERC20 *CompatibleERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type CompatibleERC20Session 

type CompatibleERC20Session struct {
	Contract     *CompatibleERC20  // 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
}

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

func (*CompatibleERC20Session) Allowance 

func (_CompatibleERC20 *CompatibleERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

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

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

func (*CompatibleERC20Session) Approve 

func (_CompatibleERC20 *CompatibleERC20Session) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

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

Solidity: function approve(spender address, value uint256) returns()

func (*CompatibleERC20Session) BalanceOf 

func (_CompatibleERC20 *CompatibleERC20Session) BalanceOf(who common.Address) (*big.Int, error)

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

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

func (*CompatibleERC20Session) TotalSupply 

func (_CompatibleERC20 *CompatibleERC20Session) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

func (*CompatibleERC20Session) Transfer 

func (_CompatibleERC20 *CompatibleERC20Session) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

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

Solidity: function transfer(to address, value uint256) returns()

func (*CompatibleERC20Session) TransferFrom 

func (_CompatibleERC20 *CompatibleERC20Session) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

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

Solidity: function transferFrom(from address, to address, value uint256) returns()

type CompatibleERC20Transactor 

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

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

func NewCompatibleERC20Transactor 

func NewCompatibleERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*CompatibleERC20Transactor, error)

NewCompatibleERC20Transactor creates a new write-only instance of CompatibleERC20, bound to a specific deployed contract.

func (*CompatibleERC20Transactor) Approve 

func (_CompatibleERC20 *CompatibleERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error)

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

Solidity: function approve(spender address, value uint256) returns()

func (*CompatibleERC20Transactor) Transfer 

func (_CompatibleERC20 *CompatibleERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error)

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

Solidity: function transfer(to address, value uint256) returns()

func (*CompatibleERC20Transactor) TransferFrom 

func (_CompatibleERC20 *CompatibleERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

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

Solidity: function transferFrom(from address, to address, value uint256) returns()

type CompatibleERC20TransactorRaw 

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

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

func (*CompatibleERC20TransactorRaw) Transact 

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

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

func (*CompatibleERC20TransactorRaw) Transfer 

func (_CompatibleERC20 *CompatibleERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type CompatibleERC20TransactorSession 

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

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

func (*CompatibleERC20TransactorSession) Approve 

func (_CompatibleERC20 *CompatibleERC20TransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

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

Solidity: function approve(spender address, value uint256) returns()

func (*CompatibleERC20TransactorSession) Transfer 

func (_CompatibleERC20 *CompatibleERC20TransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

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

Solidity: function transfer(to address, value uint256) returns()

func (*CompatibleERC20TransactorSession) TransferFrom 

func (_CompatibleERC20 *CompatibleERC20TransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

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

Solidity: function transferFrom(from address, to address, value uint256) returns()

type CompatibleERC20Transfer 

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

CompatibleERC20Transfer represents a Transfer event raised by the CompatibleERC20 contract.

type CompatibleERC20TransferIterator 

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

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

func (*CompatibleERC20TransferIterator) Close 

func (it *CompatibleERC20TransferIterator) Close() error

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

func (*CompatibleERC20TransferIterator) Error 

func (it *CompatibleERC20TransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*CompatibleERC20TransferIterator) Next 

func (it *CompatibleERC20TransferIterator) 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 Math 

type Math struct {
	MathCaller     // Read-only binding to the contract
	MathTransactor // Write-only binding to the contract
	MathFilterer   // Log filterer for contract events
}

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

func DeployMath 

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

DeployMath deploys a new Ethereum contract, binding an instance of Math to it.

func NewMath 

func NewMath(address common.Address, backend bind.ContractBackend) (*Math, error)

NewMath creates a new instance of Math, bound to a specific deployed contract.

type MathCaller 

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

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

func NewMathCaller 

func NewMathCaller(address common.Address, caller bind.ContractCaller) (*MathCaller, error)

NewMathCaller creates a new read-only instance of Math, bound to a specific deployed contract.

type MathCallerRaw 

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

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

func (*MathCallerRaw) Call 

func (_Math *MathCallerRaw) 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 MathCallerSession 

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

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

type MathFilterer 

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

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

func NewMathFilterer 

func NewMathFilterer(address common.Address, filterer bind.ContractFilterer) (*MathFilterer, error)

NewMathFilterer creates a new log filterer instance of Math, bound to a specific deployed contract.

type MathRaw 

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

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

func (*MathRaw) Call 

func (_Math *MathRaw) 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 (*MathRaw) Transact 

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

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

func (*MathRaw) Transfer 

func (_Math *MathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type MathSession 

type MathSession struct {
	Contract     *Math             // 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
}

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

type MathTransactor 

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

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

func NewMathTransactor 

func NewMathTransactor(address common.Address, transactor bind.ContractTransactor) (*MathTransactor, error)

NewMathTransactor creates a new write-only instance of Math, bound to a specific deployed contract.

type MathTransactorRaw 

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

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

func (*MathTransactorRaw) Transact 

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

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

func (*MathTransactorRaw) Transfer 

func (_Math *MathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type MathTransactorSession 

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

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

type RenExAtomicSwapper 

type RenExAtomicSwapper struct {
	RenExAtomicSwapperCaller     // Read-only binding to the contract
	RenExAtomicSwapperTransactor // Write-only binding to the contract
	RenExAtomicSwapperFilterer   // Log filterer for contract events
}

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

func DeployRenExAtomicSwapper 

func DeployRenExAtomicSwapper(auth *bind.TransactOpts, backend bind.ContractBackend, _VERSION string, _TOKEN_ADDRESS common.Address) (common.Address, *types.Transaction, *RenExAtomicSwapper, error)

DeployRenExAtomicSwapper deploys a new Ethereum contract, binding an instance of RenExAtomicSwapper to it.

func NewRenExAtomicSwapper 

func NewRenExAtomicSwapper(address common.Address, backend bind.ContractBackend) (*RenExAtomicSwapper, error)

NewRenExAtomicSwapper creates a new instance of RenExAtomicSwapper, bound to a specific deployed contract.

type RenExAtomicSwapperCaller 

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

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

func NewRenExAtomicSwapperCaller 

func NewRenExAtomicSwapperCaller(address common.Address, caller bind.ContractCaller) (*RenExAtomicSwapperCaller, error)

NewRenExAtomicSwapperCaller creates a new read-only instance of RenExAtomicSwapper, bound to a specific deployed contract.

func (*RenExAtomicSwapperCaller) Audit 

func (_RenExAtomicSwapper *RenExAtomicSwapperCaller) Audit(opts *bind.CallOpts, _swapID [32]byte) (struct {
	Timelock   *big.Int
	Value      *big.Int
	To         common.Address
	From       common.Address
	SecretLock [32]byte
}, error)

Audit is a free data retrieval call binding the contract method 0xc140635b.

Solidity: function audit(_swapID bytes32) constant returns(timelock uint256, value uint256, to address, from address, secretLock bytes32)

func (*RenExAtomicSwapperCaller) AuditSecret 

func (_RenExAtomicSwapper *RenExAtomicSwapperCaller) AuditSecret(opts *bind.CallOpts, _swapID [32]byte) ([32]byte, error)

AuditSecret is a free data retrieval call binding the contract method 0x976d00f4.

Solidity: function auditSecret(_swapID bytes32) constant returns(secretKey bytes32)

func (*RenExAtomicSwapperCaller) Initiatable 

func (_RenExAtomicSwapper *RenExAtomicSwapperCaller) Initiatable(opts *bind.CallOpts, _swapID [32]byte) (bool, error)

Initiatable is a free data retrieval call binding the contract method 0x09ece618.

Solidity: function initiatable(_swapID bytes32) constant returns(bool)

func (*RenExAtomicSwapperCaller) Redeemable 

func (_RenExAtomicSwapper *RenExAtomicSwapperCaller) Redeemable(opts *bind.CallOpts, _swapID [32]byte) (bool, error)

Redeemable is a free data retrieval call binding the contract method 0x68f06b29.

Solidity: function redeemable(_swapID bytes32) constant returns(bool)

func (*RenExAtomicSwapperCaller) RedeemedAt 

func (_RenExAtomicSwapper *RenExAtomicSwapperCaller) RedeemedAt(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error)

RedeemedAt is a free data retrieval call binding the contract method 0xbc4fcc4a.

Solidity: function redeemedAt( bytes32) constant returns(uint256)

func (*RenExAtomicSwapperCaller) Refundable 

func (_RenExAtomicSwapper *RenExAtomicSwapperCaller) Refundable(opts *bind.CallOpts, _swapID [32]byte) (bool, error)

Refundable is a free data retrieval call binding the contract method 0x9fb31475.

Solidity: function refundable(_swapID bytes32) constant returns(bool)

func (*RenExAtomicSwapperCaller) SwapID 

func (_RenExAtomicSwapper *RenExAtomicSwapperCaller) SwapID(opts *bind.CallOpts, _secretLock [32]byte, _timelock *big.Int) ([32]byte, error)

SwapID is a free data retrieval call binding the contract method 0x4b2ac3fa.

Solidity: function swapID(_secretLock bytes32, _timelock uint256) constant returns(bytes32)

func (*RenExAtomicSwapperCaller) TOKENADDRESS 

func (_RenExAtomicSwapper *RenExAtomicSwapperCaller) TOKENADDRESS(opts *bind.CallOpts) (common.Address, error)

TOKENADDRESS is a free data retrieval call binding the contract method 0x0bdf5300.

Solidity: function TOKEN_ADDRESS() constant returns(address)

func (*RenExAtomicSwapperCaller) VERSION 

func (_RenExAtomicSwapper *RenExAtomicSwapperCaller) VERSION(opts *bind.CallOpts) (string, error)

VERSION is a free data retrieval call binding the contract method 0xffa1ad74.

Solidity: function VERSION() constant returns(string)

type RenExAtomicSwapperCallerRaw 

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

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

func (*RenExAtomicSwapperCallerRaw) Call 

func (_RenExAtomicSwapper *RenExAtomicSwapperCallerRaw) 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 RenExAtomicSwapperCallerSession 

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

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

func (*RenExAtomicSwapperCallerSession) Audit 

func (_RenExAtomicSwapper *RenExAtomicSwapperCallerSession) Audit(_swapID [32]byte) (struct {
	Timelock   *big.Int
	Value      *big.Int
	To         common.Address
	From       common.Address
	SecretLock [32]byte
}, error)

Audit is a free data retrieval call binding the contract method 0xc140635b.

Solidity: function audit(_swapID bytes32) constant returns(timelock uint256, value uint256, to address, from address, secretLock bytes32)

func (*RenExAtomicSwapperCallerSession) AuditSecret 

func (_RenExAtomicSwapper *RenExAtomicSwapperCallerSession) AuditSecret(_swapID [32]byte) ([32]byte, error)

AuditSecret is a free data retrieval call binding the contract method 0x976d00f4.

Solidity: function auditSecret(_swapID bytes32) constant returns(secretKey bytes32)

func (*RenExAtomicSwapperCallerSession) Initiatable 

func (_RenExAtomicSwapper *RenExAtomicSwapperCallerSession) Initiatable(_swapID [32]byte) (bool, error)

Initiatable is a free data retrieval call binding the contract method 0x09ece618.

Solidity: function initiatable(_swapID bytes32) constant returns(bool)

func (*RenExAtomicSwapperCallerSession) Redeemable 

func (_RenExAtomicSwapper *RenExAtomicSwapperCallerSession) Redeemable(_swapID [32]byte) (bool, error)

Redeemable is a free data retrieval call binding the contract method 0x68f06b29.

Solidity: function redeemable(_swapID bytes32) constant returns(bool)

func (*RenExAtomicSwapperCallerSession) RedeemedAt 

func (_RenExAtomicSwapper *RenExAtomicSwapperCallerSession) RedeemedAt(arg0 [32]byte) (*big.Int, error)

RedeemedAt is a free data retrieval call binding the contract method 0xbc4fcc4a.

Solidity: function redeemedAt( bytes32) constant returns(uint256)

func (*RenExAtomicSwapperCallerSession) Refundable 

func (_RenExAtomicSwapper *RenExAtomicSwapperCallerSession) Refundable(_swapID [32]byte) (bool, error)

Refundable is a free data retrieval call binding the contract method 0x9fb31475.

Solidity: function refundable(_swapID bytes32) constant returns(bool)

func (*RenExAtomicSwapperCallerSession) SwapID 

func (_RenExAtomicSwapper *RenExAtomicSwapperCallerSession) SwapID(_secretLock [32]byte, _timelock *big.Int) ([32]byte, error)

SwapID is a free data retrieval call binding the contract method 0x4b2ac3fa.

Solidity: function swapID(_secretLock bytes32, _timelock uint256) constant returns(bytes32)

func (*RenExAtomicSwapperCallerSession) TOKENADDRESS 

func (_RenExAtomicSwapper *RenExAtomicSwapperCallerSession) TOKENADDRESS() (common.Address, error)

TOKENADDRESS is a free data retrieval call binding the contract method 0x0bdf5300.

Solidity: function TOKEN_ADDRESS() constant returns(address)

func (*RenExAtomicSwapperCallerSession) VERSION 

func (_RenExAtomicSwapper *RenExAtomicSwapperCallerSession) VERSION() (string, error)

VERSION is a free data retrieval call binding the contract method 0xffa1ad74.

Solidity: function VERSION() constant returns(string)

type RenExAtomicSwapperFilterer 

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

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

func NewRenExAtomicSwapperFilterer 

func NewRenExAtomicSwapperFilterer(address common.Address, filterer bind.ContractFilterer) (*RenExAtomicSwapperFilterer, error)

NewRenExAtomicSwapperFilterer creates a new log filterer instance of RenExAtomicSwapper, bound to a specific deployed contract.

func (*RenExAtomicSwapperFilterer) FilterLogClose 

func (_RenExAtomicSwapper *RenExAtomicSwapperFilterer) FilterLogClose(opts *bind.FilterOpts) (*RenExAtomicSwapperLogCloseIterator, error)

FilterLogClose is a free log retrieval operation binding the contract event 0x07da1fa25a1d885732677ce9c192cbec27051a4b69d391c9a64850f5a5112ba0.

Solidity: e LogClose(_swapID bytes32, _secretKey bytes32)

func (*RenExAtomicSwapperFilterer) FilterLogExpire 

func (_RenExAtomicSwapper *RenExAtomicSwapperFilterer) FilterLogExpire(opts *bind.FilterOpts) (*RenExAtomicSwapperLogExpireIterator, error)

FilterLogExpire is a free log retrieval operation binding the contract event 0xeb711459e1247171382f0da0387b86239b8e3ca60af3b15a9ff2f1eb3d7f6a1d.

Solidity: e LogExpire(_swapID bytes32)

func (*RenExAtomicSwapperFilterer) FilterLogOpen 

func (_RenExAtomicSwapper *RenExAtomicSwapperFilterer) FilterLogOpen(opts *bind.FilterOpts) (*RenExAtomicSwapperLogOpenIterator, error)

FilterLogOpen is a free log retrieval operation binding the contract event 0x497d46e9505eefe8b910d1a02e6b40d8769510023b0053c3ac4b9574b81c97bf.

Solidity: e LogOpen(_swapID bytes32, _withdrawTrader address, _secretLock bytes32)

func (*RenExAtomicSwapperFilterer) WatchLogClose 

func (_RenExAtomicSwapper *RenExAtomicSwapperFilterer) WatchLogClose(opts *bind.WatchOpts, sink chan<- *RenExAtomicSwapperLogClose) (event.Subscription, error)

WatchLogClose is a free log subscription operation binding the contract event 0x07da1fa25a1d885732677ce9c192cbec27051a4b69d391c9a64850f5a5112ba0.

Solidity: e LogClose(_swapID bytes32, _secretKey bytes32)

func (*RenExAtomicSwapperFilterer) WatchLogExpire 

func (_RenExAtomicSwapper *RenExAtomicSwapperFilterer) WatchLogExpire(opts *bind.WatchOpts, sink chan<- *RenExAtomicSwapperLogExpire) (event.Subscription, error)

WatchLogExpire is a free log subscription operation binding the contract event 0xeb711459e1247171382f0da0387b86239b8e3ca60af3b15a9ff2f1eb3d7f6a1d.

Solidity: e LogExpire(_swapID bytes32)

func (*RenExAtomicSwapperFilterer) WatchLogOpen 

func (_RenExAtomicSwapper *RenExAtomicSwapperFilterer) WatchLogOpen(opts *bind.WatchOpts, sink chan<- *RenExAtomicSwapperLogOpen) (event.Subscription, error)

WatchLogOpen is a free log subscription operation binding the contract event 0x497d46e9505eefe8b910d1a02e6b40d8769510023b0053c3ac4b9574b81c97bf.

Solidity: e LogOpen(_swapID bytes32, _withdrawTrader address, _secretLock bytes32)

type RenExAtomicSwapperLogClose 

type RenExAtomicSwapperLogClose struct {
	SwapID    [32]byte
	SecretKey [32]byte
	Raw       types.Log // Blockchain specific contextual infos
}

RenExAtomicSwapperLogClose represents a LogClose event raised by the RenExAtomicSwapper contract.

type RenExAtomicSwapperLogCloseIterator 

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

RenExAtomicSwapperLogCloseIterator is returned from FilterLogClose and is used to iterate over the raw logs and unpacked data for LogClose events raised by the RenExAtomicSwapper contract.

func (*RenExAtomicSwapperLogCloseIterator) Close 

func (it *RenExAtomicSwapperLogCloseIterator) Close() error

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

func (*RenExAtomicSwapperLogCloseIterator) Error 

func (it *RenExAtomicSwapperLogCloseIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RenExAtomicSwapperLogCloseIterator) Next 

func (it *RenExAtomicSwapperLogCloseIterator) 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 RenExAtomicSwapperLogExpire 

type RenExAtomicSwapperLogExpire struct {
	SwapID [32]byte
	Raw    types.Log // Blockchain specific contextual infos
}

RenExAtomicSwapperLogExpire represents a LogExpire event raised by the RenExAtomicSwapper contract.

type RenExAtomicSwapperLogExpireIterator 

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

RenExAtomicSwapperLogExpireIterator is returned from FilterLogExpire and is used to iterate over the raw logs and unpacked data for LogExpire events raised by the RenExAtomicSwapper contract.

func (*RenExAtomicSwapperLogExpireIterator) Close 

func (it *RenExAtomicSwapperLogExpireIterator) Close() error

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

func (*RenExAtomicSwapperLogExpireIterator) Error 

func (it *RenExAtomicSwapperLogExpireIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RenExAtomicSwapperLogExpireIterator) Next 

func (it *RenExAtomicSwapperLogExpireIterator) 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 RenExAtomicSwapperLogOpen 

type RenExAtomicSwapperLogOpen struct {
	SwapID         [32]byte
	WithdrawTrader common.Address
	SecretLock     [32]byte
	Raw            types.Log // Blockchain specific contextual infos
}

RenExAtomicSwapperLogOpen represents a LogOpen event raised by the RenExAtomicSwapper contract.

type RenExAtomicSwapperLogOpenIterator 

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

RenExAtomicSwapperLogOpenIterator is returned from FilterLogOpen and is used to iterate over the raw logs and unpacked data for LogOpen events raised by the RenExAtomicSwapper contract.

func (*RenExAtomicSwapperLogOpenIterator) Close 

func (it *RenExAtomicSwapperLogOpenIterator) Close() error

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

func (*RenExAtomicSwapperLogOpenIterator) Error 

func (it *RenExAtomicSwapperLogOpenIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RenExAtomicSwapperLogOpenIterator) Next 

func (it *RenExAtomicSwapperLogOpenIterator) 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 RenExAtomicSwapperRaw 

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

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

func (*RenExAtomicSwapperRaw) Call 

func (_RenExAtomicSwapper *RenExAtomicSwapperRaw) 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 (*RenExAtomicSwapperRaw) Transact 

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

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

func (*RenExAtomicSwapperRaw) Transfer 

func (_RenExAtomicSwapper *RenExAtomicSwapperRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type RenExAtomicSwapperSession 

type RenExAtomicSwapperSession struct {
	Contract     *RenExAtomicSwapper // 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
}

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

func (*RenExAtomicSwapperSession) Audit 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) Audit(_swapID [32]byte) (struct {
	Timelock   *big.Int
	Value      *big.Int
	To         common.Address
	From       common.Address
	SecretLock [32]byte
}, error)

Audit is a free data retrieval call binding the contract method 0xc140635b.

Solidity: function audit(_swapID bytes32) constant returns(timelock uint256, value uint256, to address, from address, secretLock bytes32)

func (*RenExAtomicSwapperSession) AuditSecret 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) AuditSecret(_swapID [32]byte) ([32]byte, error)

AuditSecret is a free data retrieval call binding the contract method 0x976d00f4.

Solidity: function auditSecret(_swapID bytes32) constant returns(secretKey bytes32)

func (*RenExAtomicSwapperSession) Initiatable 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) Initiatable(_swapID [32]byte) (bool, error)

Initiatable is a free data retrieval call binding the contract method 0x09ece618.

Solidity: function initiatable(_swapID bytes32) constant returns(bool)

func (*RenExAtomicSwapperSession) Initiate 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) Initiate(_swapID [32]byte, _withdrawTrader common.Address, _secretLock [32]byte, _timelock *big.Int, _value *big.Int) (*types.Transaction, error)

Initiate is a paid mutator transaction binding the contract method 0x027a2577.

Solidity: function initiate(_swapID bytes32, _withdrawTrader address, _secretLock bytes32, _timelock uint256, _value uint256) returns()

func (*RenExAtomicSwapperSession) Redeem 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) Redeem(_swapID [32]byte, _secretKey [32]byte) (*types.Transaction, error)

Redeem is a paid mutator transaction binding the contract method 0xb31597ad.

Solidity: function redeem(_swapID bytes32, _secretKey bytes32) returns()

func (*RenExAtomicSwapperSession) Redeemable 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) Redeemable(_swapID [32]byte) (bool, error)

Redeemable is a free data retrieval call binding the contract method 0x68f06b29.

Solidity: function redeemable(_swapID bytes32) constant returns(bool)

func (*RenExAtomicSwapperSession) RedeemedAt 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) RedeemedAt(arg0 [32]byte) (*big.Int, error)

RedeemedAt is a free data retrieval call binding the contract method 0xbc4fcc4a.

Solidity: function redeemedAt( bytes32) constant returns(uint256)

func (*RenExAtomicSwapperSession) Refund 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) Refund(_swapID [32]byte) (*types.Transaction, error)

Refund is a paid mutator transaction binding the contract method 0x7249fbb6.

Solidity: function refund(_swapID bytes32) returns()

func (*RenExAtomicSwapperSession) Refundable 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) Refundable(_swapID [32]byte) (bool, error)

Refundable is a free data retrieval call binding the contract method 0x9fb31475.

Solidity: function refundable(_swapID bytes32) constant returns(bool)

func (*RenExAtomicSwapperSession) SwapID 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) SwapID(_secretLock [32]byte, _timelock *big.Int) ([32]byte, error)

SwapID is a free data retrieval call binding the contract method 0x4b2ac3fa.

Solidity: function swapID(_secretLock bytes32, _timelock uint256) constant returns(bytes32)

func (*RenExAtomicSwapperSession) TOKENADDRESS 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) TOKENADDRESS() (common.Address, error)

TOKENADDRESS is a free data retrieval call binding the contract method 0x0bdf5300.

Solidity: function TOKEN_ADDRESS() constant returns(address)

func (*RenExAtomicSwapperSession) VERSION 

func (_RenExAtomicSwapper *RenExAtomicSwapperSession) VERSION() (string, error)

VERSION is a free data retrieval call binding the contract method 0xffa1ad74.

Solidity: function VERSION() constant returns(string)

type RenExAtomicSwapperTransactor 

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

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

func NewRenExAtomicSwapperTransactor 

func NewRenExAtomicSwapperTransactor(address common.Address, transactor bind.ContractTransactor) (*RenExAtomicSwapperTransactor, error)

NewRenExAtomicSwapperTransactor creates a new write-only instance of RenExAtomicSwapper, bound to a specific deployed contract.

func (*RenExAtomicSwapperTransactor) Initiate 

func (_RenExAtomicSwapper *RenExAtomicSwapperTransactor) Initiate(opts *bind.TransactOpts, _swapID [32]byte, _withdrawTrader common.Address, _secretLock [32]byte, _timelock *big.Int, _value *big.Int) (*types.Transaction, error)

Initiate is a paid mutator transaction binding the contract method 0x027a2577.

Solidity: function initiate(_swapID bytes32, _withdrawTrader address, _secretLock bytes32, _timelock uint256, _value uint256) returns()

func (*RenExAtomicSwapperTransactor) Redeem 

func (_RenExAtomicSwapper *RenExAtomicSwapperTransactor) Redeem(opts *bind.TransactOpts, _swapID [32]byte, _secretKey [32]byte) (*types.Transaction, error)

Redeem is a paid mutator transaction binding the contract method 0xb31597ad.

Solidity: function redeem(_swapID bytes32, _secretKey bytes32) returns()

func (*RenExAtomicSwapperTransactor) Refund 

func (_RenExAtomicSwapper *RenExAtomicSwapperTransactor) Refund(opts *bind.TransactOpts, _swapID [32]byte) (*types.Transaction, error)

Refund is a paid mutator transaction binding the contract method 0x7249fbb6.

Solidity: function refund(_swapID bytes32) returns()

type RenExAtomicSwapperTransactorRaw 

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

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

func (*RenExAtomicSwapperTransactorRaw) Transact 

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

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

func (*RenExAtomicSwapperTransactorRaw) Transfer 

func (_RenExAtomicSwapper *RenExAtomicSwapperTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type RenExAtomicSwapperTransactorSession 

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

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

func (*RenExAtomicSwapperTransactorSession) Initiate 

func (_RenExAtomicSwapper *RenExAtomicSwapperTransactorSession) Initiate(_swapID [32]byte, _withdrawTrader common.Address, _secretLock [32]byte, _timelock *big.Int, _value *big.Int) (*types.Transaction, error)

Initiate is a paid mutator transaction binding the contract method 0x027a2577.

Solidity: function initiate(_swapID bytes32, _withdrawTrader address, _secretLock bytes32, _timelock uint256, _value uint256) returns()

func (*RenExAtomicSwapperTransactorSession) Redeem 

func (_RenExAtomicSwapper *RenExAtomicSwapperTransactorSession) Redeem(_swapID [32]byte, _secretKey [32]byte) (*types.Transaction, error)

Redeem is a paid mutator transaction binding the contract method 0xb31597ad.

Solidity: function redeem(_swapID bytes32, _secretKey bytes32) returns()

func (*RenExAtomicSwapperTransactorSession) Refund 

func (_RenExAtomicSwapper *RenExAtomicSwapperTransactorSession) Refund(_swapID [32]byte) (*types.Transaction, error)

Refund is a paid mutator transaction binding the contract method 0x7249fbb6.

Solidity: function refund(_swapID bytes32) returns()

type SafeMath 

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

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

func DeploySafeMath 

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

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

func NewSafeMath 

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

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

type SafeMathCaller 

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

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

func NewSafeMathCaller 

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

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

type SafeMathCallerRaw 

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

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

func (*SafeMathCallerRaw) Call 

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

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

type SafeMathCallerSession 

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

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

type SafeMathFilterer 

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

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

func NewSafeMathFilterer 

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

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

type SafeMathRaw 

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

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

func (*SafeMathRaw) Call 

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

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

func (*SafeMathRaw) Transact 

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

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

func (*SafeMathRaw) Transfer 

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

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

type SafeMathSession 

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

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

type SafeMathTransactor 

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

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

func NewSafeMathTransactor 

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

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

type SafeMathTransactorRaw 

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

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

func (*SafeMathTransactorRaw) Transact 

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

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

func (*SafeMathTransactorRaw) Transfer 

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

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

type SafeMathTransactorSession 

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

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.