blockchain

type BlockchainPublisher ¶

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

Can publish to the blockchain, signing messages using the provided signer

func NewBlockchainPublisher(
	ctx context.Context,
	logger *zap.Logger,
	client *ethclient.Client,
	signer TransactionSigner,
	contractOptions config.ContractsOptions,
) (*BlockchainPublisher, error)

func (m *BlockchainPublisher) PublishGroupMessage(
	ctx context.Context,
	groupID [32]byte,
	message []byte,
) (*groupmessages.GroupMessagesMessageSent, error)

func (m *BlockchainPublisher) PublishIdentityUpdate(
	ctx context.Context,
	inboxId [32]byte,
	identityUpdate []byte,
) (*identityupdates.IdentityUpdatesIdentityUpdateCreated, error)

type ChainClient ¶

type ChainClient interface {
	ethereum.BlockNumberReader
	ethereum.LogFilterer
	ethereum.ChainIDReader
	ethereum.ChainReader
}

type ContractConfig ¶ added in v0.2.2

type ContractConfig struct {
	FromBlock       uint64
	ContractAddress common.Address
	Topics          []common.Hash
	EventChannel    chan<- types.Log
	// contains filtered or unexported fields
}

Struct defining all the information required to filter events from logs

type IBlockchainPublisher ¶

type IBlockchainPublisher interface {
	PublishIdentityUpdate(
		ctx context.Context,
		inboxId [32]byte,
		identityUpdate []byte,
	) (*identityupdates.IdentityUpdatesIdentityUpdateCreated, error)
	PublishGroupMessage(
		ctx context.Context,
		groupdId [32]byte,
		message []byte,
	) (*groupmessages.GroupMessagesMessageSent, error)
}

type LogStreamBuilder ¶

type LogStreamBuilder interface {
	ListenForContractEvent(
		fromBlock uint64,
		contractAddress common.Address,
		topic common.Hash,
	) <-chan types.Log
	Build() (LogStreamer, error)
}

Construct a raw blockchain listener that can be used to listen for events across many contract event types

type LogStreamer ¶

type LogStreamer interface {
	Start(ctx context.Context) error
}

type NodeRegistry ¶

type NodeRegistry interface {
	AddNode(
		ctx context.Context,
		owner string,
		signingKeyPub *ecdsa.PublicKey,
		httpAddress string,
	) error
}

type NodeRegistryAdmin ¶

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

* A NodeRegistryAdmin is a struct responsible for calling admin functions on the node registry *

func NewNodeRegistryAdmin(
	logger *zap.Logger,
	client *ethclient.Client,
	signer TransactionSigner,
	contractsOptions config.ContractsOptions,
) (*NodeRegistryAdmin, error)

func (n *NodeRegistryAdmin) AddNode(
	ctx context.Context,
	owner string,
	signingKeyPub *ecdsa.PublicKey,
	httpAddress string,
) error

func (n *NodeRegistryAdmin) UpdateHealth(
	ctx context.Context, nodeId int64, health bool,
) error

func (n *NodeRegistryAdmin) UpdateHttpAddress(
	ctx context.Context, nodeId int64, address string,
) error

type NodeRegistryCaller ¶

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

* A NodeRegistryCaller is a struct responsible for calling public functions on the node registry *

func NewNodeRegistryCaller(
	logger *zap.Logger,
	client *ethclient.Client,
	contractsOptions config.ContractsOptions,
) (*NodeRegistryCaller, error)

func (n *NodeRegistryCaller) GetAllNodes(
	ctx context.Context,
) ([]nodes.NodesNodeWithId, error)

type PrivateKeySigner ¶

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

* PrivateKeySigner is a naive and not secure implementation of the TransactionSigner interface.

It is meant to be used in tests only *

func NewPrivateKeySigner(privateKeyString string, chainID int) (*PrivateKeySigner, error)

func (s *PrivateKeySigner) FromAddress() common.Address

func (s *PrivateKeySigner) SignerFunc() bind.SignerFn

type RpcLogStreamBuilder ¶

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

The builder that allows you to configure contract events to listen for

func NewRpcLogStreamBuilder(
	ctx context.Context,
	client *ethclient.Client,
	logger *zap.Logger,
) *RpcLogStreamBuilder

func (c *RpcLogStreamBuilder) Build() (*RpcLogStreamer, error)

func (c *RpcLogStreamBuilder) ListenForContractEvent(
	fromBlock uint64,
	contractAddress common.Address,
	topics []common.Hash,
	maxDisconnectTime time.Duration,
) (<-chan types.Log, chan<- uint64)

type RpcLogStreamer ¶

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

* A RpcLogStreamer is a naive implementation of the ChainStreamer interface. It queries a remote blockchain node for log events to backfill history, and then streams new events, to get a complete history of events on a chain. *

func NewRpcLogStreamer(
	ctx context.Context,
	client ChainClient,
	logger *zap.Logger,
	watchers []ContractConfig,
) *RpcLogStreamer

func (r *RpcLogStreamer) Client() ChainClient

func (r *RpcLogStreamer) GetNextPage(
	config ContractConfig,
	fromBlock uint64,
) (logs []types.Log, nextBlock *uint64, err error)

func (r *RpcLogStreamer) Start()

func (r *RpcLogStreamer) Stop()

type TransactionSigner ¶

type TransactionSigner interface {
	FromAddress() common.Address
	SignerFunc() bind.SignerFn
}