registry

package

Go to main page

Versions in this module

v0

v0.2.0

Dec 19, 2019

Changes in this version

+ const MultiAdminABI

+ const MultiAdminBin

+ const RegistryABI

+ const RegistryBin

type BrokerDealerCaller

+ func (_BrokerDealer *BrokerDealerCaller) Registry(opts *bind.CallOpts) (common.Address, error)

+ func (_BrokerDealer *BrokerDealerCaller) ZEROADDRESS(opts *bind.CallOpts) (common.Address, error)

type BrokerDealerCallerSession

+ func (_BrokerDealer *BrokerDealerCallerSession) Registry() (common.Address, error)

+ func (_BrokerDealer *BrokerDealerCallerSession) ZEROADDRESS() (common.Address, error)

type BrokerDealerSession

+ func (_BrokerDealer *BrokerDealerSession) Registry() (common.Address, error)

+ func (_BrokerDealer *BrokerDealerSession) SetRegistry(r common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerSession) ZEROADDRESS() (common.Address, error)

type BrokerDealerTransactor

+ func (_BrokerDealer *BrokerDealerTransactor) SetRegistry(opts *bind.TransactOpts, r common.Address) (*types.Transaction, error)

type BrokerDealerTransactorSession

+ func (_BrokerDealer *BrokerDealerTransactorSession) SetRegistry(r common.Address) (*types.Transaction, error)

type CustodianCaller

+ func (_Custodian *CustodianCaller) Registry(opts *bind.CallOpts) (common.Address, error)

+ func (_Custodian *CustodianCaller) ZEROADDRESS(opts *bind.CallOpts) (common.Address, error)

type CustodianCallerSession

+ func (_Custodian *CustodianCallerSession) Registry() (common.Address, error)

+ func (_Custodian *CustodianCallerSession) ZEROADDRESS() (common.Address, error)

type CustodianSession

+ func (_Custodian *CustodianSession) Registry() (common.Address, error)

+ func (_Custodian *CustodianSession) SetRegistry(r common.Address) (*types.Transaction, error)

+ func (_Custodian *CustodianSession) ZEROADDRESS() (common.Address, error)

type CustodianTransactor

+ func (_Custodian *CustodianTransactor) SetRegistry(opts *bind.TransactOpts, r common.Address) (*types.Transaction, error)

type CustodianTransactorSession

+ func (_Custodian *CustodianTransactorSession) SetRegistry(r common.Address) (*types.Transaction, error)

type ExternalInvestorCaller

+ func (_ExternalInvestor *ExternalInvestorCaller) AdminAt(opts *bind.CallOpts, index *big.Int) (common.Address, error)

+ func (_ExternalInvestor *ExternalInvestorCaller) Registry(opts *bind.CallOpts) (common.Address, error)

+ func (_ExternalInvestor *ExternalInvestorCaller) ZEROADDRESS(opts *bind.CallOpts) (common.Address, error)

type ExternalInvestorCallerSession

+ func (_ExternalInvestor *ExternalInvestorCallerSession) AdminAt(index *big.Int) (common.Address, error)

+ func (_ExternalInvestor *ExternalInvestorCallerSession) Registry() (common.Address, error)

+ func (_ExternalInvestor *ExternalInvestorCallerSession) ZEROADDRESS() (common.Address, error)

type ExternalInvestorFilterer

+ func (_ExternalInvestor *ExternalInvestorFilterer) FilterInvestorUpdated(opts *bind.FilterOpts, investor []common.Address, owner []common.Address) (*ExternalInvestorInvestorUpdatedIterator, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) WatchInvestorUpdated(opts *bind.WatchOpts, sink chan<- *ExternalInvestorInvestorUpdated, ...) (event.Subscription, error)

+ type ExternalInvestorInvestorUpdated struct

+ Investor common.Address

+ Owner common.Address

+ Raw types.Log

+ type ExternalInvestorInvestorUpdatedIterator struct

+ Event *ExternalInvestorInvestorUpdated

+ func (it *ExternalInvestorInvestorUpdatedIterator) Close() error

+ func (it *ExternalInvestorInvestorUpdatedIterator) Error() error

+ func (it *ExternalInvestorInvestorUpdatedIterator) Next() bool

type ExternalInvestorSession

+ func (_ExternalInvestor *ExternalInvestorSession) AdminAt(index *big.Int) (common.Address, error)

+ func (_ExternalInvestor *ExternalInvestorSession) Registry() (common.Address, error)

+ func (_ExternalInvestor *ExternalInvestorSession) SetAdmin(addr common.Address, add bool) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) SetRegistry(r common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) ZEROADDRESS() (common.Address, error)

type ExternalInvestorTransactor

+ func (_ExternalInvestor *ExternalInvestorTransactor) SetAdmin(opts *bind.TransactOpts, addr common.Address, add bool) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) SetRegistry(opts *bind.TransactOpts, r common.Address) (*types.Transaction, error)

type ExternalInvestorTransactorSession

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) SetAdmin(addr common.Address, add bool) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) SetRegistry(r common.Address) (*types.Transaction, error)

type InvestorCaller

+ func (_Investor *InvestorCaller) Registry(opts *bind.CallOpts) (common.Address, error)

+ func (_Investor *InvestorCaller) ZEROADDRESS(opts *bind.CallOpts) (common.Address, error)

type InvestorCallerSession

+ func (_Investor *InvestorCallerSession) Registry() (common.Address, error)

+ func (_Investor *InvestorCallerSession) ZEROADDRESS() (common.Address, error)

type InvestorFilterer

+ func (_Investor *InvestorFilterer) FilterInvestorUpdated(opts *bind.FilterOpts, investor []common.Address, owner []common.Address) (*InvestorInvestorUpdatedIterator, error)

+ func (_Investor *InvestorFilterer) WatchInvestorUpdated(opts *bind.WatchOpts, sink chan<- *InvestorInvestorUpdated, ...) (event.Subscription, error)

+ type InvestorInvestorUpdated struct

+ Investor common.Address

+ Owner common.Address

+ Raw types.Log

+ type InvestorInvestorUpdatedIterator struct

+ Event *InvestorInvestorUpdated

+ func (it *InvestorInvestorUpdatedIterator) Close() error

+ func (it *InvestorInvestorUpdatedIterator) Error() error

+ func (it *InvestorInvestorUpdatedIterator) Next() bool

type InvestorSession

+ func (_Investor *InvestorSession) Registry() (common.Address, error)

+ func (_Investor *InvestorSession) SetRegistry(r common.Address) (*types.Transaction, error)

+ func (_Investor *InvestorSession) ZEROADDRESS() (common.Address, error)

type InvestorTransactor

+ func (_Investor *InvestorTransactor) SetRegistry(opts *bind.TransactOpts, r common.Address) (*types.Transaction, error)

type InvestorTransactorSession

+ func (_Investor *InvestorTransactorSession) SetRegistry(r common.Address) (*types.Transaction, error)

+ type MultiAdmin struct

+ func DeployMultiAdmin(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MultiAdmin, error)

+ func NewMultiAdmin(address common.Address, backend bind.ContractBackend) (*MultiAdmin, error)

+ type MultiAdminCaller struct

+ func NewMultiAdminCaller(address common.Address, caller bind.ContractCaller) (*MultiAdminCaller, error)

+ func (_MultiAdmin *MultiAdminCaller) AddressFor(opts *bind.CallOpts, salt *big.Int) (common.Address, error)

+ func (_MultiAdmin *MultiAdminCaller) AdminAt(opts *bind.CallOpts, index *big.Int) (common.Address, error)

+ func (_MultiAdmin *MultiAdminCaller) Admins(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiAdmin *MultiAdminCaller) BallotDuration(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiAdmin *MultiAdminCaller) Creator(opts *bind.CallOpts) (common.Address, error)

+ func (_MultiAdmin *MultiAdminCaller) ElectionResults(opts *bind.CallOpts) (uint8, common.Address, uint8, common.Address, *big.Int, error)

+ func (_MultiAdmin *MultiAdminCaller) HasVoted(opts *bind.CallOpts, voter common.Address) (bool, error)

+ func (_MultiAdmin *MultiAdminCaller) IsAdmin(opts *bind.CallOpts, addr common.Address) (bool, error)

+ func (_MultiAdmin *MultiAdminCaller) Registry(opts *bind.CallOpts) (common.Address, error)

+ func (_MultiAdmin *MultiAdminCaller) VoteThreshold(opts *bind.CallOpts) (*big.Int, error)

+ type MultiAdminCallerRaw struct

+ Contract *MultiAdminCaller

