rules

package
v0.0.2 Latest Latest
Warning

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

 Go to latest Published: Feb 15, 2019 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const RestrictABI = "" /* 1800-byte string literal not displayed */

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

View Source 
const RestrictAllABI = "" /* 1116-byte string literal not displayed */

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

View Source 
const RestrictAllBin = `` /* 2468-byte string literal not displayed */

RestrictAllBin is the compiled bytecode used for deploying new contracts.

View Source 
const RestrictBin = `` /* 3778-byte string literal not displayed */

RestrictBin is the compiled bytecode used for deploying new contracts.

View Source 
const RestrictFromAffiliateABI = "" /* 1558-byte string literal not displayed */

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

View Source 
const RestrictFromAffiliateBin = `` /* 3388-byte string literal not displayed */

RestrictFromAffiliateBin is the compiled bytecode used for deploying new contracts.

View Source 
const RestrictFromInvestorABI = "" /* 1116-byte string literal not displayed */

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

View Source 
const RestrictFromInvestorBin = `` /* 2794-byte string literal not displayed */

RestrictFromInvestorBin is the compiled bytecode used for deploying new contracts.

View Source 
const RestrictToAccreditedInvestorABI = "" /* 1116-byte string literal not displayed */

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

View Source 
const RestrictToAccreditedInvestorBin = `` /* 2894-byte string literal not displayed */

RestrictToAccreditedInvestorBin is the compiled bytecode used for deploying new contracts.

View Source 
const RestrictToBrokerOrCustodialAccountABI = "" /* 1116-byte string literal not displayed */

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

View Source 
const RestrictToBrokerOrCustodialAccountBin = `` /* 2594-byte string literal not displayed */

RestrictToBrokerOrCustodialAccountBin is the compiled bytecode used for deploying new contracts.

View Source 
const RestrictToContractABI = "" /* 1116-byte string literal not displayed */

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

View Source 
const RestrictToContractBin = `` /* 2516-byte string literal not displayed */

RestrictToContractBin is the compiled bytecode used for deploying new contracts.

View Source 
const RestrictToCustodianOrCustodialAccountOrBrokerABI = "" /* 1116-byte string literal not displayed */

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

View Source 
const RestrictToCustodianOrCustodialAccountOrBrokerBin = `` /* 2546-byte string literal not displayed */

RestrictToCustodianOrCustodialAccountOrBrokerBin is the compiled bytecode used for deploying new contracts.

View Source 
const RestrictTransferFromABI = "" /* 1116-byte string literal not displayed */

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

View Source 
const RestrictTransferFromBin = `` /* 2554-byte string literal not displayed */

RestrictTransferFromBin is the compiled bytecode used for deploying new contracts.

View Source 
const RuleABI = "" /* 396-byte string literal not displayed */

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

Variables

This section is empty.

Functions

This section is empty.

Types

type Restrict 

type Restrict struct {
	RestrictCaller     // Read-only binding to the contract
	RestrictTransactor // Write-only binding to the contract
	RestrictFilterer   // Log filterer for contract events
}

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

func DeployRestrict 

func DeployRestrict(auth *bind.TransactOpts, backend bind.ContractBackend, a common.Address) (common.Address, *types.Transaction, *Restrict, error)

DeployRestrict deploys a new Ethereum contract, binding an instance of Restrict to it.

func NewRestrict 

func NewRestrict(address common.Address, backend bind.ContractBackend) (*Restrict, error)

NewRestrict creates a new instance of Restrict, bound to a specific deployed contract.

type RestrictAll 

type RestrictAll struct {
	RestrictAllCaller     // Read-only binding to the contract
	RestrictAllTransactor // Write-only binding to the contract
	RestrictAllFilterer   // Log filterer for contract events
}

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

func DeployRestrictAll 

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

DeployRestrictAll deploys a new Ethereum contract, binding an instance of RestrictAll to it.

func NewRestrictAll 

func NewRestrictAll(address common.Address, backend bind.ContractBackend) (*RestrictAll, error)

NewRestrictAll creates a new instance of RestrictAll, bound to a specific deployed contract.

type RestrictAllCaller 

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

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

func NewRestrictAllCaller 

func NewRestrictAllCaller(address common.Address, caller bind.ContractCaller) (*RestrictAllCaller, error)

NewRestrictAllCaller creates a new read-only instance of RestrictAll, bound to a specific deployed contract.

func (*RestrictAllCaller) Owner 

func (_RestrictAll *RestrictAllCaller) 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 RestrictAllCallerRaw 

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

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

func (*RestrictAllCallerRaw) Call 

func (_RestrictAll *RestrictAllCallerRaw) 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 RestrictAllCallerSession 

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

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

func (*RestrictAllCallerSession) Owner 

