token

package
v0.0.2 Latest Latest
Warning

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

 Go to latest Published: May 5, 2019 License: GPL-3.0 Imports: 8 Imported by: 0

README

Kvartalo token

Token code: https://github.com/kvartalo/token

Token go build

abigen --sol token.sol --pkg token --out=token.go

Documentation

Index

Constants

View Source 
const OffchainsigABI = "" /* 218-byte string literal not displayed */

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

View Source 
const OffchainsigBin = `` /* 510-byte string literal not displayed */

OffchainsigBin is the compiled bytecode used for deploying new contracts.

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

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

View Source 
const OwnableBin = `0x`

OwnableBin 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.

View Source 
const TokenABI = "" /* 5260-byte string literal not displayed */

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

View Source 
const TokenBin = `` /* 8154-byte string literal not displayed */

TokenBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type Offchainsig 

type Offchainsig struct {
	OffchainsigCaller     // Read-only binding to the contract
	OffchainsigTransactor // Write-only binding to the contract
	OffchainsigFilterer   // Log filterer for contract events
}

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

func DeployOffchainsig 

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

DeployOffchainsig deploys a new Ethereum contract, binding an instance of Offchainsig to it.

func NewOffchainsig 

func NewOffchainsig(address common.Address, backend bind.ContractBackend) (*Offchainsig, error)

NewOffchainsig creates a new instance of Offchainsig, bound to a specific deployed contract.

type OffchainsigCaller 

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

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

func NewOffchainsigCaller 

func NewOffchainsigCaller(address common.Address, caller bind.ContractCaller) (*OffchainsigCaller, error)

NewOffchainsigCaller creates a new read-only instance of Offchainsig, bound to a specific deployed contract.

func (*OffchainsigCaller) NonceOf 

func (_Offchainsig *OffchainsigCaller) NonceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error)

NonceOf is a free data retrieval call binding the contract method 0xed2a2d64.

Solidity: function nonceOf(address _owner) constant returns(uint256)

type OffchainsigCallerRaw 

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

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

func (*OffchainsigCallerRaw) Call 

func (_Offchainsig *OffchainsigCallerRaw) 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 OffchainsigCallerSession 

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

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

func (*OffchainsigCallerSession) NonceOf 

func (_Offchainsig *OffchainsigCallerSession) NonceOf(_owner common.Address) (*big.Int, error)

NonceOf is a free data retrieval call binding the contract method 0xed2a2d64.

Solidity: function nonceOf(address _owner) constant returns(uint256)

type OffchainsigFilterer 

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

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

func NewOffchainsigFilterer 

func NewOffchainsigFilterer(address common.Address, filterer bind.ContractFilterer) (*OffchainsigFilterer, error)

NewOffchainsigFilterer creates a new log filterer instance of Offchainsig, bound to a specific deployed contract.

type OffchainsigRaw 

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

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

func (*OffchainsigRaw) Call 

func (_Offchainsig *OffchainsigRaw) 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 (*OffchainsigRaw) Transact 

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

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

func (*OffchainsigRaw) Transfer 

func (_Offchainsig *OffchainsigRaw) 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 OffchainsigSession 

type OffchainsigSession struct {
	Contract     *Offchainsig      // 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
}

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

func (*OffchainsigSession) NonceOf 

func (_Offchainsig *OffchainsigSession) NonceOf(_owner common.Address) (*big.Int, error)

NonceOf is a free data retrieval call binding the contract method 0xed2a2d64.

Solidity: function nonceOf(address _owner) constant returns(uint256)

type OffchainsigTransactor 

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

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

func NewOffchainsigTransactor 

func NewOffchainsigTransactor(address common.Address, transactor bind.ContractTransactor) (*OffchainsigTransactor, error)

NewOffchainsigTransactor creates a new write-only instance of Offchainsig, bound to a specific deployed contract.

type OffchainsigTransactorRaw 

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

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

func (*OffchainsigTransactorRaw) Transact 

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

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

func (*OffchainsigTransactorRaw) Transfer 

func (_Offchainsig *OffchainsigTransactorRaw) 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 OffchainsigTransactorSession 

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

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

type Ownable 

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

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

func DeployOwnable 

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

DeployOwnable deploys a new Ethereum contract, binding an instance of Ownable to it.

func NewOwnable 

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

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

type OwnableCaller 

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

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

func NewOwnableCaller 

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

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

