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

package/dist/crypto/index.d.ts

@@ -0,0 +1,6 @@
+export { generateMlKem768Keypair } from './generateKeypair';
+export { encapsulateMlKem768 } from './encapsulate';
+export { decapsulateMlKem768 } from './decapsulate';
+export * from './keyDerivation';
+export * from './keyshareEncryption';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/crypto/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC"}

package/dist/crypto/index.js

@@ -0,0 +1,6 @@
+export { generateMlKem768Keypair } from './generateKeypair';
+export { encapsulateMlKem768 } from './encapsulate';
+export { decapsulateMlKem768 } from './decapsulate';
+export * from './keyDerivation';
+export * from './keyshareEncryption';
+//# sourceMappingURL=index.js.map

package/dist/crypto/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/crypto/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC","sourcesContent":["export { generateMlKem768Keypair } from './generateKeypair';\nexport { encapsulateMlKem768 } from './encapsulate';\nexport { decapsulateMlKem768 } from './decapsulate';\nexport * from './keyDerivation';\nexport * from './keyshareEncryption';\n"]}

package/dist/crypto/keyDerivation.d.ts

@@ -0,0 +1,14 @@
+export declare const AES_256_GCM_KEY_SIZE = 32;
+export declare const AES_256_GCM_NONCE_SIZE = 12;
+export declare const AES_256_GCM_TAG_SIZE = 16;
+export declare const HKDF_SALT_SIZE = 32;
+/**
+ * Derive AES-256 key from ML-KEM shared secret using HKDF
+ * Following NIST SP 800-56C recommendations
+ */
+export declare function deriveAESKey(sharedSecret: Uint8Array, salt: Uint8Array, info: string): Uint8Array;
+/**
+ * Create standardized context info for HKDF
+ */
+export declare function createKeyDerivationInfo(purpose: 'keyshare' | 'hmac', connectionId: string, version?: number): string;
+//# sourceMappingURL=keyDerivation.d.ts.map

package/dist/crypto/keyDerivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyDerivation.d.ts","sourceRoot":"","sources":["../../src/crypto/keyDerivation.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,YAAY,EAAE,UAAU,EACxB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,GACX,UAAU,CAGZ;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,UAAU,GAAG,MAAM,EAC5B,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,MAAU,GAClB,MAAM,CAER"}

package/dist/crypto/keyDerivation.js

@@ -0,0 +1,21 @@
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+export const AES_256_GCM_KEY_SIZE = 32; // 256 bits
+export const AES_256_GCM_NONCE_SIZE = 12; // 96 bits
+export const AES_256_GCM_TAG_SIZE = 16; // 128 bits
+export const HKDF_SALT_SIZE = 32; // 256 bits
+/**
+ * Derive AES-256 key from ML-KEM shared secret using HKDF
+ * Following NIST SP 800-56C recommendations
+ */
+export function deriveAESKey(sharedSecret, salt, info) {
+    const infoBytes = new TextEncoder().encode(info);
+    return hkdf(sha256, sharedSecret, salt, infoBytes, AES_256_GCM_KEY_SIZE);
+}
+/**
+ * Create standardized context info for HKDF
+ */
+export function createKeyDerivationInfo(purpose, connectionId, version = 1) {
+    return `forward-mpc-${purpose}-v${version}-${connectionId}`;
+}
+//# sourceMappingURL=keyDerivation.js.map