func (_RestrictAll *RestrictAllCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

type RestrictAllFilterer 

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

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

func NewRestrictAllFilterer 

func NewRestrictAllFilterer(address common.Address, filterer bind.ContractFilterer) (*RestrictAllFilterer, error)

NewRestrictAllFilterer creates a new log filterer instance of RestrictAll, bound to a specific deployed contract.

func (*RestrictAllFilterer) FilterOwnerTransferred 

func (_RestrictAll *RestrictAllFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*RestrictAllOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*RestrictAllFilterer) WatchOwnerTransferred 

func (_RestrictAll *RestrictAllFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *RestrictAllOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type RestrictAllOwnerTransferred 

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

RestrictAllOwnerTransferred represents a OwnerTransferred event raised by the RestrictAll contract.

type RestrictAllOwnerTransferredIterator 

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

RestrictAllOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the RestrictAll contract.

func (*RestrictAllOwnerTransferredIterator) Close 

func (it *RestrictAllOwnerTransferredIterator) Close() error

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

func (*RestrictAllOwnerTransferredIterator) Error 

func (it *RestrictAllOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RestrictAllOwnerTransferredIterator) Next 

func (it *RestrictAllOwnerTransferredIterator) 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 RestrictAllRaw 

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

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

func (*RestrictAllRaw) Call 

func (_RestrictAll *RestrictAllRaw) 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 (*RestrictAllRaw) Transact 

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

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

func (*RestrictAllRaw) Transfer 

func (_RestrictAll *RestrictAllRaw) 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 RestrictAllSession 

type RestrictAllSession struct {
	Contract     *RestrictAll      // 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
}

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

func (*RestrictAllSession) Check 

func (_RestrictAll *RestrictAllSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictAllSession) Kill 

func (_RestrictAll *RestrictAllSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictAllSession) Owner 

func (_RestrictAll *RestrictAllSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RestrictAllSession) TransferOwner 

func (_RestrictAll *RestrictAllSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictAllTransactor 

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

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

func NewRestrictAllTransactor 

func NewRestrictAllTransactor(address common.Address, transactor bind.ContractTransactor) (*RestrictAllTransactor, error)

NewRestrictAllTransactor creates a new write-only instance of RestrictAll, bound to a specific deployed contract.

func (*RestrictAllTransactor) Check 

func (_RestrictAll *RestrictAllTransactor) Check(opts *bind.TransactOpts, initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictAllTransactor) Kill 

func (_RestrictAll *RestrictAllTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictAllTransactor) TransferOwner 

func (_RestrictAll *RestrictAllTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictAllTransactorRaw 

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

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

func (*RestrictAllTransactorRaw) Transact 

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

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

func (*RestrictAllTransactorRaw) Transfer 

func (_RestrictAll *RestrictAllTransactorRaw) 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 RestrictAllTransactorSession 

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

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

func (*RestrictAllTransactorSession) Check 

func (_RestrictAll *RestrictAllTransactorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictAllTransactorSession) Kill 

func (_RestrictAll *RestrictAllTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictAllTransactorSession) TransferOwner 

func (_RestrictAll *RestrictAllTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictCaller 

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

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

func NewRestrictCaller 

func NewRestrictCaller(address common.Address, caller bind.ContractCaller) (*RestrictCaller, error)

NewRestrictCaller creates a new read-only instance of Restrict, bound to a specific deployed contract.

func (*RestrictCaller) Administrable 

func (_Restrict *RestrictCaller) Administrable(opts *bind.CallOpts) (common.Address, error)

Administrable is a free data retrieval call binding the contract method 0x834b1ab0.

Solidity: function administrable() constant returns(address)

func (*RestrictCaller) IsRestricted 

func (_Restrict *RestrictCaller) IsRestricted(opts *bind.CallOpts) (bool, error)

IsRestricted is a free data retrieval call binding the contract method 0x1f5e8f4c.

Solidity: function isRestricted() constant returns(bool)

func (*RestrictCaller) Owner 

func (_Restrict *RestrictCaller) 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 RestrictCallerRaw 

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

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

func (*RestrictCallerRaw) Call 

func (_Restrict *RestrictCallerRaw) 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 RestrictCallerSession 

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

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

func (*RestrictCallerSession) Administrable 

func (_Restrict *RestrictCallerSession) Administrable() (common.Address, error)

Administrable is a free data retrieval call binding the contract method 0x834b1ab0.

Solidity: function administrable() constant returns(address)

func (*RestrictCallerSession) IsRestricted 

func (_Restrict *RestrictCallerSession) IsRestricted() (bool, error)

IsRestricted is a free data retrieval call binding the contract method 0x1f5e8f4c.

Solidity: function isRestricted() constant returns(bool)

func (*RestrictCallerSession) Owner 

func (_Restrict *RestrictCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

type RestrictFilterer 

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

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

func NewRestrictFilterer 

func NewRestrictFilterer(address common.Address, filterer bind.ContractFilterer) (*RestrictFilterer, error)

NewRestrictFilterer creates a new log filterer instance of Restrict, bound to a specific deployed contract.

func (*RestrictFilterer) FilterOwnerTransferred 

func (_Restrict *RestrictFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*RestrictOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*RestrictFilterer) WatchOwnerTransferred 

func (_Restrict *RestrictFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *RestrictOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type RestrictFromAffiliate 

type RestrictFromAffiliate struct {
	RestrictFromAffiliateCaller     // Read-only binding to the contract
	RestrictFromAffiliateTransactor // Write-only binding to the contract
	RestrictFromAffiliateFilterer   // Log filterer for contract events
}

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

func DeployRestrictFromAffiliate 

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

DeployRestrictFromAffiliate deploys a new Ethereum contract, binding an instance of RestrictFromAffiliate to it.

func NewRestrictFromAffiliate 

func NewRestrictFromAffiliate(address common.Address, backend bind.ContractBackend) (*RestrictFromAffiliate, error)

NewRestrictFromAffiliate creates a new instance of RestrictFromAffiliate, bound to a specific deployed contract.

type RestrictFromAffiliateCaller 

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

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

func NewRestrictFromAffiliateCaller 

func NewRestrictFromAffiliateCaller(address common.Address, caller bind.ContractCaller) (*RestrictFromAffiliateCaller, error)

NewRestrictFromAffiliateCaller creates a new read-only instance of RestrictFromAffiliate, bound to a specific deployed contract.

func (*RestrictFromAffiliateCaller) Affiliates 

func (_RestrictFromAffiliate *RestrictFromAffiliateCaller) Affiliates(opts *bind.CallOpts, arg0 common.Address) (bool, error)

Affiliates is a free data retrieval call binding the contract method 0x4f51e294.

Solidity: function affiliates( address) constant returns(bool)

func (*RestrictFromAffiliateCaller) Owner 

func (_RestrictFromAffiliate *RestrictFromAffiliateCaller) 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 RestrictFromAffiliateCallerRaw 

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

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

func (*RestrictFromAffiliateCallerRaw) Call 

func (_RestrictFromAffiliate *RestrictFromAffiliateCallerRaw) 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 RestrictFromAffiliateCallerSession 

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

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

func (*RestrictFromAffiliateCallerSession) Affiliates 

func (_RestrictFromAffiliate *RestrictFromAffiliateCallerSession) Affiliates(arg0 common.Address) (bool, error)

Affiliates is a free data retrieval call binding the contract method 0x4f51e294.

Solidity: function affiliates( address) constant returns(bool)

func (*RestrictFromAffiliateCallerSession) Owner 

func (_RestrictFromAffiliate *RestrictFromAffiliateCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

type RestrictFromAffiliateFilterer 

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

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

func NewRestrictFromAffiliateFilterer 

func NewRestrictFromAffiliateFilterer(address common.Address, filterer bind.ContractFilterer) (*RestrictFromAffiliateFilterer, error)

NewRestrictFromAffiliateFilterer creates a new log filterer instance of RestrictFromAffiliate, bound to a specific deployed contract.

func (*RestrictFromAffiliateFilterer) FilterOwnerTransferred 

func (_RestrictFromAffiliate *RestrictFromAffiliateFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*RestrictFromAffiliateOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*RestrictFromAffiliateFilterer) WatchOwnerTransferred 

func (_RestrictFromAffiliate *RestrictFromAffiliateFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *RestrictFromAffiliateOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type RestrictFromAffiliateOwnerTransferred 

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

RestrictFromAffiliateOwnerTransferred represents a OwnerTransferred event raised by the RestrictFromAffiliate contract.

type RestrictFromAffiliateOwnerTransferredIterator 

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

RestrictFromAffiliateOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the RestrictFromAffiliate contract.

func (*RestrictFromAffiliateOwnerTransferredIterator) Close 

func (it *RestrictFromAffiliateOwnerTransferredIterator) Close() error

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

func (*RestrictFromAffiliateOwnerTransferredIterator) Error 

func (it *RestrictFromAffiliateOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RestrictFromAffiliateOwnerTransferredIterator) Next 

func (it *RestrictFromAffiliateOwnerTransferredIterator) 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 RestrictFromAffiliateRaw 

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

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

func (*RestrictFromAffiliateRaw) Call 

func (_RestrictFromAffiliate *RestrictFromAffiliateRaw) 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 (*RestrictFromAffiliateRaw) Transact 

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

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

func (*RestrictFromAffiliateRaw) Transfer 

func (_RestrictFromAffiliate *RestrictFromAffiliateRaw) 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 RestrictFromAffiliateSession 

type RestrictFromAffiliateSession struct {
	Contract     *RestrictFromAffiliate // 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
}

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

func (*RestrictFromAffiliateSession) Affiliates 

func (_RestrictFromAffiliate *RestrictFromAffiliateSession) Affiliates(arg0 common.Address) (bool, error)

Affiliates is a free data retrieval call binding the contract method 0x4f51e294.

Solidity: function affiliates( address) constant returns(bool)

func (*RestrictFromAffiliateSession) Check 

func (_RestrictFromAffiliate *RestrictFromAffiliateSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictFromAffiliateSession) Kill 

func (_RestrictFromAffiliate *RestrictFromAffiliateSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictFromAffiliateSession) Owner 

func (_RestrictFromAffiliate *RestrictFromAffiliateSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RestrictFromAffiliateSession) SetAffiliate 

func (_RestrictFromAffiliate *RestrictFromAffiliateSession) SetAffiliate(addr common.Address, status bool) (*types.Transaction, error)

SetAffiliate is a paid mutator transaction binding the contract method 0x8863ebbb.

Solidity: function setAffiliate(addr address, status bool) returns()

func (*RestrictFromAffiliateSession) TransferOwner 

func (_RestrictFromAffiliate *RestrictFromAffiliateSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictFromAffiliateTransactor 

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

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

func NewRestrictFromAffiliateTransactor 

func NewRestrictFromAffiliateTransactor(address common.Address, transactor bind.ContractTransactor) (*RestrictFromAffiliateTransactor, error)

NewRestrictFromAffiliateTransactor creates a new write-only instance of RestrictFromAffiliate, bound to a specific deployed contract.

func (*RestrictFromAffiliateTransactor) Check 

func (_RestrictFromAffiliate *RestrictFromAffiliateTransactor) Check(opts *bind.TransactOpts, initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictFromAffiliateTransactor) Kill 

func (_RestrictFromAffiliate *RestrictFromAffiliateTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictFromAffiliateTransactor) SetAffiliate 

func (_RestrictFromAffiliate *RestrictFromAffiliateTransactor) SetAffiliate(opts *bind.TransactOpts, addr common.Address, status bool) (*types.Transaction, error)

SetAffiliate is a paid mutator transaction binding the contract method 0x8863ebbb.

Solidity: function setAffiliate(addr address, status bool) returns()

func (*RestrictFromAffiliateTransactor) TransferOwner 

func (_RestrictFromAffiliate *RestrictFromAffiliateTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictFromAffiliateTransactorRaw 

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

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

func (*RestrictFromAffiliateTransactorRaw) Transact 

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

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

func (*RestrictFromAffiliateTransactorRaw) Transfer 

func (_RestrictFromAffiliate *RestrictFromAffiliateTransactorRaw) 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 RestrictFromAffiliateTransactorSession 

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

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

func (*RestrictFromAffiliateTransactorSession) Check 

func (_RestrictFromAffiliate *RestrictFromAffiliateTransactorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictFromAffiliateTransactorSession) Kill 

func (_RestrictFromAffiliate *RestrictFromAffiliateTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictFromAffiliateTransactorSession) SetAffiliate 

func (_RestrictFromAffiliate *RestrictFromAffiliateTransactorSession) SetAffiliate(addr common.Address, status bool) (*types.Transaction, error)

SetAffiliate is a paid mutator transaction binding the contract method 0x8863ebbb.

Solidity: function setAffiliate(addr address, status bool) returns()

func (*RestrictFromAffiliateTransactorSession) TransferOwner 

func (_RestrictFromAffiliate *RestrictFromAffiliateTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictFromInvestor 

type RestrictFromInvestor struct {
	RestrictFromInvestorCaller     // Read-only binding to the contract
	RestrictFromInvestorTransactor // Write-only binding to the contract
	RestrictFromInvestorFilterer   // Log filterer for contract events
}

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

func DeployRestrictFromInvestor 

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

DeployRestrictFromInvestor deploys a new Ethereum contract, binding an instance of RestrictFromInvestor to it.

func NewRestrictFromInvestor 

func NewRestrictFromInvestor(address common.Address, backend bind.ContractBackend) (*RestrictFromInvestor, error)

NewRestrictFromInvestor creates a new instance of RestrictFromInvestor, bound to a specific deployed contract.

type RestrictFromInvestorCaller 

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

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

func NewRestrictFromInvestorCaller 

func NewRestrictFromInvestorCaller(address common.Address, caller bind.ContractCaller) (*RestrictFromInvestorCaller, error)

NewRestrictFromInvestorCaller creates a new read-only instance of RestrictFromInvestor, bound to a specific deployed contract.

func (*RestrictFromInvestorCaller) Owner 

func (_RestrictFromInvestor *RestrictFromInvestorCaller) 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 RestrictFromInvestorCallerRaw 

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

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

func (*RestrictFromInvestorCallerRaw) Call 

func (_RestrictFromInvestor *RestrictFromInvestorCallerRaw) 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 RestrictFromInvestorCallerSession 

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

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

func (*RestrictFromInvestorCallerSession) Owner 

func (_RestrictFromInvestor *RestrictFromInvestorCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

type RestrictFromInvestorFilterer 

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

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

func NewRestrictFromInvestorFilterer 

func NewRestrictFromInvestorFilterer(address common.Address, filterer bind.ContractFilterer) (*RestrictFromInvestorFilterer, error)

NewRestrictFromInvestorFilterer creates a new log filterer instance of RestrictFromInvestor, bound to a specific deployed contract.

func (*RestrictFromInvestorFilterer) FilterOwnerTransferred 

func (_RestrictFromInvestor *RestrictFromInvestorFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*RestrictFromInvestorOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*RestrictFromInvestorFilterer) WatchOwnerTransferred 

func (_RestrictFromInvestor *RestrictFromInvestorFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *RestrictFromInvestorOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type RestrictFromInvestorOwnerTransferred 

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

RestrictFromInvestorOwnerTransferred represents a OwnerTransferred event raised by the RestrictFromInvestor contract.

type RestrictFromInvestorOwnerTransferredIterator 

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

RestrictFromInvestorOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the RestrictFromInvestor contract.

func (*RestrictFromInvestorOwnerTransferredIterator) Close 

func (it *RestrictFromInvestorOwnerTransferredIterator) Close() error

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

func (*RestrictFromInvestorOwnerTransferredIterator) Error 

func (it *RestrictFromInvestorOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RestrictFromInvestorOwnerTransferredIterator) Next 

func (it *RestrictFromInvestorOwnerTransferredIterator) 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 RestrictFromInvestorRaw 

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

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

func (*RestrictFromInvestorRaw) Call 

func (_RestrictFromInvestor *RestrictFromInvestorRaw) 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 (*RestrictFromInvestorRaw) Transact 

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

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

func (*RestrictFromInvestorRaw) Transfer 

func (_RestrictFromInvestor *RestrictFromInvestorRaw) 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 RestrictFromInvestorSession 

type RestrictFromInvestorSession struct {
	Contract     *RestrictFromInvestor // 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
}

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

func (*RestrictFromInvestorSession) Check 

func (_RestrictFromInvestor *RestrictFromInvestorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictFromInvestorSession) Kill 

func (_RestrictFromInvestor *RestrictFromInvestorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictFromInvestorSession) Owner 

func (_RestrictFromInvestor *RestrictFromInvestorSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RestrictFromInvestorSession) TransferOwner 

func (_RestrictFromInvestor *RestrictFromInvestorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictFromInvestorTransactor 

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

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

func NewRestrictFromInvestorTransactor 

func NewRestrictFromInvestorTransactor(address common.Address, transactor bind.ContractTransactor) (*RestrictFromInvestorTransactor, error)

NewRestrictFromInvestorTransactor creates a new write-only instance of RestrictFromInvestor, bound to a specific deployed contract.

func (*RestrictFromInvestorTransactor) Check 

func (_RestrictFromInvestor *RestrictFromInvestorTransactor) Check(opts *bind.TransactOpts, initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictFromInvestorTransactor) Kill 

func (_RestrictFromInvestor *RestrictFromInvestorTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictFromInvestorTransactor) TransferOwner 

func (_RestrictFromInvestor *RestrictFromInvestorTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictFromInvestorTransactorRaw 

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

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

func (*RestrictFromInvestorTransactorRaw) Transact 

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

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

func (*RestrictFromInvestorTransactorRaw) Transfer 

func (_RestrictFromInvestor *RestrictFromInvestorTransactorRaw) 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 RestrictFromInvestorTransactorSession 

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

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

func (*RestrictFromInvestorTransactorSession) Check 

func (_RestrictFromInvestor *RestrictFromInvestorTransactorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictFromInvestorTransactorSession) Kill 

func (_RestrictFromInvestor *RestrictFromInvestorTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictFromInvestorTransactorSession) TransferOwner 

func (_RestrictFromInvestor *RestrictFromInvestorTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictOwnerTransferred 

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

RestrictOwnerTransferred represents a OwnerTransferred event raised by the Restrict contract.

type RestrictOwnerTransferredIterator 

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

RestrictOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the Restrict contract.

func (*RestrictOwnerTransferredIterator) Close 

func (it *RestrictOwnerTransferredIterator) Close() error

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

func (*RestrictOwnerTransferredIterator) Error 

func (it *RestrictOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RestrictOwnerTransferredIterator) Next 

func (it *RestrictOwnerTransferredIterator) 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 RestrictRaw 

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

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

func (*RestrictRaw) Call 

func (_Restrict *RestrictRaw) 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 (*RestrictRaw) Transact 

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

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

func (*RestrictRaw) Transfer 

func (_Restrict *RestrictRaw) 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 RestrictSession 

type RestrictSession struct {
	Contract     *Restrict         // 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
}

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

func (*RestrictSession) Administrable 

func (_Restrict *RestrictSession) Administrable() (common.Address, error)

Administrable is a free data retrieval call binding the contract method 0x834b1ab0.

Solidity: function administrable() constant returns(address)

func (*RestrictSession) Check 

func (_Restrict *RestrictSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictSession) IsRestricted 

func (_Restrict *RestrictSession) IsRestricted() (bool, error)

IsRestricted is a free data retrieval call binding the contract method 0x1f5e8f4c.

Solidity: function isRestricted() constant returns(bool)

func (*RestrictSession) Kill 

func (_Restrict *RestrictSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictSession) Owner 

func (_Restrict *RestrictSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RestrictSession) SetRestricted 

func (_Restrict *RestrictSession) SetRestricted(restricted bool) (*types.Transaction, error)

SetRestricted is a paid mutator transaction binding the contract method 0x24daddc5.

Solidity: function setRestricted(restricted bool) returns()

func (*RestrictSession) TransferOwner 

func (_Restrict *RestrictSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToAccreditedInvestor 

type RestrictToAccreditedInvestor struct {
	RestrictToAccreditedInvestorCaller     // Read-only binding to the contract
	RestrictToAccreditedInvestorTransactor // Write-only binding to the contract
	RestrictToAccreditedInvestorFilterer   // Log filterer for contract events
}

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

func DeployRestrictToAccreditedInvestor 

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

DeployRestrictToAccreditedInvestor deploys a new Ethereum contract, binding an instance of RestrictToAccreditedInvestor to it.

func NewRestrictToAccreditedInvestor 

func NewRestrictToAccreditedInvestor(address common.Address, backend bind.ContractBackend) (*RestrictToAccreditedInvestor, error)

NewRestrictToAccreditedInvestor creates a new instance of RestrictToAccreditedInvestor, bound to a specific deployed contract.

type RestrictToAccreditedInvestorCaller 

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

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

func NewRestrictToAccreditedInvestorCaller 

func NewRestrictToAccreditedInvestorCaller(address common.Address, caller bind.ContractCaller) (*RestrictToAccreditedInvestorCaller, error)

NewRestrictToAccreditedInvestorCaller creates a new read-only instance of RestrictToAccreditedInvestor, bound to a specific deployed contract.

func (*RestrictToAccreditedInvestorCaller) Owner 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorCaller) 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 RestrictToAccreditedInvestorCallerRaw 

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

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

func (*RestrictToAccreditedInvestorCallerRaw) Call 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorCallerRaw) 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 RestrictToAccreditedInvestorCallerSession 

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

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

func (*RestrictToAccreditedInvestorCallerSession) Owner 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

type RestrictToAccreditedInvestorFilterer 

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

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

func NewRestrictToAccreditedInvestorFilterer 

func NewRestrictToAccreditedInvestorFilterer(address common.Address, filterer bind.ContractFilterer) (*RestrictToAccreditedInvestorFilterer, error)

NewRestrictToAccreditedInvestorFilterer creates a new log filterer instance of RestrictToAccreditedInvestor, bound to a specific deployed contract.

func (*RestrictToAccreditedInvestorFilterer) FilterOwnerTransferred 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*RestrictToAccreditedInvestorOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*RestrictToAccreditedInvestorFilterer) WatchOwnerTransferred 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *RestrictToAccreditedInvestorOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type RestrictToAccreditedInvestorOwnerTransferred 

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

RestrictToAccreditedInvestorOwnerTransferred represents a OwnerTransferred event raised by the RestrictToAccreditedInvestor contract.

type RestrictToAccreditedInvestorOwnerTransferredIterator 

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

RestrictToAccreditedInvestorOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the RestrictToAccreditedInvestor contract.

func (*RestrictToAccreditedInvestorOwnerTransferredIterator) Close 

func (it *RestrictToAccreditedInvestorOwnerTransferredIterator) Close() error

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

func (*RestrictToAccreditedInvestorOwnerTransferredIterator) Error 

func (it *RestrictToAccreditedInvestorOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RestrictToAccreditedInvestorOwnerTransferredIterator) Next 

func (it *RestrictToAccreditedInvestorOwnerTransferredIterator) 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 RestrictToAccreditedInvestorRaw 

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

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

func (*RestrictToAccreditedInvestorRaw) Call 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorRaw) 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 (*RestrictToAccreditedInvestorRaw) Transact 

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

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

func (*RestrictToAccreditedInvestorRaw) Transfer 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorRaw) 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 RestrictToAccreditedInvestorSession 

type RestrictToAccreditedInvestorSession struct {
	Contract     *RestrictToAccreditedInvestor // 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
}

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

func (*RestrictToAccreditedInvestorSession) Check 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToAccreditedInvestorSession) Kill 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToAccreditedInvestorSession) Owner 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RestrictToAccreditedInvestorSession) TransferOwner 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToAccreditedInvestorTransactor 

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

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

func NewRestrictToAccreditedInvestorTransactor 

func NewRestrictToAccreditedInvestorTransactor(address common.Address, transactor bind.ContractTransactor) (*RestrictToAccreditedInvestorTransactor, error)

NewRestrictToAccreditedInvestorTransactor creates a new write-only instance of RestrictToAccreditedInvestor, bound to a specific deployed contract.

func (*RestrictToAccreditedInvestorTransactor) Check 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorTransactor) Check(opts *bind.TransactOpts, initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToAccreditedInvestorTransactor) Kill 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToAccreditedInvestorTransactor) TransferOwner 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToAccreditedInvestorTransactorRaw 

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

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

func (*RestrictToAccreditedInvestorTransactorRaw) Transact 

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

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

func (*RestrictToAccreditedInvestorTransactorRaw) Transfer 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorTransactorRaw) 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 RestrictToAccreditedInvestorTransactorSession 

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

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

func (*RestrictToAccreditedInvestorTransactorSession) Check 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorTransactorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToAccreditedInvestorTransactorSession) Kill 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToAccreditedInvestorTransactorSession) TransferOwner 

func (_RestrictToAccreditedInvestor *RestrictToAccreditedInvestorTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToBrokerOrCustodialAccount 

type RestrictToBrokerOrCustodialAccount struct {
	RestrictToBrokerOrCustodialAccountCaller     // Read-only binding to the contract
	RestrictToBrokerOrCustodialAccountTransactor // Write-only binding to the contract
	RestrictToBrokerOrCustodialAccountFilterer   // Log filterer for contract events
}

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

func DeployRestrictToBrokerOrCustodialAccount 

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

DeployRestrictToBrokerOrCustodialAccount deploys a new Ethereum contract, binding an instance of RestrictToBrokerOrCustodialAccount to it.

func NewRestrictToBrokerOrCustodialAccount 

func NewRestrictToBrokerOrCustodialAccount(address common.Address, backend bind.ContractBackend) (*RestrictToBrokerOrCustodialAccount, error)

NewRestrictToBrokerOrCustodialAccount creates a new instance of RestrictToBrokerOrCustodialAccount, bound to a specific deployed contract.

type RestrictToBrokerOrCustodialAccountCaller 

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

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

func NewRestrictToBrokerOrCustodialAccountCaller 

func NewRestrictToBrokerOrCustodialAccountCaller(address common.Address, caller bind.ContractCaller) (*RestrictToBrokerOrCustodialAccountCaller, error)

NewRestrictToBrokerOrCustodialAccountCaller creates a new read-only instance of RestrictToBrokerOrCustodialAccount, bound to a specific deployed contract.

func (*RestrictToBrokerOrCustodialAccountCaller) Owner 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountCaller) 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 RestrictToBrokerOrCustodialAccountCallerRaw 

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

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

func (*RestrictToBrokerOrCustodialAccountCallerRaw) Call 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountCallerRaw) 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 RestrictToBrokerOrCustodialAccountCallerSession 

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

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

func (*RestrictToBrokerOrCustodialAccountCallerSession) Owner 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

type RestrictToBrokerOrCustodialAccountFilterer 

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

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

func NewRestrictToBrokerOrCustodialAccountFilterer 

func NewRestrictToBrokerOrCustodialAccountFilterer(address common.Address, filterer bind.ContractFilterer) (*RestrictToBrokerOrCustodialAccountFilterer, error)

NewRestrictToBrokerOrCustodialAccountFilterer creates a new log filterer instance of RestrictToBrokerOrCustodialAccount, bound to a specific deployed contract.

func (*RestrictToBrokerOrCustodialAccountFilterer) FilterOwnerTransferred 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*RestrictToBrokerOrCustodialAccountOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*RestrictToBrokerOrCustodialAccountFilterer) WatchOwnerTransferred 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *RestrictToBrokerOrCustodialAccountOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type RestrictToBrokerOrCustodialAccountOwnerTransferred 

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

RestrictToBrokerOrCustodialAccountOwnerTransferred represents a OwnerTransferred event raised by the RestrictToBrokerOrCustodialAccount contract.

type RestrictToBrokerOrCustodialAccountOwnerTransferredIterator 

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

RestrictToBrokerOrCustodialAccountOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the RestrictToBrokerOrCustodialAccount contract.

func (*RestrictToBrokerOrCustodialAccountOwnerTransferredIterator) Close 

func (it *RestrictToBrokerOrCustodialAccountOwnerTransferredIterator) Close() error

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

func (*RestrictToBrokerOrCustodialAccountOwnerTransferredIterator) Error 

func (it *RestrictToBrokerOrCustodialAccountOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RestrictToBrokerOrCustodialAccountOwnerTransferredIterator) Next 

func (it *RestrictToBrokerOrCustodialAccountOwnerTransferredIterator) 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 RestrictToBrokerOrCustodialAccountRaw 

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

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

func (*RestrictToBrokerOrCustodialAccountRaw) Call 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountRaw) 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 (*RestrictToBrokerOrCustodialAccountRaw) Transact 

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

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

func (*RestrictToBrokerOrCustodialAccountRaw) Transfer 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountRaw) 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 RestrictToBrokerOrCustodialAccountSession 

type RestrictToBrokerOrCustodialAccountSession struct {
	Contract     *RestrictToBrokerOrCustodialAccount // 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
}

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

func (*RestrictToBrokerOrCustodialAccountSession) Check 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToBrokerOrCustodialAccountSession) Kill 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToBrokerOrCustodialAccountSession) Owner 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RestrictToBrokerOrCustodialAccountSession) TransferOwner 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToBrokerOrCustodialAccountTransactor 

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

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

