authmailboxrpc

type AuthSignature struct {

	// The client's Schnorr signature over the challenge hash provided by
	// the server.
	Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
	// contains filtered or unexported fields
}

type BitcoinMerkleInclusionProof struct {

	// The raw Bitcoin transaction bytes, in standard Bitcoin serialization
	// format, containing the outpoint being claimed. The server will hash this
	// to get the TXID.
	RawTxData []byte `protobuf:"bytes,1,opt,name=raw_tx_data,json=rawTxData,proto3" json:"raw_tx_data,omitempty"`
	// The raw block header bytes (typically 80 bytes) of the block in which the
	// transaction was mined. Contains the Merkle root against which the proof
	// is verified.
	RawBlockHeaderData []byte `protobuf:"bytes,2,opt,name=raw_block_header_data,json=rawBlockHeaderData,proto3" json:"raw_block_header_data,omitempty"`
	// The height at which the block was mined. This is used to determine the
	// block's validity and to ensure the transaction is not too old.
	BlockHeight uint32 `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	// The Merkle path proving the transaction's inclusion in the block header's
	// Merkle root.
	MerkleProof *MerkleProof `protobuf:"bytes,4,opt,name=merkle_proof,json=merkleProof,proto3" json:"merkle_proof,omitempty"`
	// The specific output within the provided transaction being claimed as the
	// proof "token". The output at the given index must be a P2TR output.
	// The server must verify that the txid_hex matches the hash of the provided
	// transaction data, and that this specific outpoint index exists in the
	// transaction.
	ClaimedOutpoint *taprpc.OutPoint `protobuf:"bytes,5,opt,name=claimed_outpoint,json=claimedOutpoint,proto3" json:"claimed_outpoint,omitempty"`
	// The Taproot internal key used to construct the P2TR output that is
	// claimed by the outpoint above. Must be provided alongside the Taproot
	// Merkle root to prove knowledge of the output's construction.
	InternalKey []byte `protobuf:"bytes,6,opt,name=internal_key,json=internalKey,proto3" json:"internal_key,omitempty"`
	// The Taproot Merkle root, if applicable. This, alongside the internal key,
	// is used to prove knowledge of the output's construction. If this is not
	// provided (empty or nil), a BIP-0086 construction is assumed.
	MerkleRoot []byte `protobuf:"bytes,7,opt,name=merkle_root,json=merkleRoot,proto3" json:"merkle_root,omitempty"`
	// contains filtered or unexported fields
}

type Challenge struct {

	// The challenge hash that the client must sign to prove ownership of the
	// receiver's public key.
	ChallengeHash []byte `protobuf:"bytes,1,opt,name=challenge_hash,json=challengeHash,proto3" json:"challenge_hash,omitempty"`
	// contains filtered or unexported fields
}

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

type InitReceive struct {

	// The public key identifier of the receiver of the messages that should be
	// received through a message receive stream, encoded as the raw bytes of
	// the compressed public key.
	ReceiverId []byte `protobuf:"bytes,1,opt,name=receiver_id,json=receiverId,proto3" json:"receiver_id,omitempty"`
	// The exclusive start message ID, meaning messages with this ID or higher
	// will be included in the response. This allows the client to resume
	// receiving messages from a specific point without missing any. One of
	// start_message_id_exclusive, start_block_height_inclusive or
	// start_timestamp_exclusive must be at their non-default values for any
	// existing messages to be returned!
	StartMessageIdExclusive uint64 `` /* 135-byte string literal not displayed */
	// The inclusive start block height, meaning messages from this block height
	// or higher will be included in the response. This allows the client to
	// filter messages based on the block height at which they were produced.
	// One of start_message_id_exclusive, start_block_height_inclusive or
	// start_timestamp_exclusive must be at their non-default values for any
	// existing messages to be returned!
	StartBlockHeightInclusive uint32 `` /* 141-byte string literal not displayed */
	// The exclusive start timestamp in Unix epoch seconds, meaning messages
	// with a timestamp strictly greater than this value will be included in the
	// response. This allows the client to filter messages based on their
	// arrival time at the server. One of start_message_id_exclusive,
	// start_block_height_inclusive or start_timestamp_exclusive must be at
	// their non-default values for any existing messages to be returned!
	StartTimestampExclusive int64 `` /* 133-byte string literal not displayed */
	// contains filtered or unexported fields
}

type MailboxClient interface {
	// Sends a single message to a receiver's mailbox. Requires a valid, unused
	// Bitcoin P2TR transaction outpoint as proof of uniqueness, included in a
	// block as proof of work.
	SendMessage(ctx context.Context, in *SendMessageRequest, opts ...grpc.CallOption) (*SendMessageResponse, error)
	// Initiates a bidirectional stream to receive messages for a specific
	// receiver. This stream implements the challenge-response handshake required
	// for receiver authentication before messages are delivered.
	//
	// Expected flow:
	// 1. Client -> Server: ReceiveMessagesRequest(init = InitReceive{...})
	// 2. Server -> Client: ReceiveMessagesResponse(challenge = Challenge{...})
	// 3. Client -> Server: ReceiveMessagesRequest(auth_sig = AuthSignature{...})
	// 4. Server -> Client: [Stream of ReceiveMessagesResponse(
	// message = MailboxMessage{...}
	// )]
	// 5. Server -> Client: ReceiveMessagesResponse(eos = EndOfStream{})
	ReceiveMessages(ctx context.Context, opts ...grpc.CallOption) (Mailbox_ReceiveMessagesClient, error)
	// Returns basic server information.
	MailboxInfo(ctx context.Context, in *MailboxInfoRequest, opts ...grpc.CallOption) (*MailboxInfoResponse, error)
	// Removes one or more messages from the mailbox. The caller must prove
	// ownership of the receiver key by providing a Schnorr signature over
	// SHA256(receiver_id || big-endian uint64 message_id_1 || ...).
	// Only messages that belong to the authenticated receiver are deleted.
	RemoveMessage(ctx context.Context, in *RemoveMessageRequest, opts ...grpc.CallOption) (*RemoveMessageResponse, error)
}

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

type MailboxInfoResponse struct {

	// The current server time in Unix epoch seconds.
	ServerTime int64 `protobuf:"varint,1,opt,name=server_time,json=serverTime,proto3" json:"server_time,omitempty"`
	// The number of messages currently stored on the server.
	MessageCount uint64 `protobuf:"varint,2,opt,name=message_count,json=messageCount,proto3" json:"message_count,omitempty"`
	// contains filtered or unexported fields
}

type MailboxMessage struct {

	// The unique ID assigned to the message by the server upon storage.
	MessageId uint64 `protobuf:"varint,1,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	// The ECIES encrypted message payload, intended for the receiver.
	EncryptedPayload []byte `protobuf:"bytes,2,opt,name=encrypted_payload,json=encryptedPayload,proto3" json:"encrypted_payload,omitempty"`
	// Timestamp (Unix epoch seconds) when the message arrived at the server.
	ArrivalTimestamp int64 `protobuf:"varint,3,opt,name=arrival_timestamp,json=arrivalTimestamp,proto3" json:"arrival_timestamp,omitempty"`
	// contains filtered or unexported fields
}