func (*OwnableCaller) IsOwner 

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

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

Solidity: function isOwner() constant returns(bool)

func (*OwnableCaller) Owner 

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

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

Solidity: function owner() constant returns(address)

type OwnableCallerRaw 

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

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

func (*OwnableCallerRaw) Call 

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

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

type OwnableCallerSession 

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

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

func (*OwnableCallerSession) IsOwner 

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

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

Solidity: function isOwner() constant returns(bool)

func (*OwnableCallerSession) Owner 

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

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

Solidity: function owner() constant returns(address)

type OwnableFilterer 

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

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

func NewOwnableFilterer 

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

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

func (*OwnableFilterer) FilterOwnershipTransferred 

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

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

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

func (*OwnableFilterer) WatchOwnershipTransferred 

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

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

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

type OwnableOwnershipTransferred 

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

OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract.

type OwnableOwnershipTransferredIterator 

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

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

func (*OwnableOwnershipTransferredIterator) Close 

func (it *OwnableOwnershipTransferredIterator) Close() error

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

func (*OwnableOwnershipTransferredIterator) Error 

func (it *OwnableOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OwnableOwnershipTransferredIterator) Next 

func (it *OwnableOwnershipTransferredIterator) Next() bool

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

type OwnableRaw 

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

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

func (*OwnableRaw) Call 

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

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

func (*OwnableRaw) Transact 

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

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

func (*OwnableRaw) Transfer 

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

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

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

func (*OwnableSession) IsOwner 

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

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

Solidity: function isOwner() constant returns(bool)

func (*OwnableSession) Owner 

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

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

Solidity: function owner() constant returns(address)

func (*OwnableSession) RenounceOwnership 

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

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

Solidity: function renounceOwnership() returns()

func (*OwnableSession) TransferOwnership 

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

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

Solidity: function transferOwnership(address newOwner) returns()

type OwnableTransactor 

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

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

func NewOwnableTransactor 

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

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

func (*OwnableTransactor) RenounceOwnership 

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

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

Solidity: function renounceOwnership() returns()

func (*OwnableTransactor) TransferOwnership 

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

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

Solidity: function transferOwnership(address newOwner) returns()

type OwnableTransactorRaw 

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

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

func (*OwnableTransactorRaw) Transact 

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

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

func (*OwnableTransactorRaw) Transfer 

func (_Ownable *OwnableTransactorRaw) 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 OwnableTransactorSession 

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

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

func (*OwnableTransactorSession) RenounceOwnership 

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

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

Solidity: function renounceOwnership() returns()

func (*OwnableTransactorSession) TransferOwnership 

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

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

Solidity: function transferOwnership(address newOwner) 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.

type Token 

type Token struct {
	TokenCaller     // Read-only binding to the contract
	TokenTransactor // Write-only binding to the contract
	TokenFilterer   // Log filterer for contract events
}

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

func DeployToken 

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

DeployToken deploys a new Ethereum contract, binding an instance of Token to it.

func NewToken 

func NewToken(address common.Address, backend bind.ContractBackend) (*Token, error)

NewToken creates a new instance of Token, bound to a specific deployed contract.

type TokenBurn 

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

TokenBurn represents a Burn event raised by the Token contract.

type TokenBurnIterator 

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

TokenBurnIterator is returned from FilterBurn and is used to iterate over the raw logs and unpacked data for Burn events raised by the Token contract.

func (*TokenBurnIterator) Close 

func (it *TokenBurnIterator) Close() error

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

func (*TokenBurnIterator) Error 

func (it *TokenBurnIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenBurnIterator) Next 

func (it *TokenBurnIterator) 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 TokenCaller 

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

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

func NewTokenCaller 

func NewTokenCaller(address common.Address, caller bind.ContractCaller) (*TokenCaller, error)

NewTokenCaller creates a new read-only instance of Token, bound to a specific deployed contract.

func (*TokenCaller) BalanceOf 

func (_Token *TokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error)

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

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

func (*TokenCaller) DefaultBalanceLimit 

func (_Token *TokenCaller) DefaultBalanceLimit(opts *bind.CallOpts) (*big.Int, error)

DefaultBalanceLimit is a free data retrieval call binding the contract method 0x47cf5f04.

Solidity: function defaultBalanceLimit() constant returns(uint256)

func (*TokenCaller) IsOwner 