+ func (_MultiAdmin *MultiAdminCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type MultiAdminCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MultiAdminCaller

+ func (_MultiAdmin *MultiAdminCallerSession) AddressFor(salt *big.Int) (common.Address, error)

+ func (_MultiAdmin *MultiAdminCallerSession) AdminAt(index *big.Int) (common.Address, error)

+ func (_MultiAdmin *MultiAdminCallerSession) Admins() (*big.Int, error)

+ func (_MultiAdmin *MultiAdminCallerSession) BallotDuration() (*big.Int, error)

+ func (_MultiAdmin *MultiAdminCallerSession) Creator() (common.Address, error)

+ func (_MultiAdmin *MultiAdminCallerSession) ElectionResults() (uint8, common.Address, uint8, common.Address, *big.Int, error)

+ func (_MultiAdmin *MultiAdminCallerSession) HasVoted(voter common.Address) (bool, error)

+ func (_MultiAdmin *MultiAdminCallerSession) IsAdmin(addr common.Address) (bool, error)

+ func (_MultiAdmin *MultiAdminCallerSession) Registry() (common.Address, error)

+ func (_MultiAdmin *MultiAdminCallerSession) VoteThreshold() (*big.Int, error)

+ type MultiAdminElectionClosed struct

+ Challenger common.Address

+ Incumbent common.Address

+ Margin *big.Int

+ Passed bool

+ Raw types.Log

+ type MultiAdminElectionClosedIterator struct

+ Event *MultiAdminElectionClosed

+ func (it *MultiAdminElectionClosedIterator) Close() error

+ func (it *MultiAdminElectionClosedIterator) Error() error

+ func (it *MultiAdminElectionClosedIterator) Next() bool

+ type MultiAdminElectionCreated struct

+ Challenger common.Address

+ Incumbent common.Address

+ Raw types.Log

+ type MultiAdminElectionCreatedIterator struct

+ Event *MultiAdminElectionCreated

+ func (it *MultiAdminElectionCreatedIterator) Close() error

+ func (it *MultiAdminElectionCreatedIterator) Error() error

+ func (it *MultiAdminElectionCreatedIterator) Next() bool

+ type MultiAdminFilterer struct

+ func NewMultiAdminFilterer(address common.Address, filterer bind.ContractFilterer) (*MultiAdminFilterer, error)

+ func (_MultiAdmin *MultiAdminFilterer) FilterElectionClosed(opts *bind.FilterOpts, incumbent []common.Address, challenger []common.Address, ...) (*MultiAdminElectionClosedIterator, error)

+ func (_MultiAdmin *MultiAdminFilterer) FilterElectionCreated(opts *bind.FilterOpts, incumbent []common.Address, challenger []common.Address) (*MultiAdminElectionCreatedIterator, error)

+ func (_MultiAdmin *MultiAdminFilterer) FilterVoteCast(opts *bind.FilterOpts, incumbent []common.Address, challenger []common.Address) (*MultiAdminVoteCastIterator, error)

+ func (_MultiAdmin *MultiAdminFilterer) WatchElectionClosed(opts *bind.WatchOpts, sink chan<- *MultiAdminElectionClosed, ...) (event.Subscription, error)

+ func (_MultiAdmin *MultiAdminFilterer) WatchElectionCreated(opts *bind.WatchOpts, sink chan<- *MultiAdminElectionCreated, ...) (event.Subscription, error)

+ func (_MultiAdmin *MultiAdminFilterer) WatchVoteCast(opts *bind.WatchOpts, sink chan<- *MultiAdminVoteCast, ...) (event.Subscription, error)

+ type MultiAdminRaw struct

+ Contract *MultiAdmin

+ func (_MultiAdmin *MultiAdminRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_MultiAdmin *MultiAdminRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MultiAdminSession struct

+ CallOpts bind.CallOpts

+ Contract *MultiAdmin

+ TransactOpts bind.TransactOpts

+ func (_MultiAdmin *MultiAdminSession) AddressFor(salt *big.Int) (common.Address, error)

+ func (_MultiAdmin *MultiAdminSession) AdminAt(index *big.Int) (common.Address, error)

+ func (_MultiAdmin *MultiAdminSession) Admins() (*big.Int, error)

+ func (_MultiAdmin *MultiAdminSession) BallotDuration() (*big.Int, error)

+ func (_MultiAdmin *MultiAdminSession) Clone(salt *big.Int) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminSession) CreateElection(incumbent common.Address, challenger common.Address) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminSession) Creator() (common.Address, error)

+ func (_MultiAdmin *MultiAdminSession) ElectionResults() (uint8, common.Address, uint8, common.Address, *big.Int, error)

+ func (_MultiAdmin *MultiAdminSession) HasVoted(voter common.Address) (bool, error)

+ func (_MultiAdmin *MultiAdminSession) Init(registryAddress common.Address, adminAddresses []common.Address) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminSession) IsAdmin(addr common.Address) (bool, error)

+ func (_MultiAdmin *MultiAdminSession) Registry() (common.Address, error)

+ func (_MultiAdmin *MultiAdminSession) SetRegistry(r common.Address) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminSession) Vote(incumbent common.Address, challenger common.Address, yea bool) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminSession) VoteThreshold() (*big.Int, error)

+ type MultiAdminTransactor struct

+ func NewMultiAdminTransactor(address common.Address, transactor bind.ContractTransactor) (*MultiAdminTransactor, error)

+ func (_MultiAdmin *MultiAdminTransactor) Clone(opts *bind.TransactOpts, salt *big.Int) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminTransactor) CreateElection(opts *bind.TransactOpts, incumbent common.Address, challenger common.Address) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminTransactor) Init(opts *bind.TransactOpts, registryAddress common.Address, ...) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminTransactor) SetRegistry(opts *bind.TransactOpts, r common.Address) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminTransactor) Vote(opts *bind.TransactOpts, incumbent common.Address, challenger common.Address, ...) (*types.Transaction, error)

+ type MultiAdminTransactorRaw struct

+ Contract *MultiAdminTransactor

+ func (_MultiAdmin *MultiAdminTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MultiAdminTransactorSession struct

+ Contract *MultiAdminTransactor

+ TransactOpts bind.TransactOpts

+ func (_MultiAdmin *MultiAdminTransactorSession) Clone(salt *big.Int) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminTransactorSession) CreateElection(incumbent common.Address, challenger common.Address) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminTransactorSession) Init(registryAddress common.Address, adminAddresses []common.Address) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminTransactorSession) SetRegistry(r common.Address) (*types.Transaction, error)

+ func (_MultiAdmin *MultiAdminTransactorSession) Vote(incumbent common.Address, challenger common.Address, yea bool) (*types.Transaction, error)

+ type MultiAdminVoteCast struct

+ Challenger common.Address

+ Incumbent common.Address

+ Raw types.Log

+ type MultiAdminVoteCastIterator struct

+ Event *MultiAdminVoteCast

+ func (it *MultiAdminVoteCastIterator) Close() error

+ func (it *MultiAdminVoteCastIterator) Error() error

+ func (it *MultiAdminVoteCastIterator) Next() bool

+ type Registry struct

+ func DeployRegistry(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Registry, error)

+ func NewRegistry(address common.Address, backend bind.ContractBackend) (*Registry, error)

+ type RegistryCaller struct

+ func NewRegistryCaller(address common.Address, caller bind.ContractCaller) (*RegistryCaller, error)

+ func (_Registry *RegistryCaller) AccountAt(opts *bind.CallOpts, index *big.Int) (common.Address, uint8, bool, common.Address, [32]byte, error)

+ func (_Registry *RegistryCaller) AccountAtHash(opts *bind.CallOpts, hash [32]byte, index *big.Int) (common.Address, uint8, bool, common.Address, [32]byte, error)

+ func (_Registry *RegistryCaller) AccountExists(opts *bind.CallOpts, addr common.Address) (bool, error)

+ func (_Registry *RegistryCaller) AccountFrozen(opts *bind.CallOpts, addr common.Address) (bool, error)

+ func (_Registry *RegistryCaller) AccountGet(opts *bind.CallOpts, addr common.Address) (uint8, bool, common.Address, [32]byte, error)

+ func (_Registry *RegistryCaller) AccountHash(opts *bind.CallOpts, addr common.Address) ([32]byte, error)

+ func (_Registry *RegistryCaller) AccountIndexOf(opts *bind.CallOpts, addr common.Address) (*big.Int, error)

+ func (_Registry *RegistryCaller) AccountKind(opts *bind.CallOpts, addr common.Address) (uint8, error)

+ func (_Registry *RegistryCaller) AccountKindAndFrozen(opts *bind.CallOpts, addr common.Address) (uint8, bool, error)

+ func (_Registry *RegistryCaller) AccountKindAndFrozenAddress(opts *bind.CallOpts, addr common.Address) (uint8, common.Address, error)

+ func (_Registry *RegistryCaller) AccountKindAndFrozenAddressLineage(opts *bind.CallOpts, addr common.Address) (uint8, common.Address, []common.Address, error)

+ func (_Registry *RegistryCaller) AccountKindExists(opts *bind.CallOpts, addr common.Address, kind uint8) (bool, error)

+ func (_Registry *RegistryCaller) AccountLineage(opts *bind.CallOpts, addresses []common.Address) ([]common.Address, error)

+ func (_Registry *RegistryCaller) AccountParent(opts *bind.CallOpts, addr common.Address) (common.Address, error)

+ func (_Registry *RegistryCaller) Accounts(opts *bind.CallOpts) (*big.Int, error)

+ func (_Registry *RegistryCaller) AddressAtHash(opts *bind.CallOpts, hash [32]byte, index *big.Int) (common.Address, error)

+ func (_Registry *RegistryCaller) Data(opts *bind.CallOpts, arg0 common.Address, arg1 uint8) ([32]byte, error)

+ func (_Registry *RegistryCaller) Hashes(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error)

+ func (_Registry *RegistryCaller) IsLocked(opts *bind.CallOpts) (bool, error)

