Versions in this module Expand all Collapse all v0 v0.0.2 May 5, 2019 v0.0.1 Mar 15, 2019 Changes in this version + const OffchainsigABI + const OffchainsigBin + const OwnableABI + const OwnableBin + const SafeMathABI + const SafeMathBin + const TokenABI + const TokenBin + type Offchainsig struct + func DeployOffchainsig(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Offchainsig, error) + func NewOffchainsig(address common.Address, backend bind.ContractBackend) (*Offchainsig, error) + type OffchainsigCaller struct + func NewOffchainsigCaller(address common.Address, caller bind.ContractCaller) (*OffchainsigCaller, error) + func (_Offchainsig *OffchainsigCaller) NonceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) + type OffchainsigCallerRaw struct + Contract *OffchainsigCaller + func (_Offchainsig *OffchainsigCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error + type OffchainsigCallerSession struct + CallOpts bind.CallOpts + Contract *OffchainsigCaller + func (_Offchainsig *OffchainsigCallerSession) NonceOf(_owner common.Address) (*big.Int, error) + type OffchainsigFilterer struct + func NewOffchainsigFilterer(address common.Address, filterer bind.ContractFilterer) (*OffchainsigFilterer, error) + type OffchainsigRaw struct + Contract *Offchainsig + func (_Offchainsig *OffchainsigRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error + func (_Offchainsig *OffchainsigRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) + func (_Offchainsig *OffchainsigRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) + type OffchainsigSession struct + CallOpts bind.CallOpts + Contract *Offchainsig + TransactOpts bind.TransactOpts + func (_Offchainsig *OffchainsigSession) NonceOf(_owner common.Address) (*big.Int, error) + type OffchainsigTransactor struct + func NewOffchainsigTransactor(address common.Address, transactor bind.ContractTransactor) (*OffchainsigTransactor, error) + type OffchainsigTransactorRaw struct + Contract *OffchainsigTransactor + func (_Offchainsig *OffchainsigTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) + func (_Offchainsig *OffchainsigTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) + type OffchainsigTransactorSession struct + Contract *OffchainsigTransactor + TransactOpts bind.TransactOpts + type Ownable struct + func DeployOwnable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Ownable, error) + func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) + type OwnableCaller struct + func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error) + func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error) + func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) + type OwnableCallerRaw struct + Contract *OwnableCaller + func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error + type OwnableCallerSession struct + CallOpts bind.CallOpts + Contract *OwnableCaller + func (_Ownable *OwnableCallerSession) IsOwner() (bool, error) + func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) + type OwnableFilterer struct + func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error) + func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OwnableOwnershipTransferredIterator, error) + func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, ...) (event.Subscription, error) + type OwnableOwnershipTransferred struct + NewOwner common.Address + PreviousOwner common.Address + Raw types.Log + type OwnableOwnershipTransferredIterator struct + Event *OwnableOwnershipTransferred + func (it *OwnableOwnershipTransferredIterator) Close() error + func (it *OwnableOwnershipTransferredIterator) Error() error + func (it *OwnableOwnershipTransferredIterator) Next() bool + type OwnableRaw struct + Contract *Ownable + func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error + func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) + func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) + type OwnableSession struct + CallOpts bind.CallOpts + Contract *Ownable + TransactOpts bind.TransactOpts + func (_Ownable *OwnableSession) IsOwner() (bool, error) + func (_Ownable *OwnableSession) Owner() (common.Address, error) + func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error) + func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) + type OwnableTransactor struct + func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error) + func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) + func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) + type OwnableTransactorRaw struct + Contract *OwnableTransactor + func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) + func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) + type OwnableTransactorSession struct + Contract *OwnableTransactor + TransactOpts bind.TransactOpts + func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error) + func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) + type SafeMath struct + func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) + func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) + type SafeMathCaller struct + func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) + type SafeMathCallerRaw struct + Contract *SafeMathCaller + func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error + type SafeMathCallerSession struct + CallOpts bind.CallOpts + Contract *SafeMathCaller + type SafeMathFilterer struct + func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) + type SafeMathRaw struct + Contract *SafeMath + func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error + func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) + func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) + type SafeMathSession struct + CallOpts bind.CallOpts + Contract *SafeMath + TransactOpts bind.TransactOpts + type SafeMathTransactor struct + func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) + type SafeMathTransactorRaw struct + Contract *SafeMathTransactor + func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) + func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) + type SafeMathTransactorSession struct + Contract *SafeMathTransactor + TransactOpts bind.TransactOpts + type Token struct + func DeployToken(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Token, error) + func NewToken(address common.Address, backend bind.ContractBackend) (*Token, error) + type TokenBurn struct + Raw types.Log + Value *big.Int + type TokenBurnIterator struct + Event *TokenBurn + func (it *TokenBurnIterator) Close() error + func (it *TokenBurnIterator) Error() error + func (it *TokenBurnIterator) Next() bool + type TokenCaller struct + func NewTokenCaller(address common.Address, caller bind.ContractCaller) (*TokenCaller, error) + func (_Token *TokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) + func (_Token *TokenCaller) DefaultBalanceLimit(opts *bind.CallOpts) (*big.Int, error) + func (_Token *TokenCaller) IsOwner(opts *bind.CallOpts) (bool, error) + func (_Token *TokenCaller) LimitOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) + func (_Token *TokenCaller) NameOf(opts *bind.CallOpts, _owner common.Address) (string, error) + func (_Token *TokenCaller) NonceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) + func (_Token *TokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) + func (_Token *TokenCaller) TaxDestination(opts *bind.CallOpts) (common.Address, error) + func (_Token *TokenCaller) TaxPercent(opts *bind.CallOpts) (*big.Int, error) + func (_Token *TokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) + type TokenCallerRaw struct + Contract *TokenCaller + func (_Token *TokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error + type TokenCallerSession struct + CallOpts bind.CallOpts + Contract *TokenCaller + func (_Token *TokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) + func (_Token *TokenCallerSession) DefaultBalanceLimit() (*big.Int, error) + func (_Token *TokenCallerSession) IsOwner() (bool, error) + func (_Token *TokenCallerSession) LimitOf(_owner common.Address) (*big.Int, error) + func (_Token *TokenCallerSession) NameOf(_owner common.Address) (string, error) + func (_Token *TokenCallerSession) NonceOf(_owner common.Address) (*big.Int, error) + func (_Token *TokenCallerSession) Owner() (common.Address, error) + func (_Token *TokenCallerSession) TaxDestination() (common.Address, error) + func (_Token *TokenCallerSession) TaxPercent() (*big.Int, error) + func (_Token *TokenCallerSession) TotalSupply() (*big.Int, error) + type TokenFilterer struct + func NewTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenFilterer, error) + func (_Token *TokenFilterer) FilterBurn(opts *bind.FilterOpts) (*TokenBurnIterator, error) + func (_Token *TokenFilterer) FilterLimitChanged(opts *bind.FilterOpts) (*TokenLimitChangedIterator, error) + func (_Token *TokenFilterer) FilterMint(opts *bind.FilterOpts) (*TokenMintIterator, error) + func (_Token *TokenFilterer) FilterNameChanged(opts *bind.FilterOpts) (*TokenNameChangedIterator, error) + func (_Token *TokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*TokenOwnershipTransferredIterator, error) + func (_Token *TokenFilterer) FilterTaxDestinationChanged(opts *bind.FilterOpts) (*TokenTaxDestinationChangedIterator, error) + func (_Token *TokenFilterer) FilterTransfer(opts *bind.FilterOpts) (*TokenTransferIterator, error) + func (_Token *TokenFilterer) WatchBurn(opts *bind.WatchOpts, sink chan<- *TokenBurn) (event.Subscription, error) + func (_Token *TokenFilterer) WatchLimitChanged(opts *bind.WatchOpts, sink chan<- *TokenLimitChanged) (event.Subscription, error) + func (_Token *TokenFilterer) WatchMint(opts *bind.WatchOpts, sink chan<- *TokenMint) (event.Subscription, error) + func (_Token *TokenFilterer) WatchNameChanged(opts *bind.WatchOpts, sink chan<- *TokenNameChanged) (event.Subscription, error) + func (_Token *TokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *TokenOwnershipTransferred, ...) (event.Subscription, error) + func (_Token *TokenFilterer) WatchTaxDestinationChanged(opts *bind.WatchOpts, sink chan<- *TokenTaxDestinationChanged) (event.Subscription, error) + func (_Token *TokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *TokenTransfer) (event.Subscription, error) + type TokenLimitChanged struct + Addr common.Address + Raw types.Log + Value *big.Int + type TokenLimitChangedIterator struct + Event *TokenLimitChanged + func (it *TokenLimitChangedIterator) Close() error + func (it *TokenLimitChangedIterator) Error() error + func (it *TokenLimitChangedIterator) Next() bool + type TokenMint struct + Raw types.Log + Value *big.Int + type TokenMintIterator struct + Event *TokenMint + func (it *TokenMintIterator) Close() error + func (it *TokenMintIterator) Error() error + func (it *TokenMintIterator) Next() bool + type TokenNameChanged struct + Addr common.Address + Raw types.Log + Value string + type TokenNameChangedIterator struct + Event *TokenNameChanged + func (it *TokenNameChangedIterator) Close() error + func (it *TokenNameChangedIterator) Error() error + func (it *TokenNameChangedIterator) Next() bool + type TokenOwnershipTransferred struct + NewOwner common.Address + PreviousOwner common.Address + Raw types.Log + type TokenOwnershipTransferredIterator struct + Event *TokenOwnershipTransferred + func (it *TokenOwnershipTransferredIterator) Close() error + func (it *TokenOwnershipTransferredIterator) Error() error + func (it *TokenOwnershipTransferredIterator) Next() bool + type TokenRaw struct + Contract *Token + func (_Token *TokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error + func (_Token *TokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) + func (_Token *TokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) + type TokenSession struct + CallOpts bind.CallOpts + Contract *Token + TransactOpts bind.TransactOpts + func (_Token *TokenSession) BalanceOf(_owner common.Address) (*big.Int, error) + func (_Token *TokenSession) Burn(_value *big.Int) (*types.Transaction, error) + func (_Token *TokenSession) DefaultBalanceLimit() (*big.Int, error) + func (_Token *TokenSession) IsOwner() (bool, error) + func (_Token *TokenSession) LimitOf(_owner common.Address) (*big.Int, error) + func (_Token *TokenSession) Mint(_account common.Address, _value *big.Int) (*types.Transaction, error) + func (_Token *TokenSession) NameOf(_owner common.Address) (string, error) + func (_Token *TokenSession) NonceOf(_owner common.Address) (*big.Int, error) + func (_Token *TokenSession) Owner() (common.Address, error) + func (_Token *TokenSession) RenounceOwnership() (*types.Transaction, error) + func (_Token *TokenSession) SetLimit(_addr common.Address, _limit *big.Int) (*types.Transaction, error) + func (_Token *TokenSession) SetName(_from common.Address, _name string, _r [32]byte, _s [32]byte, _v uint8) (*types.Transaction, error) + func (_Token *TokenSession) SetTaxDestination(_taxDestination common.Address, _taxPercent *big.Int) (*types.Transaction, error) + func (_Token *TokenSession) TaxDestination() (common.Address, error) + func (_Token *TokenSession) TaxPercent() (*big.Int, error) + func (_Token *TokenSession) TotalSupply() (*big.Int, error) + func (_Token *TokenSession) Transfer(_from common.Address, _to common.Address, _value *big.Int, _r [32]byte, ...) (*types.Transaction, error) + func (_Token *TokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) + type TokenTaxDestinationChanged struct + Addr common.Address + Raw types.Log + type TokenTaxDestinationChangedIterator struct + Event *TokenTaxDestinationChanged + func (it *TokenTaxDestinationChangedIterator) Close() error + func (it *TokenTaxDestinationChangedIterator) Error() error + func (it *TokenTaxDestinationChangedIterator) Next() bool + type TokenTransactor struct + func NewTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenTransactor, error) + func (_Token *TokenTransactor) Burn(opts *bind.TransactOpts, _value *big.Int) (*types.Transaction, error) + func (_Token *TokenTransactor) Mint(opts *bind.TransactOpts, _account common.Address, _value *big.Int) (*types.Transaction, error) + func (_Token *TokenTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) + func (_Token *TokenTransactor) SetLimit(opts *bind.TransactOpts, _addr common.Address, _limit *big.Int) (*types.Transaction, error) + func (_Token *TokenTransactor) SetName(opts *bind.TransactOpts, _from common.Address, _name string, _r [32]byte, ...) (*types.Transaction, error) + func (_Token *TokenTransactor) SetTaxDestination(opts *bind.TransactOpts, _taxDestination common.Address, _taxPercent *big.Int) (*types.Transaction, error) + func (_Token *TokenTransactor) Transfer(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error) + func (_Token *TokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) + type TokenTransactorRaw struct + Contract *TokenTransactor + func (_Token *TokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) + func (_Token *TokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) + type TokenTransactorSession struct + Contract *TokenTransactor + TransactOpts bind.TransactOpts + func (_Token *TokenTransactorSession) Burn(_value *big.Int) (*types.Transaction, error) + func (_Token *TokenTransactorSession) Mint(_account common.Address, _value *big.Int) (*types.Transaction, error) + func (_Token *TokenTransactorSession) RenounceOwnership() (*types.Transaction, error) + func (_Token *TokenTransactorSession) SetLimit(_addr common.Address, _limit *big.Int) (*types.Transaction, error) + func (_Token *TokenTransactorSession) SetName(_from common.Address, _name string, _r [32]byte, _s [32]byte, _v uint8) (*types.Transaction, error) + func (_Token *TokenTransactorSession) SetTaxDestination(_taxDestination common.Address, _taxPercent *big.Int) (*types.Transaction, error) + func (_Token *TokenTransactorSession) Transfer(_from common.Address, _to common.Address, _value *big.Int, _r [32]byte, ...) (*types.Transaction, error) + func (_Token *TokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) + type TokenTransfer struct + From common.Address + IsTax bool + Raw types.Log + To common.Address + Value *big.Int + type TokenTransferIterator struct + Event *TokenTransfer + func (it *TokenTransferIterator) Close() error + func (it *TokenTransferIterator) Error() error + func (it *TokenTransferIterator) Next() bool
Go to main page