func (_Token *TokenCaller) IsOwner(opts *bind.CallOpts) (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*TokenCaller) LimitOf 

func (_Token *TokenCaller) LimitOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error)

LimitOf is a free data retrieval call binding the contract method 0x546a2ca4.

Solidity: function limitOf(address _owner) constant returns(uint256)

func (*TokenCaller) NameOf 

func (_Token *TokenCaller) NameOf(opts *bind.CallOpts, _owner common.Address) (string, error)

NameOf is a free data retrieval call binding the contract method 0xf5c57382.

Solidity: function nameOf(address _owner) constant returns(string)

func (*TokenCaller) NonceOf 

func (_Token *TokenCaller) NonceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error)

NonceOf is a free data retrieval call binding the contract method 0xed2a2d64.

Solidity: function nonceOf(address _owner) constant returns(uint256)

func (*TokenCaller) Owner 

func (_Token *TokenCaller) Owner(opts *bind.CallOpts) (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*TokenCaller) TaxDestination 

func (_Token *TokenCaller) TaxDestination(opts *bind.CallOpts) (common.Address, error)

TaxDestination is a free data retrieval call binding the contract method 0x2c547b3d.

Solidity: function taxDestination() constant returns(address)

func (*TokenCaller) TaxPercent 

func (_Token *TokenCaller) TaxPercent(opts *bind.CallOpts) (*big.Int, error)

TaxPercent is a free data retrieval call binding the contract method 0x7541f41c.

Solidity: function taxPercent() constant returns(uint256)

func (*TokenCaller) TotalSupply 

func (_Token *TokenCaller) 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 TokenCallerRaw 

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

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

func (*TokenCallerRaw) Call 

func (_Token *TokenCallerRaw) 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 TokenCallerSession 

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

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

func (*TokenCallerSession) BalanceOf 

func (_Token *TokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error)

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

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

func (*TokenCallerSession) DefaultBalanceLimit 

func (_Token *TokenCallerSession) DefaultBalanceLimit() (*big.Int, error)

DefaultBalanceLimit is a free data retrieval call binding the contract method 0x47cf5f04.

Solidity: function defaultBalanceLimit() constant returns(uint256)

func (*TokenCallerSession) IsOwner 

func (_Token *TokenCallerSession) IsOwner() (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*TokenCallerSession) LimitOf 

func (_Token *TokenCallerSession) LimitOf(_owner common.Address) (*big.Int, error)

LimitOf is a free data retrieval call binding the contract method 0x546a2ca4.

Solidity: function limitOf(address _owner) constant returns(uint256)

func (*TokenCallerSession) NameOf 

func (_Token *TokenCallerSession) NameOf(_owner common.Address) (string, error)

NameOf is a free data retrieval call binding the contract method 0xf5c57382.

Solidity: function nameOf(address _owner) constant returns(string)

func (*TokenCallerSession) NonceOf 

func (_Token *TokenCallerSession) NonceOf(_owner common.Address) (*big.Int, error)

NonceOf is a free data retrieval call binding the contract method 0xed2a2d64.

Solidity: function nonceOf(address _owner) constant returns(uint256)

func (*TokenCallerSession) Owner 

func (_Token *TokenCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*TokenCallerSession) TaxDestination 

func (_Token *TokenCallerSession) TaxDestination() (common.Address, error)

TaxDestination is a free data retrieval call binding the contract method 0x2c547b3d.

Solidity: function taxDestination() constant returns(address)

func (*TokenCallerSession) TaxPercent 

func (_Token *TokenCallerSession) TaxPercent() (*big.Int, error)

TaxPercent is a free data retrieval call binding the contract method 0x7541f41c.

Solidity: function taxPercent() constant returns(uint256)

func (*TokenCallerSession) TotalSupply 

func (_Token *TokenCallerSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

type TokenFilterer 

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

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

func NewTokenFilterer 

func NewTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenFilterer, error)

NewTokenFilterer creates a new log filterer instance of Token, bound to a specific deployed contract.

func (*TokenFilterer) FilterBurn 

func (_Token *TokenFilterer) FilterBurn(opts *bind.FilterOpts) (*TokenBurnIterator, error)

FilterBurn is a free log retrieval operation binding the contract event 0xb90306ad06b2a6ff86ddc9327db583062895ef6540e62dc50add009db5b356eb.

Solidity: event Burn(uint256 value)