package/dist/crypto/keyDerivation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyDerivation.js","sourceRoot":"","sources":["../../src/crypto/keyDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC,CAAC,WAAW;AACnD,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC,CAAC,UAAU;AACpD,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC,CAAC,WAAW;AACnD,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,CAAC,CAAC,WAAW;AAE7C;;;GAGG;AACH,MAAM,UAAU,YAAY,CAC1B,YAAwB,EACxB,IAAgB,EAChB,IAAY;IAEZ,MAAM,SAAS,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjD,OAAO,IAAI,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,oBAAoB,CAAC,CAAC;AAC3E,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,uBAAuB,CACrC,OAA4B,EAC5B,YAAoB,EACpB,UAAkB,CAAC;IAEnB,OAAO,eAAe,OAAO,KAAK,OAAO,IAAI,YAAY,EAAE,CAAC;AAC9D,CAAC","sourcesContent":["import { hkdf } from '@noble/hashes/hkdf.js';\nimport { sha256 } from '@noble/hashes/sha2.js';\n\nexport const AES_256_GCM_KEY_SIZE = 32; // 256 bits\nexport const AES_256_GCM_NONCE_SIZE = 12; // 96 bits\nexport const AES_256_GCM_TAG_SIZE = 16; // 128 bits\nexport const HKDF_SALT_SIZE = 32; // 256 bits\n\n/**\n * Derive AES-256 key from ML-KEM shared secret using HKDF\n * Following NIST SP 800-56C recommendations\n */\nexport function deriveAESKey(\n  sharedSecret: Uint8Array,\n  salt: Uint8Array,\n  info: string\n): Uint8Array {\n  const infoBytes = new TextEncoder().encode(info);\n  return hkdf(sha256, sharedSecret, salt, infoBytes, AES_256_GCM_KEY_SIZE);\n}\n\n/**\n * Create standardized context info for HKDF\n */\nexport function createKeyDerivationInfo(\n  purpose: 'keyshare' | 'hmac',\n  connectionId: string,\n  version: number = 1\n): string {\n  return `forward-mpc-${purpose}-v${version}-${connectionId}`;\n}\n"]}

package/dist/crypto/keyshareEncryption.d.ts

@@ -0,0 +1,13 @@
+import type { EncryptedKeyshare } from '../codecs/EncryptedKeyshareCodec';
+import type { SigningAlgorithmName } from '../signing/allAlgorithms';
+/**
+ * Encrypt keyshare using AES-256-GCM with ML-KEM derived key
+ *
+ * @param keyshare - The keyshare object from Dynamic Wallet SDK
+ * @param sharedSecret - ML-KEM shared secret from handshake
+ * @param connectionId - Unique connection identifier
+ * @param signingAlgorithm - Algorithm name for context
+ * @returns Encrypted keyshare with salt and encrypted payload
+ */
+export declare function encryptKeyshare(keyshare: any, sharedSecret: Uint8Array, connectionId: string, signingAlgorithm: SigningAlgorithmName): Promise<EncryptedKeyshare>;
+//# sourceMappingURL=keyshareEncryption.d.ts.map

package/dist/crypto/keyshareEncryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyshareEncryption.d.ts","sourceRoot":"","sources":["../../src/crypto/keyshareEncryption.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,GAAG,EACb,YAAY,EAAE,UAAU,EACxB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,oBAAoB,GACrC,OAAO,CAAC,iBAAiB,CAAC,CA+B5B"}

package/dist/crypto/keyshareEncryption.js

@@ -0,0 +1,39 @@
+import { gcm } from '@noble/ciphers/aes';
+import { bytesToHex, randomBytes } from '@noble/hashes/utils.js';
+import { deriveAESKey, createKeyDerivationInfo } from './keyDerivation';
+/**
+ * Encrypt keyshare using AES-256-GCM with ML-KEM derived key
+ *
+ * @param keyshare - The keyshare object from Dynamic Wallet SDK
+ * @param sharedSecret - ML-KEM shared secret from handshake
+ * @param connectionId - Unique connection identifier
+ * @param signingAlgorithm - Algorithm name for context
+ * @returns Encrypted keyshare with salt and encrypted payload
+ */
+export async function encryptKeyshare(keyshare, sharedSecret, connectionId, signingAlgorithm) {
+    // Generate random salt for HKDF
+    const salt = randomBytes(32);
+    // Derive AES key using HKDF with connection-specific context
+    const keyshareInfo = createKeyDerivationInfo('keyshare', connectionId);
+    const aesKey = deriveAESKey(sharedSecret, salt, keyshareInfo);
+    // Prepare keyshare data for encryption
+    const keyshareData = {
+        keyshare,
+        signingAlgorithm,
+        timestamp: Date.now(),
+        nonce: bytesToHex(randomBytes(16)),
+    };
+    // Encrypt with AES-256-GCM
+    const nonce = randomBytes(12);
+    const aes256Gcm = gcm(aesKey, nonce);
+    const plaintext = new TextEncoder().encode(JSON.stringify(keyshareData));
+    const ciphertext = aes256Gcm.encrypt(plaintext);
+    // Combine nonce + ciphertext for single payload
+    const encryptedPayload = new Uint8Array(nonce.length + ciphertext.length);
+    encryptedPayload.set(nonce, 0);
+    encryptedPayload.set(ciphertext, nonce.length);
+    // Clear sensitive data from memory
+    aesKey.fill(0);
+    return { salt, encryptedPayload };
+}
+//# sourceMappingURL=keyshareEncryption.js.map

