@dynamic-labs-wallet/forward-mpc-shared 0.1.0-alpha.6

package/dist/messages/SignMessageV1Response.d.ts

@@ -0,0 +1,47 @@
+import { TypeOf } from 'io-ts';
+import { WebSocketError } from '../types';
+/**
+ * Sign Message Response Runtime Data
+ */
+export interface SignMessageResponseData {
+    signature?: Uint8Array;
+    error?: WebSocketError;
+}
+/**
+ * Sign Message Response Wire Format
+ */
+export interface SignMessageResponseWire {
+    type: 'signMessage_response';
+    version: 1;
+    signature?: string;
+    error?: WebSocketError;
+}
+/**
+ * Sign Message Response Schema (built using Ultra-DRY utilities)
+ * Schema expects wire format types (string for signature)
+ */
+export declare const SignMessageResponseSchema: import("io-ts").Type<any, any, unknown>;
+export type SignMessageResponse = TypeOf<typeof SignMessageResponseSchema>;
+/**
+ * Sign Message V1 Response Message Class (Ultra-DRY implementation)
+ */
+export declare const SignMessageV1ResponseMessage: {
+    new (data: SignMessageResponseData): {
+        readonly type: "signMessage_response";
+        readonly version: 1;
+        encode(): SignMessageResponseWire;
+        readonly data: SignMessageResponseData;
+        getData(): SignMessageResponseData;
+    };
+    readonly MESSAGE_TYPE: "signMessage_response";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: import("io-ts").Type<any, any, unknown>;
+    decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+        readonly type: "signMessage_response";
+        readonly version: 1;
+        encode(): SignMessageResponseWire;
+        readonly data: SignMessageResponseData;
+        getData(): SignMessageResponseData;
+    }>;
+};
+//# sourceMappingURL=SignMessageV1Response.d.ts.map

package/dist/messages/SignMessageV1Response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignMessageV1Response.d.ts","sourceRoot":"","sources":["../../src/messages/SignMessageV1Response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqC,MAAM,OAAO,CAAC;AAOlE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAI1C;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,sBAAsB,CAAC;IAC7B,OAAO,EAAE,CAAC,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,yCAOrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;CAgBvC,CAAC"}

package/dist/messages/SignMessageV1Response.js

@@ -0,0 +1,28 @@
+import { union, undefined as undefinedType } from 'io-ts';
+import { buildMessageSchema, createStandardMessage, createComplexEncoder, createStandardDecoder, } from './utils';
+import { WebSocketErrorCodec } from '../codecs/WebSocketErrorCodec';
+import { Uint8ArrayOrHexCodec } from '../codecs/Uint8ArrayOrHexCodec';
+/**
+ * Sign Message Response Schema (built using Ultra-DRY utilities)
+ * Schema expects wire format types (string for signature)
+ */
+export const SignMessageResponseSchema = buildMessageSchema('signMessage_response', 1, {
+    signature: union([Uint8ArrayOrHexCodec, undefinedType]), // Codec handles both hex string and Uint8Array
+    error: union([WebSocketErrorCodec, undefinedType]),
+});
+/**
+ * Sign Message V1 Response Message Class (Ultra-DRY implementation)
+ */
+export const SignMessageV1ResponseMessage = createStandardMessage({
+    messageType: 'signMessage_response',
+    version: 1,
+    schema: SignMessageResponseSchema,
+    encodeData: createComplexEncoder('signMessage_response', 1, {
+        signature: (value) => Uint8ArrayOrHexCodec.encode(value),
+    }),
+    decodeData: createStandardDecoder((decoded) => ({
+        signature: decoded.signature,
+        error: decoded.error,
+    })),
+});
+//# sourceMappingURL=SignMessageV1Response.js.map

