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

package/dist/messages/HandshakeV1Response.d.ts

@@ -1,47 +0,0 @@
-import { TypeOf } from 'io-ts';
-/**
- * Handshake Response Runtime Data
- */
-export interface HandshakeResponseData {
-    encapsulatedSharedSecret: string;
-    attestationDoc: string;
-    connectionId: string;
-}
-/**
- * Handshake Response Wire Format
- */
-export interface HandshakeResponseWire {
-    type: 'handshake_response';
-    version: 1;
-    encapsulatedSharedSecret: string;
-    attestationDoc: string;
-    connectionId: string;
-}
-/**
- * Handshake Response Schema (built using Ultra-DRY utilities)
- */
-export declare const HandshakeResponseSchema: import("io-ts").Type<any, any, unknown>;
-export type HandshakeResponse = TypeOf<typeof HandshakeResponseSchema>;
-/**
- * Handshake V1 Response Message Class (Ultra-DRY implementation)
- */
-export declare const HandshakeV1ResponseMessage: {
-    new (data: HandshakeResponseData): {
-        readonly type: "handshake_response";
-        readonly version: 1;
-        encode(): any;
-        readonly data: HandshakeResponseData;
-        getData(): 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: HandshakeResponseData;
-        getData(): HandshakeResponseData;
-    }>;
-};
-//# sourceMappingURL=HandshakeV1Response.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"HandshakeV1Response.d.ts","sourceRoot":"","sources":["../../src/messages/HandshakeV1Response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,OAAO,CAAC;AAGvC;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,wBAAwB,EAAE,MAAM,CAAC;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,CAAC,CAAC;IACX,wBAAwB,EAAE,MAAM,CAAC;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,yCAQnC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEvE;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;CAQrC,CAAC"}

package/dist/messages/HandshakeV1Response.js

@@ -1,20 +0,0 @@
-import { string } from 'io-ts';
-import { buildMessageSchema, createSimpleMessage } from './utils';
-/**
- * Handshake Response Schema (built using Ultra-DRY utilities)
- */
-export const HandshakeResponseSchema = buildMessageSchema('handshake_response', 1, {
-    encapsulatedSharedSecret: string,
-    attestationDoc: string,
-    connectionId: string,
-});
-/**
- * Handshake V1 Response Message Class (Ultra-DRY implementation)
- */
-export const HandshakeV1ResponseMessage = createSimpleMessage({
-    messageType: 'handshake_response',
-    version: 1,
-    schema: HandshakeResponseSchema,
-});
-// HandshakeResponse naturally implements IMessageConstructor through its static properties
-//# sourceMappingURL=HandshakeV1Response.js.map