func (*TokenFilterer) FilterLimitChanged 

func (_Token *TokenFilterer) FilterLimitChanged(opts *bind.FilterOpts) (*TokenLimitChangedIterator, error)

FilterLimitChanged is a free log retrieval operation binding the contract event 0xef9c668177207fb68ca5e3894a1efacebb659762b27a737fde58ceebc4f30ad3.

Solidity: event LimitChanged(address addr, uint256 value)

func (*TokenFilterer) FilterMint 

func (_Token *TokenFilterer) FilterMint(opts *bind.FilterOpts) (*TokenMintIterator, error)

FilterMint is a free log retrieval operation binding the contract event 0x07883703ed0e86588a40d76551c92f8a4b329e3bf19765e0e6749473c1a84665.

Solidity: event Mint(uint256 value)

func (*TokenFilterer) FilterNameChanged 

func (_Token *TokenFilterer) FilterNameChanged(opts *bind.FilterOpts) (*TokenNameChangedIterator, error)

FilterNameChanged is a free log retrieval operation binding the contract event 0x3b0a43ccc1ccd1c76ebb1a8d998fdfe1ded3766582dbbbcdda83889170bec53d.

Solidity: event NameChanged(address addr, string value)

func (*TokenFilterer) FilterOwnershipTransferred 

func (_Token *TokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*TokenOwnershipTransferredIterator, error)

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

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

func (*TokenFilterer) FilterTaxDestinationChanged 

func (_Token *TokenFilterer) FilterTaxDestinationChanged(opts *bind.FilterOpts) (*TokenTaxDestinationChangedIterator, error)

FilterTaxDestinationChanged is a free log retrieval operation binding the contract event 0x09eee28d8d70bfad809ce8acadd46ce657b1fa64646b1e4b414e6bbb2eb2c8fa.

Solidity: event TaxDestinationChanged(address addr)

func (*TokenFilterer) FilterTransfer 

func (_Token *TokenFilterer) FilterTransfer(opts *bind.FilterOpts) (*TokenTransferIterator, error)

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

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

func (*TokenFilterer) WatchBurn 

func (_Token *TokenFilterer) WatchBurn(opts *bind.WatchOpts, sink chan<- *TokenBurn) (event.Subscription, error)

WatchBurn is a free log subscription operation binding the contract event 0xb90306ad06b2a6ff86ddc9327db583062895ef6540e62dc50add009db5b356eb.

Solidity: event Burn(uint256 value)

func (*TokenFilterer) WatchLimitChanged 

func (_Token *TokenFilterer) WatchLimitChanged(opts *bind.WatchOpts, sink chan<- *TokenLimitChanged) (event.Subscription, error)

WatchLimitChanged is a free log subscription operation binding the contract event 0xef9c668177207fb68ca5e3894a1efacebb659762b27a737fde58ceebc4f30ad3.

Solidity: event LimitChanged(address addr, uint256 value)

func (*TokenFilterer) WatchMint 

func (_Token *TokenFilterer) WatchMint(opts *bind.WatchOpts, sink chan<- *TokenMint) (event.Subscription, error)

WatchMint is a free log subscription operation binding the contract event 0x07883703ed0e86588a40d76551c92f8a4b329e3bf19765e0e6749473c1a84665.

Solidity: event Mint(uint256 value)

func (*TokenFilterer) WatchNameChanged 

func (_Token *TokenFilterer) WatchNameChanged(opts *bind.WatchOpts, sink chan<- *TokenNameChanged) (event.Subscription, error)

WatchNameChanged is a free log subscription operation binding the contract event 0x3b0a43ccc1ccd1c76ebb1a8d998fdfe1ded3766582dbbbcdda83889170bec53d.

Solidity: event NameChanged(address addr, string value)

func (*TokenFilterer) WatchOwnershipTransferred 