package/dist/messages/SignMessageV1Response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignMessageV1Response.js","sourceRoot":"","sources":["../../src/messages/SignMessageV1Response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,OAAO,CAAC;AAClE,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAoBtE;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,kBAAkB,CACzD,sBAAsB,EACtB,CAAC,EACD;IACE,SAAS,EAAE,KAAK,CAAC,CAAC,oBAAoB,EAAE,aAAa,CAAC,CAAC,EAAE,+CAA+C;IACxG,KAAK,EAAE,KAAK,CAAC,CAAC,mBAAmB,EAAE,aAAa,CAAC,CAAC;CACnD,CACF,CAAC;AAIF;;GAEG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,qBAAqB,CAK/D;IACA,WAAW,EAAE,sBAAsB;IACnC,OAAO,EAAE,CAAC;IACV,MAAM,EAAE,yBAAyB;IACjC,UAAU,EAAE,oBAAoB,CAAC,sBAAsB,EAAE,CAAC,EAAE;QAC1D,SAAS,EAAE,CAAC,KAAiB,EAAE,EAAE,CAAC,oBAAoB,CAAC,MAAM,CAAC,KAAK,CAAC;KACrE,CAAC;IACF,UAAU,EAAE,qBAAqB,CAA0B,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACvE,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,KAAK,EAAE,OAAO,CAAC,KAAK;KACrB,CAAC,CAAC;CACJ,CAAC,CAAC","sourcesContent":["import { TypeOf, union, undefined as undefinedType } from 'io-ts';\nimport {\n  buildMessageSchema,\n  createStandardMessage,\n  createComplexEncoder,\n  createStandardDecoder,\n} from './utils';\nimport { WebSocketError } from '../types';\nimport { WebSocketErrorCodec } from '../codecs/WebSocketErrorCodec';\nimport { Uint8ArrayOrHexCodec } from '../codecs/Uint8ArrayOrHexCodec';\n\n/**\n * Sign Message Response Runtime Data\n */\nexport interface SignMessageResponseData {\n  signature?: Uint8Array; // The signature as byte array - present on success\n  error?: WebSocketError; // Error details - present on failure\n}\n\n/**\n * Sign Message Response Wire Format\n */\nexport interface SignMessageResponseWire {\n  type: 'signMessage_response';\n  version: 1;\n  signature?: string; // The signature (hex-encoded) - present on success\n  error?: WebSocketError; // Error details - present on failure\n}\n\n/**\n * Sign Message Response Schema (built using Ultra-DRY utilities)\n * Schema expects wire format types (string for signature)\n */\nexport const SignMessageResponseSchema = buildMessageSchema(\n  'signMessage_response',\n  1,\n  {\n    signature: union([Uint8ArrayOrHexCodec, undefinedType]), // Codec handles both hex string and Uint8Array\n    error: union([WebSocketErrorCodec, undefinedType]),\n  }\n);\n\nexport type SignMessageResponse = TypeOf<typeof SignMessageResponseSchema>;\n\n/**\n * Sign Message V1 Response Message Class (Ultra-DRY implementation)\n */\nexport const SignMessageV1ResponseMessage = createStandardMessage<\n  SignMessageResponseData,\n  SignMessageResponseWire,\n  'signMessage_response',\n  1\n>({\n  messageType: 'signMessage_response',\n  version: 1,\n  schema: SignMessageResponseSchema,\n  encodeData: createComplexEncoder('signMessage_response', 1, {\n    signature: (value: Uint8Array) => Uint8ArrayOrHexCodec.encode(value),\n  }),\n  decodeData: createStandardDecoder<SignMessageResponseData>((decoded) => ({\n    signature: decoded.signature,\n    error: decoded.error,\n  })),\n});\n"]}

package/dist/messages/allMessages.d.ts

@@ -0,0 +1,259 @@
+/**
+ * 🎯 SINGLE SOURCE OF TRUTH - Add new messages here and everything else is automatic!
+ * This is the ONLY place you need to add new message types
+ */
+export declare const ALL_MESSAGE_CLASSES: {
+    readonly 'handshake@1': {
+        new (data: import("./HandshakeV1Request").HandshakeRequestData): {
+            readonly type: "handshake";
+            readonly version: 1;
+            encode(): import("./HandshakeV1Request").HandshakeRequestWire;
+            readonly data: import("./HandshakeV1Request").HandshakeRequestData;
+            getData(): import("./HandshakeV1Request").HandshakeRequestData;
+        };
+        readonly MESSAGE_TYPE: "handshake";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+            readonly type: "handshake";
+            readonly version: 1;
+            encode(): import("./HandshakeV1Request").HandshakeRequestWire;
+            readonly data: import("./HandshakeV1Request").HandshakeRequestData;
+            getData(): import("./HandshakeV1Request").HandshakeRequestData;
+        }>;
+    };
+    readonly 'handshake_response@1': {
+        new (data: import("./HandshakeV1Response").HandshakeResponseData): {
+            readonly type: "handshake_response";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./HandshakeV1Response").HandshakeResponseData;
+            getData(): import("./HandshakeV1Response").HandshakeResponseData;
+        };
+        readonly MESSAGE_TYPE: "handshake_response";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+            readonly type: "handshake_response";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./HandshakeV1Response").HandshakeResponseData;
+            getData(): import("./HandshakeV1Response").HandshakeResponseData;
+        }>;
+    };
+    readonly 'signMessage@1': {
+        new (data: import("./SignMessageV1Request").SignMessageRequestData): {
+            readonly type: "signMessage";
+            readonly version: 1;
+            encode(): unknown;
+            readonly data: import("./SignMessageV1Request").SignMessageRequestData;
+            getData(): import("./SignMessageV1Request").SignMessageRequestData;
+        };
+        readonly MESSAGE_TYPE: "signMessage";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+            readonly type: "signMessage";
+            readonly version: 1;
+            encode(): unknown;
+            readonly data: import("./SignMessageV1Request").SignMessageRequestData;
+            getData(): import("./SignMessageV1Request").SignMessageRequestData;
+        }>;
+    };
+    readonly 'signMessage_response@1': {
+        new (data: import("./SignMessageV1Response").SignMessageResponseData): {
+            readonly type: "signMessage_response";
+            readonly version: 1;
+            encode(): import("./SignMessageV1Response").SignMessageResponseWire;
+            readonly data: import("./SignMessageV1Response").SignMessageResponseData;
+            getData(): import("./SignMessageV1Response").SignMessageResponseData;
+        };
+        readonly MESSAGE_TYPE: "signMessage_response";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+            readonly type: "signMessage_response";
+            readonly version: 1;
+            encode(): import("./SignMessageV1Response").SignMessageResponseWire;
+            readonly data: import("./SignMessageV1Response").SignMessageResponseData;
+            getData(): import("./SignMessageV1Response").SignMessageResponseData;
+        }>;
+    };
+    readonly 'connection_ack@1': {
+        new (data: import("./ConnectionAckV1Request").ConnectionAckRequestData): {
+            readonly type: "connection_ack";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./ConnectionAckV1Request").ConnectionAckRequestData;
+            getData(): import("./ConnectionAckV1Request").ConnectionAckRequestData;
+        };
+        readonly MESSAGE_TYPE: "connection_ack";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+            readonly type: "connection_ack";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./ConnectionAckV1Request").ConnectionAckRequestData;
+            getData(): import("./ConnectionAckV1Request").ConnectionAckRequestData;
+        }>;
+    };
+    readonly 'connection_ack_response@1': {
+        new (data: import("./ConnectionAckV1Response").ConnectionAckResponseData): {
+            readonly type: "connection_ack_response";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./ConnectionAckV1Response").ConnectionAckResponseData;
+            getData(): import("./ConnectionAckV1Response").ConnectionAckResponseData;
+        };
+        readonly MESSAGE_TYPE: "connection_ack_response";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+            readonly type: "connection_ack_response";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./ConnectionAckV1Response").ConnectionAckResponseData;
+            getData(): import("./ConnectionAckV1Response").ConnectionAckResponseData;
+        }>;
+    };
+};
+/**
+ * Derive message type union from classes
+ */
+export type AllMessageTypes = keyof typeof ALL_MESSAGE_CLASSES;
+/**
+ * Derive runtime array of message keys from classes
+ */
+export declare const ALL_MESSAGE_KEYS: AllMessageTypes[];
+/**
+ * Get message class by type and version (derived from single source)
+ */
+export declare function getMessageClass(type: string, version: number): {
+    new (data: import("./HandshakeV1Request").HandshakeRequestData): {
+        readonly type: "handshake";
+        readonly version: 1;
+        encode(): import("./HandshakeV1Request").HandshakeRequestWire;
+        readonly data: import("./HandshakeV1Request").HandshakeRequestData;
+        getData(): import("./HandshakeV1Request").HandshakeRequestData;
+    };
+    readonly MESSAGE_TYPE: "handshake";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: import("io-ts").Type<any, any, unknown>;
+    decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+        readonly type: "handshake";
+        readonly version: 1;
+        encode(): import("./HandshakeV1Request").HandshakeRequestWire;
+        readonly data: import("./HandshakeV1Request").HandshakeRequestData;
+        getData(): import("./HandshakeV1Request").HandshakeRequestData;
+    }>;
+} | {
+    new (data: import("./HandshakeV1Response").HandshakeResponseData): {
+        readonly type: "handshake_response";
+        readonly version: 1;
+        encode(): any;
+        readonly data: import("./HandshakeV1Response").HandshakeResponseData;
+        getData(): import("./HandshakeV1Response").HandshakeResponseData;
+    };
+    readonly MESSAGE_TYPE: "handshake_response";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: import("io-ts").Type<any, any, unknown>;
+    decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+        readonly type: "handshake_response";
+        readonly version: 1;
+        encode(): any;
+        readonly data: import("./HandshakeV1Response").HandshakeResponseData;
+        getData(): import("./HandshakeV1Response").HandshakeResponseData;
+    }>;
+} | {
+    new (data: import("./SignMessageV1Request").SignMessageRequestData): {
+        readonly type: "signMessage";
+        readonly version: 1;
+        encode(): unknown;
+        readonly data: import("./SignMessageV1Request").SignMessageRequestData;
+        getData(): import("./SignMessageV1Request").SignMessageRequestData;
+    };
+    readonly MESSAGE_TYPE: "signMessage";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: import("io-ts").Type<any, any, unknown>;
+    decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+        readonly type: "signMessage";
+        readonly version: 1;
+        encode(): unknown;
+        readonly data: import("./SignMessageV1Request").SignMessageRequestData;
+        getData(): import("./SignMessageV1Request").SignMessageRequestData;
+    }>;
+} | {
+    new (data: import("./SignMessageV1Response").SignMessageResponseData): {
+        readonly type: "signMessage_response";
+        readonly version: 1;
+        encode(): import("./SignMessageV1Response").SignMessageResponseWire;
+        readonly data: import("./SignMessageV1Response").SignMessageResponseData;
+        getData(): import("./SignMessageV1Response").SignMessageResponseData;
+    };
+    readonly MESSAGE_TYPE: "signMessage_response";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: import("io-ts").Type<any, any, unknown>;
+    decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+        readonly type: "signMessage_response";
+        readonly version: 1;
+        encode(): import("./SignMessageV1Response").SignMessageResponseWire;
+        readonly data: import("./SignMessageV1Response").SignMessageResponseData;
+        getData(): import("./SignMessageV1Response").SignMessageResponseData;
+    }>;
+} | {
+    new (data: import("./ConnectionAckV1Request").ConnectionAckRequestData): {
+        readonly type: "connection_ack";
+        readonly version: 1;
+        encode(): any;
+        readonly data: import("./ConnectionAckV1Request").ConnectionAckRequestData;
+        getData(): import("./ConnectionAckV1Request").ConnectionAckRequestData;
+    };
+    readonly MESSAGE_TYPE: "connection_ack";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: import("io-ts").Type<any, any, unknown>;
+    decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+        readonly type: "connection_ack";
+        readonly version: 1;
+        encode(): any;
+        readonly data: import("./ConnectionAckV1Request").ConnectionAckRequestData;
+        getData(): import("./ConnectionAckV1Request").ConnectionAckRequestData;
+    }>;
+} | {
+    new (data: import("./ConnectionAckV1Response").ConnectionAckResponseData): {
+        readonly type: "connection_ack_response";
+        readonly version: 1;
+        encode(): any;
+        readonly data: import("./ConnectionAckV1Response").ConnectionAckResponseData;
+        getData(): import("./ConnectionAckV1Response").ConnectionAckResponseData;
+    };
+    readonly MESSAGE_TYPE: "connection_ack_response";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: import("io-ts").Type<any, any, unknown>;
+    decode(wireData: unknown): import("fp-ts/lib/Either").Either<import("io-ts").Errors, {
+        readonly type: "connection_ack_response";
+        readonly version: 1;
+        encode(): any;
+        readonly data: import("./ConnectionAckV1Response").ConnectionAckResponseData;
+        getData(): import("./ConnectionAckV1Response").ConnectionAckResponseData;
+    }>;
+};
+/**
+ * Type-safe check if message type exists
+ */
+export declare function isValidMessageType(type: string, version: number): boolean;
+/**
+ * Get all supported message types and versions
+ */
+export declare function getAllSupportedMessages(): Array<{
+    type: string;
+    version: number;
+}>;
+/**
+ * Helper to extract message type and version from key
+ */
+export declare function parseMessageKey(key: AllMessageTypes): {
+    type: string;
+    version: number;
+};
+//# sourceMappingURL=allMessages.d.ts.map

