Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

abis

package

Go to main page

Versions in this module

v0

v0.1.3

Dec 13, 2024

v0.1.2

Dec 6, 2024

v0.1.1

Nov 26, 2024

v0.1.0

Oct 21, 2024

Changes in this version

+ var GroupMessagesABI = GroupMessagesMetaData.ABI

+ var GroupMessagesMetaData = &bind.MetaData

+ var IdentityUpdatesABI = IdentityUpdatesMetaData.ABI

+ var IdentityUpdatesMetaData = &bind.MetaData

+ var NodesABI = NodesMetaData.ABI

+ var NodesMetaData = &bind.MetaData

+ type GroupMessages struct

+ func NewGroupMessages(address common.Address, backend bind.ContractBackend) (*GroupMessages, error)

+ type GroupMessagesCaller struct

+ func NewGroupMessagesCaller(address common.Address, caller bind.ContractCaller) (*GroupMessagesCaller, error)

+ type GroupMessagesCallerRaw struct

+ Contract *GroupMessagesCaller

+ func (_GroupMessages *GroupMessagesCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type GroupMessagesCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *GroupMessagesCaller

+ type GroupMessagesFilterer struct

+ func NewGroupMessagesFilterer(address common.Address, filterer bind.ContractFilterer) (*GroupMessagesFilterer, error)

+ func (_GroupMessages *GroupMessagesFilterer) FilterMessageSent(opts *bind.FilterOpts) (*GroupMessagesMessageSentIterator, error)

+ func (_GroupMessages *GroupMessagesFilterer) ParseMessageSent(log types.Log) (*GroupMessagesMessageSent, error)

+ func (_GroupMessages *GroupMessagesFilterer) WatchMessageSent(opts *bind.WatchOpts, sink chan<- *GroupMessagesMessageSent) (event.Subscription, error)

+ type GroupMessagesMessageSent struct

+ GroupId [32]byte

+ Message []byte

+ Raw types.Log

+ SequenceId uint64

+ type GroupMessagesMessageSentIterator struct

+ Event *GroupMessagesMessageSent

+ func (it *GroupMessagesMessageSentIterator) Close() error

+ func (it *GroupMessagesMessageSentIterator) Error() error

+ func (it *GroupMessagesMessageSentIterator) Next() bool

+ type GroupMessagesRaw struct

+ Contract *GroupMessages

+ func (_GroupMessages *GroupMessagesRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_GroupMessages *GroupMessagesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GroupMessagesSession struct

+ CallOpts bind.CallOpts

+ Contract *GroupMessages

+ TransactOpts bind.TransactOpts

+ func (_GroupMessages *GroupMessagesSession) AddMessage(groupId [32]byte, message []byte) (*types.Transaction, error)

+ type GroupMessagesTransactor struct

+ func NewGroupMessagesTransactor(address common.Address, transactor bind.ContractTransactor) (*GroupMessagesTransactor, error)

+ func (_GroupMessages *GroupMessagesTransactor) AddMessage(opts *bind.TransactOpts, groupId [32]byte, message []byte) (*types.Transaction, error)

+ type GroupMessagesTransactorRaw struct

+ Contract *GroupMessagesTransactor

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

+ func (_GroupMessages *GroupMessagesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GroupMessagesTransactorSession struct

+ Contract *GroupMessagesTransactor

+ TransactOpts bind.TransactOpts

+ func (_GroupMessages *GroupMessagesTransactorSession) AddMessage(groupId [32]byte, message []byte) (*types.Transaction, error)

+ type IdentityUpdates struct

+ func NewIdentityUpdates(address common.Address, backend bind.ContractBackend) (*IdentityUpdates, error)

+ type IdentityUpdatesCaller struct

+ func NewIdentityUpdatesCaller(address common.Address, caller bind.ContractCaller) (*IdentityUpdatesCaller, error)

+ type IdentityUpdatesCallerRaw struct

+ Contract *IdentityUpdatesCaller

+ func (_IdentityUpdates *IdentityUpdatesCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type IdentityUpdatesCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IdentityUpdatesCaller

+ type IdentityUpdatesFilterer struct

+ func NewIdentityUpdatesFilterer(address common.Address, filterer bind.ContractFilterer) (*IdentityUpdatesFilterer, error)

+ func (_IdentityUpdates *IdentityUpdatesFilterer) FilterIdentityUpdateCreated(opts *bind.FilterOpts) (*IdentityUpdatesIdentityUpdateCreatedIterator, error)

+ func (_IdentityUpdates *IdentityUpdatesFilterer) ParseIdentityUpdateCreated(log types.Log) (*IdentityUpdatesIdentityUpdateCreated, error)

+ func (_IdentityUpdates *IdentityUpdatesFilterer) WatchIdentityUpdateCreated(opts *bind.WatchOpts, sink chan<- *IdentityUpdatesIdentityUpdateCreated) (event.Subscription, error)

+ type IdentityUpdatesIdentityUpdateCreated struct

+ InboxId [32]byte

+ Raw types.Log

+ SequenceId uint64

+ Update []byte

+ type IdentityUpdatesIdentityUpdateCreatedIterator struct

+ Event *IdentityUpdatesIdentityUpdateCreated

+ func (it *IdentityUpdatesIdentityUpdateCreatedIterator) Close() error

+ func (it *IdentityUpdatesIdentityUpdateCreatedIterator) Error() error

+ func (it *IdentityUpdatesIdentityUpdateCreatedIterator) Next() bool

+ type IdentityUpdatesRaw struct

+ Contract *IdentityUpdates

+ func (_IdentityUpdates *IdentityUpdatesRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_IdentityUpdates *IdentityUpdatesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IdentityUpdatesSession struct

+ CallOpts bind.CallOpts

+ Contract *IdentityUpdates

+ TransactOpts bind.TransactOpts

+ func (_IdentityUpdates *IdentityUpdatesSession) AddIdentityUpdate(inboxId [32]byte, update []byte) (*types.Transaction, error)

+ type IdentityUpdatesTransactor struct

+ func NewIdentityUpdatesTransactor(address common.Address, transactor bind.ContractTransactor) (*IdentityUpdatesTransactor, error)

+ func (_IdentityUpdates *IdentityUpdatesTransactor) AddIdentityUpdate(opts *bind.TransactOpts, inboxId [32]byte, update []byte) (*types.Transaction, error)

+ type IdentityUpdatesTransactorRaw struct

+ Contract *IdentityUpdatesTransactor

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

+ func (_IdentityUpdates *IdentityUpdatesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IdentityUpdatesTransactorSession struct

+ Contract *IdentityUpdatesTransactor

+ TransactOpts bind.TransactOpts

+ func (_IdentityUpdates *IdentityUpdatesTransactorSession) AddIdentityUpdate(inboxId [32]byte, update []byte) (*types.Transaction, error)

+ type Nodes struct

+ func NewNodes(address common.Address, backend bind.ContractBackend) (*Nodes, error)

+ type NodesApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type NodesApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type NodesApprovalForAllIterator struct

+ Event *NodesApprovalForAll

+ func (it *NodesApprovalForAllIterator) Close() error

+ func (it *NodesApprovalForAllIterator) Error() error

+ func (it *NodesApprovalForAllIterator) Next() bool

+ type NodesApprovalIterator struct

+ Event *NodesApproval

+ func (it *NodesApprovalIterator) Close() error

+ func (it *NodesApprovalIterator) Error() error

+ func (it *NodesApprovalIterator) Next() bool

+ type NodesCaller struct

+ func NewNodesCaller(address common.Address, caller bind.ContractCaller) (*NodesCaller, error)

+ func (_Nodes *NodesCaller) AllNodes(opts *bind.CallOpts) ([]NodesNodeWithId, error)

+ func (_Nodes *NodesCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_Nodes *NodesCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_Nodes *NodesCaller) GetNode(opts *bind.CallOpts, tokenId *big.Int) (NodesNode, error)

+ func (_Nodes *NodesCaller) HealthyNodes(opts *bind.CallOpts) ([]NodesNodeWithId, error)

+ func (_Nodes *NodesCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_Nodes *NodesCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_Nodes *NodesCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Nodes *NodesCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_Nodes *NodesCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_Nodes *NodesCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_Nodes *NodesCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ type NodesCallerRaw struct

+ Contract *NodesCaller

+ func (_Nodes *NodesCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type NodesCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *NodesCaller

+ func (_Nodes *NodesCallerSession) AllNodes() ([]NodesNodeWithId, error)

+ func (_Nodes *NodesCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_Nodes *NodesCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_Nodes *NodesCallerSession) GetNode(tokenId *big.Int) (NodesNode, error)

+ func (_Nodes *NodesCallerSession) HealthyNodes() ([]NodesNodeWithId, error)

+ func (_Nodes *NodesCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_Nodes *NodesCallerSession) Name() (string, error)

+ func (_Nodes *NodesCallerSession) Owner() (common.Address, error)

+ func (_Nodes *NodesCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_Nodes *NodesCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_Nodes *NodesCallerSession) Symbol() (string, error)

+ func (_Nodes *NodesCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ type NodesFilterer struct

+ func NewNodesFilterer(address common.Address, filterer bind.ContractFilterer) (*NodesFilterer, error)

+ func (_Nodes *NodesFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*NodesApprovalIterator, error)

+ func (_Nodes *NodesFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*NodesApprovalForAllIterator, error)

+ func (_Nodes *NodesFilterer) FilterNodeUpdated(opts *bind.FilterOpts) (*NodesNodeUpdatedIterator, error)

+ func (_Nodes *NodesFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*NodesOwnershipTransferredIterator, error)

+ func (_Nodes *NodesFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*NodesTransferIterator, error)

+ func (_Nodes *NodesFilterer) ParseApproval(log types.Log) (*NodesApproval, error)

+ func (_Nodes *NodesFilterer) ParseApprovalForAll(log types.Log) (*NodesApprovalForAll, error)

+ func (_Nodes *NodesFilterer) ParseNodeUpdated(log types.Log) (*NodesNodeUpdated, error)

+ func (_Nodes *NodesFilterer) ParseOwnershipTransferred(log types.Log) (*NodesOwnershipTransferred, error)

+ func (_Nodes *NodesFilterer) ParseTransfer(log types.Log) (*NodesTransfer, error)

+ func (_Nodes *NodesFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *NodesApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_Nodes *NodesFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *NodesApprovalForAll, owner []common.Address, ...) (event.Subscription, error)

+ func (_Nodes *NodesFilterer) WatchNodeUpdated(opts *bind.WatchOpts, sink chan<- *NodesNodeUpdated) (event.Subscription, error)

+ func (_Nodes *NodesFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *NodesOwnershipTransferred, ...) (event.Subscription, error)

+ func (_Nodes *NodesFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *NodesTransfer, from []common.Address, ...) (event.Subscription, error)

+ type NodesNode struct

+ HttpAddress string

+ IsHealthy bool

+ SigningKeyPub []byte

+ type NodesNodeUpdated struct

+ Node NodesNode

+ NodeId *big.Int

+ Raw types.Log

+ type NodesNodeUpdatedIterator struct

+ Event *NodesNodeUpdated

+ func (it *NodesNodeUpdatedIterator) Close() error

+ func (it *NodesNodeUpdatedIterator) Error() error

+ func (it *NodesNodeUpdatedIterator) Next() bool

+ type NodesNodeWithId struct

+ Node NodesNode

+ NodeId uint32

+ type NodesOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type NodesOwnershipTransferredIterator struct

+ Event *NodesOwnershipTransferred

+ func (it *NodesOwnershipTransferredIterator) Close() error

+ func (it *NodesOwnershipTransferredIterator) Error() error

+ func (it *NodesOwnershipTransferredIterator) Next() bool

+ type NodesRaw struct

+ Contract *Nodes

+ func (_Nodes *NodesRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_Nodes *NodesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type NodesSession struct

+ CallOpts bind.CallOpts

+ Contract *Nodes

+ TransactOpts bind.TransactOpts

+ func (_Nodes *NodesSession) AddNode(to common.Address, signingKeyPub []byte, httpAddress string) (*types.Transaction, error)

+ func (_Nodes *NodesSession) AllNodes() ([]NodesNodeWithId, error)

+ func (_Nodes *NodesSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_Nodes *NodesSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_Nodes *NodesSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_Nodes *NodesSession) GetNode(tokenId *big.Int) (NodesNode, error)

+ func (_Nodes *NodesSession) HealthyNodes() ([]NodesNodeWithId, error)

+ func (_Nodes *NodesSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_Nodes *NodesSession) Name() (string, error)

+ func (_Nodes *NodesSession) Owner() (common.Address, error)

+ func (_Nodes *NodesSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_Nodes *NodesSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Nodes *NodesSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_Nodes *NodesSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_Nodes *NodesSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error)

+ func (_Nodes *NodesSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_Nodes *NodesSession) Symbol() (string, error)

+ func (_Nodes *NodesSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_Nodes *NodesSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_Nodes *NodesSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_Nodes *NodesSession) UpdateHealth(tokenId *big.Int, isHealthy bool) (*types.Transaction, error)

+ func (_Nodes *NodesSession) UpdateHttpAddress(tokenId *big.Int, httpAddress string) (*types.Transaction, error)

+ type NodesTransactor struct

+ func NewNodesTransactor(address common.Address, transactor bind.ContractTransactor) (*NodesTransactor, error)

+ func (_Nodes *NodesTransactor) AddNode(opts *bind.TransactOpts, to common.Address, signingKeyPub []byte, ...) (*types.Transaction, error)

+ func (_Nodes *NodesTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_Nodes *NodesTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Nodes *NodesTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_Nodes *NodesTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_Nodes *NodesTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, approved bool) (*types.Transaction, error)

+ func (_Nodes *NodesTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_Nodes *NodesTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_Nodes *NodesTransactor) UpdateHealth(opts *bind.TransactOpts, tokenId *big.Int, isHealthy bool) (*types.Transaction, error)

+ func (_Nodes *NodesTransactor) UpdateHttpAddress(opts *bind.TransactOpts, tokenId *big.Int, httpAddress string) (*types.Transaction, error)

+ type NodesTransactorRaw struct

+ Contract *NodesTransactor

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

+ func (_Nodes *NodesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type NodesTransactorSession struct

+ Contract *NodesTransactor

+ TransactOpts bind.TransactOpts

+ func (_Nodes *NodesTransactorSession) AddNode(to common.Address, signingKeyPub []byte, httpAddress string) (*types.Transaction, error)

+ func (_Nodes *NodesTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_Nodes *NodesTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Nodes *NodesTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_Nodes *NodesTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_Nodes *NodesTransactorSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error)

+ func (_Nodes *NodesTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_Nodes *NodesTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_Nodes *NodesTransactorSession) UpdateHealth(tokenId *big.Int, isHealthy bool) (*types.Transaction, error)

+ func (_Nodes *NodesTransactorSession) UpdateHttpAddress(tokenId *big.Int, httpAddress string) (*types.Transaction, error)

+ type NodesTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type NodesTransferIterator struct

+ Event *NodesTransfer

+ func (it *NodesTransferIterator) Close() error

+ func (it *NodesTransferIterator) Error() error

+ func (it *NodesTransferIterator) Next() bool