package/dist/messages/HandshakeV1Response.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HandshakeV1Response.js","sourceRoot":"","sources":["../../src/messages/HandshakeV1Response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAsBlE;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,kBAAkB,CACvD,oBAAoB,EACpB,CAAC,EACD;IACE,wBAAwB,EAAE,MAAM;IAChC,cAAc,EAAE,MAAM;IACtB,YAAY,EAAE,MAAM;CACrB,CACF,CAAC;AAIF;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,mBAAmB,CAI3D;IACA,WAAW,EAAE,oBAAoB;IACjC,OAAO,EAAE,CAAC;IACV,MAAM,EAAE,uBAAuB;CAChC,CAAC,CAAC;AAEH,2FAA2F","sourcesContent":["import { string, TypeOf } from 'io-ts';\nimport { buildMessageSchema, createSimpleMessage } from './utils';\n\n/**\n * Handshake Response Runtime Data\n */\nexport interface HandshakeResponseData {\n  encapsulatedSharedSecret: string; // hex-encoded\n  attestationDoc: string; // hex-encoded\n  connectionId: string; // Server's connection ID for key derivation\n}\n\n/**\n * Handshake Response Wire Format\n */\nexport interface HandshakeResponseWire {\n  type: 'handshake_response';\n  version: 1;\n  encapsulatedSharedSecret: string; // hex-encoded\n  attestationDoc: string; // base64-encoded\n  connectionId: string; // Server's connection ID for key derivation\n}\n\n/**\n * Handshake Response Schema (built using Ultra-DRY utilities)\n */\nexport const HandshakeResponseSchema = buildMessageSchema(\n  'handshake_response',\n  1,\n  {\n    encapsulatedSharedSecret: string,\n    attestationDoc: string,\n    connectionId: string,\n  }\n);\n\nexport type HandshakeResponse = TypeOf<typeof HandshakeResponseSchema>;\n\n/**\n * Handshake V1 Response Message Class (Ultra-DRY implementation)\n */\nexport const HandshakeV1ResponseMessage = createSimpleMessage<\n  HandshakeResponseData,\n  'handshake_response',\n  1\n>({\n  messageType: 'handshake_response',\n  version: 1,\n  schema: HandshakeResponseSchema,\n});\n\n// HandshakeResponse naturally implements IMessageConstructor through its static properties\n"]}

package/dist/messages/SignMessageV1Request.d.ts

@@ -1,63 +0,0 @@
-import { TypeOf } from 'io-ts';
-import { HashAlgorithm } from '../constants';
-import { type EncryptedKeyshare } from '../codecs/EncryptedKeyshareCodec';
-import { SigningAlgorithm } from '@dynamic-labs-wallet/core';
-/**
- * Sign Message Request Runtime Data
- */
-export interface SignMessageRequestData {
-    relayDomain: string;
-    signingAlgo: SigningAlgorithm;
-    hashAlgo?: HashAlgorithm;
-    derivationPath?: Uint32Array;
-    tweak?: Uint8Array;
-    keyshare: EncryptedKeyshare;
-    message: Uint8Array | string;
-    roomUuid: string;
-}
-/**
- * Sign Message Request Wire Format
- */
-export interface SignMessageRequestWire {
-    type: 'signMessage';
-    version: 1;
-    relayDomain: string;
-    signingAlgo: SigningAlgorithm;
-    hashAlgo?: HashAlgorithm;
-    derivationPath?: string;
-    tweak?: string;
-    keyshare: {
-        salt: string;
-        encryptedPayload: string;
-    };
-    message: string;
-    roomUuid: string;
-}
-/**
- * Sign Message Request Schema - uses codecs that handle both formats automatically
- */
-export declare const SignMessageRequestSchema: import("io-ts").Type<any, any, unknown>;
-export type SignMessageRequest = TypeOf<typeof SignMessageRequestSchema>;
-/**
- * Sign Message V1 Request Message Class - Clean implementation using createComplexEncoder
- */
-export declare const SignMessageV1RequestMessage: {
-    new (data: SignMessageRequestData): {
-        readonly type: "signMessage";
-        readonly version: 1;
-        encode(): unknown;
-        readonly data: SignMessageRequestData;
-        getData(): 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: SignMessageRequestData;
-        getData(): SignMessageRequestData;
-    }>;
-};
-//# sourceMappingURL=SignMessageV1Request.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"SignMessageV1Request.d.ts","sourceRoot":"","sources":["../../src/messages/SignMessageV1Request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EACL,aAAa,EAGd,MAAM,cAAc,CAAC;AAEtB,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,kCAAkC,CAAC;AAQ1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,gBAAgB,CAAC;IAC9B,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,cAAc,CAAC,EAAE,WAAW,CAAC;IAC7B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,OAAO,EAAE,UAAU,GAAG,MAAM,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,CAAC,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,gBAAgB,CAAC;IAC9B,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,yCAUpC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;CAuBtC,CAAC"}

package/dist/messages/SignMessageV1Request.js

@@ -1,42 +0,0 @@
-import { string } from 'io-ts';
-import { Uint32ArrayCodec, Uint8ArrayCodec } from '../codecs';
-import { SignatureAlgoSchema, fromDynamicSigningAlgorithm, } from '../constants';
-import { DomainCodec } from '../codecs/DomainCodec';
-import { EncryptedKeyshareCodec, } from '../codecs/EncryptedKeyshareCodec';
-import { buildMessageSchema, createStandardMessage, createStandardDecoder, createComplexEncoder, } from './utils';
-import { Uint8ArrayOrHexCodec } from '../codecs/Uint8ArrayOrHexCodec';
-/**
- * Sign Message Request Schema - uses codecs that handle both formats automatically
- */
-export const SignMessageRequestSchema = buildMessageSchema('signMessage', 1, {
-    relayDomain: DomainCodec,
-    keyshare: EncryptedKeyshareCodec,
-    message: Uint8ArrayOrHexCodec,
-    roomUuid: string,
-}, SignatureAlgoSchema);
-/**
- * Sign Message V1 Request Message Class - Clean implementation using createComplexEncoder
- */
-export const SignMessageV1RequestMessage = createStandardMessage({
-    messageType: 'signMessage',
-    version: 1,
-    schema: SignMessageRequestSchema,
-    encodeData: createComplexEncoder('signMessage', 1, {
-        signingAlgo: (value) => fromDynamicSigningAlgorithm(value),
-        derivationPath: (value) => Uint32ArrayCodec.encode(value),
-        tweak: (value) => Uint8ArrayCodec.encode(value),
-        keyshare: (value) => EncryptedKeyshareCodec.encode(value),
-        message: (value) => Uint8ArrayOrHexCodec.encode(value),
-    }),
-    decodeData: createStandardDecoder((decoded) => ({
-        relayDomain: decoded.relayDomain,
-        signingAlgo: decoded.signingAlgo,
-        hashAlgo: decoded.hashAlgo,
-        derivationPath: decoded.derivationPath,
-        tweak: decoded.tweak,
-        keyshare: decoded.keyshare,
-        message: decoded.message,
-        roomUuid: decoded.roomUuid,
-    })),
-});
-//# sourceMappingURL=SignMessageV1Request.js.map

package/dist/messages/SignMessageV1Request.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SignMessageV1Request.js","sourceRoot":"","sources":["../../src/messages/SignMessageV1Request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC9D,OAAO,EAEL,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EACL,sBAAsB,GAEvB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAoCtE;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,kBAAkB,CACxD,aAAa,EACb,CAAC,EACD;IACE,WAAW,EAAE,WAAW;IACxB,QAAQ,EAAE,sBAAsB;IAChC,OAAO,EAAE,oBAAoB;IAC7B,QAAQ,EAAE,MAAM;CACjB,EACD,mBAAmB,CACpB,CAAC;AAIF;;GAEG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,qBAAqB,CAAC;IAC/D,WAAW,EAAE,aAAsB;IACnC,OAAO,EAAE,CAAU;IACnB,MAAM,EAAE,wBAAwB;IAChC,UAAU,EAAE,oBAAoB,CAAC,aAAa,EAAE,CAAC,EAAE;QACjD,WAAW,EAAE,CAAC,KAAuB,EAAE,EAAE,CACvC,2BAA2B,CAAC,KAAK,CAAC;QACpC,cAAc,EAAE,CAAC,KAAkB,EAAE,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC;QACtE,KAAK,EAAE,CAAC,KAAiB,EAAE,EAAE,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC;QAC3D,QAAQ,EAAE,CAAC,KAAwB,EAAE,EAAE,CACrC,sBAAsB,CAAC,MAAM,CAAC,KAAK,CAAC;QACtC,OAAO,EAAE,CAAC,KAA0B,EAAE,EAAE,CAAC,oBAAoB,CAAC,MAAM,CAAC,KAAK,CAAC;KAC5E,CAAC;IACF,UAAU,EAAE,qBAAqB,CAAyB,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACtE,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,cAAc,EAAE,OAAO,CAAC,cAAc;QACtC,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,QAAQ,EAAE,OAAO,CAAC,QAAQ;KAC3B,CAAC,CAAC;CACJ,CAAC,CAAC","sourcesContent":["import { string, TypeOf } from 'io-ts';\nimport { Uint32ArrayCodec, Uint8ArrayCodec } from '../codecs';\nimport {\n  HashAlgorithm,\n  SignatureAlgoSchema,\n  fromDynamicSigningAlgorithm,\n} from '../constants';\nimport { DomainCodec } from '../codecs/DomainCodec';\nimport {\n  EncryptedKeyshareCodec,\n  type EncryptedKeyshare,\n} from '../codecs/EncryptedKeyshareCodec';\nimport {\n  buildMessageSchema,\n  createStandardMessage,\n  createStandardDecoder,\n  createComplexEncoder,\n} from './utils';\nimport { Uint8ArrayOrHexCodec } from '../codecs/Uint8ArrayOrHexCodec';\nimport { SigningAlgorithm } from '@dynamic-labs-wallet/core';\n\n/**\n * Sign Message Request Runtime Data\n */\nexport interface SignMessageRequestData {\n  relayDomain: string;\n  signingAlgo: SigningAlgorithm;\n  hashAlgo?: HashAlgorithm;\n  derivationPath?: Uint32Array;\n  tweak?: Uint8Array;\n  keyshare: EncryptedKeyshare;\n  message: Uint8Array | string;\n  roomUuid: string;\n}\n\n/**\n * Sign Message Request Wire Format\n */\nexport interface SignMessageRequestWire {\n  type: 'signMessage';\n  version: 1;\n  relayDomain: string;\n  signingAlgo: SigningAlgorithm;\n  hashAlgo?: HashAlgorithm;\n  derivationPath?: string; // hex string\n  tweak?: string; // hex string\n  keyshare: {\n    salt: string; // hex string\n    encryptedPayload: string; // hex string\n  };\n  message: string; // hex string\n  roomUuid: string;\n}\n\n/**\n * Sign Message Request Schema - uses codecs that handle both formats automatically\n */\nexport const SignMessageRequestSchema = buildMessageSchema(\n  'signMessage',\n  1,\n  {\n    relayDomain: DomainCodec,\n    keyshare: EncryptedKeyshareCodec,\n    message: Uint8ArrayOrHexCodec,\n    roomUuid: string,\n  },\n  SignatureAlgoSchema\n);\n\nexport type SignMessageRequest = TypeOf<typeof SignMessageRequestSchema>;\n\n/**\n * Sign Message V1 Request Message Class - Clean implementation using createComplexEncoder\n */\nexport const SignMessageV1RequestMessage = createStandardMessage({\n  messageType: 'signMessage' as const,\n  version: 1 as const,\n  schema: SignMessageRequestSchema,\n  encodeData: createComplexEncoder('signMessage', 1, {\n    signingAlgo: (value: SigningAlgorithm) =>\n      fromDynamicSigningAlgorithm(value),\n    derivationPath: (value: Uint32Array) => Uint32ArrayCodec.encode(value),\n    tweak: (value: Uint8Array) => Uint8ArrayCodec.encode(value),\n    keyshare: (value: EncryptedKeyshare) =>\n      EncryptedKeyshareCodec.encode(value),\n    message: (value: Uint8Array | string) => Uint8ArrayOrHexCodec.encode(value),\n  }),\n  decodeData: createStandardDecoder<SignMessageRequestData>((decoded) => ({\n    relayDomain: decoded.relayDomain,\n    signingAlgo: decoded.signingAlgo,\n    hashAlgo: decoded.hashAlgo,\n    derivationPath: decoded.derivationPath,\n    tweak: decoded.tweak,\n    keyshare: decoded.keyshare,\n    message: decoded.message,\n    roomUuid: decoded.roomUuid,\n  })),\n});\n"]}

package/dist/messages/SignMessageV1Response.d.ts

@@ -1,47 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,28 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,259 +0,0 @@
-/**
- * 🎯 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

@@ -1 +0,0 @@
-{"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

@@ -1,57 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,27 +0,0 @@
-/**
- * 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