+ func (_Registry *RegistryCaller) LineageCount(opts *bind.CallOpts, addr common.Address) (*big.Int, error)

+ func (_Registry *RegistryCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Registry *RegistryCaller) PermissionAt(opts *bind.CallOpts, kind uint8, index *big.Int) (common.Address, error)

+ func (_Registry *RegistryCaller) PermissionExists(opts *bind.CallOpts, kind uint8, addr common.Address) (bool, error)

+ func (_Registry *RegistryCaller) PermissionIndexOf(opts *bind.CallOpts, kind uint8, addr common.Address) (*big.Int, error)

+ func (_Registry *RegistryCaller) Permissions(opts *bind.CallOpts, arg0 uint8) (*big.Int, error)

+ func (_Registry *RegistryCaller) ZEROADDRESS(opts *bind.CallOpts) (common.Address, error)

+ type RegistryCallerRaw struct

+ Contract *RegistryCaller

+ func (_Registry *RegistryCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type RegistryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *RegistryCaller

+ func (_Registry *RegistryCallerSession) AccountAt(index *big.Int) (common.Address, uint8, bool, common.Address, [32]byte, error)

+ func (_Registry *RegistryCallerSession) AccountAtHash(hash [32]byte, index *big.Int) (common.Address, uint8, bool, common.Address, [32]byte, error)

+ func (_Registry *RegistryCallerSession) AccountExists(addr common.Address) (bool, error)

+ func (_Registry *RegistryCallerSession) AccountFrozen(addr common.Address) (bool, error)

+ func (_Registry *RegistryCallerSession) AccountGet(addr common.Address) (uint8, bool, common.Address, [32]byte, error)

+ func (_Registry *RegistryCallerSession) AccountHash(addr common.Address) ([32]byte, error)

+ func (_Registry *RegistryCallerSession) AccountIndexOf(addr common.Address) (*big.Int, error)

+ func (_Registry *RegistryCallerSession) AccountKind(addr common.Address) (uint8, error)

+ func (_Registry *RegistryCallerSession) AccountKindAndFrozen(addr common.Address) (uint8, bool, error)

+ func (_Registry *RegistryCallerSession) AccountKindAndFrozenAddress(addr common.Address) (uint8, common.Address, error)

+ func (_Registry *RegistryCallerSession) AccountKindAndFrozenAddressLineage(addr common.Address) (uint8, common.Address, []common.Address, error)

+ func (_Registry *RegistryCallerSession) AccountKindExists(addr common.Address, kind uint8) (bool, error)

+ func (_Registry *RegistryCallerSession) AccountLineage(addresses []common.Address) ([]common.Address, error)

+ func (_Registry *RegistryCallerSession) AccountParent(addr common.Address) (common.Address, error)

+ func (_Registry *RegistryCallerSession) Accounts() (*big.Int, error)

+ func (_Registry *RegistryCallerSession) AddressAtHash(hash [32]byte, index *big.Int) (common.Address, error)

+ func (_Registry *RegistryCallerSession) Data(arg0 common.Address, arg1 uint8) ([32]byte, error)

+ func (_Registry *RegistryCallerSession) Hashes(arg0 [32]byte) (*big.Int, error)

+ func (_Registry *RegistryCallerSession) IsLocked() (bool, error)

+ func (_Registry *RegistryCallerSession) LineageCount(addr common.Address) (*big.Int, error)

+ func (_Registry *RegistryCallerSession) Owner() (common.Address, error)

+ func (_Registry *RegistryCallerSession) PermissionAt(kind uint8, index *big.Int) (common.Address, error)

+ func (_Registry *RegistryCallerSession) PermissionExists(kind uint8, addr common.Address) (bool, error)

+ func (_Registry *RegistryCallerSession) PermissionIndexOf(kind uint8, addr common.Address) (*big.Int, error)

+ func (_Registry *RegistryCallerSession) Permissions(arg0 uint8) (*big.Int, error)

+ func (_Registry *RegistryCallerSession) ZEROADDRESS() (common.Address, error)

+ type RegistryFilterer struct

+ func NewRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*RegistryFilterer, error)

+ func (_Registry *RegistryFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*RegistryOwnerTransferredIterator, error)

+ func (_Registry *RegistryFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *RegistryOwnerTransferred, ...) (event.Subscription, error)

+ type RegistryOwnerTransferred struct

+ NewOwner common.Address

+ OldOwner common.Address

+ Raw types.Log

+ type RegistryOwnerTransferredIterator struct

+ Event *RegistryOwnerTransferred

+ func (it *RegistryOwnerTransferredIterator) Close() error

+ func (it *RegistryOwnerTransferredIterator) Error() error

+ func (it *RegistryOwnerTransferredIterator) Next() bool

+ type RegistryRaw struct

+ Contract *Registry