func NewRestrictToBrokerOrCustodialAccountTransactor 

func NewRestrictToBrokerOrCustodialAccountTransactor(address common.Address, transactor bind.ContractTransactor) (*RestrictToBrokerOrCustodialAccountTransactor, error)

NewRestrictToBrokerOrCustodialAccountTransactor creates a new write-only instance of RestrictToBrokerOrCustodialAccount, bound to a specific deployed contract.

func (*RestrictToBrokerOrCustodialAccountTransactor) Check 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountTransactor) Check(opts *bind.TransactOpts, initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToBrokerOrCustodialAccountTransactor) Kill 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToBrokerOrCustodialAccountTransactor) TransferOwner 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToBrokerOrCustodialAccountTransactorRaw 

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

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

func (*RestrictToBrokerOrCustodialAccountTransactorRaw) Transact 

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

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

func (*RestrictToBrokerOrCustodialAccountTransactorRaw) Transfer 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountTransactorRaw) 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 RestrictToBrokerOrCustodialAccountTransactorSession 

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

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

func (*RestrictToBrokerOrCustodialAccountTransactorSession) Check 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountTransactorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToBrokerOrCustodialAccountTransactorSession) Kill 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToBrokerOrCustodialAccountTransactorSession) TransferOwner 

