authmailbox

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

type ClientConfig struct {
	// ServerAddress is the domain:port of the mailbox server.
	ServerAddress string

	// ProxyAddress is the SOCKS proxy that should be used to establish the
	// connection.
	ProxyAddress string

	// Insecure signals that no TLS should be used if set to true.
	Insecure bool

	// SkipTlsVerify signals that the TLS certificate of the mailbox server
	// should not be verified. This is only needed if the server uses a
	// self-signed certificate.
	SkipTlsVerify bool

	// TLSPathServer is the path to a local file that holds the mailbox
	// server's TLS certificate. This is only needed if the server is using
	// a self-signed cert.
	TLSPathServer string

	// DialOpts is a list of additional options that should be used when
	// dialing the gRPC connection.
	DialOpts []grpc.DialOption

	// Signer is the signing interface used to sign messages during the
	// authentication handshake with the mailbox server.
	Signer lndclient.SignerClient

	// MinBackoff is the minimum time waited before the next re-connect
	// attempt is made. After each try the backoff is doubled until
	// MaxBackoff is reached.
	MinBackoff time.Duration

	// MaxBackoff is the maximum time waited between connection attempts.
	MaxBackoff time.Duration
}

type Message struct {
	// ID is the unique identifier for this message, assigned by the
	// mailbox server.
	ID uint64

	// ReceiverKey is the intended recipient of the message. This is the
	// public key of the receiver.
	ReceiverKey btcec.PublicKey

	// EncryptedPayload is the encrypted message payload. This is the actual
	// content of the message, encrypted with EICS.
	EncryptedPayload []byte

	// ArrivalTimestamp is the time when the message was received and
	// validated by the mailbox server.
	ArrivalTimestamp time.Time

	// ProofBlockHeight is the block height of the block that was used as
	// the tx proof for this message.
	ProofBlockHeight uint32
}

type MessageFilter struct {
	// ReceiverKey is the message receiver's public key.
	ReceiverKey btcec.PublicKey

	// After is the time after which the message was received. If set, the
	// filter will cause only messages that arrived after this time to be
	// returned (exclusive).
	After time.Time

	// AfterID is the ID of the message after which the message was
	// received. If set, the filter will cause only messages that arrived
	// after this ID to be returned (exclusive).
	AfterID uint64

	// StartBlock is the block height after which the message was received.
	// If set, the filter will cause only messages that arrived at this
	// block or later to be returned (inclusive).
	StartBlock uint32
}

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

type MockServer struct {
	ListenAddr string
	// contains filtered or unexported fields
}

type MsgStore interface {
	// StoreMessage stores a message in the mailbox, referencing the claimed
	// outpoint of the transaction that was used to prove the message's
	// authenticity. If a message with the same outpoint already exists,
	// it returns proof.ErrTxMerkleProofExists.
	StoreMessage(ctx context.Context, proof proof.TxProof,
		msg *Message) (uint64, error)

	// FetchMessage retrieves a message from the mailbox by its ID.
	FetchMessage(ctx context.Context, id uint64) (*Message, error)

	// FetchMessageByOutPoint retrieves a message from the mailbox by its
	// claimed outpoint of the TX proof that was used to send it. If no
	// message with the given outpoint exists, it returns
	// ErrMessageNotFound.
	FetchMessageByOutPoint(ctx context.Context,
		claimedOp wire.OutPoint) (*Message, error)

	// QueryMessages retrieves messages based on a query.
	QueryMessages(ctx context.Context, filter MessageFilter) ([]*Message,
		error)

	// NumMessages returns the number of messages currently in the mailbox.
	// Implementations should make sure that this can be calculated quickly
	// and efficiently (e.g., by caching the result), as it might be queried
	// often.
	NumMessages(ctx context.Context) uint64
}

type MultiSubscription struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type ReceiveSubscription interface {
	// IsSubscribed returns true if the subscription is active and the
	// stream to the server is open. This might flip to false if the server
	// connection is lost. As long as the subscription isn't stopped, it
	// will try to reconnect to the server automatically and indefinitely.
	IsSubscribed() bool

	// Stop can be used to terminate the subscription. This will close the
	// stream to the server.
	Stop() error
}

type ReceivedMessages struct {
	// Receiver is the key descriptor of the receiver that these messages
	// are intended for.
	Receiver keychain.KeyDescriptor

	// Messages is the list of messages that were received from the server.
	Messages []*mboxrpc.MailboxMessage
}

type Server struct {
	mboxrpc.UnimplementedMailboxServer

	*lfn.ContextGuard
	// contains filtered or unexported fields
}

type ServerConfig struct {
	// AuthTimeout is the maximum time the server will wait for the client
	// to authenticate before closing the connection.
	AuthTimeout time.Duration

	// Signer is the lndclient.SignerClient used to verify the
	// authentication signature.
	Signer lndclient.SignerClient

	// HeaderVerifier is the proof.HeaderVerifier used to verify the TX
	// proofs sent by clients to prove the rate limit of their messages.
	HeaderVerifier proof.HeaderVerifier

	// MerkleVerifier is the proof.MerkleVerifier used to verify the
	// TX proofs sent by clients to prove the rate limit of their messages.
	MerkleVerifier proof.MerkleVerifier

	// MsgStore is the message store used to store and retrieve messages
	// sent to the mailbox server.
	MsgStore MsgStore
}