type MailboxMessages struct {

	// The list of mailbox messages.
	Messages []*MailboxMessage `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages,omitempty"`
	// contains filtered or unexported fields
}

type MailboxServer interface {
	// Sends a single message to a receiver's mailbox. Requires a valid, unused
	// Bitcoin P2TR transaction outpoint as proof of uniqueness, included in a
	// block as proof of work.
	SendMessage(context.Context, *SendMessageRequest) (*SendMessageResponse, error)
	// Initiates a bidirectional stream to receive messages for a specific
	// receiver. This stream implements the challenge-response handshake required
	// for receiver authentication before messages are delivered.
	//
	// Expected flow:
	// 1. Client -> Server: ReceiveMessagesRequest(init = InitReceive{...})
	// 2. Server -> Client: ReceiveMessagesResponse(challenge = Challenge{...})
	// 3. Client -> Server: ReceiveMessagesRequest(auth_sig = AuthSignature{...})
	// 4. Server -> Client: [Stream of ReceiveMessagesResponse(
	// message = MailboxMessage{...}
	// )]
	// 5. Server -> Client: ReceiveMessagesResponse(eos = EndOfStream{})
	ReceiveMessages(Mailbox_ReceiveMessagesServer) error
	// Returns basic server information.
	MailboxInfo(context.Context, *MailboxInfoRequest) (*MailboxInfoResponse, error)
	// Removes one or more messages from the mailbox. The caller must prove
	// ownership of the receiver key by providing a Schnorr signature over
	// SHA256(receiver_id || big-endian uint64 message_id_1 || ...).
	// Only messages that belong to the authenticated receiver are deleted.
	RemoveMessage(context.Context, *RemoveMessageRequest) (*RemoveMessageResponse, error)
	// contains filtered or unexported methods
}