func (_RestrictToBrokerOrCustodialAccount *RestrictToBrokerOrCustodialAccountTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToContract 

type RestrictToContract struct {
	RestrictToContractCaller     // Read-only binding to the contract
	RestrictToContractTransactor // Write-only binding to the contract
	RestrictToContractFilterer   // Log filterer for contract events
}

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

func DeployRestrictToContract 

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

DeployRestrictToContract deploys a new Ethereum contract, binding an instance of RestrictToContract to it.

func NewRestrictToContract 

func NewRestrictToContract(address common.Address, backend bind.ContractBackend) (*RestrictToContract, error)

NewRestrictToContract creates a new instance of RestrictToContract, bound to a specific deployed contract.

type RestrictToContractCaller 

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

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

func NewRestrictToContractCaller 

func NewRestrictToContractCaller(address common.Address, caller bind.ContractCaller) (*RestrictToContractCaller, error)

NewRestrictToContractCaller creates a new read-only instance of RestrictToContract, bound to a specific deployed contract.

func (*RestrictToContractCaller) Owner 

func (_RestrictToContract *RestrictToContractCaller) 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 RestrictToContractCallerRaw 

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

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

func (*RestrictToContractCallerRaw) Call 

func (_RestrictToContract *RestrictToContractCallerRaw) 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 RestrictToContractCallerSession 

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

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

func (*RestrictToContractCallerSession) Owner 

func (_RestrictToContract *RestrictToContractCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

type RestrictToContractFilterer 

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

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

func NewRestrictToContractFilterer 

func NewRestrictToContractFilterer(address common.Address, filterer bind.ContractFilterer) (*RestrictToContractFilterer, error)

NewRestrictToContractFilterer creates a new log filterer instance of RestrictToContract, bound to a specific deployed contract.

func (*RestrictToContractFilterer) FilterOwnerTransferred 

func (_RestrictToContract *RestrictToContractFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*RestrictToContractOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*RestrictToContractFilterer) WatchOwnerTransferred 

func (_RestrictToContract *RestrictToContractFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *RestrictToContractOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type RestrictToContractOwnerTransferred 

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

RestrictToContractOwnerTransferred represents a OwnerTransferred event raised by the RestrictToContract contract.

type RestrictToContractOwnerTransferredIterator 

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

RestrictToContractOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the RestrictToContract contract.

func (*RestrictToContractOwnerTransferredIterator) Close 

func (it *RestrictToContractOwnerTransferredIterator) Close() error

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

func (*RestrictToContractOwnerTransferredIterator) Error 

func (it *RestrictToContractOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RestrictToContractOwnerTransferredIterator) Next 

func (it *RestrictToContractOwnerTransferredIterator) 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 RestrictToContractRaw 

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

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

func (*RestrictToContractRaw) Call 

func (_RestrictToContract *RestrictToContractRaw) 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 (*RestrictToContractRaw) Transact 

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

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

func (*RestrictToContractRaw) Transfer 

func (_RestrictToContract *RestrictToContractRaw) 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 RestrictToContractSession 

type RestrictToContractSession struct {
	Contract     *RestrictToContract // 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
}

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

func (*RestrictToContractSession) Check 

func (_RestrictToContract *RestrictToContractSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToContractSession) Kill 

func (_RestrictToContract *RestrictToContractSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToContractSession) Owner 

func (_RestrictToContract *RestrictToContractSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RestrictToContractSession) TransferOwner 

func (_RestrictToContract *RestrictToContractSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToContractTransactor 

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

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

func NewRestrictToContractTransactor 

func NewRestrictToContractTransactor(address common.Address, transactor bind.ContractTransactor) (*RestrictToContractTransactor, error)

NewRestrictToContractTransactor creates a new write-only instance of RestrictToContract, bound to a specific deployed contract.

func (*RestrictToContractTransactor) Check 

func (_RestrictToContract *RestrictToContractTransactor) Check(opts *bind.TransactOpts, initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToContractTransactor) Kill 

func (_RestrictToContract *RestrictToContractTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToContractTransactor) TransferOwner 

func (_RestrictToContract *RestrictToContractTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToContractTransactorRaw 

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

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

func (*RestrictToContractTransactorRaw) Transact 

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

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

func (*RestrictToContractTransactorRaw) Transfer 

func (_RestrictToContract *RestrictToContractTransactorRaw) 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 RestrictToContractTransactorSession 

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

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

func (*RestrictToContractTransactorSession) Check 

func (_RestrictToContract *RestrictToContractTransactorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToContractTransactorSession) Kill 

func (_RestrictToContract *RestrictToContractTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToContractTransactorSession) TransferOwner 

func (_RestrictToContract *RestrictToContractTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToCustodianOrCustodialAccountOrBroker 

type RestrictToCustodianOrCustodialAccountOrBroker struct {
	RestrictToCustodianOrCustodialAccountOrBrokerCaller     // Read-only binding to the contract
	RestrictToCustodianOrCustodialAccountOrBrokerTransactor // Write-only binding to the contract
	RestrictToCustodianOrCustodialAccountOrBrokerFilterer   // Log filterer for contract events
}

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

func DeployRestrictToCustodianOrCustodialAccountOrBroker 

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

DeployRestrictToCustodianOrCustodialAccountOrBroker deploys a new Ethereum contract, binding an instance of RestrictToCustodianOrCustodialAccountOrBroker to it.

func NewRestrictToCustodianOrCustodialAccountOrBroker 

func NewRestrictToCustodianOrCustodialAccountOrBroker(address common.Address, backend bind.ContractBackend) (*RestrictToCustodianOrCustodialAccountOrBroker, error)

NewRestrictToCustodianOrCustodialAccountOrBroker creates a new instance of RestrictToCustodianOrCustodialAccountOrBroker, bound to a specific deployed contract.

type RestrictToCustodianOrCustodialAccountOrBrokerCaller 

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

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

func NewRestrictToCustodianOrCustodialAccountOrBrokerCaller 

func NewRestrictToCustodianOrCustodialAccountOrBrokerCaller(address common.Address, caller bind.ContractCaller) (*RestrictToCustodianOrCustodialAccountOrBrokerCaller, error)

NewRestrictToCustodianOrCustodialAccountOrBrokerCaller creates a new read-only instance of RestrictToCustodianOrCustodialAccountOrBroker, bound to a specific deployed contract.

func (*RestrictToCustodianOrCustodialAccountOrBrokerCaller) Owner 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerCaller) 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 RestrictToCustodianOrCustodialAccountOrBrokerCallerRaw 

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

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

func (*RestrictToCustodianOrCustodialAccountOrBrokerCallerRaw) Call 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerCallerRaw) 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 RestrictToCustodianOrCustodialAccountOrBrokerCallerSession 

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

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

func (*RestrictToCustodianOrCustodialAccountOrBrokerCallerSession) Owner 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

type RestrictToCustodianOrCustodialAccountOrBrokerFilterer 

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

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

func NewRestrictToCustodianOrCustodialAccountOrBrokerFilterer 

func NewRestrictToCustodianOrCustodialAccountOrBrokerFilterer(address common.Address, filterer bind.ContractFilterer) (*RestrictToCustodianOrCustodialAccountOrBrokerFilterer, error)

NewRestrictToCustodianOrCustodialAccountOrBrokerFilterer creates a new log filterer instance of RestrictToCustodianOrCustodialAccountOrBroker, bound to a specific deployed contract.

func (*RestrictToCustodianOrCustodialAccountOrBrokerFilterer) FilterOwnerTransferred 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*RestrictToCustodianOrCustodialAccountOrBrokerFilterer) WatchOwnerTransferred 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferred 

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

RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferred represents a OwnerTransferred event raised by the RestrictToCustodianOrCustodialAccountOrBroker contract.

type RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferredIterator 

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

RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the RestrictToCustodianOrCustodialAccountOrBroker contract.

func (*RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferredIterator) Close 

func (it *RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferredIterator) Close() error

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

func (*RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferredIterator) Error 

func (it *RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferredIterator) Next 

func (it *RestrictToCustodianOrCustodialAccountOrBrokerOwnerTransferredIterator) 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 RestrictToCustodianOrCustodialAccountOrBrokerRaw 

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

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

func (*RestrictToCustodianOrCustodialAccountOrBrokerRaw) Call 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerRaw) 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 (*RestrictToCustodianOrCustodialAccountOrBrokerRaw) Transact 

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

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

func (*RestrictToCustodianOrCustodialAccountOrBrokerRaw) Transfer 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerRaw) 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 RestrictToCustodianOrCustodialAccountOrBrokerSession 

type RestrictToCustodianOrCustodialAccountOrBrokerSession struct {
	Contract     *RestrictToCustodianOrCustodialAccountOrBroker // 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
}

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

func (*RestrictToCustodianOrCustodialAccountOrBrokerSession) Check 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToCustodianOrCustodialAccountOrBrokerSession) Kill 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToCustodianOrCustodialAccountOrBrokerSession) Owner 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RestrictToCustodianOrCustodialAccountOrBrokerSession) TransferOwner 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToCustodianOrCustodialAccountOrBrokerTransactor 

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

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