+ func (_Registry *RegistryRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_Registry *RegistryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Registry *RegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type RegistrySession struct

+ CallOpts bind.CallOpts

+ Contract *Registry

+ TransactOpts bind.TransactOpts

+ func (_Registry *RegistrySession) AccountAt(index *big.Int) (common.Address, uint8, bool, common.Address, [32]byte, error)

+ func (_Registry *RegistrySession) AccountAtHash(hash [32]byte, index *big.Int) (common.Address, uint8, bool, common.Address, [32]byte, error)

+ func (_Registry *RegistrySession) AccountExists(addr common.Address) (bool, error)

+ func (_Registry *RegistrySession) AccountFrozen(addr common.Address) (bool, error)

+ func (_Registry *RegistrySession) AccountGet(addr common.Address) (uint8, bool, common.Address, [32]byte, error)

+ func (_Registry *RegistrySession) AccountHash(addr common.Address) ([32]byte, error)

+ func (_Registry *RegistrySession) AccountIndexOf(addr common.Address) (*big.Int, error)

+ func (_Registry *RegistrySession) AccountKind(addr common.Address) (uint8, error)

+ func (_Registry *RegistrySession) AccountKindAndFrozen(addr common.Address) (uint8, bool, error)

+ func (_Registry *RegistrySession) AccountKindAndFrozenAddress(addr common.Address) (uint8, common.Address, error)

+ func (_Registry *RegistrySession) AccountKindAndFrozenAddressLineage(addr common.Address) (uint8, common.Address, []common.Address, error)

+ func (_Registry *RegistrySession) AccountKindExists(addr common.Address, kind uint8) (bool, error)

+ func (_Registry *RegistrySession) AccountLineage(addresses []common.Address) ([]common.Address, error)

+ func (_Registry *RegistrySession) AccountParent(addr common.Address) (common.Address, error)

+ func (_Registry *RegistrySession) Accounts() (*big.Int, error)

+ func (_Registry *RegistrySession) AddAccount(addr common.Address, kind uint8, isFrozen bool, parent common.Address, ...) (*types.Transaction, error)

+ func (_Registry *RegistrySession) AddressAtHash(hash [32]byte, index *big.Int) (common.Address, error)

+ func (_Registry *RegistrySession) Data(arg0 common.Address, arg1 uint8) ([32]byte, error)

+ func (_Registry *RegistrySession) Hashes(arg0 [32]byte) (*big.Int, error)

+ func (_Registry *RegistrySession) IsLocked() (bool, error)

+ func (_Registry *RegistrySession) Kill() (*types.Transaction, error)

+ func (_Registry *RegistrySession) LineageCount(addr common.Address) (*big.Int, error)

+ func (_Registry *RegistrySession) Owner() (common.Address, error)

+ func (_Registry *RegistrySession) PermissionAt(kind uint8, index *big.Int) (common.Address, error)

+ func (_Registry *RegistrySession) PermissionExists(kind uint8, addr common.Address) (bool, error)

+ func (_Registry *RegistrySession) PermissionIndexOf(kind uint8, addr common.Address) (*big.Int, error)

+ func (_Registry *RegistrySession) Permissions(arg0 uint8) (*big.Int, error)

+ func (_Registry *RegistrySession) RemoveAccount(addr common.Address) (*types.Transaction, error)

+ func (_Registry *RegistrySession) SetAccountData(addr common.Address, index uint8, customData [32]byte) (*types.Transaction, error)

+ func (_Registry *RegistrySession) SetAccountFrozen(addr common.Address, frozen bool) (*types.Transaction, error)

+ func (_Registry *RegistrySession) SetAccountHash(addr common.Address, hash [32]byte) (*types.Transaction, error)

+ func (_Registry *RegistrySession) SetAccountParent(addr common.Address, parent common.Address) (*types.Transaction, error)

+ func (_Registry *RegistrySession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_Registry *RegistrySession) SetPermission(kind uint8, addr common.Address, grant bool) (*types.Transaction, error)

+ func (_Registry *RegistrySession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

+ func (_Registry *RegistrySession) ZEROADDRESS() (common.Address, error)

+ type RegistryTransactor struct

+ func NewRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*RegistryTransactor, error)

+ func (_Registry *RegistryTransactor) AddAccount(opts *bind.TransactOpts, addr common.Address, kind uint8, isFrozen bool, ...) (*types.Transaction, error)

+ func (_Registry *RegistryTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Registry *RegistryTransactor) RemoveAccount(opts *bind.TransactOpts, addr common.Address) (*types.Transaction, error)

+ func (_Registry *RegistryTransactor) SetAccountData(opts *bind.TransactOpts, addr common.Address, index uint8, customData [32]byte) (*types.Transaction, error)

+ func (_Registry *RegistryTransactor) SetAccountFrozen(opts *bind.TransactOpts, addr common.Address, frozen bool) (*types.Transaction, error)

+ func (_Registry *RegistryTransactor) SetAccountHash(opts *bind.TransactOpts, addr common.Address, hash [32]byte) (*types.Transaction, error)

+ func (_Registry *RegistryTransactor) SetAccountParent(opts *bind.TransactOpts, addr common.Address, parent common.Address) (*types.Transaction, error)

+ func (_Registry *RegistryTransactor) SetLocked(opts *bind.TransactOpts, locked bool) (*types.Transaction, error)

+ func (_Registry *RegistryTransactor) SetPermission(opts *bind.TransactOpts, kind uint8, addr common.Address, grant bool) (*types.Transaction, error)

+ func (_Registry *RegistryTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type RegistryTransactorRaw struct

+ Contract *RegistryTransactor

+ func (_Registry *RegistryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Registry *RegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type RegistryTransactorSession struct

+ Contract *RegistryTransactor

+ TransactOpts bind.TransactOpts

+ func (_Registry *RegistryTransactorSession) AddAccount(addr common.Address, kind uint8, isFrozen bool, parent common.Address, ...) (*types.Transaction, error)

+ func (_Registry *RegistryTransactorSession) Kill() (*types.Transaction, error)

+ func (_Registry *RegistryTransactorSession) RemoveAccount(addr common.Address) (*types.Transaction, error)

+ func (_Registry *RegistryTransactorSession) SetAccountData(addr common.Address, index uint8, customData [32]byte) (*types.Transaction, error)

+ func (_Registry *RegistryTransactorSession) SetAccountFrozen(addr common.Address, frozen bool) (*types.Transaction, error)

+ func (_Registry *RegistryTransactorSession) SetAccountHash(addr common.Address, hash [32]byte) (*types.Transaction, error)

+ func (_Registry *RegistryTransactorSession) SetAccountParent(addr common.Address, parent common.Address) (*types.Transaction, error)

+ func (_Registry *RegistryTransactorSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_Registry *RegistryTransactorSession) SetPermission(kind uint8, addr common.Address, grant bool) (*types.Transaction, error)

+ func (_Registry *RegistryTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

v0.0.5

May 15, 2019

v0.0.3

Mar 14, 2019

v0.0.2

Feb 15, 2019

Changes in this version

+ const BrokerDealerABI

+ const BrokerDealerBin

+ const CustodianABI

+ const CustodianBin

+ const ExternalInvestorABI

+ const ExternalInvestorBin

+ const InvestorABI

+ const InvestorBin

+ const StorageABI

+ const StorageBin

+ type BrokerDealer struct

+ func DeployBrokerDealer(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BrokerDealer, error)

+ func NewBrokerDealer(address common.Address, backend bind.ContractBackend) (*BrokerDealer, error)

+ type BrokerDealerBrokerDealerAdded struct

+ BrokerDealer common.Address

+ Owner common.Address

+ Raw types.Log

+ type BrokerDealerBrokerDealerAddedIterator struct

+ Event *BrokerDealerBrokerDealerAdded

+ func (it *BrokerDealerBrokerDealerAddedIterator) Close() error

+ func (it *BrokerDealerBrokerDealerAddedIterator) Error() error

+ func (it *BrokerDealerBrokerDealerAddedIterator) Next() bool

+ type BrokerDealerBrokerDealerFrozen struct

+ BrokerDealer common.Address

+ Frozen bool

+ Owner common.Address

+ Raw types.Log

+ type BrokerDealerBrokerDealerFrozenIterator struct

+ Event *BrokerDealerBrokerDealerFrozen

+ func (it *BrokerDealerBrokerDealerFrozenIterator) Close() error

+ func (it *BrokerDealerBrokerDealerFrozenIterator) Error() error

+ func (it *BrokerDealerBrokerDealerFrozenIterator) Next() bool

+ type BrokerDealerBrokerDealerRemoved struct

+ BrokerDealer common.Address

+ Owner common.Address

+ Raw types.Log

+ type BrokerDealerBrokerDealerRemovedIterator struct

+ Event *BrokerDealerBrokerDealerRemoved

+ func (it *BrokerDealerBrokerDealerRemovedIterator) Close() error

+ func (it *BrokerDealerBrokerDealerRemovedIterator) Error() error

+ func (it *BrokerDealerBrokerDealerRemovedIterator) Next() bool

+ type BrokerDealerCaller struct

+ func NewBrokerDealerCaller(address common.Address, caller bind.ContractCaller) (*BrokerDealerCaller, error)

+ func (_BrokerDealer *BrokerDealerCaller) IsLocked(opts *bind.CallOpts) (bool, error)

+ func (_BrokerDealer *BrokerDealerCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_BrokerDealer *BrokerDealerCaller) Store(opts *bind.CallOpts) (common.Address, error)

+ type BrokerDealerCallerRaw struct

+ Contract *BrokerDealerCaller

+ func (_BrokerDealer *BrokerDealerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type BrokerDealerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BrokerDealerCaller

+ func (_BrokerDealer *BrokerDealerCallerSession) IsLocked() (bool, error)

+ func (_BrokerDealer *BrokerDealerCallerSession) Owner() (common.Address, error)

+ func (_BrokerDealer *BrokerDealerCallerSession) Store() (common.Address, error)

+ type BrokerDealerFilterer struct

+ func NewBrokerDealerFilterer(address common.Address, filterer bind.ContractFilterer) (*BrokerDealerFilterer, error)

+ func (_BrokerDealer *BrokerDealerFilterer) FilterBrokerDealerAdded(opts *bind.FilterOpts, brokerDealer []common.Address, owner []common.Address) (*BrokerDealerBrokerDealerAddedIterator, error)

+ func (_BrokerDealer *BrokerDealerFilterer) FilterBrokerDealerFrozen(opts *bind.FilterOpts, brokerDealer []common.Address, frozen []bool, ...) (*BrokerDealerBrokerDealerFrozenIterator, error)

+ func (_BrokerDealer *BrokerDealerFilterer) FilterBrokerDealerRemoved(opts *bind.FilterOpts, brokerDealer []common.Address, owner []common.Address) (*BrokerDealerBrokerDealerRemovedIterator, error)

+ func (_BrokerDealer *BrokerDealerFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*BrokerDealerOwnerTransferredIterator, error)

+ func (_BrokerDealer *BrokerDealerFilterer) WatchBrokerDealerAdded(opts *bind.WatchOpts, sink chan<- *BrokerDealerBrokerDealerAdded, ...) (event.Subscription, error)

+ func (_BrokerDealer *BrokerDealerFilterer) WatchBrokerDealerFrozen(opts *bind.WatchOpts, sink chan<- *BrokerDealerBrokerDealerFrozen, ...) (event.Subscription, error)

+ func (_BrokerDealer *BrokerDealerFilterer) WatchBrokerDealerRemoved(opts *bind.WatchOpts, sink chan<- *BrokerDealerBrokerDealerRemoved, ...) (event.Subscription, error)

+ func (_BrokerDealer *BrokerDealerFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *BrokerDealerOwnerTransferred, ...) (event.Subscription, error)

+ type BrokerDealerOwnerTransferred struct

+ NewOwner common.Address

+ OldOwner common.Address

+ Raw types.Log

+ type BrokerDealerOwnerTransferredIterator struct

+ Event *BrokerDealerOwnerTransferred

+ func (it *BrokerDealerOwnerTransferredIterator) Close() error

+ func (it *BrokerDealerOwnerTransferredIterator) Error() error

+ func (it *BrokerDealerOwnerTransferredIterator) Next() bool

+ type BrokerDealerRaw struct

+ Contract *BrokerDealer

+ func (_BrokerDealer *BrokerDealerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_BrokerDealer *BrokerDealerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BrokerDealerSession struct

+ CallOpts bind.CallOpts

+ Contract *BrokerDealer

+ TransactOpts bind.TransactOpts

+ func (_BrokerDealer *BrokerDealerSession) Add(brokerDealer common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerSession) AddAccount(brokerDealer common.Address, account common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerSession) IsLocked() (bool, error)

+ func (_BrokerDealer *BrokerDealerSession) Kill() (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerSession) Owner() (common.Address, error)

+ func (_BrokerDealer *BrokerDealerSession) Remove(brokerDealer common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerSession) RemoveAccount(account common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerSession) SetFrozen(brokerDealer common.Address, frozen bool) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerSession) SetStorage(s common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerSession) Store() (common.Address, error)

+ func (_BrokerDealer *BrokerDealerSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

+ type BrokerDealerTransactor struct

+ func NewBrokerDealerTransactor(address common.Address, transactor bind.ContractTransactor) (*BrokerDealerTransactor, error)

+ func (_BrokerDealer *BrokerDealerTransactor) Add(opts *bind.TransactOpts, brokerDealer common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactor) AddAccount(opts *bind.TransactOpts, brokerDealer common.Address, account common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactor) Remove(opts *bind.TransactOpts, brokerDealer common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactor) RemoveAccount(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactor) SetFrozen(opts *bind.TransactOpts, brokerDealer common.Address, frozen bool) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactor) SetLocked(opts *bind.TransactOpts, locked bool) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactor) SetStorage(opts *bind.TransactOpts, s common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type BrokerDealerTransactorRaw struct

+ Contract *BrokerDealerTransactor

+ func (_BrokerDealer *BrokerDealerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BrokerDealerTransactorSession struct

+ Contract *BrokerDealerTransactor

+ TransactOpts bind.TransactOpts

+ func (_BrokerDealer *BrokerDealerTransactorSession) Add(brokerDealer common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactorSession) AddAccount(brokerDealer common.Address, account common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactorSession) Kill() (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactorSession) Remove(brokerDealer common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactorSession) RemoveAccount(account common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactorSession) SetFrozen(brokerDealer common.Address, frozen bool) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactorSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactorSession) SetStorage(s common.Address) (*types.Transaction, error)

+ func (_BrokerDealer *BrokerDealerTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

+ type Custodian struct

+ func DeployCustodian(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Custodian, error)

+ func NewCustodian(address common.Address, backend bind.ContractBackend) (*Custodian, error)

+ type CustodianCaller struct

+ func NewCustodianCaller(address common.Address, caller bind.ContractCaller) (*CustodianCaller, error)

+ func (_Custodian *CustodianCaller) IsLocked(opts *bind.CallOpts) (bool, error)

+ func (_Custodian *CustodianCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Custodian *CustodianCaller) Store(opts *bind.CallOpts) (common.Address, error)

+ type CustodianCallerRaw struct

+ Contract *CustodianCaller

+ func (_Custodian *CustodianCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type CustodianCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *CustodianCaller

+ func (_Custodian *CustodianCallerSession) IsLocked() (bool, error)

+ func (_Custodian *CustodianCallerSession) Owner() (common.Address, error)

+ func (_Custodian *CustodianCallerSession) Store() (common.Address, error)

+ type CustodianCustodianAdded struct

+ Custodian common.Address

+ Owner common.Address

+ Raw types.Log

+ type CustodianCustodianAddedIterator struct

+ Event *CustodianCustodianAdded

+ func (it *CustodianCustodianAddedIterator) Close() error

+ func (it *CustodianCustodianAddedIterator) Error() error

+ func (it *CustodianCustodianAddedIterator) Next() bool

+ type CustodianCustodianFrozen struct

+ Custodian common.Address

+ Frozen bool

+ Owner common.Address

+ Raw types.Log

+ type CustodianCustodianFrozenIterator struct

+ Event *CustodianCustodianFrozen

+ func (it *CustodianCustodianFrozenIterator) Close() error

+ func (it *CustodianCustodianFrozenIterator) Error() error

+ func (it *CustodianCustodianFrozenIterator) Next() bool

+ type CustodianCustodianRemoved struct

+ Custodian common.Address

+ Owner common.Address

+ Raw types.Log

+ type CustodianCustodianRemovedIterator struct

+ Event *CustodianCustodianRemoved

+ func (it *CustodianCustodianRemovedIterator) Close() error

+ func (it *CustodianCustodianRemovedIterator) Error() error

+ func (it *CustodianCustodianRemovedIterator) Next() bool

+ type CustodianFilterer struct

+ func NewCustodianFilterer(address common.Address, filterer bind.ContractFilterer) (*CustodianFilterer, error)

+ func (_Custodian *CustodianFilterer) FilterCustodianAdded(opts *bind.FilterOpts, custodian []common.Address, owner []common.Address) (*CustodianCustodianAddedIterator, error)

+ func (_Custodian *CustodianFilterer) FilterCustodianFrozen(opts *bind.FilterOpts, custodian []common.Address, frozen []bool, ...) (*CustodianCustodianFrozenIterator, error)

+ func (_Custodian *CustodianFilterer) FilterCustodianRemoved(opts *bind.FilterOpts, custodian []common.Address, owner []common.Address) (*CustodianCustodianRemovedIterator, error)

+ func (_Custodian *CustodianFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*CustodianOwnerTransferredIterator, error)

+ func (_Custodian *CustodianFilterer) WatchCustodianAdded(opts *bind.WatchOpts, sink chan<- *CustodianCustodianAdded, ...) (event.Subscription, error)

+ func (_Custodian *CustodianFilterer) WatchCustodianFrozen(opts *bind.WatchOpts, sink chan<- *CustodianCustodianFrozen, ...) (event.Subscription, error)

+ func (_Custodian *CustodianFilterer) WatchCustodianRemoved(opts *bind.WatchOpts, sink chan<- *CustodianCustodianRemoved, ...) (event.Subscription, error)

+ func (_Custodian *CustodianFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *CustodianOwnerTransferred, ...) (event.Subscription, error)

+ type CustodianOwnerTransferred struct

+ NewOwner common.Address

+ OldOwner common.Address

+ Raw types.Log

+ type CustodianOwnerTransferredIterator struct

+ Event *CustodianOwnerTransferred

+ func (it *CustodianOwnerTransferredIterator) Close() error

+ func (it *CustodianOwnerTransferredIterator) Error() error

+ func (it *CustodianOwnerTransferredIterator) Next() bool

+ type CustodianRaw struct

+ Contract *Custodian

+ func (_Custodian *CustodianRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_Custodian *CustodianRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Custodian *CustodianRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CustodianSession struct

+ CallOpts bind.CallOpts

+ Contract *Custodian

+ TransactOpts bind.TransactOpts

+ func (_Custodian *CustodianSession) Add(custodian common.Address) (*types.Transaction, error)

+ func (_Custodian *CustodianSession) IsLocked() (bool, error)

+ func (_Custodian *CustodianSession) Kill() (*types.Transaction, error)

+ func (_Custodian *CustodianSession) Owner() (common.Address, error)

+ func (_Custodian *CustodianSession) Remove(custodian common.Address) (*types.Transaction, error)

+ func (_Custodian *CustodianSession) SetFrozen(custodian common.Address, frozen bool) (*types.Transaction, error)

+ func (_Custodian *CustodianSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_Custodian *CustodianSession) SetStorage(s common.Address) (*types.Transaction, error)

+ func (_Custodian *CustodianSession) Store() (common.Address, error)

+ func (_Custodian *CustodianSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

+ type CustodianTransactor struct

+ func NewCustodianTransactor(address common.Address, transactor bind.ContractTransactor) (*CustodianTransactor, error)

+ func (_Custodian *CustodianTransactor) Add(opts *bind.TransactOpts, custodian common.Address) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactor) Remove(opts *bind.TransactOpts, custodian common.Address) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactor) SetFrozen(opts *bind.TransactOpts, custodian common.Address, frozen bool) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactor) SetLocked(opts *bind.TransactOpts, locked bool) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactor) SetStorage(opts *bind.TransactOpts, s common.Address) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type CustodianTransactorRaw struct

+ Contract *CustodianTransactor

+ func (_Custodian *CustodianTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CustodianTransactorSession struct

+ Contract *CustodianTransactor

+ TransactOpts bind.TransactOpts

+ func (_Custodian *CustodianTransactorSession) Add(custodian common.Address) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactorSession) Kill() (*types.Transaction, error)

+ func (_Custodian *CustodianTransactorSession) Remove(custodian common.Address) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactorSession) SetFrozen(custodian common.Address, frozen bool) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactorSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactorSession) SetStorage(s common.Address) (*types.Transaction, error)

+ func (_Custodian *CustodianTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

+ type ExternalInvestor struct

+ func DeployExternalInvestor(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ExternalInvestor, error)

+ func NewExternalInvestor(address common.Address, backend bind.ContractBackend) (*ExternalInvestor, error)

+ type ExternalInvestorAdminAdded struct

+ Admin common.Address

+ Raw types.Log

+ type ExternalInvestorAdminAddedIterator struct

+ Event *ExternalInvestorAdminAdded

+ func (it *ExternalInvestorAdminAddedIterator) Close() error

+ func (it *ExternalInvestorAdminAddedIterator) Error() error

+ func (it *ExternalInvestorAdminAddedIterator) Next() bool

+ type ExternalInvestorAdminRemoved struct

+ Admin common.Address

+ Raw types.Log

+ type ExternalInvestorAdminRemovedIterator struct

+ Event *ExternalInvestorAdminRemoved

+ func (it *ExternalInvestorAdminRemovedIterator) Close() error

+ func (it *ExternalInvestorAdminRemovedIterator) Error() error

+ func (it *ExternalInvestorAdminRemovedIterator) Next() bool

+ type ExternalInvestorCaller struct

+ func NewExternalInvestorCaller(address common.Address, caller bind.ContractCaller) (*ExternalInvestorCaller, error)

+ func (_ExternalInvestor *ExternalInvestorCaller) Admins(opts *bind.CallOpts) (*big.Int, error)

+ func (_ExternalInvestor *ExternalInvestorCaller) GetAccreditation(opts *bind.CallOpts, addr common.Address) (*big.Int, error)

+ func (_ExternalInvestor *ExternalInvestorCaller) GetCountry(opts *bind.CallOpts, addr common.Address) ([2]byte, error)

+ func (_ExternalInvestor *ExternalInvestorCaller) GetHash(opts *bind.CallOpts, addr common.Address) ([32]byte, error)

+ func (_ExternalInvestor *ExternalInvestorCaller) IsAdmin(opts *bind.CallOpts, addr common.Address) (bool, error)

+ func (_ExternalInvestor *ExternalInvestorCaller) IsLocked(opts *bind.CallOpts) (bool, error)

+ func (_ExternalInvestor *ExternalInvestorCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_ExternalInvestor *ExternalInvestorCaller) Store(opts *bind.CallOpts) (common.Address, error)

+ type ExternalInvestorCallerRaw struct

+ Contract *ExternalInvestorCaller

+ func (_ExternalInvestor *ExternalInvestorCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ExternalInvestorCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ExternalInvestorCaller

+ func (_ExternalInvestor *ExternalInvestorCallerSession) Admins() (*big.Int, error)

+ func (_ExternalInvestor *ExternalInvestorCallerSession) GetAccreditation(addr common.Address) (*big.Int, error)

+ func (_ExternalInvestor *ExternalInvestorCallerSession) GetCountry(addr common.Address) ([2]byte, error)

+ func (_ExternalInvestor *ExternalInvestorCallerSession) GetHash(addr common.Address) ([32]byte, error)

+ func (_ExternalInvestor *ExternalInvestorCallerSession) IsAdmin(addr common.Address) (bool, error)

+ func (_ExternalInvestor *ExternalInvestorCallerSession) IsLocked() (bool, error)

+ func (_ExternalInvestor *ExternalInvestorCallerSession) Owner() (common.Address, error)

+ func (_ExternalInvestor *ExternalInvestorCallerSession) Store() (common.Address, error)

+ type ExternalInvestorFilterer struct

+ func NewExternalInvestorFilterer(address common.Address, filterer bind.ContractFilterer) (*ExternalInvestorFilterer, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) FilterAdminAdded(opts *bind.FilterOpts, admin []common.Address) (*ExternalInvestorAdminAddedIterator, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) FilterAdminRemoved(opts *bind.FilterOpts, admin []common.Address) (*ExternalInvestorAdminRemovedIterator, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) FilterInvestorAdded(opts *bind.FilterOpts, investor []common.Address, owner []common.Address) (*ExternalInvestorInvestorAddedIterator, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) FilterInvestorFrozen(opts *bind.FilterOpts, investor []common.Address, frozen []bool, ...) (*ExternalInvestorInvestorFrozenIterator, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) FilterInvestorRemoved(opts *bind.FilterOpts, investor []common.Address, owner []common.Address) (*ExternalInvestorInvestorRemovedIterator, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*ExternalInvestorOwnerTransferredIterator, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) WatchAdminAdded(opts *bind.WatchOpts, sink chan<- *ExternalInvestorAdminAdded, ...) (event.Subscription, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) WatchAdminRemoved(opts *bind.WatchOpts, sink chan<- *ExternalInvestorAdminRemoved, ...) (event.Subscription, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) WatchInvestorAdded(opts *bind.WatchOpts, sink chan<- *ExternalInvestorInvestorAdded, ...) (event.Subscription, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) WatchInvestorFrozen(opts *bind.WatchOpts, sink chan<- *ExternalInvestorInvestorFrozen, ...) (event.Subscription, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) WatchInvestorRemoved(opts *bind.WatchOpts, sink chan<- *ExternalInvestorInvestorRemoved, ...) (event.Subscription, error)

+ func (_ExternalInvestor *ExternalInvestorFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *ExternalInvestorOwnerTransferred, ...) (event.Subscription, error)

+ type ExternalInvestorInvestorAdded struct

+ Investor common.Address

+ Owner common.Address

+ Raw types.Log

+ type ExternalInvestorInvestorAddedIterator struct

+ Event *ExternalInvestorInvestorAdded

+ func (it *ExternalInvestorInvestorAddedIterator) Close() error

+ func (it *ExternalInvestorInvestorAddedIterator) Error() error

+ func (it *ExternalInvestorInvestorAddedIterator) Next() bool

+ type ExternalInvestorInvestorFrozen struct

+ Frozen bool

+ Investor common.Address

+ Owner common.Address

+ Raw types.Log

+ type ExternalInvestorInvestorFrozenIterator struct

+ Event *ExternalInvestorInvestorFrozen

+ func (it *ExternalInvestorInvestorFrozenIterator) Close() error

+ func (it *ExternalInvestorInvestorFrozenIterator) Error() error

+ func (it *ExternalInvestorInvestorFrozenIterator) Next() bool

+ type ExternalInvestorInvestorRemoved struct

+ Investor common.Address

+ Owner common.Address

+ Raw types.Log

+ type ExternalInvestorInvestorRemovedIterator struct

+ Event *ExternalInvestorInvestorRemoved

+ func (it *ExternalInvestorInvestorRemovedIterator) Close() error

+ func (it *ExternalInvestorInvestorRemovedIterator) Error() error

+ func (it *ExternalInvestorInvestorRemovedIterator) Next() bool

+ type ExternalInvestorOwnerTransferred struct

+ NewOwner common.Address

+ OldOwner common.Address

+ Raw types.Log

+ type ExternalInvestorOwnerTransferredIterator struct

+ Event *ExternalInvestorOwnerTransferred

+ func (it *ExternalInvestorOwnerTransferredIterator) Close() error

+ func (it *ExternalInvestorOwnerTransferredIterator) Error() error

+ func (it *ExternalInvestorOwnerTransferredIterator) Next() bool

+ type ExternalInvestorRaw struct

+ Contract *ExternalInvestor

+ func (_ExternalInvestor *ExternalInvestorRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ExternalInvestor *ExternalInvestorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ExternalInvestorSession struct

+ CallOpts bind.CallOpts

+ Contract *ExternalInvestor

+ TransactOpts bind.TransactOpts

+ func (_ExternalInvestor *ExternalInvestorSession) Add(investor common.Address, hash [32]byte, country [2]byte, ...) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) AddAdmin(admin common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) Admins() (*big.Int, error)

+ func (_ExternalInvestor *ExternalInvestorSession) GetAccreditation(addr common.Address) (*big.Int, error)

+ func (_ExternalInvestor *ExternalInvestorSession) GetCountry(addr common.Address) ([2]byte, error)

+ func (_ExternalInvestor *ExternalInvestorSession) GetHash(addr common.Address) ([32]byte, error)

+ func (_ExternalInvestor *ExternalInvestorSession) IsAdmin(addr common.Address) (bool, error)

+ func (_ExternalInvestor *ExternalInvestorSession) IsLocked() (bool, error)

+ func (_ExternalInvestor *ExternalInvestorSession) Kill() (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) Owner() (common.Address, error)

+ func (_ExternalInvestor *ExternalInvestorSession) Remove(investor common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) RemoveAdmin(admin common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) SetAccreditation(investor common.Address, accreditation *big.Int) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) SetCountry(investor common.Address, country [2]byte) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) SetFrozen(investor common.Address, frozen bool) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) SetHash(investor common.Address, hash [32]byte) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) SetStorage(s common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorSession) Store() (common.Address, error)

+ func (_ExternalInvestor *ExternalInvestorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

+ type ExternalInvestorTransactor struct

+ func NewExternalInvestorTransactor(address common.Address, transactor bind.ContractTransactor) (*ExternalInvestorTransactor, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) Add(opts *bind.TransactOpts, investor common.Address, hash [32]byte, ...) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) AddAdmin(opts *bind.TransactOpts, admin common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) Remove(opts *bind.TransactOpts, investor common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) RemoveAdmin(opts *bind.TransactOpts, admin common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) SetAccreditation(opts *bind.TransactOpts, investor common.Address, accreditation *big.Int) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) SetCountry(opts *bind.TransactOpts, investor common.Address, country [2]byte) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) SetFrozen(opts *bind.TransactOpts, investor common.Address, frozen bool) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) SetHash(opts *bind.TransactOpts, investor common.Address, hash [32]byte) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) SetLocked(opts *bind.TransactOpts, locked bool) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) SetStorage(opts *bind.TransactOpts, s common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type ExternalInvestorTransactorRaw struct

+ Contract *ExternalInvestorTransactor

+ func (_ExternalInvestor *ExternalInvestorTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ExternalInvestorTransactorSession struct

+ Contract *ExternalInvestorTransactor

+ TransactOpts bind.TransactOpts

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) Add(investor common.Address, hash [32]byte, country [2]byte, ...) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) AddAdmin(admin common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) Kill() (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) Remove(investor common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) RemoveAdmin(admin common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) SetAccreditation(investor common.Address, accreditation *big.Int) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) SetCountry(investor common.Address, country [2]byte) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) SetFrozen(investor common.Address, frozen bool) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) SetHash(investor common.Address, hash [32]byte) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) SetStorage(s common.Address) (*types.Transaction, error)

