Envelope = object
  publicKey*: PublicKey
  domain*: string
  payloadType*: seq[byte]
  payload: seq[byte]
  signature*: Signature

EnvelopeError = enum
  EnvelopeInvalidProtobuf, EnvelopeFieldMissing, EnvelopeInvalidSignature,
  EnvelopeWrongType

SignedPayload[T] = object
  envelope*: Envelope
  data*: T

proc decode(T: typedesc[Envelope]; buf: seq[byte]; domain: string): Result[
    Envelope, EnvelopeError] {....raises: [].}

proc decode[T](_: typedesc[SignedPayload[T]]; buffer: seq[byte]): Result[
    SignedPayload[T], EnvelopeError] {....raises: [].}

proc encode(env: Envelope): Result[seq[byte], CryptoError] {....raises: [],
    tags: [].}

proc encode[T](msg: SignedPayload[T]): Result[seq[byte], CryptoError] {.
    ...raises: [].}

proc getField(pb: ProtoBuffer; field: int; value: var Envelope; domain: string): ProtoResult[
    bool] {.inline, ...raises: [], tags: [RootEffect].}

proc getField[T](pb: ProtoBuffer; field: int; value: var SignedPayload[T]): ProtoResult[
    bool] {.inline, ...raises: [].}

proc init(T: typedesc[Envelope]; privateKey: PrivateKey; payloadType: seq[byte];
          payload: seq[byte]; domain: string): Result[Envelope, CryptoError] {.
    ...raises: [].}

proc init[T](_: typedesc[SignedPayload[T]]; privateKey: PrivateKey; data: T): Result[
    SignedPayload[T], CryptoError] {....raises: [].}

proc payload(env: Envelope): seq[byte] {....raises: [], tags: [].}

proc write(pb: var ProtoBuffer; field: int; env: Envelope): Result[void,
    CryptoError] {....raises: [], tags: [].}