package/dist/messages/allMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allMessages.d.ts","sourceRoot":"","sources":["../../src/messages/allMessages.ts"],"names":[],"mappings":"AAOA;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOtB,CAAC;AAMX;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,mBAAmB,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAExB,eAAe,EAAE,CAAC;AAEvB;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS5D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAGzE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,KAAK,CAAC;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,CAKD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAGA"}

package/dist/messages/allMessages.js

@@ -0,0 +1,57 @@
+import { HandshakeV1RequestMessage } from './HandshakeV1Request';
+import { HandshakeV1ResponseMessage } from './HandshakeV1Response';
+import { SignMessageV1RequestMessage } from './SignMessageV1Request';
+import { SignMessageV1ResponseMessage } from './SignMessageV1Response';
+import { ConnectionAckV1RequestMessage } from './ConnectionAckV1Request';
+import { ConnectionAckV1ResponseMessage } from './ConnectionAckV1Response';
+/**
+ * 🎯 SINGLE SOURCE OF TRUTH - Add new messages here and everything else is automatic!
+ * This is the ONLY place you need to add new message types
+ */
+export const ALL_MESSAGE_CLASSES = {
+    'handshake@1': HandshakeV1RequestMessage,
+    'handshake_response@1': HandshakeV1ResponseMessage,
+    'signMessage@1': SignMessageV1RequestMessage,
+    'signMessage_response@1': SignMessageV1ResponseMessage,
+    'connection_ack@1': ConnectionAckV1RequestMessage,
+    'connection_ack_response@1': ConnectionAckV1ResponseMessage,
+};
+/**
+ * Derive runtime array of message keys from classes
+ */
+export const ALL_MESSAGE_KEYS = Object.keys(ALL_MESSAGE_CLASSES);
+/**
+ * Get message class by type and version (derived from single source)
+ */
+export function getMessageClass(type, version) {
+    const key = `${type}@${version}`;
+    const MessageClass = ALL_MESSAGE_CLASSES[key];
+    if (!MessageClass) {
+        throw new Error(`Unknown message type: ${type} version ${version}`);
+    }
+    return MessageClass;
+}
+/**
+ * Type-safe check if message type exists
+ */
+export function isValidMessageType(type, version) {
+    const key = `${type}@${version}`;
+    return key in ALL_MESSAGE_CLASSES;
+}
+/**
+ * Get all supported message types and versions
+ */
+export function getAllSupportedMessages() {
+    return ALL_MESSAGE_KEYS.map((key) => {
+        const [type, versionStr] = key.split('@');
+        return { type, version: parseInt(versionStr, 10) };
+    });
+}
+/**
+ * Helper to extract message type and version from key
+ */
+export function parseMessageKey(key) {
+    const [type, versionStr] = key.split('@');
+    return { type, version: parseInt(versionStr, 10) };
+}
+//# sourceMappingURL=allMessages.js.map