func NewRestrictToCustodianOrCustodialAccountOrBrokerTransactor 

func NewRestrictToCustodianOrCustodialAccountOrBrokerTransactor(address common.Address, transactor bind.ContractTransactor) (*RestrictToCustodianOrCustodialAccountOrBrokerTransactor, error)

NewRestrictToCustodianOrCustodialAccountOrBrokerTransactor creates a new write-only instance of RestrictToCustodianOrCustodialAccountOrBroker, bound to a specific deployed contract.

func (*RestrictToCustodianOrCustodialAccountOrBrokerTransactor) Check 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerTransactor) Check(opts *bind.TransactOpts, initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToCustodianOrCustodialAccountOrBrokerTransactor) Kill 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToCustodianOrCustodialAccountOrBrokerTransactor) TransferOwner 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictToCustodianOrCustodialAccountOrBrokerTransactorRaw 

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

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

func (*RestrictToCustodianOrCustodialAccountOrBrokerTransactorRaw) Transact 

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

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

func (*RestrictToCustodianOrCustodialAccountOrBrokerTransactorRaw) Transfer 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerTransactorRaw) 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 RestrictToCustodianOrCustodialAccountOrBrokerTransactorSession 

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

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

func (*RestrictToCustodianOrCustodialAccountOrBrokerTransactorSession) Check 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerTransactorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictToCustodianOrCustodialAccountOrBrokerTransactorSession) Kill 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictToCustodianOrCustodialAccountOrBrokerTransactorSession) TransferOwner 