type Mailbox_ReceiveMessagesClient interface {
	Send(*ReceiveMessagesRequest) error
	Recv() (*ReceiveMessagesResponse, error)
	grpc.ClientStream
}

type Mailbox_ReceiveMessagesServer interface {
	Send(*ReceiveMessagesResponse) error
	Recv() (*ReceiveMessagesRequest, error)
	grpc.ServerStream
}

type MerkleProof struct {

	// List of sibling hashes in the Merkle path, ordered from the transaction's
	// sibling up towards the root. Each hash is typically 32 bytes.
	SiblingHashes [][]byte `protobuf:"bytes,1,rep,name=sibling_hashes,json=siblingHashes,proto3" json:"sibling_hashes,omitempty"`
	// The bitmask indicating the direction (left/right) of each sibling hash
	// in the Merkle tree. Each bit corresponds to a sibling hash in the
	// sibling_hashes list. 0 indicates left, 1 indicates right.
	Bits []bool `protobuf:"varint,2,rep,packed,name=bits,proto3" json:"bits,omitempty"`
	// contains filtered or unexported fields
}

type ReceiveMessagesRequest struct {

	// Types that are valid to be assigned to RequestType:
	//
	//	*ReceiveMessagesRequest_Init
	//	*ReceiveMessagesRequest_AuthSig
	RequestType isReceiveMessagesRequest_RequestType `protobuf_oneof:"request_type"`
	// contains filtered or unexported fields
}

type ReceiveMessagesRequest_AuthSig struct {
	// The client's signature in response to the server's challenge.
	AuthSig *AuthSignature `protobuf:"bytes,2,opt,name=auth_sig,json=authSig,proto3,oneof"`
}

type ReceiveMessagesRequest_Init struct {
	// The initial parameters sent by the client to start receiving
	// messages.
	Init *InitReceive `protobuf:"bytes,1,opt,name=init,proto3,oneof"`
}

type ReceiveMessagesResponse struct {

	// Types that are valid to be assigned to ResponseType:
	//
	//	*ReceiveMessagesResponse_Challenge
	//	*ReceiveMessagesResponse_AuthSuccess
	//	*ReceiveMessagesResponse_Messages
	//	*ReceiveMessagesResponse_Eos
	ResponseType isReceiveMessagesResponse_ResponseType `protobuf_oneof:"response_type"`
	// contains filtered or unexported fields
}

type ReceiveMessagesResponse_AuthSuccess struct {
	// A successful authentication response, indicating the client has
	// successfully signed the challenge and is now authenticated to receive
	// messages.
	AuthSuccess bool `protobuf:"varint,2,opt,name=auth_success,json=authSuccess,proto3,oneof"`
}