package/dist/messages/allMessages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allMessages.js","sourceRoot":"","sources":["../../src/messages/allMessages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAE3E;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,aAAa,EAAE,yBAAyB;IACxC,sBAAsB,EAAE,0BAA0B;IAClD,eAAe,EAAE,2BAA2B;IAC5C,wBAAwB,EAAE,4BAA4B;IACtD,kBAAkB,EAAE,6BAA6B;IACjD,2BAA2B,EAAE,8BAA8B;CACnD,CAAC;AAWX;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,IAAI,CACzC,mBAAmB,CACC,CAAC;AAEvB;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,OAAe;IAC3D,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,OAAO,EAAqB,CAAC;IACpD,MAAM,YAAY,GAAG,mBAAmB,CAAC,GAAG,CAAC,CAAC;IAE9C,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,MAAM,IAAI,KAAK,CAAC,yBAAyB,IAAI,YAAY,OAAO,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,YAAY,CAAC;AACtB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY,EAAE,OAAe;IAC9D,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,OAAO,EAAE,CAAC;IACjC,OAAO,GAAG,IAAI,mBAAmB,CAAC;AACpC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,uBAAuB;IAIrC,OAAO,gBAAgB,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;QAClC,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC1C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,EAAE,CAAC;IACrD,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,GAAoB;IAIlD,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC1C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,EAAE,CAAC;AACrD,CAAC","sourcesContent":["import { HandshakeV1RequestMessage } from './HandshakeV1Request';\nimport { HandshakeV1ResponseMessage } from './HandshakeV1Response';\nimport { SignMessageV1RequestMessage } from './SignMessageV1Request';\nimport { SignMessageV1ResponseMessage } from './SignMessageV1Response';\nimport { ConnectionAckV1RequestMessage } from './ConnectionAckV1Request';\nimport { ConnectionAckV1ResponseMessage } from './ConnectionAckV1Response';\n\n/**\n * 🎯 SINGLE SOURCE OF TRUTH - Add new messages here and everything else is automatic!\n * This is the ONLY place you need to add new message types\n */\nexport const ALL_MESSAGE_CLASSES = {\n  'handshake@1': HandshakeV1RequestMessage,\n  'handshake_response@1': HandshakeV1ResponseMessage,\n  'signMessage@1': SignMessageV1RequestMessage,\n  'signMessage_response@1': SignMessageV1ResponseMessage,\n  'connection_ack@1': ConnectionAckV1RequestMessage,\n  'connection_ack_response@1': ConnectionAckV1ResponseMessage,\n} as const;\n\n// ========================================\n// 🤖 EVERYTHING BELOW IS AUTOMATICALLY DERIVED\n// ========================================\n\n/**\n * Derive message type union from classes\n */\nexport type AllMessageTypes = keyof typeof ALL_MESSAGE_CLASSES;\n\n/**\n * Derive runtime array of message keys from classes\n */\nexport const ALL_MESSAGE_KEYS = Object.keys(\n  ALL_MESSAGE_CLASSES\n) as AllMessageTypes[];\n\n/**\n * Get message class by type and version (derived from single source)\n */\nexport function getMessageClass(type: string, version: number) {\n  const key = `${type}@${version}` as AllMessageTypes;\n  const MessageClass = ALL_MESSAGE_CLASSES[key];\n\n  if (!MessageClass) {\n    throw new Error(`Unknown message type: ${type} version ${version}`);\n  }\n\n  return MessageClass;\n}\n\n/**\n * Type-safe check if message type exists\n */\nexport function isValidMessageType(type: string, version: number): boolean {\n  const key = `${type}@${version}`;\n  return key in ALL_MESSAGE_CLASSES;\n}\n\n/**\n * Get all supported message types and versions\n */\nexport function getAllSupportedMessages(): Array<{\n  type: string;\n  version: number;\n}> {\n  return ALL_MESSAGE_KEYS.map((key) => {\n    const [type, versionStr] = key.split('@');\n    return { type, version: parseInt(versionStr, 10) };\n  });\n}\n\n/**\n * Helper to extract message type and version from key\n */\nexport function parseMessageKey(key: AllMessageTypes): {\n  type: string;\n  version: number;\n} {\n  const [type, versionStr] = key.split('@');\n  return { type, version: parseInt(versionStr, 10) };\n}\n"]}