func (_RestrictToCustodianOrCustodialAccountOrBroker *RestrictToCustodianOrCustodialAccountOrBrokerTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictTransactor 

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

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

func NewRestrictTransactor 

func NewRestrictTransactor(address common.Address, transactor bind.ContractTransactor) (*RestrictTransactor, error)

NewRestrictTransactor creates a new write-only instance of Restrict, bound to a specific deployed contract.

func (*RestrictTransactor) Check 

func (_Restrict *RestrictTransactor) Check(opts *bind.TransactOpts, initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictTransactor) Kill 

func (_Restrict *RestrictTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictTransactor) SetRestricted 

func (_Restrict *RestrictTransactor) SetRestricted(opts *bind.TransactOpts, restricted bool) (*types.Transaction, error)

SetRestricted is a paid mutator transaction binding the contract method 0x24daddc5.

Solidity: function setRestricted(restricted bool) returns()

func (*RestrictTransactor) TransferOwner 

func (_Restrict *RestrictTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictTransactorRaw 

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

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

func (*RestrictTransactorRaw) Transact 

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

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

func (*RestrictTransactorRaw) Transfer 

func (_Restrict *RestrictTransactorRaw) 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 RestrictTransactorSession 

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

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

func (*RestrictTransactorSession) Check 

func (_Restrict *RestrictTransactorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictTransactorSession) Kill 

func (_Restrict *RestrictTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictTransactorSession) SetRestricted 

func (_Restrict *RestrictTransactorSession) SetRestricted(restricted bool) (*types.Transaction, error)

SetRestricted is a paid mutator transaction binding the contract method 0x24daddc5.

Solidity: function setRestricted(restricted bool) returns()

func (*RestrictTransactorSession) TransferOwner 

func (_Restrict *RestrictTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictTransferFrom 

type RestrictTransferFrom struct {
	RestrictTransferFromCaller     // Read-only binding to the contract
	RestrictTransferFromTransactor // Write-only binding to the contract
	RestrictTransferFromFilterer   // Log filterer for contract events
}

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

func DeployRestrictTransferFrom 

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

DeployRestrictTransferFrom deploys a new Ethereum contract, binding an instance of RestrictTransferFrom to it.

func NewRestrictTransferFrom 

func NewRestrictTransferFrom(address common.Address, backend bind.ContractBackend) (*RestrictTransferFrom, error)

NewRestrictTransferFrom creates a new instance of RestrictTransferFrom, bound to a specific deployed contract.

type RestrictTransferFromCaller 

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

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

func NewRestrictTransferFromCaller 

func NewRestrictTransferFromCaller(address common.Address, caller bind.ContractCaller) (*RestrictTransferFromCaller, error)

NewRestrictTransferFromCaller creates a new read-only instance of RestrictTransferFrom, bound to a specific deployed contract.

func (*RestrictTransferFromCaller) Owner 

func (_RestrictTransferFrom *RestrictTransferFromCaller) 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 RestrictTransferFromCallerRaw 

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

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

func (*RestrictTransferFromCallerRaw) Call 

func (_RestrictTransferFrom *RestrictTransferFromCallerRaw) 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 RestrictTransferFromCallerSession 

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

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

func (*RestrictTransferFromCallerSession) Owner 

func (_RestrictTransferFrom *RestrictTransferFromCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

type RestrictTransferFromFilterer 

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

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

func NewRestrictTransferFromFilterer 

func NewRestrictTransferFromFilterer(address common.Address, filterer bind.ContractFilterer) (*RestrictTransferFromFilterer, error)

NewRestrictTransferFromFilterer creates a new log filterer instance of RestrictTransferFrom, bound to a specific deployed contract.

func (*RestrictTransferFromFilterer) FilterOwnerTransferred 

func (_RestrictTransferFrom *RestrictTransferFromFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*RestrictTransferFromOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*RestrictTransferFromFilterer) WatchOwnerTransferred 

func (_RestrictTransferFrom *RestrictTransferFromFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *RestrictTransferFromOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type RestrictTransferFromOwnerTransferred 

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

RestrictTransferFromOwnerTransferred represents a OwnerTransferred event raised by the RestrictTransferFrom contract.

type RestrictTransferFromOwnerTransferredIterator 

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

RestrictTransferFromOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the RestrictTransferFrom contract.

func (*RestrictTransferFromOwnerTransferredIterator) Close 

func (it *RestrictTransferFromOwnerTransferredIterator) Close() error

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

func (*RestrictTransferFromOwnerTransferredIterator) Error 

func (it *RestrictTransferFromOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RestrictTransferFromOwnerTransferredIterator) Next 

func (it *RestrictTransferFromOwnerTransferredIterator) 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 RestrictTransferFromRaw 

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

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

func (*RestrictTransferFromRaw) Call 

func (_RestrictTransferFrom *RestrictTransferFromRaw) 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 (*RestrictTransferFromRaw) Transact 

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

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

func (*RestrictTransferFromRaw) Transfer 

func (_RestrictTransferFrom *RestrictTransferFromRaw) 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 RestrictTransferFromSession 

type RestrictTransferFromSession struct {
	Contract     *RestrictTransferFrom // 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
}

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

func (*RestrictTransferFromSession) Check 

func (_RestrictTransferFrom *RestrictTransferFromSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictTransferFromSession) Kill 

func (_RestrictTransferFrom *RestrictTransferFromSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictTransferFromSession) Owner 

func (_RestrictTransferFrom *RestrictTransferFromSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RestrictTransferFromSession) TransferOwner 

func (_RestrictTransferFrom *RestrictTransferFromSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictTransferFromTransactor 

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

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

func NewRestrictTransferFromTransactor 

func NewRestrictTransferFromTransactor(address common.Address, transactor bind.ContractTransactor) (*RestrictTransferFromTransactor, error)

NewRestrictTransferFromTransactor creates a new write-only instance of RestrictTransferFrom, bound to a specific deployed contract.

func (*RestrictTransferFromTransactor) Check 

func (_RestrictTransferFrom *RestrictTransferFromTransactor) Check(opts *bind.TransactOpts, initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictTransferFromTransactor) Kill 

func (_RestrictTransferFrom *RestrictTransferFromTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictTransferFromTransactor) TransferOwner 

func (_RestrictTransferFrom *RestrictTransferFromTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type RestrictTransferFromTransactorRaw 

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

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

func (*RestrictTransferFromTransactorRaw) Transact 

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

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

func (*RestrictTransferFromTransactorRaw) Transfer 

func (_RestrictTransferFrom *RestrictTransferFromTransactorRaw) 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 RestrictTransferFromTransactorSession 

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

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

func (*RestrictTransferFromTransactorSession) Check 

func (_RestrictTransferFrom *RestrictTransferFromTransactorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

func (*RestrictTransferFromTransactorSession) Kill 

func (_RestrictTransferFrom *RestrictTransferFromTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*RestrictTransferFromTransactorSession) TransferOwner 

func (_RestrictTransferFrom *RestrictTransferFromTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type Rule 

type Rule struct {
	RuleCaller     // Read-only binding to the contract
	RuleTransactor // Write-only binding to the contract
	RuleFilterer   // Log filterer for contract events
}

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

func NewRule 

func NewRule(address common.Address, backend bind.ContractBackend) (*Rule, error)

NewRule creates a new instance of Rule, bound to a specific deployed contract.

type RuleCaller 

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

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

func NewRuleCaller 

func NewRuleCaller(address common.Address, caller bind.ContractCaller) (*RuleCaller, error)

NewRuleCaller creates a new read-only instance of Rule, bound to a specific deployed contract.

type RuleCallerRaw 

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

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

func (*RuleCallerRaw) Call 

func (_Rule *RuleCallerRaw) 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 RuleCallerSession 

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

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

type RuleFilterer 

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

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

func NewRuleFilterer 

func NewRuleFilterer(address common.Address, filterer bind.ContractFilterer) (*RuleFilterer, error)

NewRuleFilterer creates a new log filterer instance of Rule, bound to a specific deployed contract.

type RuleRaw 

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

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

func (*RuleRaw) Call 

func (_Rule *RuleRaw) 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 (*RuleRaw) Transact 

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

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

func (*RuleRaw) Transfer 

func (_Rule *RuleRaw) 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 RuleSession 

type RuleSession struct {
	Contract     *Rule             // 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
}

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

func (*RuleSession) Check 

func (_Rule *RuleSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

type RuleTransactor 

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

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

func NewRuleTransactor 

func NewRuleTransactor(address common.Address, transactor bind.ContractTransactor) (*RuleTransactor, error)

NewRuleTransactor creates a new write-only instance of Rule, bound to a specific deployed contract.

func (*RuleTransactor) Check 

func (_Rule *RuleTransactor) Check(opts *bind.TransactOpts, initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

type RuleTransactorRaw 

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

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

func (*RuleTransactorRaw) Transact 

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

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

func (*RuleTransactorRaw) Transfer 

func (_Rule *RuleTransactorRaw) 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 RuleTransactorSession 

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

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

func (*RuleTransactorSession) Check 

func (_Rule *RuleTransactorSession) Check(initiator common.Address, from common.Address, to common.Address, toKind uint8, tokens *big.Int, store common.Address) (*types.Transaction, error)

Check is a paid mutator transaction binding the contract method 0xb762c76d.

Solidity: function check(initiator address, from address, to address, toKind uint8, tokens uint256, store address) returns()

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.