func (_Token *TokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *TokenOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

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

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

func (*TokenFilterer) WatchTaxDestinationChanged 

func (_Token *TokenFilterer) WatchTaxDestinationChanged(opts *bind.WatchOpts, sink chan<- *TokenTaxDestinationChanged) (event.Subscription, error)

WatchTaxDestinationChanged is a free log subscription operation binding the contract event 0x09eee28d8d70bfad809ce8acadd46ce657b1fa64646b1e4b414e6bbb2eb2c8fa.

Solidity: event TaxDestinationChanged(address addr)

func (*TokenFilterer) WatchTransfer 

func (_Token *TokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *TokenTransfer) (event.Subscription, error)

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

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

type TokenLimitChanged 

type TokenLimitChanged struct {
	Addr  common.Address
	Value *big.Int
	Raw   types.Log // Blockchain specific contextual infos
}

TokenLimitChanged represents a LimitChanged event raised by the Token contract.

type TokenLimitChangedIterator 

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

TokenLimitChangedIterator is returned from FilterLimitChanged and is used to iterate over the raw logs and unpacked data for LimitChanged events raised by the Token contract.

func (*TokenLimitChangedIterator) Close 

func (it *TokenLimitChangedIterator) Close() error

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

func (*TokenLimitChangedIterator) Error 

func (it *TokenLimitChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenLimitChangedIterator) Next 

func (it *TokenLimitChangedIterator) 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 TokenMint 

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

TokenMint represents a Mint event raised by the Token contract.

type TokenMintIterator 

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

TokenMintIterator is returned from FilterMint and is used to iterate over the raw logs and unpacked data for Mint events raised by the Token contract.

func (*TokenMintIterator) Close 

func (it *TokenMintIterator) Close() error

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

func (*TokenMintIterator) Error 

func (it *TokenMintIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenMintIterator) Next 

func (it *TokenMintIterator) 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 TokenNameChanged 

type TokenNameChanged struct {
	Addr  common.Address
	Value string
	Raw   types.Log // Blockchain specific contextual infos
}

TokenNameChanged represents a NameChanged event raised by the Token contract.

type TokenNameChangedIterator 

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

TokenNameChangedIterator is returned from FilterNameChanged and is used to iterate over the raw logs and unpacked data for NameChanged events raised by the Token contract.

func (*TokenNameChangedIterator) Close 

func (it *TokenNameChangedIterator) Close() error

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

func (*TokenNameChangedIterator) Error 

func (it *TokenNameChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenNameChangedIterator) Next 

func (it *TokenNameChangedIterator) 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 TokenOwnershipTransferred 

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

TokenOwnershipTransferred represents a OwnershipTransferred event raised by the Token contract.

type TokenOwnershipTransferredIterator 

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

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

func (*TokenOwnershipTransferredIterator) Close 

func (it *TokenOwnershipTransferredIterator) Close() error

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

func (*TokenOwnershipTransferredIterator) Error 

func (it *TokenOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenOwnershipTransferredIterator) Next 

func (it *TokenOwnershipTransferredIterator) 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 TokenRaw 

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

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

func (*TokenRaw) Call 

func (_Token *TokenRaw) 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 (*TokenRaw) Transact 

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

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

func (*TokenRaw) Transfer 

func (_Token *TokenRaw) 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 TokenSession 

type TokenSession struct {
	Contract     *Token            // 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
}

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

func (*TokenSession) BalanceOf 

func (_Token *TokenSession) BalanceOf(_owner common.Address) (*big.Int, error)

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

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

func (*TokenSession) Burn 

func (_Token *TokenSession) Burn(_value *big.Int) (*types.Transaction, error)

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

Solidity: function burn(uint256 _value) returns()

func (*TokenSession) DefaultBalanceLimit 

func (_Token *TokenSession) DefaultBalanceLimit() (*big.Int, error)

DefaultBalanceLimit is a free data retrieval call binding the contract method 0x47cf5f04.

Solidity: function defaultBalanceLimit() constant returns(uint256)

func (*TokenSession) IsOwner 

func (_Token *TokenSession) IsOwner() (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*TokenSession) LimitOf 

func (_Token *TokenSession) LimitOf(_owner common.Address) (*big.Int, error)

LimitOf is a free data retrieval call binding the contract method 0x546a2ca4.

Solidity: function limitOf(address _owner) constant returns(uint256)

func (*TokenSession) Mint 

func (_Token *TokenSession) Mint(_account common.Address, _value *big.Int) (*types.Transaction, error)

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

Solidity: function mint(address _account, uint256 _value) returns()

func (*TokenSession) NameOf 

func (_Token *TokenSession) NameOf(_owner common.Address) (string, error)

NameOf is a free data retrieval call binding the contract method 0xf5c57382.

Solidity: function nameOf(address _owner) constant returns(string)

func (*TokenSession) NonceOf 

func (_Token *TokenSession) NonceOf(_owner common.Address) (*big.Int, error)

NonceOf is a free data retrieval call binding the contract method 0xed2a2d64.

Solidity: function nonceOf(address _owner) constant returns(uint256)

func (*TokenSession) Owner 

func (_Token *TokenSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*TokenSession) RenounceOwnership 

func (_Token *TokenSession) RenounceOwnership() (*types.Transaction, error)

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

Solidity: function renounceOwnership() returns()

func (*TokenSession) SetLimit 

func (_Token *TokenSession) SetLimit(_addr common.Address, _limit *big.Int) (*types.Transaction, error)

SetLimit is a paid mutator transaction binding the contract method 0x36db43b5.

Solidity: function setLimit(address _addr, uint256 _limit) returns()

func (*TokenSession) SetName 

func (_Token *TokenSession) SetName(_from common.Address, _name string, _r [32]byte, _s [32]byte, _v uint8) (*types.Transaction, error)

SetName is a paid mutator transaction binding the contract method 0xe69babe8.

Solidity: function setName(address _from, string _name, bytes32 _r, bytes32 _s, uint8 _v) returns()

func (*TokenSession) SetTaxDestination 

func (_Token *TokenSession) SetTaxDestination(_taxDestination common.Address, _taxPercent *big.Int) (*types.Transaction, error)

SetTaxDestination is a paid mutator transaction binding the contract method 0xd0c3fe0b.

Solidity: function setTaxDestination(address _taxDestination, uint256 _taxPercent) returns()

func (*TokenSession) TaxDestination 

func (_Token *TokenSession) TaxDestination() (common.Address, error)

TaxDestination is a free data retrieval call binding the contract method 0x2c547b3d.

Solidity: function taxDestination() constant returns(address)

func (*TokenSession) TaxPercent 

func (_Token *TokenSession) TaxPercent() (*big.Int, error)

TaxPercent is a free data retrieval call binding the contract method 0x7541f41c.

Solidity: function taxPercent() constant returns(uint256)

func (*TokenSession) TotalSupply 

func (_Token *TokenSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

func (*TokenSession) Transfer 

func (_Token *TokenSession) Transfer(_from common.Address, _to common.Address, _value *big.Int, _r [32]byte, _s [32]byte, _v uint8) (*types.Transaction, error)

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

Solidity: function transfer(address _from, address _to, uint256 _value, bytes32 _r, bytes32 _s, uint8 _v) returns()

func (*TokenSession) TransferOwnership 

func (_Token *TokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

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

Solidity: function transferOwnership(address newOwner) returns()

type TokenTaxDestinationChanged 

type TokenTaxDestinationChanged struct {
	Addr common.Address
	Raw  types.Log // Blockchain specific contextual infos
}

TokenTaxDestinationChanged represents a TaxDestinationChanged event raised by the Token contract.

type TokenTaxDestinationChangedIterator 

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

TokenTaxDestinationChangedIterator is returned from FilterTaxDestinationChanged and is used to iterate over the raw logs and unpacked data for TaxDestinationChanged events raised by the Token contract.

func (*TokenTaxDestinationChangedIterator) Close 

func (it *TokenTaxDestinationChangedIterator) Close() error

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

func (*TokenTaxDestinationChangedIterator) Error 

func (it *TokenTaxDestinationChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenTaxDestinationChangedIterator) Next 

func (it *TokenTaxDestinationChangedIterator) 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 TokenTransactor 

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

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

func NewTokenTransactor 

func NewTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenTransactor, error)

NewTokenTransactor creates a new write-only instance of Token, bound to a specific deployed contract.

func (*TokenTransactor) Burn 

func (_Token *TokenTransactor) Burn(opts *bind.TransactOpts, _value *big.Int) (*types.Transaction, error)

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

Solidity: function burn(uint256 _value) returns()

func (*TokenTransactor) Mint 

func (_Token *TokenTransactor) Mint(opts *bind.TransactOpts, _account common.Address, _value *big.Int) (*types.Transaction, error)

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

Solidity: function mint(address _account, uint256 _value) returns()

func (*TokenTransactor) RenounceOwnership 

func (_Token *TokenTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

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

Solidity: function renounceOwnership() returns()

func (*TokenTransactor) SetLimit 

func (_Token *TokenTransactor) SetLimit(opts *bind.TransactOpts, _addr common.Address, _limit *big.Int) (*types.Transaction, error)

SetLimit is a paid mutator transaction binding the contract method 0x36db43b5.

Solidity: function setLimit(address _addr, uint256 _limit) returns()

func (*TokenTransactor) SetName 

func (_Token *TokenTransactor) SetName(opts *bind.TransactOpts, _from common.Address, _name string, _r [32]byte, _s [32]byte, _v uint8) (*types.Transaction, error)

SetName is a paid mutator transaction binding the contract method 0xe69babe8.

Solidity: function setName(address _from, string _name, bytes32 _r, bytes32 _s, uint8 _v) returns()

func (*TokenTransactor) SetTaxDestination 

func (_Token *TokenTransactor) SetTaxDestination(opts *bind.TransactOpts, _taxDestination common.Address, _taxPercent *big.Int) (*types.Transaction, error)

SetTaxDestination is a paid mutator transaction binding the contract method 0xd0c3fe0b.

Solidity: function setTaxDestination(address _taxDestination, uint256 _taxPercent) returns()

func (*TokenTransactor) Transfer 

func (_Token *TokenTransactor) Transfer(opts *bind.TransactOpts, _from common.Address, _to common.Address, _value *big.Int, _r [32]byte, _s [32]byte, _v uint8) (*types.Transaction, error)

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

Solidity: function transfer(address _from, address _to, uint256 _value, bytes32 _r, bytes32 _s, uint8 _v) returns()

func (*TokenTransactor) TransferOwnership 

func (_Token *TokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

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

Solidity: function transferOwnership(address newOwner) returns()

type TokenTransactorRaw 

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

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

func (*TokenTransactorRaw) Transact 

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

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

func (*TokenTransactorRaw) Transfer 

func (_Token *TokenTransactorRaw) 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 TokenTransactorSession 

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

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

func (*TokenTransactorSession) Burn 

func (_Token *TokenTransactorSession) Burn(_value *big.Int) (*types.Transaction, error)

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

Solidity: function burn(uint256 _value) returns()

func (*TokenTransactorSession) Mint 

func (_Token *TokenTransactorSession) Mint(_account common.Address, _value *big.Int) (*types.Transaction, error)

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

Solidity: function mint(address _account, uint256 _value) returns()

func (*TokenTransactorSession) RenounceOwnership 

func (_Token *TokenTransactorSession) RenounceOwnership() (*types.Transaction, error)

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

Solidity: function renounceOwnership() returns()

func (*TokenTransactorSession) SetLimit 

func (_Token *TokenTransactorSession) SetLimit(_addr common.Address, _limit *big.Int) (*types.Transaction, error)

SetLimit is a paid mutator transaction binding the contract method 0x36db43b5.

Solidity: function setLimit(address _addr, uint256 _limit) returns()

func (*TokenTransactorSession) SetName 

func (_Token *TokenTransactorSession) SetName(_from common.Address, _name string, _r [32]byte, _s [32]byte, _v uint8) (*types.Transaction, error)

SetName is a paid mutator transaction binding the contract method 0xe69babe8.

Solidity: function setName(address _from, string _name, bytes32 _r, bytes32 _s, uint8 _v) returns()

func (*TokenTransactorSession) SetTaxDestination 

func (_Token *TokenTransactorSession) SetTaxDestination(_taxDestination common.Address, _taxPercent *big.Int) (*types.Transaction, error)

SetTaxDestination is a paid mutator transaction binding the contract method 0xd0c3fe0b.

Solidity: function setTaxDestination(address _taxDestination, uint256 _taxPercent) returns()

func (*TokenTransactorSession) Transfer 

func (_Token *TokenTransactorSession) Transfer(_from common.Address, _to common.Address, _value *big.Int, _r [32]byte, _s [32]byte, _v uint8) (*types.Transaction, error)

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

Solidity: function transfer(address _from, address _to, uint256 _value, bytes32 _r, bytes32 _s, uint8 _v) returns()

func (*TokenTransactorSession) TransferOwnership 

func (_Token *TokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

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

Solidity: function transferOwnership(address newOwner) returns()

type TokenTransfer 

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

TokenTransfer represents a Transfer event raised by the Token contract.

type TokenTransferIterator 

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

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

func (*TokenTransferIterator) Close 

func (it *TokenTransferIterator) Close() error

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

func (*TokenTransferIterator) Error 

func (it *TokenTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenTransferIterator) Next 

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

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.