package/dist/crypto/keyshareEncryption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyshareEncryption.js","sourceRoot":"","sources":["../../src/crypto/keyshareEncryption.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAIxE;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,QAAa,EACb,YAAwB,EACxB,YAAoB,EACpB,gBAAsC;IAEtC,gCAAgC;IAChC,MAAM,IAAI,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;IAE7B,6DAA6D;IAC7D,MAAM,YAAY,GAAG,uBAAuB,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;IACvE,MAAM,MAAM,GAAG,YAAY,CAAC,YAAY,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;IAE9D,uCAAuC;IACvC,MAAM,YAAY,GAAG;QACnB,QAAQ;QACR,gBAAgB;QAChB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;QACrB,KAAK,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;KACnC,CAAC;IAEF,2BAA2B;IAC3B,MAAM,KAAK,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;IAC9B,MAAM,SAAS,GAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACrC,MAAM,SAAS,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC;IACzE,MAAM,UAAU,GAAG,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAEhD,gDAAgD;IAChD,MAAM,gBAAgB,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAC1E,gBAAgB,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC/B,gBAAgB,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAE/C,mCAAmC;IACnC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAEf,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC;AACpC,CAAC","sourcesContent":["import { gcm } from '@noble/ciphers/aes';\nimport { bytesToHex, randomBytes } from '@noble/hashes/utils.js';\nimport { deriveAESKey, createKeyDerivationInfo } from './keyDerivation';\nimport type { EncryptedKeyshare } from '../codecs/EncryptedKeyshareCodec';\nimport type { SigningAlgorithmName } from '../signing/allAlgorithms';\n\n/**\n * Encrypt keyshare using AES-256-GCM with ML-KEM derived key\n *\n * @param keyshare - The keyshare object from Dynamic Wallet SDK\n * @param sharedSecret - ML-KEM shared secret from handshake\n * @param connectionId - Unique connection identifier\n * @param signingAlgorithm - Algorithm name for context\n * @returns Encrypted keyshare with salt and encrypted payload\n */\nexport async function encryptKeyshare(\n  keyshare: any,\n  sharedSecret: Uint8Array,\n  connectionId: string,\n  signingAlgorithm: SigningAlgorithmName\n): Promise<EncryptedKeyshare> {\n  // Generate random salt for HKDF\n  const salt = randomBytes(32);\n\n  // Derive AES key using HKDF with connection-specific context\n  const keyshareInfo = createKeyDerivationInfo('keyshare', connectionId);\n  const aesKey = deriveAESKey(sharedSecret, salt, keyshareInfo);\n\n  // Prepare keyshare data for encryption\n  const keyshareData = {\n    keyshare,\n    signingAlgorithm,\n    timestamp: Date.now(),\n    nonce: bytesToHex(randomBytes(16)),\n  };\n\n  // Encrypt with AES-256-GCM\n  const nonce = randomBytes(12);\n  const aes256Gcm = gcm(aesKey, nonce);\n  const plaintext = new TextEncoder().encode(JSON.stringify(keyshareData));\n  const ciphertext = aes256Gcm.encrypt(plaintext);\n\n  // Combine nonce + ciphertext for single payload\n  const encryptedPayload = new Uint8Array(nonce.length + ciphertext.length);\n  encryptedPayload.set(nonce, 0);\n  encryptedPayload.set(ciphertext, nonce.length);\n\n  // Clear sensitive data from memory\n  aesKey.fill(0);\n\n  return { salt, encryptedPayload };\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './messages';
+export * from './codecs';
+export * from './crypto';
+export * from './utils/assertDefined';
+export * from './constants';
+export * from './signing';
+export { toDynamicSigningAlgorithm, fromDynamicSigningAlgorithm, } from './constants/algorithms';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,SAAS,CAAC;AAGxB,cAAc,YAAY,CAAC;AAG3B,cAAc,UAAU,CAAC;AAGzB,cAAc,UAAU,CAAC;AAGzB,cAAc,uBAAuB,CAAC;AAGtC,cAAc,aAAa,CAAC;AAG5B,cAAc,WAAW,CAAC;AAK1B,OAAO,EACL,yBAAyB,EACzB,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+// Export types
+export * from './types';
+// Export all message schemas, types, and classes
+export * from './messages';
+// Export codecs
+export * from './codecs';
+// Export crypto functions
+export * from './crypto';
+// Export utilities
+export * from './utils/assertDefined';
+// Export constants
+export * from './constants';
+// Export signing algorithms (Ultra-DRY)
+export * from './signing';
+// Attestation verification has been moved to the client package
+// Export algorithm conversion utilities
+export { toDynamicSigningAlgorithm, fromDynamicSigningAlgorithm, } from './constants/algorithms';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,cAAc,SAAS,CAAC;AAExB,iDAAiD;AACjD,cAAc,YAAY,CAAC;AAE3B,gBAAgB;AAChB,cAAc,UAAU,CAAC;AAEzB,0BAA0B;AAC1B,cAAc,UAAU,CAAC;AAEzB,mBAAmB;AACnB,cAAc,uBAAuB,CAAC;AAEtC,mBAAmB;AACnB,cAAc,aAAa,CAAC;AAE5B,wCAAwC;AACxC,cAAc,WAAW,CAAC;AAE1B,gEAAgE;AAEhE,wCAAwC;AACxC,OAAO,EACL,yBAAyB,EACzB,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC","sourcesContent":["// Export types\nexport * from './types';\n\n// Export all message schemas, types, and classes\nexport * from './messages';\n\n// Export codecs\nexport * from './codecs';\n\n// Export crypto functions\nexport * from './crypto';\n\n// Export utilities\nexport * from './utils/assertDefined';\n\n// Export constants\nexport * from './constants';\n\n// Export signing algorithms (Ultra-DRY)\nexport * from './signing';\n\n// Attestation verification has been moved to the client package\n\n// Export algorithm conversion utilities\nexport {\n  toDynamicSigningAlgorithm,\n  fromDynamicSigningAlgorithm,\n} from './constants/algorithms';\n"]}

package/dist/messages/ConnectionAckV1Request.d.ts

@@ -0,0 +1,43 @@
+import { TypeOf } from 'io-ts';
+/**
+ * Connection Acknowledgment Request Runtime Data
+ */
+export interface ConnectionAckRequestData {
+    connectionId?: string;
+}
+/**
+ * Connection Acknowledgment Request Wire Format
+ */
+export interface ConnectionAckRequestWire {
+    type: 'connection_ack';
+    version: 1;
+    connectionId?: string;
+}
+/**
+ * Connection Acknowledgment Request Schema (built using Ultra-DRY utilities)
+ */
+export declare const ConnectionAckRequestSchema: import("io-ts").Type<any, any, unknown>;
+export type ConnectionAckRequest = TypeOf<typeof ConnectionAckRequestSchema>;
+/**
+ * Connection Acknowledgment V1 Request Message Class (Ultra-DRY implementation)
+ */
+export declare const ConnectionAckV1RequestMessage: {
+    new (data: ConnectionAckRequestData): {
+        readonly type: "connection_ack";
+        readonly version: 1;
+        encode(): any;
+        readonly data: ConnectionAckRequestData;
+        getData(): 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: ConnectionAckRequestData;
+        getData(): ConnectionAckRequestData;
+    }>;
+};
+//# sourceMappingURL=ConnectionAckV1Request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionAckV1Request.d.ts","sourceRoot":"","sources":["../../src/messages/ConnectionAckV1Request.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6C,MAAM,EAAE,MAAM,OAAO,CAAC;AAG1E;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,CAAC,CAAC;IACX,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B,yCAMtC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;CAQxC,CAAC"}

package/dist/messages/ConnectionAckV1Request.js

@@ -0,0 +1,17 @@
+import { union, string, undefined as undefinedType } from 'io-ts';
+import { buildMessageSchema, createSimpleMessage } from './utils';
+/**
+ * Connection Acknowledgment Request Schema (built using Ultra-DRY utilities)
+ */
+export const ConnectionAckRequestSchema = buildMessageSchema('connection_ack', 1, {
+    connectionId: union([string, undefinedType]), // Optional string connectionId
+});
+/**
+ * Connection Acknowledgment V1 Request Message Class (Ultra-DRY implementation)
+ */
+export const ConnectionAckV1RequestMessage = createSimpleMessage({
+    messageType: 'connection_ack',
+    version: 1,
+    schema: ConnectionAckRequestSchema,
+});
+//# sourceMappingURL=ConnectionAckV1Request.js.map

package/dist/messages/ConnectionAckV1Request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionAckV1Request.js","sourceRoot":"","sources":["../../src/messages/ConnectionAckV1Request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,IAAI,aAAa,EAAU,MAAM,OAAO,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAkBlE;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,kBAAkB,CAC1D,gBAAgB,EAChB,CAAC,EACD;IACE,YAAY,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,+BAA+B;CAC9E,CACF,CAAC;AAIF;;GAEG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,mBAAmB,CAI9D;IACA,WAAW,EAAE,gBAAgB;IAC7B,OAAO,EAAE,CAAC;IACV,MAAM,EAAE,0BAA0B;CACnC,CAAC,CAAC","sourcesContent":["import { union, string, undefined as undefinedType, TypeOf } from 'io-ts';\nimport { buildMessageSchema, createSimpleMessage } from './utils';\n\n/**\n * Connection Acknowledgment Request Runtime Data\n */\nexport interface ConnectionAckRequestData {\n  connectionId?: string;\n}\n\n/**\n * Connection Acknowledgment Request Wire Format\n */\nexport interface ConnectionAckRequestWire {\n  type: 'connection_ack';\n  version: 1;\n  connectionId?: string;\n}\n\n/**\n * Connection Acknowledgment Request Schema (built using Ultra-DRY utilities)\n */\nexport const ConnectionAckRequestSchema = buildMessageSchema(\n  'connection_ack',\n  1,\n  {\n    connectionId: union([string, undefinedType]), // Optional string connectionId\n  }\n);\n\nexport type ConnectionAckRequest = TypeOf<typeof ConnectionAckRequestSchema>;\n\n/**\n * Connection Acknowledgment V1 Request Message Class (Ultra-DRY implementation)\n */\nexport const ConnectionAckV1RequestMessage = createSimpleMessage<\n  ConnectionAckRequestData,\n  'connection_ack',\n  1\n>({\n  messageType: 'connection_ack',\n  version: 1,\n  schema: ConnectionAckRequestSchema,\n});\n"]}

package/dist/messages/ConnectionAckV1Response.d.ts

@@ -0,0 +1,45 @@
+import { TypeOf } from 'io-ts';
+/**
+ * Connection Acknowledgment Response Runtime Data
+ */
+export interface ConnectionAckResponseData {
+    status: 'acknowledged';
+    timestamp: string;
+}
+/**
+ * Connection Acknowledgment Response Wire Format
+ */
+export interface ConnectionAckResponseWire {
+    type: 'connection_ack_response';
+    version: 1;
+    status: 'acknowledged';
+    timestamp: string;
+}
+/**
+ * Connection Acknowledgment Response Schema (built using Ultra-DRY utilities)
+ */
+export declare const ConnectionAckResponseSchema: import("io-ts").Type<any, any, unknown>;
+export type ConnectionAckResponse = TypeOf<typeof ConnectionAckResponseSchema>;
+/**
+ * Connection Acknowledgment V1 Response Message Class (Ultra-DRY implementation)
+ */
+export declare const ConnectionAckV1ResponseMessage: {
+    new (data: ConnectionAckResponseData): {
+        readonly type: "connection_ack_response";
+        readonly version: 1;
+        encode(): any;
+        readonly data: ConnectionAckResponseData;
+        getData(): 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: ConnectionAckResponseData;
+        getData(): ConnectionAckResponseData;
+    }>;
+};
+//# sourceMappingURL=ConnectionAckV1Response.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionAckV1Response.d.ts","sourceRoot":"","sources":["../../src/messages/ConnectionAckV1Response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,MAAM,EAAE,MAAM,OAAO,CAAC;AAGhD;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,cAAc,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,yBAAyB,CAAC;IAChC,OAAO,EAAE,CAAC,CAAC;IACX,MAAM,EAAE,cAAc,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,2BAA2B,yCAOvC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAE/E;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;CAQzC,CAAC"}

package/dist/messages/ConnectionAckV1Response.js

@@ -0,0 +1,18 @@
+import { literal, string } from 'io-ts';
+import { buildMessageSchema, createSimpleMessage } from './utils';
+/**
+ * Connection Acknowledgment Response Schema (built using Ultra-DRY utilities)
+ */
+export const ConnectionAckResponseSchema = buildMessageSchema('connection_ack_response', 1, {
+    status: literal('acknowledged'),
+    timestamp: string, // ISO timestamp string
+});
+/**
+ * Connection Acknowledgment V1 Response Message Class (Ultra-DRY implementation)
+ */
+export const ConnectionAckV1ResponseMessage = createSimpleMessage({
+    messageType: 'connection_ack_response',
+    version: 1,
+    schema: ConnectionAckResponseSchema,
+});
+//# sourceMappingURL=ConnectionAckV1Response.js.map

package/dist/messages/ConnectionAckV1Response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionAckV1Response.js","sourceRoot":"","sources":["../../src/messages/ConnectionAckV1Response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAU,MAAM,OAAO,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAoBlE;;GAEG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,kBAAkB,CAC3D,yBAAyB,EACzB,CAAC,EACD;IACE,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC;IAC/B,SAAS,EAAE,MAAM,EAAE,uBAAuB;CAC3C,CACF,CAAC;AAIF;;GAEG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,mBAAmB,CAI/D;IACA,WAAW,EAAE,yBAAyB;IACtC,OAAO,EAAE,CAAC;IACV,MAAM,EAAE,2BAA2B;CACpC,CAAC,CAAC","sourcesContent":["import { literal, string, TypeOf } from 'io-ts';\nimport { buildMessageSchema, createSimpleMessage } from './utils';\n\n/**\n * Connection Acknowledgment Response Runtime Data\n */\nexport interface ConnectionAckResponseData {\n  status: 'acknowledged';\n  timestamp: string;\n}\n\n/**\n * Connection Acknowledgment Response Wire Format\n */\nexport interface ConnectionAckResponseWire {\n  type: 'connection_ack_response';\n  version: 1;\n  status: 'acknowledged';\n  timestamp: string;\n}\n\n/**\n * Connection Acknowledgment Response Schema (built using Ultra-DRY utilities)\n */\nexport const ConnectionAckResponseSchema = buildMessageSchema(\n  'connection_ack_response',\n  1,\n  {\n    status: literal('acknowledged'),\n    timestamp: string, // ISO timestamp string\n  }\n);\n\nexport type ConnectionAckResponse = TypeOf<typeof ConnectionAckResponseSchema>;\n\n/**\n * Connection Acknowledgment V1 Response Message Class (Ultra-DRY implementation)\n */\nexport const ConnectionAckV1ResponseMessage = createSimpleMessage<\n  ConnectionAckResponseData,\n  'connection_ack_response',\n  1\n>({\n  messageType: 'connection_ack_response',\n  version: 1,\n  schema: ConnectionAckResponseSchema,\n});\n"]}

package/dist/messages/HandshakeV1Request.d.ts

@@ -0,0 +1,45 @@
+import { TypeOf } from 'io-ts';
+/**
+ * Handshake Request Runtime Data
+ */
+export interface HandshakeRequestData {
+    challenge: Uint8Array;
+    nonce: Uint8Array;
+}
+/**
+ * Handshake Request Wire Format
+ */
+export interface HandshakeRequestWire {
+    type: 'handshake';
+    version: 1;
+    challenge: string;
+    nonce: string;
+}
+/**
+ * Handshake Request Schema (built using Ultra-DRY utilities)
+ */
+export declare const HandshakeRequestSchema: import("io-ts").Type<any, any, unknown>;
+export type HandshakeRequest = TypeOf<typeof HandshakeRequestSchema>;
+/**
+ * Handshake V1 Request Message Class (Ultra-DRY implementation)
+ */
+export declare const HandshakeV1RequestMessage: {
+    new (data: HandshakeRequestData): {
+        readonly type: "handshake";
+        readonly version: 1;
+        encode(): HandshakeRequestWire;
+        readonly data: HandshakeRequestData;
+        getData(): 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(): HandshakeRequestWire;
+        readonly data: HandshakeRequestData;
+        getData(): HandshakeRequestData;
+    }>;
+};
+//# sourceMappingURL=HandshakeV1Request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HandshakeV1Request.d.ts","sourceRoot":"","sources":["../../src/messages/HandshakeV1Request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAQ/B;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,UAAU,CAAC;IACtB,KAAK,EAAE,UAAU,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,CAAC,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,yCAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAErE;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;CAepC,CAAC"}

package/dist/messages/HandshakeV1Request.js

@@ -0,0 +1,28 @@
+import { Uint8ArrayCodec } from '../codecs';
+import { buildMessageSchema, createStandardMessage, createStandardDecoder, } from './utils';
+/**
+ * Handshake Request Schema (built using Ultra-DRY utilities)
+ */
+export const HandshakeRequestSchema = buildMessageSchema('handshake', 1, {
+    challenge: Uint8ArrayCodec,
+    nonce: Uint8ArrayCodec,
+});
+/**
+ * Handshake V1 Request Message Class (Ultra-DRY implementation)
+ */
+export const HandshakeV1RequestMessage = createStandardMessage({
+    messageType: 'handshake',
+    version: 1,
+    schema: HandshakeRequestSchema,
+    encodeData: (data) => HandshakeRequestSchema.encode({
+        type: 'handshake',
+        version: 1,
+        challenge: data.challenge,
+        nonce: data.nonce,
+    }),
+    decodeData: createStandardDecoder((decoded) => ({
+        challenge: decoded.challenge,
+        nonce: decoded.nonce,
+    })),
+});
+//# sourceMappingURL=HandshakeV1Request.js.map

package/dist/messages/HandshakeV1Request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HandshakeV1Request.js","sourceRoot":"","sources":["../../src/messages/HandshakeV1Request.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,SAAS,CAAC;AAoBjB;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,kBAAkB,CAAC,WAAW,EAAE,CAAC,EAAE;IACvE,SAAS,EAAE,eAAe;IAC1B,KAAK,EAAE,eAAe;CACvB,CAAC,CAAC;AAIH;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,qBAAqB,CAAC;IAC7D,WAAW,EAAE,WAAoB;IACjC,OAAO,EAAE,CAAU;IACnB,MAAM,EAAE,sBAAsB;IAC9B,UAAU,EAAE,CAAC,IAA0B,EAAwB,EAAE,CAC/D,sBAAsB,CAAC,MAAM,CAAC;QAC5B,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,CAAC;QACV,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,KAAK,EAAE,IAAI,CAAC,KAAK;KAClB,CAAC;IACJ,UAAU,EAAE,qBAAqB,CAAuB,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACpE,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,KAAK,EAAE,OAAO,CAAC,KAAK;KACrB,CAAC,CAAC;CACJ,CAAC,CAAC","sourcesContent":["import { TypeOf } from 'io-ts';\nimport { Uint8ArrayCodec } from '../codecs';\nimport {\n  buildMessageSchema,\n  createStandardMessage,\n  createStandardDecoder,\n} from './utils';\n\n/**\n * Handshake Request Runtime Data\n */\nexport interface HandshakeRequestData {\n  challenge: Uint8Array;\n  nonce: Uint8Array;\n}\n\n/**\n * Handshake Request Wire Format\n */\nexport interface HandshakeRequestWire {\n  type: 'handshake';\n  version: 1;\n  challenge: string; // hex string\n  nonce: string; // hex string\n}\n\n/**\n * Handshake Request Schema (built using Ultra-DRY utilities)\n */\nexport const HandshakeRequestSchema = buildMessageSchema('handshake', 1, {\n  challenge: Uint8ArrayCodec,\n  nonce: Uint8ArrayCodec,\n});\n\nexport type HandshakeRequest = TypeOf<typeof HandshakeRequestSchema>;\n\n/**\n * Handshake V1 Request Message Class (Ultra-DRY implementation)\n */\nexport const HandshakeV1RequestMessage = createStandardMessage({\n  messageType: 'handshake' as const,\n  version: 1 as const,\n  schema: HandshakeRequestSchema,\n  encodeData: (data: HandshakeRequestData): HandshakeRequestWire =>\n    HandshakeRequestSchema.encode({\n      type: 'handshake',\n      version: 1,\n      challenge: data.challenge,\n      nonce: data.nonce,\n    }),\n  decodeData: createStandardDecoder<HandshakeRequestData>((decoded) => ({\n    challenge: decoded.challenge,\n    nonce: decoded.nonce,\n  })),\n});\n"]}

package/dist/messages/HandshakeV1Response.d.ts

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

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

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

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

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

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

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

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