type ReceiveMessagesResponse_Challenge struct {
	// The challenge sent by the server to the client, which the client
	// must sign to prove ownership of the receiver's public key.
	Challenge *Challenge `protobuf:"bytes,1,opt,name=challenge,proto3,oneof"`
}

type ReceiveMessagesResponse_Eos struct {
	// An EndOfStream message indicating that the server is shutting down.
	Eos *EndOfStream `protobuf:"bytes,4,opt,name=eos,proto3,oneof"`
}

type ReceiveMessagesResponse_Messages struct {
	// A list of mailbox messages sent to the client. This will be
	// sent after the client has successfully authenticated by signing the
	// challenge. The client should expect a stream of these messages
	// until the server sends an EndOfStream message.
	Messages *MailboxMessages `protobuf:"bytes,3,opt,name=messages,proto3,oneof"`
}

type RemoveMessageRequest struct {

	// The public key identifier of the receiver whose messages should be
	// removed, encoded as the raw bytes of the compressed public key. This
	// is the same key used when subscribing for messages via ReceiveMessages.
	ReceiverId []byte `protobuf:"bytes,1,opt,name=receiver_id,json=receiverId,proto3" json:"receiver_id,omitempty"`
	// The IDs of the messages to remove. Only messages that belong to the
	// specified receiver will be deleted. IDs that don't exist or belong to
	// a different receiver are silently skipped.
	MessageIds []uint64 `protobuf:"varint,2,rep,packed,name=message_ids,json=messageIds,proto3" json:"message_ids,omitempty"`
	// A Schnorr signature proving ownership of the receiver key. The
	// signature must be over SHA256(receiver_id || msg_id_1 || msg_id_2 ||
	// ...) where each message ID is encoded as a big-endian uint64.
	Signature []byte `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	// contains filtered or unexported fields
}

type RemoveMessageResponse struct {

	// The number of messages that were actually removed.
	NumRemoved uint64 `protobuf:"varint,1,opt,name=num_removed,json=numRemoved,proto3" json:"num_removed,omitempty"`
	// contains filtered or unexported fields
}

type SendMessageRequest struct {

	// The public key identifier of the intended receiver (ReceiverID), encoded
	// as the raw bytes of the compressed public key.
	ReceiverId []byte `protobuf:"bytes,1,opt,name=receiver_id,json=receiverId,proto3" json:"receiver_id,omitempty"`
	// The ECIES encrypted message payload.
	EncryptedPayload []byte `protobuf:"bytes,2,opt,name=encrypted_payload,json=encryptedPayload,proto3" json:"encrypted_payload,omitempty"`
	// A proof of the sender's identity, typically a Bitcoin transaction or
	// another proof that work was done to create the message.
	//
	// Types that are valid to be assigned to Proof:
	//
	//	*SendMessageRequest_TxProof
	Proof isSendMessageRequest_Proof `protobuf_oneof:"proof"`
	// contains filtered or unexported fields
}

type SendMessageRequest_TxProof struct {
	// The Bitcoin Merkle Inclusion Proof used as the sender's
	// authentication. The server MUST perform full validation of this
	// proof:
	//  1. Verify claimed_outpoint.txid_hex matches hash(raw_tx_data).
	//  2. Verify claimed_outpoint.index is valid for the transaction.
	//  3. Verify merkle_proof connects the transaction hash to the
	//     raw_block_header_data's Merkle root.
	//  4. Verify block_header validity (e.g., PoW, potentially chain
	//     context).
	//  5. Ensure the claimed_outpoint has not been used previously (check
	//     used_proofs table).
	TxProof *BitcoinMerkleInclusionProof `protobuf:"bytes,4,opt,name=tx_proof,json=txProof,proto3,oneof"`
}

type SendMessageResponse struct {

	// The unique ID assigned to the stored message by the server.
	MessageId uint64 `protobuf:"varint,1,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedMailboxServer struct {
}

type UnsafeMailboxServer interface {
	// contains filtered or unexported methods
}