package/dist/messages/base.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Base interface for all messages
+ */
+export interface IMessage<TRuntime = any, TWire = any> {
+    readonly type: string;
+    readonly version: number;
+    /**
+     * Encode this message to wire format for transmission
+     */
+    encode(): TWire;
+    /**
+     * Get the runtime data of this message
+     */
+    getData(): TRuntime;
+}
+/**
+ * Abstract base class for all messages
+ */
+export declare abstract class BaseMessage<TRuntime = any, TWire = any> implements IMessage<TRuntime, TWire> {
+    readonly data: TRuntime;
+    abstract readonly type: string;
+    abstract readonly version: number;
+    protected constructor(data: TRuntime);
+    abstract encode(): TWire;
+    getData(): TRuntime;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/messages/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/messages/base.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,QAAQ,GAAG,GAAG,EAAE,KAAK,GAAG,GAAG;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,MAAM,IAAI,KAAK,CAAC;IAEhB;;OAEG;IACH,OAAO,IAAI,QAAQ,CAAC;CACrB;AAED;;GAEG;AACH,8BAAsB,WAAW,CAAC,QAAQ,GAAG,GAAG,EAAE,KAAK,GAAG,GAAG,CAC3D,YAAW,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;aAKE,IAAI,EAAE,QAAQ;IAHpD,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAElC,SAAS,aAA6B,IAAI,EAAE,QAAQ;IAEpD,QAAQ,CAAC,MAAM,IAAI,KAAK;IAExB,OAAO,IAAI,QAAQ;CAGpB"}

package/dist/messages/base.js

@@ -0,0 +1,12 @@
+/**
+ * Abstract base class for all messages
+ */
+export class BaseMessage {
+    constructor(data) {
+        this.data = data;
+    }
+    getData() {
+        return this.data;
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/messages/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/messages/base.ts"],"names":[],"mappings":"AAkBA;;GAEG;AACH,MAAM,OAAgB,WAAW;IAM/B,YAAsC,IAAc;QAAd,SAAI,GAAJ,IAAI,CAAU;IAAG,CAAC;IAIxD,OAAO;QACL,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;CACF","sourcesContent":["/**\n * Base interface for all messages\n */\nexport interface IMessage<TRuntime = any, TWire = any> {\n  readonly type: string;\n  readonly version: number;\n\n  /**\n   * Encode this message to wire format for transmission\n   */\n  encode(): TWire;\n\n  /**\n   * Get the runtime data of this message\n   */\n  getData(): TRuntime;\n}\n\n/**\n * Abstract base class for all messages\n */\nexport abstract class BaseMessage<TRuntime = any, TWire = any>\n  implements IMessage<TRuntime, TWire>\n{\n  abstract readonly type: string;\n  abstract readonly version: number;\n\n  protected constructor(public readonly data: TRuntime) {}\n\n  abstract encode(): TWire;\n\n  getData(): TRuntime {\n    return this.data;\n  }\n}\n"]}

package/dist/messages/index.d.ts

@@ -0,0 +1,11 @@
+export * from './base';
+export * from './registry';
+export * from './HandshakeV1Request';
+export * from './HandshakeV1Response';
+export * from './SignMessageV1Request';
+export * from './SignMessageV1Response';
+export * from './ConnectionAckV1Request';
+export * from './ConnectionAckV1Response';
+export * from './allMessages';
+export { messageRegistry } from './registry';
+//# sourceMappingURL=index.d.ts.map

package/dist/messages/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/messages/index.ts"],"names":[],"mappings":"AACA,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAG3B,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAG1C,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/dist/messages/index.js

@@ -0,0 +1,14 @@
+// Export base classes and interfaces
+export * from './base';
+export * from './registry';
+// Export concrete message classes
+export * from './HandshakeV1Request';
+export * from './HandshakeV1Response';
+export * from './SignMessageV1Request';
+export * from './SignMessageV1Response';
+export * from './ConnectionAckV1Request';
+export * from './ConnectionAckV1Response';
+// Export Ultra-DRY message system
+export * from './allMessages';
+export { messageRegistry } from './registry';
+//# sourceMappingURL=index.js.map

package/dist/messages/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/messages/index.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAE3B,kCAAkC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAE1C,kCAAkC;AAClC,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC","sourcesContent":["// Export base classes and interfaces\nexport * from './base';\nexport * from './registry';\n\n// Export concrete message classes\nexport * from './HandshakeV1Request';\nexport * from './HandshakeV1Response';\nexport * from './SignMessageV1Request';\nexport * from './SignMessageV1Response';\nexport * from './ConnectionAckV1Request';\nexport * from './ConnectionAckV1Response';\n\n// Export Ultra-DRY message system\nexport * from './allMessages';\nexport { messageRegistry } from './registry';\n"]}

package/dist/messages/registry.d.ts

@@ -0,0 +1,136 @@
+import { Either } from 'fp-ts/lib/Either';
+import { IMessage } from './base';
+/**
+ * Ultra-DRY Message Registry - everything is derived, no registration needed
+ */
+export declare class MessageRegistry {
+    private static instance;
+    private constructor();
+    static getInstance(): MessageRegistry;
+    /**
+     * Get a message class by type and version (derived from single source)
+     */
+    getMessageClass(type: string, version: number): {
+        new (data: import("./HandshakeV1Request").HandshakeRequestData): {
+            readonly type: "handshake";
+            readonly version: 1;
+            encode(): import("./HandshakeV1Request").HandshakeRequestWire;
+            readonly data: import("./HandshakeV1Request").HandshakeRequestData;
+            getData(): import("./HandshakeV1Request").HandshakeRequestData;
+        };
+        readonly MESSAGE_TYPE: "handshake";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): Either<import("io-ts").Errors, {
+            readonly type: "handshake";
+            readonly version: 1;
+            encode(): import("./HandshakeV1Request").HandshakeRequestWire;
+            readonly data: import("./HandshakeV1Request").HandshakeRequestData;
+            getData(): import("./HandshakeV1Request").HandshakeRequestData;
+        }>;
+    } | {
+        new (data: import("./HandshakeV1Response").HandshakeResponseData): {
+            readonly type: "handshake_response";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./HandshakeV1Response").HandshakeResponseData;
+            getData(): import("./HandshakeV1Response").HandshakeResponseData;
+        };
+        readonly MESSAGE_TYPE: "handshake_response";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): Either<import("io-ts").Errors, {
+            readonly type: "handshake_response";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./HandshakeV1Response").HandshakeResponseData;
+            getData(): import("./HandshakeV1Response").HandshakeResponseData;
+        }>;
+    } | {
+        new (data: import("./SignMessageV1Request").SignMessageRequestData): {
+            readonly type: "signMessage";
+            readonly version: 1;
+            encode(): unknown;
+            readonly data: import("./SignMessageV1Request").SignMessageRequestData;
+            getData(): import("./SignMessageV1Request").SignMessageRequestData;
+        };
+        readonly MESSAGE_TYPE: "signMessage";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): Either<import("io-ts").Errors, {
+            readonly type: "signMessage";
+            readonly version: 1;
+            encode(): unknown;
+            readonly data: import("./SignMessageV1Request").SignMessageRequestData;
+            getData(): import("./SignMessageV1Request").SignMessageRequestData;
+        }>;
+    } | {
+        new (data: import("./SignMessageV1Response").SignMessageResponseData): {
+            readonly type: "signMessage_response";
+            readonly version: 1;
+            encode(): import("./SignMessageV1Response").SignMessageResponseWire;
+            readonly data: import("./SignMessageV1Response").SignMessageResponseData;
+            getData(): import("./SignMessageV1Response").SignMessageResponseData;
+        };
+        readonly MESSAGE_TYPE: "signMessage_response";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): Either<import("io-ts").Errors, {
+            readonly type: "signMessage_response";
+            readonly version: 1;
+            encode(): import("./SignMessageV1Response").SignMessageResponseWire;
+            readonly data: import("./SignMessageV1Response").SignMessageResponseData;
+            getData(): import("./SignMessageV1Response").SignMessageResponseData;
+        }>;
+    } | {
+        new (data: import("./ConnectionAckV1Request").ConnectionAckRequestData): {
+            readonly type: "connection_ack";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./ConnectionAckV1Request").ConnectionAckRequestData;
+            getData(): import("./ConnectionAckV1Request").ConnectionAckRequestData;
+        };
+        readonly MESSAGE_TYPE: "connection_ack";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): Either<import("io-ts").Errors, {
+            readonly type: "connection_ack";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./ConnectionAckV1Request").ConnectionAckRequestData;
+            getData(): import("./ConnectionAckV1Request").ConnectionAckRequestData;
+        }>;
+    } | {
+        new (data: import("./ConnectionAckV1Response").ConnectionAckResponseData): {
+            readonly type: "connection_ack_response";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./ConnectionAckV1Response").ConnectionAckResponseData;
+            getData(): import("./ConnectionAckV1Response").ConnectionAckResponseData;
+        };
+        readonly MESSAGE_TYPE: "connection_ack_response";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: import("io-ts").Type<any, any, unknown>;
+        decode(wireData: unknown): Either<import("io-ts").Errors, {
+            readonly type: "connection_ack_response";
+            readonly version: 1;
+            encode(): any;
+            readonly data: import("./ConnectionAckV1Response").ConnectionAckResponseData;
+            getData(): import("./ConnectionAckV1Response").ConnectionAckResponseData;
+        }>;
+    } | undefined;
+    /**
+     * Create a message instance from wire data (using derived message classes)
+     */
+    decode(wireData: any): Either<string, IMessage>;
+    /**
+     * Encode a message to wire format
+     */
+    encode(message: IMessage): any;
+    /**
+     * Get all registered message types (derived from single source)
+     */
+    getRegisteredTypes(): string[];
+}
+export declare const messageRegistry: MessageRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/messages/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/messages/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAGlC;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAkB;IAEzC,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,eAAe;IAOrC;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQ7C;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;IA6B/C;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAG;IAI9B;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;CAK/B;AAGD,eAAO,MAAM,eAAe,iBAAgC,CAAC"}