@okee-e2ee/protocol 0.1.2 → 0.1.4

package/dist/crypto-core/model/brand.d.ts

@@ -7,5 +7,9 @@ declare const encodedPayloadType: unique symbol;
 export type EncodedPayload<T = unknown> = Bytes & {
     readonly [encodedPayloadType]?: T;
 };
+declare const encryptedPayloadType: unique symbol;
+export type EncryptedPayload<T = unknown> = Bytes & {
+    readonly [encryptedPayloadType]?: T;
+};
 export {};
 //# sourceMappingURL=brand.d.ts.map

package/dist/crypto-core/model/brand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brand.d.ts","sourceRoot":"","sources":["../../../src/crypto-core/model/brand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE/B,OAAO,CAAC,MAAM,KAAK,EAAE,OAAO,MAAM,CAAC;AAEnC,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,IAAI,CAAC,GAAG;IAClD,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CACxB,CAAC;AAEF,OAAO,CAAC,MAAM,kBAAkB,EAAE,OAAO,MAAM,CAAC;AAEhD,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,GAAG;IACjD,QAAQ,CAAC,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC;CAClC,CAAC"}
+{"version":3,"file":"brand.d.ts","sourceRoot":"","sources":["../../../src/crypto-core/model/brand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE/B,OAAO,CAAC,MAAM,KAAK,EAAE,OAAO,MAAM,CAAC;AAEnC,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,IAAI,CAAC,GAAG;IAClD,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CACxB,CAAC;AAEF,OAAO,CAAC,MAAM,kBAAkB,EAAE,OAAO,MAAM,CAAC;AAEhD,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,GAAG;IACjD,QAAQ,CAAC,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC;CAClC,CAAC;AAEF,OAAO,CAAC,MAAM,oBAAoB,EAAE,OAAO,MAAM,CAAC;AAElD,MAAM,MAAM,gBAAgB,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,GAAG;IACnD,QAAQ,CAAC,CAAC,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC;CACpC,CAAC"}

package/dist/crypto-core/signature/codecs/HybridSignatureCodec.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@okee-e2ee/core";
+import { DecodeError } from "@okee-e2ee/core/errors";
+import { CodecContract } from "../../../crypto-core/contracts";
+import { Bytes } from "../../../crypto-core/model";
+import { HybridSignature } from "../model";
+export declare class HybridSignatureCodec implements CodecContract<HybridSignature> {
+    encode(value: HybridSignature): Bytes;
+    decode(bytes: Bytes): Result<HybridSignature, DecodeError>;
+}
+//# sourceMappingURL=HybridSignatureCodec.d.ts.map

package/dist/crypto-core/signature/codecs/HybridSignatureCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HybridSignatureCodec.d.ts","sourceRoot":"","sources":["../../../../src/crypto-core/signature/codecs/HybridSignatureCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAE1E,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAE9D,OAAO,EAAoB,eAAe,EAAkB,MAAM,UAAU,CAAC;AAE7E,qBAAa,oBAAqB,YAAW,aAAa,CAAC,eAAe,CAAC;IACnE,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,KAAK,CAK3C;IAEM,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,eAAe,EAAE,WAAW,CAAC,CAgBhE;CACD"}

package/dist/crypto-core/signature/codecs/HybridSignatureCodec.js

@@ -0,0 +1,27 @@
+import { DecodeError } from "@okee-e2ee/core/errors";
+import { CRYPTO_SIZES_BYTES } from "../../../crypto-core/constants";
+import { ByteReader, ByteWriter } from "../../../crypto-core/encoding";
+export class HybridSignatureCodec {
+    encode(value) {
+        return new ByteWriter()
+            .writeFixedBytes(value.ed25519, CRYPTO_SIZES_BYTES.ed25519Signature)
+            .writeFixedBytes(value.mlDsa, CRYPTO_SIZES_BYTES.mlDsaSignature)
+            .toBytes();
+    }
+    decode(bytes) {
+        const reader = new ByteReader(bytes);
+        try {
+            const value = {
+                ed25519: reader.readFixedBytes(CRYPTO_SIZES_BYTES.ed25519Signature),
+                mlDsa: reader.readFixedBytes(CRYPTO_SIZES_BYTES.mlDsaSignature)
+            };
+            reader.assertEnd();
+            return { ok: true, value };
+        }
+        catch (error) {
+            if (error instanceof DecodeError)
+                return { ok: false, error };
+            throw error;
+        }
+    }
+}

package/dist/crypto-core/signature/codecs/HybridSignaturePublicKeyCodec.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@okee-e2ee/core";
+import { DecodeError } from "@okee-e2ee/core/errors";
+import { CodecContract } from "../../../crypto-core/contracts";
+import { Bytes } from "../../../crypto-core/model";
+import { HybridSignaturePublicKey } from "../model";
+export declare class HybridSignaturePublicKeyCodec implements CodecContract<HybridSignaturePublicKey> {
+    encode(value: HybridSignaturePublicKey): Bytes;
+    decode(bytes: Bytes): Result<HybridSignaturePublicKey, DecodeError>;
+}
+//# sourceMappingURL=HybridSignaturePublicKeyCodec.d.ts.map

package/dist/crypto-core/signature/codecs/HybridSignaturePublicKeyCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HybridSignaturePublicKeyCodec.d.ts","sourceRoot":"","sources":["../../../../src/crypto-core/signature/codecs/HybridSignaturePublicKeyCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAE1E,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAE9D,OAAO,EAAoB,wBAAwB,EAAkB,MAAM,UAAU,CAAC;AAEtF,qBAAa,6BAA8B,YAAW,aAAa,CAAC,wBAAwB,CAAC;IACrF,MAAM,CAAC,KAAK,EAAE,wBAAwB,GAAG,KAAK,CAKpD;IAEM,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,wBAAwB,EAAE,WAAW,CAAC,CAgBzE;CACD"}

package/dist/{transport/codecs/RelayIdentityPublicKeyCodec.js → crypto-core/signature/codecs/HybridSignaturePublicKeyCodec.js}

@@ -1,7 +1,7 @@
 import { DecodeError } from "@okee-e2ee/core/errors";
-import { CRYPTO_SIZES_BYTES } from "../../crypto-core/constants";
-import { ByteReader, ByteWriter } from "../../crypto-core/encoding";
-export class RelayIdentityPublicKeyCodec {
+import { CRYPTO_SIZES_BYTES } from "../../../crypto-core/constants";
+import { ByteReader, ByteWriter } from "../../../crypto-core/encoding";
+export class HybridSignaturePublicKeyCodec {
     encode(value) {
         return new ByteWriter()
             .writeFixedBytes(value.ed25519, CRYPTO_SIZES_BYTES.ed25519PublicKey)

package/dist/crypto-core/signature/codecs/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./HybridSignatureCodec";
+export * from "./HybridSignaturePublicKeyCodec";
+//# sourceMappingURL=index.d.ts.map

package/dist/crypto-core/signature/codecs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/crypto-core/signature/codecs/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,iCAAiC,CAAC"}

package/dist/crypto-core/signature/codecs/index.js

@@ -0,0 +1,2 @@
+export * from "./HybridSignatureCodec";
+export * from "./HybridSignaturePublicKeyCodec";

package/dist/crypto-core/signature/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./codecs";
 export * from "./contracts";
 export * from "./model";
 export * from "./SignatureFacade";

package/dist/crypto-core/signature/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto-core/signature/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto-core/signature/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC"}

package/dist/crypto-core/signature/index.js

@@ -1,3 +1,4 @@
+export * from "./codecs";
 export * from "./contracts";
 export * from "./model";
 export * from "./SignatureFacade";

package/dist/transport/codecs/DestinationSendRequestCodec.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@okee-e2ee/core";
+import { DecodeError } from "@okee-e2ee/core/errors";
+import { CodecContract } from "../../crypto-core";
+import { Bytes } from "../../crypto-core/model";
+import { DestinationSendRequest } from "../model";
+export declare class DestinationSendRequestCodec implements CodecContract<DestinationSendRequest> {
+    encode(value: DestinationSendRequest): Bytes;
+    decode(bytes: Bytes): Result<DestinationSendRequest, DecodeError>;
+}
+//# sourceMappingURL=DestinationSendRequestCodec.d.ts.map

package/dist/transport/codecs/DestinationSendRequestCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DestinationSendRequestCodec.d.ts","sourceRoot":"","sources":["../../../src/transport/codecs/DestinationSendRequestCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAGN,aAAa,EAGb,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAE9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAWlD,qBAAa,2BAA4B,YAAW,aAAa,CAAC,sBAAsB,CAAC;IACjF,MAAM,CAAC,KAAK,EAAE,sBAAsB,GAAG,KAAK,CAQlD;IAEM,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,sBAAsB,EAAE,WAAW,CAAC,CAsBvE;CACD"}

package/dist/transport/codecs/DestinationSendRequestCodec.js

@@ -0,0 +1,34 @@
+import { DecodeError } from "@okee-e2ee/core/errors";
+import { ByteReader, ByteWriter, CRYPTO_SIZES_BYTES, HybridSignatureCodec } from "../../crypto-core";
+import { decodeDestinationSendRequestPayload, encodeDestinationSendRequestPayload } from "./internal/destination-send-codec-helpers";
+const hybridSignatureCodec = new HybridSignatureCodec();
+const HYBRID_SIGNATURE_SIZE_BYTES = CRYPTO_SIZES_BYTES.ed25519Signature + CRYPTO_SIZES_BYTES.mlDsaSignature;
+export class DestinationSendRequestCodec {
+    encode(value) {
+        return new ByteWriter()
+            .writeBytes(encodeDestinationSendRequestPayload(value.payload))
+            .writeFixedBytes(hybridSignatureCodec.encode(value.authorization), HYBRID_SIGNATURE_SIZE_BYTES)
+            .toBytes();
+    }
+    decode(bytes) {
+        const reader = new ByteReader(bytes);
+        try {
+            const payloadReader = new ByteReader(reader.readBytes());
+            const payload = decodeDestinationSendRequestPayload(payloadReader);
+            payloadReader.assertEnd();
+            const authorizationResult = hybridSignatureCodec.decode(reader.readFixedBytes(HYBRID_SIGNATURE_SIZE_BYTES));
+            if (!authorizationResult.ok)
+                throw authorizationResult.error;
+            reader.assertEnd();
+            return {
+                ok: true,
+                value: { payload, authorization: authorizationResult.value }
+            };
+        }
+        catch (error) {
+            if (error instanceof DecodeError)
+                return { ok: false, error };
+            throw error;
+        }
+    }
+}

package/dist/transport/codecs/DestinationSendResponseCodec.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@okee-e2ee/core";
+import { DecodeError } from "@okee-e2ee/core/errors";
+import { CodecContract } from "../../crypto-core";
+import { Bytes } from "../../crypto-core/model";
+import { DestinationSendResponse } from "../model";
+export declare class DestinationSendResponseCodec implements CodecContract<DestinationSendResponse> {
+    encode(value: DestinationSendResponse): Bytes;
+    decode(bytes: Bytes): Result<DestinationSendResponse, DecodeError>;
+}
+//# sourceMappingURL=DestinationSendResponseCodec.d.ts.map

package/dist/transport/codecs/DestinationSendResponseCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DestinationSendResponseCodec.d.ts","sourceRoot":"","sources":["../../../src/transport/codecs/DestinationSendResponseCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAA0B,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACxF,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAG9D,OAAO,EAGN,uBAAuB,EAEvB,MAAM,UAAU,CAAC;AAElB,qBAAa,4BAA6B,YAAW,aAAa,CAAC,uBAAuB,CAAC;IACnF,MAAM,CAAC,KAAK,EAAE,uBAAuB,GAAG,KAAK,CAqBnD;IAEM,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,uBAAuB,EAAE,WAAW,CAAC,CAsCxE;CACD"}

package/dist/transport/codecs/DestinationSendResponseCodec.js

@@ -0,0 +1,65 @@
+import { DecodeError } from "@okee-e2ee/core/errors";
+import { ByteReader, ByteWriter } from "../../crypto-core";
+import { DESTINATION_SEND_FORMAT_VERSION } from "../constants";
+import { DestinationSendErrorCode, DestinationSendResponseStatus } from "../model";
+export class DestinationSendResponseCodec {
+    encode(value) {
+        if (value.formatVersion !== DESTINATION_SEND_FORMAT_VERSION) {
+            throw new RangeError(`formatVersion must be ${DESTINATION_SEND_FORMAT_VERSION}`);
+        }
+        const status = value.status;
+        const writer = new ByteWriter()
+            .writeU8(value.formatVersion)
+            .writeU8(status)
+            .writeString(value.deliveryId);
+        if (value.status === DestinationSendResponseStatus.ERROR) {
+            if (!isDestinationSendErrorCode(value.errorCode)) {
+                throw new RangeError(`unsupported error code ${value.errorCode}`);
+            }
+            writer.writeU8(value.errorCode);
+        }
+        else if (status !== DestinationSendResponseStatus.SUCCESS) {
+            throw new RangeError(`unsupported response status ${status}`);
+        }
+        return writer.toBytes();
+    }
+    decode(bytes) {
+        const reader = new ByteReader(bytes);
+        try {
+            const versionOffset = reader.offset;
+            const formatVersion = reader.readU8();
+            if (formatVersion !== DESTINATION_SEND_FORMAT_VERSION) {
+                throw new DecodeError(`unsupported formatVersion ${formatVersion}`, versionOffset);
+            }
+            const statusOffset = reader.offset;
+            const status = reader.readU8();
+            const deliveryId = reader.readString();
+            if (status === DestinationSendResponseStatus.SUCCESS) {
+                reader.assertEnd();
+                return { ok: true, value: { formatVersion, status, deliveryId } };
+            }
+            if (status !== DestinationSendResponseStatus.ERROR) {
+                throw new DecodeError(`unsupported response status ${status}`, statusOffset);
+            }
+            const errorOffset = reader.offset;
+            const errorCode = reader.readU8();
+            if (!isDestinationSendErrorCode(errorCode)) {
+                throw new DecodeError(`unsupported error code ${errorCode}`, errorOffset);
+            }
+            reader.assertEnd();
+            return {
+                ok: true,
+                value: { formatVersion, status, deliveryId, errorCode }
+            };
+        }
+        catch (error) {
+            if (error instanceof DecodeError)
+                return { ok: false, error };
+            throw error;
+        }
+    }
+}
+function isDestinationSendErrorCode(value) {
+    return (value >= DestinationSendErrorCode.QUEUE_NOT_FOUND &&
+        value <= DestinationSendErrorCode.PAYLOAD_TOO_LARGE);
+}

package/dist/transport/codecs/TransportPacketCodec.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@okee-e2ee/core";
+import { DecodeError } from "@okee-e2ee/core/errors";
+import { type Bytes, CodecContract } from "../../crypto-core";
+import { type TransportPacket } from "../model";
+export declare class TransportPacketCodec implements CodecContract<TransportPacket> {
+    encode(value: TransportPacket): Bytes;
+    decode(bytes: Bytes): Result<TransportPacket, DecodeError>;
+    private _encodeRequest;
+    private _decodeRequest;
+    private _encodeResponse;
+    private _decodeResponse;
+    private _encodeDelivery;
+    private _decodeDelivery;
+}
+//# sourceMappingURL=TransportPacketCodec.d.ts.map

package/dist/transport/codecs/TransportPacketCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransportPacketCodec.d.ts","sourceRoot":"","sources":["../../../src/transport/codecs/TransportPacketCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAEN,KAAK,KAAK,EAEV,aAAa,EAIb,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAMN,KAAK,eAAe,EAKpB,MAAM,UAAU,CAAC;AAalB,qBAAa,oBAAqB,YAAW,aAAa,CAAC,eAAe,CAAC;IACnE,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,KAAK,CAwB3C;IAEM,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,eAAe,EAAE,WAAW,CAAC,CAoChE;IAED,OAAO,CAAC,cAAc;IA6BtB,OAAO,CAAC,cAAc;IAoBtB,OAAO,CAAC,eAAe;IAoBvB,OAAO,CAAC,eAAe;IAiCvB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,eAAe;CAqBvB"}

package/dist/transport/codecs/TransportPacketCodec.js

@@ -0,0 +1,214 @@
+import { DecodeError } from "@okee-e2ee/core/errors";
+import { ByteReader, ByteWriter, CRYPTO_SIZES_BYTES, HybridSignatureCodec } from "../../crypto-core";
+import { TRANSPORT_PACKET_FORMAT_VERSION } from "../constants";
+import { TransportCommandType, TransportErrorCode, TransportPacketType, TransportResponseStatus } from "../model";
+import { decodeTransportRequestPayload, decodeTransportResponsePayload, encodeTransportRequestPayload, encodeTransportResponsePayload } from "./internal/transport-payload-codecs";
+const authorizationCodec = new HybridSignatureCodec();
+const HYBRID_SIGNATURE_SIZE_BYTES = CRYPTO_SIZES_BYTES.ed25519Signature + CRYPTO_SIZES_BYTES.mlDsaSignature;
+export class TransportPacketCodec {
+    encode(value) {
+        if (value.formatVersion !== TRANSPORT_PACKET_FORMAT_VERSION) {
+            throw new RangeError(`formatVersion must be ${TRANSPORT_PACKET_FORMAT_VERSION}`);
+        }
+        const writer = new ByteWriter().writeU8(value.formatVersion).writeU8(value.type);
+        switch (value.type) {
+            case TransportPacketType.REQUEST:
+                this._encodeRequest(writer, value);
+                break;
+            case TransportPacketType.RESPONSE:
+                this._encodeResponse(writer, value);
+                break;
+            case TransportPacketType.DELIVERY:
+                this._encodeDelivery(writer, value);
+                break;
+            default:
+                throw new RangeError("unsupported packet type");
+        }
+        return writer.toBytes();
+    }
+    decode(bytes) {
+        const reader = new ByteReader(bytes);
+        try {
+            const versionOffset = reader.offset;
+            const formatVersion = reader.readU8();
+            if (formatVersion !== TRANSPORT_PACKET_FORMAT_VERSION) {
+                throw new DecodeError(`unsupported formatVersion ${formatVersion}`, versionOffset);
+            }
+            const typeOffset = reader.offset;
+            const type = reader.readU8();
+            let value;
+            switch (type) {
+                case TransportPacketType.REQUEST:
+                    value = this._decodeRequest(reader);
+                    break;
+                case TransportPacketType.RESPONSE:
+                    value = this._decodeResponse(reader);
+                    break;
+                case TransportPacketType.DELIVERY:
+                    value = this._decodeDelivery(reader);
+                    break;
+                default:
+                    throw new DecodeError(`unsupported packet type ${type}`, typeOffset);
+            }
+            reader.assertEnd();
+            return { ok: true, value };
+        }
+        catch (error) {
+            if (error instanceof DecodeError)
+                return { ok: false, error };
+            throw error;
+        }
+    }
+    _encodeRequest(writer, value) {
+        if (!isTransportCommandType(value.command)) {
+            throw new RangeError(`unsupported command ${value.command}`);
+        }
+        writer
+            .writeString(value.requestId)
+            .writeU8(value.command)
+            .writeBytes(encodeTransportRequestPayload(value.command, value.payload));
+        const authorization = value.authorization;
+        if (!requiresPacketAuthorization(value.command)) {
+            if (authorization !== undefined) {
+                throw new RangeError(`command ${value.command} must not contain packet authorization`);
+            }
+            return;
+        }
+        if (authorization === undefined) {
+            throw new RangeError(`command ${value.command} requires packet authorization`);
+        }
+        writer.writeFixedBytes(authorizationCodec.encode(authorization), HYBRID_SIGNATURE_SIZE_BYTES);
+    }
+    _decodeRequest(reader) {
+        const requestId = reader.readString();
+        const command = readTransportCommand(reader);
+        const payload = decodeTransportRequestPayload(command, reader.readBytes());
+        const base = {
+            formatVersion: TRANSPORT_PACKET_FORMAT_VERSION,
+            type: TransportPacketType.REQUEST,
+            requestId,
+            command,
+            payload
+        };
+        if (!requiresPacketAuthorization(command))
+            return base;
+        return {
+            ...base,
+            authorization: decodeAuthorization(reader)
+        };
+    }
+    _encodeResponse(writer, value) {
+        if (!isTransportCommandType(value.command)) {
+            throw new RangeError(`unsupported command ${value.command}`);
+        }
+        writer.writeString(value.requestId).writeU8(value.command).writeU8(value.status);
+        if (value.status === TransportResponseStatus.SUCCESS) {
+            writer.writeBytes(encodeTransportResponsePayload(value.command, value.payload));
+            return;
+        }
+        if (value.status !== TransportResponseStatus.ERROR) {
+            throw new RangeError("unsupported response status");
+        }
+        if (!isTransportErrorCode(value.errorCode)) {
+            throw new RangeError(`unsupported transport error code ${value.errorCode}`);
+        }
+        writer.writeU8(value.errorCode);
+    }
+    _decodeResponse(reader) {
+        const requestId = reader.readString();
+        const command = readTransportCommand(reader);
+        const statusOffset = reader.offset;
+        const status = reader.readU8();
+        const base = {
+            formatVersion: TRANSPORT_PACKET_FORMAT_VERSION,
+            type: TransportPacketType.RESPONSE,
+            requestId,
+            command
+        };
+        if (status === TransportResponseStatus.SUCCESS) {
+            return {
+                ...base,
+                status,
+                payload: decodeTransportResponsePayload(command, reader.readBytes())
+            };
+        }
+        if (status !== TransportResponseStatus.ERROR) {
+            throw new DecodeError(`unsupported response status ${status}`, statusOffset);
+        }
+        const errorOffset = reader.offset;
+        const errorCode = reader.readU8();
+        if (!isTransportErrorCode(errorCode)) {
+            throw new DecodeError(`unsupported transport error code ${errorCode}`, errorOffset);
+        }
+        return { ...base, status, errorCode };
+    }
+    _encodeDelivery(writer, value) {
+        writer.writeString(value.recipientQueueId).writeU32(value.deliveries.length);
+        for (const delivery of value.deliveries) {
+            writer.writeString(delivery.deliveryId).writeBytes(delivery.payload);
+        }
+    }
+    _decodeDelivery(reader) {
+        const recipientQueueId = reader.readString();
+        const deliveryCount = reader.readU32();
+        const deliveries = [];
+        for (let index = 0; index < deliveryCount; index += 1) {
+            deliveries.push({
+                deliveryId: reader.readString(),
+                payload: reader.readBytes()
+            });
+        }
+        return {
+            formatVersion: TRANSPORT_PACKET_FORMAT_VERSION,
+            type: TransportPacketType.DELIVERY,
+            recipientQueueId,
+            deliveries
+        };
+    }
+}
+function readTransportCommand(reader) {
+    const offset = reader.offset;
+    const command = reader.readU8();
+    if (!isTransportCommandType(command)) {
+        throw new DecodeError(`unsupported command ${command}`, offset);
+    }
+    return command;
+}
+function decodeAuthorization(reader) {
+    const result = authorizationCodec.decode(reader.readFixedBytes(HYBRID_SIGNATURE_SIZE_BYTES));
+    if (!result.ok)
+        throw result.error;
+    return result.value;
+}
+function requiresPacketAuthorization(command) {
+    return (command !== TransportCommandType.HEALTH &&
+        command !== TransportCommandType.SEND &&
+        command !== TransportCommandType.GET_DESTINATION_BUNDLE);
+}
+function isTransportCommandType(value) {
+    switch (value) {
+        case TransportCommandType.HEALTH:
+        case TransportCommandType.CREATE_QUEUE:
+        case TransportCommandType.REMOVE_QUEUE:
+        case TransportCommandType.SUBSCRIBE_QUEUE:
+        case TransportCommandType.UNSUBSCRIBE_QUEUE:
+        case TransportCommandType.SEND:
+        case TransportCommandType.ACK:
+        case TransportCommandType.GET_DESTINATION_BUNDLE:
+            return true;
+        default:
+            return false;
+    }
+}
+function isTransportErrorCode(value) {
+    switch (value) {
+        case TransportErrorCode.UNAVAILABLE:
+        case TransportErrorCode.TIMEOUT:
+        case TransportErrorCode.KEY_UNKNOWN:
+        case TransportErrorCode.KEY_EXPIRED:
+        case TransportErrorCode.RESPONSE_INVALID:
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/transport/codecs/encode-destination-send-authorization-input.d.ts

@@ -0,0 +1,4 @@
+import { Bytes } from "../../crypto-core";
+import { DestinationSendRequestPayload } from "../model";
+export declare function encodeDestinationSendAuthorizationInput(payload: DestinationSendRequestPayload): Bytes;
+//# sourceMappingURL=encode-destination-send-authorization-input.d.ts.map

package/dist/transport/codecs/encode-destination-send-authorization-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-destination-send-authorization-input.d.ts","sourceRoot":"","sources":["../../../src/transport/codecs/encode-destination-send-authorization-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAwB,MAAM,iCAAiC,CAAC;AAG9E,OAAO,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAC;AAIzD,wBAAgB,uCAAuC,CACtD,OAAO,EAAE,6BAA6B,GACpC,KAAK,CAKP"}

package/dist/transport/codecs/encode-destination-send-authorization-input.js

@@ -0,0 +1,6 @@
+import { encodeSignatureInput } from "../../crypto-core";
+import { DESTINATION_SEND_AUTHORIZATION_CONTEXT } from "../constants";
+import { encodeDestinationSendRequestPayload } from "./internal/destination-send-codec-helpers";
+export function encodeDestinationSendAuthorizationInput(payload) {
+    return encodeSignatureInput(DESTINATION_SEND_AUTHORIZATION_CONTEXT, encodeDestinationSendRequestPayload(payload));
+}

package/dist/transport/codecs/encode-relay-key-bundle-signature-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-relay-key-bundle-signature-input.d.ts","sourceRoot":"","sources":["../../../src/transport/codecs/encode-relay-key-bundle-signature-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAwB,MAAM,iCAAiC,CAAC;AAG9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAMpD,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,wBAAwB,GAAG,KAAK,CAE1F"}

package/dist/transport/{helpers → codecs}/encode-relay-key-bundle-signature-input.js

@@ -1,6 +1,6 @@
 import { encodeSignatureInput } from "../../crypto-core";
-import { RelayEncryptionKeyBundleCodec } from "../codecs";
 import { RELAY_KEY_BUNDLE_SIGNATURE_CONTEXT } from "../constants";
+import { RelayEncryptionKeyBundleCodec } from "./internal/RelayEncryptionKeyBundleCodec";
 const keyBundleCodec = new RelayEncryptionKeyBundleCodec();
 export function encodeRelayKeyBundleSignatureInput(bundle) {
     return encodeSignatureInput(RELAY_KEY_BUNDLE_SIGNATURE_CONTEXT, keyBundleCodec.encode(bundle));

package/dist/transport/codecs/encode-s2d-associated-data.d.ts

@@ -0,0 +1,5 @@
+import { Bytes } from "../../crypto-core";
+import { S2DAssociatedDataInput } from "../model";
+export declare function encodeS2DRequestAssociatedData(input: S2DAssociatedDataInput): Bytes;
+export declare function encodeS2DResponseAssociatedData(input: S2DAssociatedDataInput): Bytes;
+//# sourceMappingURL=encode-s2d-associated-data.d.ts.map

package/dist/transport/codecs/encode-s2d-associated-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-s2d-associated-data.d.ts","sourceRoot":"","sources":["../../../src/transport/codecs/encode-s2d-associated-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkC,MAAM,iCAAiC,CAAC;AAOxF,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAElD,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,sBAAsB,GAAG,KAAK,CAEnF;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,sBAAsB,GAAG,KAAK,CAEpF"}

package/dist/transport/codecs/encode-s2d-associated-data.js

@@ -0,0 +1,19 @@
+import { ByteWriter, CRYPTO_SIZES_BYTES } from "../../crypto-core";
+import { S2D_ENVELOPE_FORMAT_VERSION, S2D_REQUEST_ASSOCIATED_DATA_CONTEXT, S2D_RESPONSE_ASSOCIATED_DATA_CONTEXT } from "../constants";
+export function encodeS2DRequestAssociatedData(input) {
+    return encodeS2DAssociatedData(S2D_REQUEST_ASSOCIATED_DATA_CONTEXT, input);
+}
+export function encodeS2DResponseAssociatedData(input) {
+    return encodeS2DAssociatedData(S2D_RESPONSE_ASSOCIATED_DATA_CONTEXT, input);
+}
+function encodeS2DAssociatedData(context, input) {
+    return new ByteWriter()
+        .writeString(context)
+        .writeU8(S2D_ENVELOPE_FORMAT_VERSION)
+        .writeString(input.requestId)
+        .writeString(input.destination.address)
+        .writeFixedBytes(input.destination.fingerprint, CRYPTO_SIZES_BYTES.sha256)
+        .writeU64(input.epoch)
+        .writeFixedBytes(input.encapsulation, CRYPTO_SIZES_BYTES.xWingCiphertext)
+        .toBytes();
+}

package/dist/transport/codecs/encode-transport-request-authorization-input.d.ts

@@ -0,0 +1,4 @@
+import { Bytes } from "../../crypto-core";
+import { TransportRequestAuthorizationInput } from "../model";
+export declare function encodeTransportRequestAuthorizationInput(input: TransportRequestAuthorizationInput): Bytes;
+//# sourceMappingURL=encode-transport-request-authorization-input.d.ts.map

package/dist/transport/codecs/encode-transport-request-authorization-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-transport-request-authorization-input.d.ts","sourceRoot":"","sources":["../../../src/transport/codecs/encode-transport-request-authorization-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoC,MAAM,iCAAiC,CAAC;AAM1F,OAAO,EAGN,kCAAkC,EAClC,MAAM,UAAU,CAAC;AAIlB,wBAAgB,wCAAwC,CACvD,KAAK,EAAE,kCAAkC,GACvC,KAAK,CAoBP"}

package/dist/transport/codecs/encode-transport-request-authorization-input.js

@@ -0,0 +1,35 @@
+import { ByteWriter, encodeSignatureInput } from "../../crypto-core";
+import { TRANSPORT_PACKET_FORMAT_VERSION, TRANSPORT_REQUEST_AUTHORIZATION_CONTEXT } from "../constants";
+import { TransportCommandType, TransportPacketType } from "../model";
+import { encodeTransportRequestPayload } from "./internal/transport-payload-codecs";
+export function encodeTransportRequestAuthorizationInput(input) {
+    if (input.formatVersion !== TRANSPORT_PACKET_FORMAT_VERSION) {
+        throw new RangeError(`formatVersion must be ${TRANSPORT_PACKET_FORMAT_VERSION}`);
+    }
+    if (input.type !== TransportPacketType.REQUEST) {
+        throw new RangeError("type must be REQUEST");
+    }
+    if (!isAuthorizedCommand(input.command)) {
+        throw new RangeError(`command ${input.command} does not use packet authorization`);
+    }
+    const payload = new ByteWriter()
+        .writeU8(input.formatVersion)
+        .writeU8(input.type)
+        .writeString(input.requestId)
+        .writeU8(input.command)
+        .writeBytes(encodeTransportRequestPayload(input.command, input.payload))
+        .toBytes();
+    return encodeSignatureInput(TRANSPORT_REQUEST_AUTHORIZATION_CONTEXT, payload);
+}
+function isAuthorizedCommand(command) {
+    switch (command) {
+        case TransportCommandType.CREATE_QUEUE:
+        case TransportCommandType.REMOVE_QUEUE:
+        case TransportCommandType.SUBSCRIBE_QUEUE:
+        case TransportCommandType.UNSUBSCRIBE_QUEUE:
+        case TransportCommandType.ACK:
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/transport/codecs/index.d.ts

@@ -1,3 +1,8 @@
-export * from "./RelayEncryptionKeyBundleCodec";
-export * from "./RelayIdentityPublicKeyCodec";
+export * from "./DestinationSendRequestCodec";
+export * from "./DestinationSendResponseCodec";
+export * from "./TransportPacketCodec";
+export * from "./encode-destination-send-authorization-input";
+export * from "./encode-relay-key-bundle-signature-input";
+export * from "./encode-s2d-associated-data";
+export * from "./encode-transport-request-authorization-input";
 //# sourceMappingURL=index.d.ts.map

package/dist/transport/codecs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transport/codecs/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transport/codecs/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,+CAA+C,CAAC;AAC9D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gDAAgD,CAAC"}

package/dist/transport/codecs/index.js

@@ -1,2 +1,7 @@
-export * from "./RelayEncryptionKeyBundleCodec";
-export * from "./RelayIdentityPublicKeyCodec";
+export * from "./DestinationSendRequestCodec";
+export * from "./DestinationSendResponseCodec";
+export * from "./TransportPacketCodec";
+export * from "./encode-destination-send-authorization-input";
+export * from "./encode-relay-key-bundle-signature-input";
+export * from "./encode-s2d-associated-data";
+export * from "./encode-transport-request-authorization-input";

package/dist/transport/codecs/internal/InternalCodec.d.ts

@@ -0,0 +1,7 @@
+import { ByteReader, Bytes, ByteWriter } from "../../../crypto-core";
+export type InternalCodec<T> = {
+    encode(value: T): Bytes;
+    decode(bytes: Bytes): T;
+};
+export declare function createInternalCodec<T>(write: (writer: ByteWriter, value: T) => void, read: (reader: ByteReader) => T): InternalCodec<T>;
+//# sourceMappingURL=InternalCodec.d.ts.map

package/dist/transport/codecs/internal/InternalCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InternalCodec.d.ts","sourceRoot":"","sources":["../../../../src/transport/codecs/internal/InternalCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAEhF,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;IAC9B,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC;IACxB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC;CACxB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,CAAC,EACpC,KAAK,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,EAC7C,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,CAAC,GAC7B,aAAa,CAAC,CAAC,CAAC,CAclB"}