+ func (_ExternalInvestor *ExternalInvestorTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

+ type Investor struct

+ func DeployInvestor(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Investor, error)

+ func NewInvestor(address common.Address, backend bind.ContractBackend) (*Investor, error)

+ type InvestorCaller struct

+ func NewInvestorCaller(address common.Address, caller bind.ContractCaller) (*InvestorCaller, error)

+ func (_Investor *InvestorCaller) GetAccreditation(opts *bind.CallOpts, addr common.Address) (*big.Int, error)

+ func (_Investor *InvestorCaller) GetCountry(opts *bind.CallOpts, addr common.Address) ([2]byte, error)

+ func (_Investor *InvestorCaller) GetHash(opts *bind.CallOpts, addr common.Address) ([32]byte, error)

+ func (_Investor *InvestorCaller) IsLocked(opts *bind.CallOpts) (bool, error)

+ func (_Investor *InvestorCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Investor *InvestorCaller) Store(opts *bind.CallOpts) (common.Address, error)

+ type InvestorCallerRaw struct

+ Contract *InvestorCaller

+ func (_Investor *InvestorCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type InvestorCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *InvestorCaller

+ func (_Investor *InvestorCallerSession) GetAccreditation(addr common.Address) (*big.Int, error)

+ func (_Investor *InvestorCallerSession) GetCountry(addr common.Address) ([2]byte, error)

+ func (_Investor *InvestorCallerSession) GetHash(addr common.Address) ([32]byte, error)

+ func (_Investor *InvestorCallerSession) IsLocked() (bool, error)

+ func (_Investor *InvestorCallerSession) Owner() (common.Address, error)

+ func (_Investor *InvestorCallerSession) Store() (common.Address, error)

+ type InvestorFilterer struct

+ func NewInvestorFilterer(address common.Address, filterer bind.ContractFilterer) (*InvestorFilterer, error)

+ func (_Investor *InvestorFilterer) FilterInvestorAdded(opts *bind.FilterOpts, investor []common.Address, owner []common.Address) (*InvestorInvestorAddedIterator, error)

+ func (_Investor *InvestorFilterer) FilterInvestorFrozen(opts *bind.FilterOpts, investor []common.Address, frozen []bool, ...) (*InvestorInvestorFrozenIterator, error)

+ func (_Investor *InvestorFilterer) FilterInvestorRemoved(opts *bind.FilterOpts, investor []common.Address, owner []common.Address) (*InvestorInvestorRemovedIterator, error)

+ func (_Investor *InvestorFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*InvestorOwnerTransferredIterator, error)

+ func (_Investor *InvestorFilterer) WatchInvestorAdded(opts *bind.WatchOpts, sink chan<- *InvestorInvestorAdded, ...) (event.Subscription, error)

+ func (_Investor *InvestorFilterer) WatchInvestorFrozen(opts *bind.WatchOpts, sink chan<- *InvestorInvestorFrozen, ...) (event.Subscription, error)

+ func (_Investor *InvestorFilterer) WatchInvestorRemoved(opts *bind.WatchOpts, sink chan<- *InvestorInvestorRemoved, ...) (event.Subscription, error)

+ func (_Investor *InvestorFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *InvestorOwnerTransferred, ...) (event.Subscription, error)

+ type InvestorInvestorAdded struct

+ Investor common.Address

+ Owner common.Address

+ Raw types.Log

+ type InvestorInvestorAddedIterator struct

+ Event *InvestorInvestorAdded

+ func (it *InvestorInvestorAddedIterator) Close() error

+ func (it *InvestorInvestorAddedIterator) Error() error

+ func (it *InvestorInvestorAddedIterator) Next() bool

+ type InvestorInvestorFrozen struct

+ Frozen bool

+ Investor common.Address

+ Owner common.Address

+ Raw types.Log

+ type InvestorInvestorFrozenIterator struct

+ Event *InvestorInvestorFrozen

+ func (it *InvestorInvestorFrozenIterator) Close() error

+ func (it *InvestorInvestorFrozenIterator) Error() error

+ func (it *InvestorInvestorFrozenIterator) Next() bool

+ type InvestorInvestorRemoved struct

+ Investor common.Address

+ Owner common.Address

+ Raw types.Log

+ type InvestorInvestorRemovedIterator struct

+ Event *InvestorInvestorRemoved

+ func (it *InvestorInvestorRemovedIterator) Close() error

+ func (it *InvestorInvestorRemovedIterator) Error() error

+ func (it *InvestorInvestorRemovedIterator) Next() bool

+ type InvestorOwnerTransferred struct

+ NewOwner common.Address

+ OldOwner common.Address

+ Raw types.Log

+ type InvestorOwnerTransferredIterator struct

+ Event *InvestorOwnerTransferred

+ func (it *InvestorOwnerTransferredIterator) Close() error

+ func (it *InvestorOwnerTransferredIterator) Error() error

+ func (it *InvestorOwnerTransferredIterator) Next() bool

+ type InvestorRaw struct

+ Contract *Investor

+ func (_Investor *InvestorRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_Investor *InvestorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Investor *InvestorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InvestorSession struct

+ CallOpts bind.CallOpts

+ Contract *Investor

+ TransactOpts bind.TransactOpts

+ func (_Investor *InvestorSession) Add(investor common.Address, hash [32]byte, country [2]byte, ...) (*types.Transaction, error)

+ func (_Investor *InvestorSession) GetAccreditation(addr common.Address) (*big.Int, error)

+ func (_Investor *InvestorSession) GetCountry(addr common.Address) ([2]byte, error)

+ func (_Investor *InvestorSession) GetHash(addr common.Address) ([32]byte, error)

+ func (_Investor *InvestorSession) IsLocked() (bool, error)

+ func (_Investor *InvestorSession) Kill() (*types.Transaction, error)

+ func (_Investor *InvestorSession) Owner() (common.Address, error)

+ func (_Investor *InvestorSession) Remove(investor common.Address) (*types.Transaction, error)

+ func (_Investor *InvestorSession) SetAccreditation(investor common.Address, accreditation *big.Int) (*types.Transaction, error)

+ func (_Investor *InvestorSession) SetCountry(investor common.Address, country [2]byte) (*types.Transaction, error)

+ func (_Investor *InvestorSession) SetFrozen(investor common.Address, frozen bool) (*types.Transaction, error)

+ func (_Investor *InvestorSession) SetHash(investor common.Address, hash [32]byte) (*types.Transaction, error)

+ func (_Investor *InvestorSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_Investor *InvestorSession) SetStorage(s common.Address) (*types.Transaction, error)

+ func (_Investor *InvestorSession) Store() (common.Address, error)

+ func (_Investor *InvestorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

+ type InvestorTransactor struct

+ func NewInvestorTransactor(address common.Address, transactor bind.ContractTransactor) (*InvestorTransactor, error)

+ func (_Investor *InvestorTransactor) Add(opts *bind.TransactOpts, investor common.Address, hash [32]byte, ...) (*types.Transaction, error)

+ func (_Investor *InvestorTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Investor *InvestorTransactor) Remove(opts *bind.TransactOpts, investor common.Address) (*types.Transaction, error)

+ func (_Investor *InvestorTransactor) SetAccreditation(opts *bind.TransactOpts, investor common.Address, accreditation *big.Int) (*types.Transaction, error)

+ func (_Investor *InvestorTransactor) SetCountry(opts *bind.TransactOpts, investor common.Address, country [2]byte) (*types.Transaction, error)

+ func (_Investor *InvestorTransactor) SetFrozen(opts *bind.TransactOpts, investor common.Address, frozen bool) (*types.Transaction, error)

+ func (_Investor *InvestorTransactor) SetHash(opts *bind.TransactOpts, investor common.Address, hash [32]byte) (*types.Transaction, error)

+ func (_Investor *InvestorTransactor) SetLocked(opts *bind.TransactOpts, locked bool) (*types.Transaction, error)

+ func (_Investor *InvestorTransactor) SetStorage(opts *bind.TransactOpts, s common.Address) (*types.Transaction, error)

+ func (_Investor *InvestorTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type InvestorTransactorRaw struct

+ Contract *InvestorTransactor

+ func (_Investor *InvestorTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Investor *InvestorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InvestorTransactorSession struct

+ Contract *InvestorTransactor

+ TransactOpts bind.TransactOpts

+ func (_Investor *InvestorTransactorSession) Add(investor common.Address, hash [32]byte, country [2]byte, ...) (*types.Transaction, error)

+ func (_Investor *InvestorTransactorSession) Kill() (*types.Transaction, error)

+ func (_Investor *InvestorTransactorSession) Remove(investor common.Address) (*types.Transaction, error)

+ func (_Investor *InvestorTransactorSession) SetAccreditation(investor common.Address, accreditation *big.Int) (*types.Transaction, error)

+ func (_Investor *InvestorTransactorSession) SetCountry(investor common.Address, country [2]byte) (*types.Transaction, error)

+ func (_Investor *InvestorTransactorSession) SetFrozen(investor common.Address, frozen bool) (*types.Transaction, error)

+ func (_Investor *InvestorTransactorSession) SetHash(investor common.Address, hash [32]byte) (*types.Transaction, error)

+ func (_Investor *InvestorTransactorSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_Investor *InvestorTransactorSession) SetStorage(s common.Address) (*types.Transaction, error)

+ func (_Investor *InvestorTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

+ type Storage struct

+ func DeployStorage(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Storage, error)

+ func NewStorage(address common.Address, backend bind.ContractBackend) (*Storage, error)

+ type StorageCaller struct

+ func NewStorageCaller(address common.Address, caller bind.ContractCaller) (*StorageCaller, error)

+ func (_Storage *StorageCaller) AccountAt(opts *bind.CallOpts, index *big.Int) (common.Address, uint8, bool, common.Address, error)

+ func (_Storage *StorageCaller) AccountExists(opts *bind.CallOpts, addr common.Address) (bool, error)

+ func (_Storage *StorageCaller) AccountFrozen(opts *bind.CallOpts, addr common.Address) (bool, error)

+ func (_Storage *StorageCaller) AccountGet(opts *bind.CallOpts, addr common.Address) (uint8, bool, common.Address, error)

+ func (_Storage *StorageCaller) AccountIndexOf(opts *bind.CallOpts, addr common.Address) (*big.Int, error)

+ func (_Storage *StorageCaller) AccountKind(opts *bind.CallOpts, addr common.Address) (uint8, error)

+ func (_Storage *StorageCaller) AccountParent(opts *bind.CallOpts, addr common.Address) (common.Address, error)

+ func (_Storage *StorageCaller) Accounts(opts *bind.CallOpts) (*big.Int, error)

+ func (_Storage *StorageCaller) Data(opts *bind.CallOpts, arg0 common.Address, arg1 uint8) ([32]byte, error)

+ func (_Storage *StorageCaller) IsLocked(opts *bind.CallOpts) (bool, error)

+ func (_Storage *StorageCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Storage *StorageCaller) PermissionAt(opts *bind.CallOpts, kind uint8, index *big.Int) (common.Address, error)

+ func (_Storage *StorageCaller) PermissionExists(opts *bind.CallOpts, kind uint8, addr common.Address) (bool, error)

+ func (_Storage *StorageCaller) PermissionIndexOf(opts *bind.CallOpts, kind uint8, addr common.Address) (*big.Int, error)

+ func (_Storage *StorageCaller) Permissions(opts *bind.CallOpts, arg0 uint8) (*big.Int, error)

+ type StorageCallerRaw struct

+ Contract *StorageCaller

+ func (_Storage *StorageCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type StorageCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *StorageCaller

+ func (_Storage *StorageCallerSession) AccountAt(index *big.Int) (common.Address, uint8, bool, common.Address, error)

+ func (_Storage *StorageCallerSession) AccountExists(addr common.Address) (bool, error)

+ func (_Storage *StorageCallerSession) AccountFrozen(addr common.Address) (bool, error)

+ func (_Storage *StorageCallerSession) AccountGet(addr common.Address) (uint8, bool, common.Address, error)

+ func (_Storage *StorageCallerSession) AccountIndexOf(addr common.Address) (*big.Int, error)

+ func (_Storage *StorageCallerSession) AccountKind(addr common.Address) (uint8, error)

+ func (_Storage *StorageCallerSession) AccountParent(addr common.Address) (common.Address, error)

+ func (_Storage *StorageCallerSession) Accounts() (*big.Int, error)

+ func (_Storage *StorageCallerSession) Data(arg0 common.Address, arg1 uint8) ([32]byte, error)

+ func (_Storage *StorageCallerSession) IsLocked() (bool, error)

+ func (_Storage *StorageCallerSession) Owner() (common.Address, error)

+ func (_Storage *StorageCallerSession) PermissionAt(kind uint8, index *big.Int) (common.Address, error)

+ func (_Storage *StorageCallerSession) PermissionExists(kind uint8, addr common.Address) (bool, error)

+ func (_Storage *StorageCallerSession) PermissionIndexOf(kind uint8, addr common.Address) (*big.Int, error)

+ func (_Storage *StorageCallerSession) Permissions(arg0 uint8) (*big.Int, error)

+ type StorageFilterer struct

+ func NewStorageFilterer(address common.Address, filterer bind.ContractFilterer) (*StorageFilterer, error)

+ func (_Storage *StorageFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*StorageOwnerTransferredIterator, error)

+ func (_Storage *StorageFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *StorageOwnerTransferred, ...) (event.Subscription, error)

+ type StorageOwnerTransferred struct

+ NewOwner common.Address

+ OldOwner common.Address

+ Raw types.Log

+ type StorageOwnerTransferredIterator struct

+ Event *StorageOwnerTransferred

+ func (it *StorageOwnerTransferredIterator) Close() error

+ func (it *StorageOwnerTransferredIterator) Error() error

+ func (it *StorageOwnerTransferredIterator) Next() bool

+ type StorageRaw struct

+ Contract *Storage

+ func (_Storage *StorageRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_Storage *StorageRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Storage *StorageRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StorageSession struct

+ CallOpts bind.CallOpts

+ Contract *Storage

+ TransactOpts bind.TransactOpts

+ func (_Storage *StorageSession) AccountAt(index *big.Int) (common.Address, uint8, bool, common.Address, error)

+ func (_Storage *StorageSession) AccountExists(addr common.Address) (bool, error)

+ func (_Storage *StorageSession) AccountFrozen(addr common.Address) (bool, error)

+ func (_Storage *StorageSession) AccountGet(addr common.Address) (uint8, bool, common.Address, error)

+ func (_Storage *StorageSession) AccountIndexOf(addr common.Address) (*big.Int, error)

+ func (_Storage *StorageSession) AccountKind(addr common.Address) (uint8, error)

+ func (_Storage *StorageSession) AccountParent(addr common.Address) (common.Address, error)

+ func (_Storage *StorageSession) Accounts() (*big.Int, error)

+ func (_Storage *StorageSession) AddAccount(addr common.Address, kind uint8, isFrozen bool, parent common.Address) (*types.Transaction, error)

+ func (_Storage *StorageSession) Data(arg0 common.Address, arg1 uint8) ([32]byte, error)

+ func (_Storage *StorageSession) GrantPermission(kind uint8, addr common.Address) (*types.Transaction, error)

+ func (_Storage *StorageSession) IsLocked() (bool, error)

+ func (_Storage *StorageSession) Kill() (*types.Transaction, error)

+ func (_Storage *StorageSession) Owner() (common.Address, error)

+ func (_Storage *StorageSession) PermissionAt(kind uint8, index *big.Int) (common.Address, error)

+ func (_Storage *StorageSession) PermissionExists(kind uint8, addr common.Address) (bool, error)

+ func (_Storage *StorageSession) PermissionIndexOf(kind uint8, addr common.Address) (*big.Int, error)

+ func (_Storage *StorageSession) Permissions(arg0 uint8) (*big.Int, error)

+ func (_Storage *StorageSession) RemoveAccount(addr common.Address) (*types.Transaction, error)

+ func (_Storage *StorageSession) RevokePermission(kind uint8, addr common.Address) (*types.Transaction, error)

+ func (_Storage *StorageSession) SetAccountData(addr common.Address, index uint8, customData [32]byte) (*types.Transaction, error)

+ func (_Storage *StorageSession) SetAccountFrozen(addr common.Address, frozen bool) (*types.Transaction, error)

+ func (_Storage *StorageSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_Storage *StorageSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

+ type StorageTransactor struct

+ func NewStorageTransactor(address common.Address, transactor bind.ContractTransactor) (*StorageTransactor, error)

+ func (_Storage *StorageTransactor) AddAccount(opts *bind.TransactOpts, addr common.Address, kind uint8, isFrozen bool, ...) (*types.Transaction, error)

+ func (_Storage *StorageTransactor) GrantPermission(opts *bind.TransactOpts, kind uint8, addr common.Address) (*types.Transaction, error)

+ func (_Storage *StorageTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Storage *StorageTransactor) RemoveAccount(opts *bind.TransactOpts, addr common.Address) (*types.Transaction, error)

+ func (_Storage *StorageTransactor) RevokePermission(opts *bind.TransactOpts, kind uint8, addr common.Address) (*types.Transaction, error)

+ func (_Storage *StorageTransactor) SetAccountData(opts *bind.TransactOpts, addr common.Address, index uint8, customData [32]byte) (*types.Transaction, error)

+ func (_Storage *StorageTransactor) SetAccountFrozen(opts *bind.TransactOpts, addr common.Address, frozen bool) (*types.Transaction, error)

+ func (_Storage *StorageTransactor) SetLocked(opts *bind.TransactOpts, locked bool) (*types.Transaction, error)

+ func (_Storage *StorageTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type StorageTransactorRaw struct

+ Contract *StorageTransactor

+ func (_Storage *StorageTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Storage *StorageTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StorageTransactorSession struct

+ Contract *StorageTransactor

+ TransactOpts bind.TransactOpts

+ func (_Storage *StorageTransactorSession) AddAccount(addr common.Address, kind uint8, isFrozen bool, parent common.Address) (*types.Transaction, error)

+ func (_Storage *StorageTransactorSession) GrantPermission(kind uint8, addr common.Address) (*types.Transaction, error)

+ func (_Storage *StorageTransactorSession) Kill() (*types.Transaction, error)

+ func (_Storage *StorageTransactorSession) RemoveAccount(addr common.Address) (*types.Transaction, error)

+ func (_Storage *StorageTransactorSession) RevokePermission(kind uint8, addr common.Address) (*types.Transaction, error)

+ func (_Storage *StorageTransactorSession) SetAccountData(addr common.Address, index uint8, customData [32]byte) (*types.Transaction, error)

+ func (_Storage *StorageTransactorSession) SetAccountFrozen(addr common.Address, frozen bool) (*types.Transaction, error)

+ func (_Storage *StorageTransactorSession) SetLocked(locked bool) (*types.Transaction, error)

+ func (_Storage *StorageTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

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