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

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# @dynamic-labs-wallet/forward-mpc-shared
+
+Shared types, schemas, and utilities for Forward MPC Client operations.
+
+## Installation
+
+```bash
+npm install @dynamic-labs-wallet/forward-mpc-shared
+# or
+pnpm add @dynamic-labs-wallet/forward-mpc-shared
+# or
+yarn add @dynamic-labs-wallet/forward-mpc-shared
+```
+
+## Usage
+
+```typescript
+import {
+  // Core types and utilities
+  ForwardMpcMessage,
+  ForwardMpcError,
+
+  // Codecs for serialization
+  DomainCodec,
+  EncryptedKeyshareCodec,
+
+  // Crypto utilities
+  generateKeypair,
+  encapsulate,
+  decapsulate,
+
+  // Signing algorithms
+  SigningAlgorithm,
+  AllSigningAlgorithms,
+} from '@dynamic-labs-wallet/forward-mpc-shared';
+```
+
+## Exports
+
+### Main Export
+
+- Core types, utilities, and constants
+
+### Sub-exports
+
+- `./codecs` - Serialization codecs for various data types
+- `./crypto` - Cryptographic utilities and key operations
+- `./utils/*` - Utility functions
+
+## License
+
+MIT

package/dist/attestation/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/attestation/index.ts"],"names":[],"mappings":""}

package/dist/attestation/index.js

@@ -0,0 +1,4 @@
+"use strict";
+// Attestation types and constants have been moved to the client package
+// since they are only used for client-side verification, not server-side generation
+//# sourceMappingURL=index.js.map

package/dist/attestation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/attestation/index.ts"],"names":[],"mappings":";AAAA,wEAAwE;AACxE,oFAAoF","sourcesContent":["// Attestation types and constants have been moved to the client package\n// since they are only used for client-side verification, not server-side generation\n"]}

package/dist/codecs/DomainCodec.d.ts

@@ -0,0 +1,11 @@
+import { Type } from 'io-ts';
+/**
+ * Codec for validating domain names without protocol or paths.
+ * Allows optional port numbers.
+ * Examples:
+ * - example.com
+ * - sub.example.com
+ * - example.com:8080
+ */
+export declare const DomainCodec: Type<string, string, unknown>;
+//# sourceMappingURL=DomainCodec.d.ts.map

package/dist/codecs/DomainCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomainCodec.d.ts","sourceRoot":"","sources":["../../src/codecs/DomainCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAA8B,MAAM,OAAO,CAAC;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,+BAuBvB,CAAC"}

package/dist/codecs/DomainCodec.js

@@ -0,0 +1,25 @@
+import { Type, failure, success, identity } from 'io-ts';
+/**
+ * Codec for validating domain names without protocol or paths.
+ * Allows optional port numbers.
+ * Examples:
+ * - example.com
+ * - sub.example.com
+ * - example.com:8080
+ */
+export const DomainCodec = new Type('DomainCodec', (u) => typeof u === 'string', (u, c) => {
+    if (typeof u !== 'string') {
+        return failure(u, c, 'Value must be a string');
+    }
+    // Domain regex pattern:
+    // - Starts with alphanumeric or hyphen
+    // - Can contain dots for subdomains
+    // - Optional port number at the end
+    // - No protocols or paths allowed
+    const domainPattern = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*(?::\d{1,5})?$/;
+    if (!domainPattern.test(u)) {
+        return failure(u, c, 'Invalid domain format');
+    }
+    return success(u);
+}, identity);
+//# sourceMappingURL=DomainCodec.js.map

package/dist/codecs/DomainCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomainCodec.js","sourceRoot":"","sources":["../../src/codecs/DomainCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEzD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,IAAI,IAAI,CACjC,aAAa,EACb,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,EACzC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;IACP,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1B,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,wBAAwB,CAAC,CAAC;IACjD,CAAC;IAED,wBAAwB;IACxB,uCAAuC;IACvC,oCAAoC;IACpC,oCAAoC;IACpC,kCAAkC;IAClC,MAAM,aAAa,GACjB,kHAAkH,CAAC;IAErH,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3B,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,uBAAuB,CAAC,CAAC;IAChD,CAAC;IAED,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC,EACD,QAAQ,CACT,CAAC","sourcesContent":["import { Type, failure, success, identity } from 'io-ts';\n\n/**\n * Codec for validating domain names without protocol or paths.\n * Allows optional port numbers.\n * Examples:\n * - example.com\n * - sub.example.com\n * - example.com:8080\n */\nexport const DomainCodec = new Type<string>(\n  'DomainCodec',\n  (u): u is string => typeof u === 'string',\n  (u, c) => {\n    if (typeof u !== 'string') {\n      return failure(u, c, 'Value must be a string');\n    }\n\n    // Domain regex pattern:\n    // - Starts with alphanumeric or hyphen\n    // - Can contain dots for subdomains\n    // - Optional port number at the end\n    // - No protocols or paths allowed\n    const domainPattern =\n      /^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*(?::\\d{1,5})?$/;\n\n    if (!domainPattern.test(u)) {\n      return failure(u, c, 'Invalid domain format');\n    }\n\n    return success(u);\n  },\n  identity\n);\n"]}

package/dist/codecs/EncryptedKeyshareCodec.d.ts

@@ -0,0 +1,11 @@
+import { TypeOf } from 'io-ts';
+/**
+ * Encrypted keyshare structure for secure transmission
+ * Contains HKDF salt and AES-256-GCM encrypted payload
+ */
+export declare const EncryptedKeyshareCodec: import("io-ts").TypeC<{
+    salt: import("io-ts").Type<Uint8Array<ArrayBufferLike>, string, unknown>;
+    encryptedPayload: import("io-ts").Type<Uint8Array<ArrayBufferLike>, string, unknown>;
+}>;
+export type EncryptedKeyshare = TypeOf<typeof EncryptedKeyshareCodec>;
+//# sourceMappingURL=EncryptedKeyshareCodec.d.ts.map

package/dist/codecs/EncryptedKeyshareCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EncryptedKeyshareCodec.d.ts","sourceRoot":"","sources":["../../src/codecs/EncryptedKeyshareCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,MAAM,EAAE,MAAM,OAAO,CAAC;AAGrC;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;EAGjC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/codecs/EncryptedKeyshareCodec.js

@@ -0,0 +1,11 @@
+import { type } from 'io-ts';
+import { Uint8ArrayCodec } from './Uint8ArrayCodec';
+/**
+ * Encrypted keyshare structure for secure transmission
+ * Contains HKDF salt and AES-256-GCM encrypted payload
+ */
+export const EncryptedKeyshareCodec = type({
+    salt: Uint8ArrayCodec,
+    encryptedPayload: Uint8ArrayCodec,
+});
+//# sourceMappingURL=EncryptedKeyshareCodec.js.map

package/dist/codecs/EncryptedKeyshareCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EncryptedKeyshareCodec.js","sourceRoot":"","sources":["../../src/codecs/EncryptedKeyshareCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAU,MAAM,OAAO,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,CAAC;IACzC,IAAI,EAAE,eAAe;IACrB,gBAAgB,EAAE,eAAe;CAClC,CAAC,CAAC","sourcesContent":["import { type, TypeOf } from 'io-ts';\nimport { Uint8ArrayCodec } from './Uint8ArrayCodec';\n\n/**\n * Encrypted keyshare structure for secure transmission\n * Contains HKDF salt and AES-256-GCM encrypted payload\n */\nexport const EncryptedKeyshareCodec = type({\n  salt: Uint8ArrayCodec,\n  encryptedPayload: Uint8ArrayCodec,\n});\n\nexport type EncryptedKeyshare = TypeOf<typeof EncryptedKeyshareCodec>;\n"]}

package/dist/codecs/Uint32ArrayCodec.d.ts

@@ -0,0 +1,3 @@
+import { Type } from 'io-ts';
+export declare const Uint32ArrayCodec: Type<Uint32Array<ArrayBufferLike>, string, unknown>;
+//# sourceMappingURL=Uint32ArrayCodec.d.ts.map

package/dist/codecs/Uint32ArrayCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uint32ArrayCodec.d.ts","sourceRoot":"","sources":["../../src/codecs/Uint32ArrayCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,IAAI,EAAE,MAAM,OAAO,CAAC;AAG/C,eAAO,MAAM,gBAAgB,qDA8C5B,CAAC"}

package/dist/codecs/Uint32ArrayCodec.js

@@ -0,0 +1,37 @@
+import { failure, success, Type } from 'io-ts';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
+export const Uint32ArrayCodec = new Type('Uint32Array', // The name of the codec
+(u) => u instanceof Uint32Array, // A type guard
+(u, c) => {
+    // The `validate` function for decoding
+    if (typeof u !== 'string') {
+        return failure(u, c, 'Expected a hex string for Uint32Array');
+    }
+    try {
+        // Remove any '0x' prefix if present
+        const cleanHex = u.startsWith('0x') ? u.slice(2) : u;
+        // Validate hex string (must be multiple of 8 characters for 32-bit values)
+        if (cleanHex.length === 0) {
+            return failure(u, c, 'Empty hex string not allowed for Uint32Array');
+        }
+        if (cleanHex.length % 8 !== 0) {
+            return failure(u, c, 'Invalid hex string format for Uint32Array (must be multiple of 8 hex characters)');
+        }
+        // Convert hex string to Uint8Array using noble-hashes
+        const uint8Array = hexToBytes(cleanHex);
+        // Convert Uint8Array to Uint32Array by interpreting the buffer
+        // Note: This assumes little-endian byte order
+        const uint32Array = new Uint32Array(uint8Array.buffer);
+        return success(uint32Array);
+    }
+    catch (e) {
+        return failure(u, c, `Invalid hex string: ${e}`);
+    }
+}, 
+// The `encode` function for converting back to the output type
+(a) => {
+    // Convert Uint32Array to Uint8Array to use noble-hashes
+    const uint8Array = new Uint8Array(a.buffer);
+    return bytesToHex(uint8Array);
+});
+//# sourceMappingURL=Uint32ArrayCodec.js.map

package/dist/codecs/Uint32ArrayCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uint32ArrayCodec.js","sourceRoot":"","sources":["../../src/codecs/Uint32ArrayCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEhE,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,IAAI,CAKtC,aAAa,EAAE,wBAAwB;AACvC,CAAC,CAAC,EAAoB,EAAE,CAAC,CAAC,YAAY,WAAW,EAAE,eAAe;AAClE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;IACP,uCAAuC;IACvC,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1B,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,uCAAuC,CAAC,CAAC;IAChE,CAAC;IACD,IAAI,CAAC;QACH,oCAAoC;QACpC,MAAM,QAAQ,GAAG,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAErD,2EAA2E;QAC3E,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,8CAA8C,CAAC,CAAC;QACvE,CAAC;QACD,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,OAAO,CACZ,CAAC,EACD,CAAC,EACD,kFAAkF,CACnF,CAAC;QACJ,CAAC;QAED,sDAAsD;QACtD,MAAM,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;QAExC,+DAA+D;QAC/D,8CAA8C;QAC9C,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAEvD,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC;IAC9B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,uBAAuB,CAAC,EAAE,CAAC,CAAC;IACnD,CAAC;AACH,CAAC;AACD,+DAA+D;AAC/D,CAAC,CAAC,EAAE,EAAE;IACJ,wDAAwD;IACxD,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAC5C,OAAO,UAAU,CAAC,UAAU,CAAC,CAAC;AAChC,CAAC,CACF,CAAC","sourcesContent":["import { failure, success, Type } from 'io-ts';\nimport { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\n\nexport const Uint32ArrayCodec = new Type<\n  Uint32Array, // A: The runtime type (the type you work with in your code)\n  string, // O: The encoded output type (e.g., JSON representation)\n  unknown // I: The input type (e.g., from JSON)\n>(\n  'Uint32Array', // The name of the codec\n  (u): u is Uint32Array => u instanceof Uint32Array, // A type guard\n  (u, c) => {\n    // The `validate` function for decoding\n    if (typeof u !== 'string') {\n      return failure(u, c, 'Expected a hex string for Uint32Array');\n    }\n    try {\n      // Remove any '0x' prefix if present\n      const cleanHex = u.startsWith('0x') ? u.slice(2) : u;\n\n      // Validate hex string (must be multiple of 8 characters for 32-bit values)\n      if (cleanHex.length === 0) {\n        return failure(u, c, 'Empty hex string not allowed for Uint32Array');\n      }\n      if (cleanHex.length % 8 !== 0) {\n        return failure(\n          u,\n          c,\n          'Invalid hex string format for Uint32Array (must be multiple of 8 hex characters)'\n        );\n      }\n\n      // Convert hex string to Uint8Array using noble-hashes\n      const uint8Array = hexToBytes(cleanHex);\n\n      // Convert Uint8Array to Uint32Array by interpreting the buffer\n      // Note: This assumes little-endian byte order\n      const uint32Array = new Uint32Array(uint8Array.buffer);\n\n      return success(uint32Array);\n    } catch (e) {\n      return failure(u, c, `Invalid hex string: ${e}`);\n    }\n  },\n  // The `encode` function for converting back to the output type\n  (a) => {\n    // Convert Uint32Array to Uint8Array to use noble-hashes\n    const uint8Array = new Uint8Array(a.buffer);\n    return bytesToHex(uint8Array);\n  }\n);\n"]}

package/dist/codecs/Uint8ArrayCodec.d.ts

@@ -0,0 +1,3 @@
+import { Type } from 'io-ts';
+export declare const Uint8ArrayCodec: Type<Uint8Array<ArrayBufferLike>, string, unknown>;
+//# sourceMappingURL=Uint8ArrayCodec.d.ts.map

package/dist/codecs/Uint8ArrayCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uint8ArrayCodec.d.ts","sourceRoot":"","sources":["../../src/codecs/Uint8ArrayCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,IAAI,EAAE,MAAM,OAAO,CAAC;AAG/C,eAAO,MAAM,eAAe,oDA6B3B,CAAC"}

package/dist/codecs/Uint8ArrayCodec.js

@@ -0,0 +1,26 @@
+import { failure, success, Type } from 'io-ts';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
+export const Uint8ArrayCodec = new Type('Uint8Array', // The name of the codec
+(u) => u instanceof Uint8Array, // A type guard
+(u, c) => {
+    // The `validate` function for decoding
+    if (typeof u !== 'string') {
+        return failure(u, c, 'Expected a hex string for Uint8Array');
+    }
+    try {
+        // Remove any '0x' prefix if present
+        const cleanHex = u.startsWith('0x') ? u.slice(2) : u;
+        // Validate hex string (must be even length and contain only hex characters)
+        if (cleanHex.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(cleanHex)) {
+            return failure(u, c, 'Invalid hex string format');
+        }
+        const decoded = hexToBytes(cleanHex);
+        return success(decoded);
+    }
+    catch (e) {
+        return failure(u, c, `Invalid hex string: ${e}`);
+    }
+}, 
+// The `encode` function for converting back to the output type
+(a) => bytesToHex(a));
+//# sourceMappingURL=Uint8ArrayCodec.js.map

package/dist/codecs/Uint8ArrayCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uint8ArrayCodec.js","sourceRoot":"","sources":["../../src/codecs/Uint8ArrayCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEhE,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,IAAI,CAKrC,YAAY,EAAE,wBAAwB;AACtC,CAAC,CAAC,EAAmB,EAAE,CAAC,CAAC,YAAY,UAAU,EAAE,eAAe;AAChE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;IACP,uCAAuC;IACvC,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1B,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,sCAAsC,CAAC,CAAC;IAC/D,CAAC;IACD,IAAI,CAAC;QACH,oCAAoC;QACpC,MAAM,QAAQ,GAAG,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAErD,4EAA4E;QAC5E,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClE,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,2BAA2B,CAAC,CAAC;QACpD,CAAC;QAED,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;QACrC,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,uBAAuB,CAAC,EAAE,CAAC,CAAC;IACnD,CAAC;AACH,CAAC;AACD,+DAA+D;AAC/D,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,CACrB,CAAC","sourcesContent":["import { failure, success, Type } from 'io-ts';\nimport { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\n\nexport const Uint8ArrayCodec = new Type<\n  Uint8Array, // A: The runtime type (the type you work with in your code)\n  string, // O: The encoded output type (e.g., JSON representation)\n  unknown // I: The input type (e.g., from JSON)\n>(\n  'Uint8Array', // The name of the codec\n  (u): u is Uint8Array => u instanceof Uint8Array, // A type guard\n  (u, c) => {\n    // The `validate` function for decoding\n    if (typeof u !== 'string') {\n      return failure(u, c, 'Expected a hex string for Uint8Array');\n    }\n    try {\n      // Remove any '0x' prefix if present\n      const cleanHex = u.startsWith('0x') ? u.slice(2) : u;\n\n      // Validate hex string (must be even length and contain only hex characters)\n      if (cleanHex.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(cleanHex)) {\n        return failure(u, c, 'Invalid hex string format');\n      }\n\n      const decoded = hexToBytes(cleanHex);\n      return success(decoded);\n    } catch (e) {\n      return failure(u, c, `Invalid hex string: ${e}`);\n    }\n  },\n  // The `encode` function for converting back to the output type\n  (a) => bytesToHex(a)\n);\n"]}

package/dist/codecs/Uint8ArrayOrHexCodec.d.ts

@@ -0,0 +1,3 @@
+import { Type } from 'io-ts';
+export declare const Uint8ArrayOrHexCodec: Type<string | Uint8Array<ArrayBufferLike>, string, unknown>;
+//# sourceMappingURL=Uint8ArrayOrHexCodec.d.ts.map

package/dist/codecs/Uint8ArrayOrHexCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uint8ArrayOrHexCodec.d.ts","sourceRoot":"","sources":["../../src/codecs/Uint8ArrayOrHexCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,IAAI,EAAE,MAAM,OAAO,CAAC;AAG/C,eAAO,MAAM,oBAAoB,6DAwChC,CAAC"}

package/dist/codecs/Uint8ArrayOrHexCodec.js

@@ -0,0 +1,35 @@
+import { failure, success, Type } from 'io-ts';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
+export const Uint8ArrayOrHexCodec = new Type('Uint8ArrayOrHex', // The name of the codec
+(u) => u instanceof Uint8Array, // A type guard
+(u, c) => {
+    // Handle Uint8Array input (already in correct format)
+    if (u instanceof Uint8Array) {
+        return success(u);
+    }
+    // Handle string input (hex string)
+    if (typeof u !== 'string') {
+        return failure(u, c, 'Expected a hex string or Uint8Array');
+    }
+    try {
+        // Remove any '0x' prefix if present
+        const cleanHex = u.startsWith('0x') ? u.slice(2) : u;
+        // Validate hex string (must be even length and contain only hex characters)
+        if (cleanHex.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(cleanHex)) {
+            return failure(u, c, 'Invalid hex string format');
+        }
+        const decoded = hexToBytes(cleanHex);
+        return success(decoded);
+    }
+    catch (e) {
+        return failure(u, c, `Invalid hex string: ${e}`);
+    }
+}, 
+// The `encode` function for converting back to the output type
+(a) => {
+    if (typeof a === 'string') {
+        return a;
+    }
+    return bytesToHex(a);
+});
+//# sourceMappingURL=Uint8ArrayOrHexCodec.js.map

package/dist/codecs/Uint8ArrayOrHexCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uint8ArrayOrHexCodec.js","sourceRoot":"","sources":["../../src/codecs/Uint8ArrayOrHexCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEhE,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,IAAI,CAK1C,iBAAiB,EAAE,wBAAwB;AAC3C,CAAC,CAAC,EAAmB,EAAE,CAAC,CAAC,YAAY,UAAU,EAAE,eAAe;AAChE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;IACP,sDAAsD;IACtD,IAAK,CAAS,YAAY,UAAU,EAAE,CAAC;QACrC,OAAO,OAAO,CAAC,CAA0B,CAAC,CAAC;IAC7C,CAAC;IAED,mCAAmC;IACnC,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1B,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,qCAAqC,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI,CAAC;QACH,oCAAoC;QACpC,MAAM,QAAQ,GAAG,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAErD,4EAA4E;QAC5E,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClE,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,2BAA2B,CAAC,CAAC;QACpD,CAAC;QAED,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;QACrC,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,uBAAuB,CAAC,EAAE,CAAC,CAAC;IACnD,CAAC;AACH,CAAC;AACD,+DAA+D;AAC/D,CAAC,CAAC,EAAE,EAAE;IACJ,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1B,OAAO,CAAC,CAAC;IACX,CAAC;IACD,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC;AACvB,CAAC,CACF,CAAC","sourcesContent":["import { failure, success, Type } from 'io-ts';\nimport { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\n\nexport const Uint8ArrayOrHexCodec = new Type<\n  Uint8Array | string, // A: The runtime type (the type you work with in your code)\n  string, // O: The encoded output type (e.g., JSON representation)\n  string | unknown // I: The input type (e.g., from JSON)\n>(\n  'Uint8ArrayOrHex', // The name of the codec\n  (u): u is Uint8Array => u instanceof Uint8Array, // A type guard\n  (u, c) => {\n    // Handle Uint8Array input (already in correct format)\n    if ((u as any) instanceof Uint8Array) {\n      return success(u as unknown as Uint8Array);\n    }\n\n    // Handle string input (hex string)\n    if (typeof u !== 'string') {\n      return failure(u, c, 'Expected a hex string or Uint8Array');\n    }\n\n    try {\n      // Remove any '0x' prefix if present\n      const cleanHex = u.startsWith('0x') ? u.slice(2) : u;\n\n      // Validate hex string (must be even length and contain only hex characters)\n      if (cleanHex.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(cleanHex)) {\n        return failure(u, c, 'Invalid hex string format');\n      }\n\n      const decoded = hexToBytes(cleanHex);\n      return success(decoded);\n    } catch (e) {\n      return failure(u, c, `Invalid hex string: ${e}`);\n    }\n  },\n  // The `encode` function for converting back to the output type\n  (a) => {\n    if (typeof a === 'string') {\n      return a;\n    }\n    return bytesToHex(a);\n  }\n);\n"]}

package/dist/codecs/WebSocketErrorCodec.d.ts

@@ -0,0 +1,15 @@
+import { TypeOf } from 'io-ts';
+/**
+ * WebSocket Error Type Codec
+ */
+export declare const WebSocketErrorTypeCodec: import("io-ts").StringC;
+/**
+ * WebSocket Error Codec
+ */
+export declare const WebSocketErrorCodec: import("io-ts").TypeC<{
+    type: import("io-ts").StringC;
+    message: import("io-ts").StringC;
+    details: import("io-ts").UnionC<[import("io-ts").UnknownC, import("io-ts").UndefinedC]>;
+}>;
+export type WebSocketErrorValidated = TypeOf<typeof WebSocketErrorCodec>;
+//# sourceMappingURL=WebSocketErrorCodec.d.ts.map

package/dist/codecs/WebSocketErrorCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketErrorCodec.d.ts","sourceRoot":"","sources":["../../src/codecs/WebSocketErrorCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,MAAM,EACP,MAAM,OAAO,CAAC;AAEf;;GAEG;AACH,eAAO,MAAM,uBAAuB,yBAAS,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/codecs/WebSocketErrorCodec.js

@@ -0,0 +1,14 @@
+import { type, string, union, undefined as undefinedType, unknown, } from 'io-ts';
+/**
+ * WebSocket Error Type Codec
+ */
+export const WebSocketErrorTypeCodec = string; // Just use string directly
+/**
+ * WebSocket Error Codec
+ */
+export const WebSocketErrorCodec = type({
+    type: WebSocketErrorTypeCodec,
+    message: string,
+    details: union([unknown, undefinedType]), // Optional details field
+});
+//# sourceMappingURL=WebSocketErrorCodec.js.map

package/dist/codecs/WebSocketErrorCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketErrorCodec.js","sourceRoot":"","sources":["../../src/codecs/WebSocketErrorCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,MAAM,EACN,KAAK,EACL,SAAS,IAAI,aAAa,EAC1B,OAAO,GAER,MAAM,OAAO,CAAC;AAEf;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC,CAAC,2BAA2B;AAE1E;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,CAAC;IACtC,IAAI,EAAE,uBAAuB;IAC7B,OAAO,EAAE,MAAM;IACf,OAAO,EAAE,KAAK,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,EAAE,yBAAyB;CACpE,CAAC,CAAC","sourcesContent":["import {\n  type,\n  string,\n  union,\n  undefined as undefinedType,\n  unknown,\n  TypeOf,\n} from 'io-ts';\n\n/**\n * WebSocket Error Type Codec\n */\nexport const WebSocketErrorTypeCodec = string; // Just use string directly\n\n/**\n * WebSocket Error Codec\n */\nexport const WebSocketErrorCodec = type({\n  type: WebSocketErrorTypeCodec,\n  message: string,\n  details: union([unknown, undefinedType]), // Optional details field\n});\n\nexport type WebSocketErrorValidated = TypeOf<typeof WebSocketErrorCodec>;\n"]}

package/dist/codecs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Uint8ArrayCodec';
+export * from './Uint32ArrayCodec';
+export * from './EncryptedKeyshareCodec';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/codecs/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC"}

package/dist/codecs/index.js

@@ -0,0 +1,4 @@
+export * from './Uint8ArrayCodec';
+export * from './Uint32ArrayCodec';
+export * from './EncryptedKeyshareCodec';
+//# sourceMappingURL=index.js.map

package/dist/codecs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/codecs/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC","sourcesContent":["export * from './Uint8ArrayCodec';\nexport * from './Uint32ArrayCodec';\nexport * from './EncryptedKeyshareCodec';\n"]}

package/dist/constants/algorithms.d.ts

@@ -0,0 +1,56 @@
+import { type AllSigningAlgorithmSchemas, type SigningAlgorithmName } from '../signing/allAlgorithms';
+import { SigningAlgorithm } from '@dynamic-labs-wallet/core';
+/**
+ * Algorithm configurations for complex properties
+ * Maps Dynamic SDK enum values to our internal algorithm names
+ */
+export declare const ALGORITHMS: {
+    readonly ECDSA: {
+        readonly name: "ecdsa";
+        readonly dynamicEnum: SigningAlgorithm.ECDSA;
+        readonly className: "Ecdsa";
+        readonly requiresHashAlgo: true;
+        readonly supportsDerivationPath: true;
+        readonly supportsTweak: false;
+        readonly supportedHashAlgos: readonly ["sha256", "sha256d", "keccak256"];
+    };
+    readonly ED25519: {
+        readonly name: "ed25519";
+        readonly dynamicEnum: SigningAlgorithm.ED25519;
+        readonly className: "Ed25519";
+        readonly requiresHashAlgo: false;
+        readonly supportsDerivationPath: true;
+        readonly supportsTweak: false;
+        readonly supportedHashAlgos: readonly [];
+    };
+    readonly BIP340: {
+        readonly name: "bip340";
+        readonly dynamicEnum: SigningAlgorithm.BIP340;
+        readonly className: "BIP340";
+        readonly requiresHashAlgo: false;
+        readonly supportsDerivationPath: true;
+        readonly supportsTweak: true;
+        readonly supportedHashAlgos: readonly [];
+    };
+};
+/**
+ * Type definitions - use Dynamic SDK's SigningAlgorithm enum
+ */
+export type HashAlgorithm = 'sha256' | 'sha256d' | 'keccak256';
+/**
+ * Helper function to convert our internal algorithm names to Dynamic SDK enum values
+ */
+export declare function toDynamicSigningAlgorithm(algorithmName: SigningAlgorithmName): SigningAlgorithm;
+/**
+ * Helper function to convert Dynamic SDK enum values to our internal algorithm names
+ */
+export declare function fromDynamicSigningAlgorithm(dynamicAlgorithm: SigningAlgorithm): SigningAlgorithmName;
+/**
+ * Union schema derived from algorithm instances (no more manual schema generation!)
+ */
+export declare const SignatureAlgoSchema: import("io-ts").Type<AllSigningAlgorithmSchemas, AllSigningAlgorithmSchemas, unknown>;
+/**
+ * Export the union type for external use
+ */
+export type { AllSigningAlgorithmSchemas as SigningAlgorithmSchemas };
+//# sourceMappingURL=algorithms.d.ts.map

package/dist/constants/algorithms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"algorithms.d.ts","sourceRoot":"","sources":["../../src/constants/algorithms.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Bb,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC;AAE/D;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,oBAAoB,GAClC,gBAAgB,CAQlB;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,gBAAgB,EAAE,gBAAgB,GACjC,oBAAoB,CAMtB;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,uFAA+B,CAAC;AAEhE;;GAEG;AACH,YAAY,EAAE,0BAA0B,IAAI,uBAAuB,EAAE,CAAC"}

package/dist/constants/algorithms.js

@@ -0,0 +1,60 @@
+import { ALL_SIGNING_ALGORITHM_SCHEMA, } from '../signing/allAlgorithms';
+import { SigningAlgorithm } from '@dynamic-labs-wallet/core';
+/**
+ * Algorithm configurations for complex properties
+ * Maps Dynamic SDK enum values to our internal algorithm names
+ */
+export const ALGORITHMS = {
+    [SigningAlgorithm.ECDSA]: {
+        name: 'ecdsa',
+        dynamicEnum: SigningAlgorithm.ECDSA,
+        className: 'Ecdsa',
+        requiresHashAlgo: true,
+        supportsDerivationPath: true,
+        supportsTweak: false,
+        supportedHashAlgos: ['sha256', 'sha256d', 'keccak256'],
+    },
+    [SigningAlgorithm.ED25519]: {
+        name: 'ed25519',
+        dynamicEnum: SigningAlgorithm.ED25519,
+        className: 'Ed25519',
+        requiresHashAlgo: false,
+        supportsDerivationPath: true,
+        supportsTweak: false,
+        supportedHashAlgos: [],
+    },
+    [SigningAlgorithm.BIP340]: {
+        name: 'bip340',
+        dynamicEnum: SigningAlgorithm.BIP340,
+        className: 'BIP340',
+        requiresHashAlgo: false,
+        supportsDerivationPath: true,
+        supportsTweak: true,
+        supportedHashAlgos: [],
+    },
+};
+/**
+ * Helper function to convert our internal algorithm names to Dynamic SDK enum values
+ */
+export function toDynamicSigningAlgorithm(algorithmName) {
+    const algorithmConfig = Object.values(ALGORITHMS).find((config) => config.name === algorithmName);
+    if (!algorithmConfig) {
+        throw new Error(`Unknown algorithm: ${algorithmName}`);
+    }
+    return algorithmConfig.dynamicEnum;
+}
+/**
+ * Helper function to convert Dynamic SDK enum values to our internal algorithm names
+ */
+export function fromDynamicSigningAlgorithm(dynamicAlgorithm) {
+    const algorithmConfig = ALGORITHMS[dynamicAlgorithm];
+    if (!algorithmConfig) {
+        throw new Error(`Unknown Dynamic SDK algorithm: ${dynamicAlgorithm}`);
+    }
+    return algorithmConfig.name;
+}
+/**
+ * Union schema derived from algorithm instances (no more manual schema generation!)
+ */
+export const SignatureAlgoSchema = ALL_SIGNING_ALGORITHM_SCHEMA;
+//# sourceMappingURL=algorithms.js.map

package/dist/constants/algorithms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"algorithms.js","sourceRoot":"","sources":["../../src/constants/algorithms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,GAG7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE;QACxB,IAAI,EAAE,OAAgB;QACtB,WAAW,EAAE,gBAAgB,CAAC,KAAK;QACnC,SAAS,EAAE,OAAgB;QAC3B,gBAAgB,EAAE,IAAI;QACtB,sBAAsB,EAAE,IAAI;QAC5B,aAAa,EAAE,KAAK;QACpB,kBAAkB,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,WAAW,CAAU;KAChE;IACD,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE;QAC1B,IAAI,EAAE,SAAkB;QACxB,WAAW,EAAE,gBAAgB,CAAC,OAAO;QACrC,SAAS,EAAE,SAAkB;QAC7B,gBAAgB,EAAE,KAAK;QACvB,sBAAsB,EAAE,IAAI;QAC5B,aAAa,EAAE,KAAK;QACpB,kBAAkB,EAAE,EAAW;KAChC;IACD,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE;QACzB,IAAI,EAAE,QAAiB;QACvB,WAAW,EAAE,gBAAgB,CAAC,MAAM;QACpC,SAAS,EAAE,QAAiB;QAC5B,gBAAgB,EAAE,KAAK;QACvB,sBAAsB,EAAE,IAAI;QAC5B,aAAa,EAAE,IAAI;QACnB,kBAAkB,EAAE,EAAW;KAChC;CACO,CAAC;AAOX;;GAEG;AACH,MAAM,UAAU,yBAAyB,CACvC,aAAmC;IAEnC,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,CACpD,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,aAAa,CAC1C,CAAC;IACF,IAAI,CAAC,eAAe,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,sBAAsB,aAAa,EAAE,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,eAAe,CAAC,WAAW,CAAC;AACrC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,2BAA2B,CACzC,gBAAkC;IAElC,MAAM,eAAe,GAAG,UAAU,CAAC,gBAAgB,CAAC,CAAC;IACrD,IAAI,CAAC,eAAe,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,kCAAkC,gBAAgB,EAAE,CAAC,CAAC;IACxE,CAAC;IACD,OAAO,eAAe,CAAC,IAAI,CAAC;AAC9B,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,4BAA4B,CAAC","sourcesContent":["import {\n  ALL_SIGNING_ALGORITHM_SCHEMA,\n  type AllSigningAlgorithmSchemas,\n  type SigningAlgorithmName,\n} from '../signing/allAlgorithms';\nimport { SigningAlgorithm } from '@dynamic-labs-wallet/core';\n\n/**\n * Algorithm configurations for complex properties\n * Maps Dynamic SDK enum values to our internal algorithm names\n */\nexport const ALGORITHMS = {\n  [SigningAlgorithm.ECDSA]: {\n    name: 'ecdsa' as const,\n    dynamicEnum: SigningAlgorithm.ECDSA,\n    className: 'Ecdsa' as const,\n    requiresHashAlgo: true,\n    supportsDerivationPath: true,\n    supportsTweak: false,\n    supportedHashAlgos: ['sha256', 'sha256d', 'keccak256'] as const,\n  },\n  [SigningAlgorithm.ED25519]: {\n    name: 'ed25519' as const,\n    dynamicEnum: SigningAlgorithm.ED25519,\n    className: 'Ed25519' as const,\n    requiresHashAlgo: false,\n    supportsDerivationPath: true,\n    supportsTweak: false,\n    supportedHashAlgos: [] as const,\n  },\n  [SigningAlgorithm.BIP340]: {\n    name: 'bip340' as const,\n    dynamicEnum: SigningAlgorithm.BIP340,\n    className: 'BIP340' as const,\n    requiresHashAlgo: false,\n    supportsDerivationPath: true,\n    supportsTweak: true,\n    supportedHashAlgos: [] as const,\n  },\n} as const;\n\n/**\n * Type definitions - use Dynamic SDK's SigningAlgorithm enum\n */\nexport type HashAlgorithm = 'sha256' | 'sha256d' | 'keccak256';\n\n/**\n * Helper function to convert our internal algorithm names to Dynamic SDK enum values\n */\nexport function toDynamicSigningAlgorithm(\n  algorithmName: SigningAlgorithmName\n): SigningAlgorithm {\n  const algorithmConfig = Object.values(ALGORITHMS).find(\n    (config) => config.name === algorithmName\n  );\n  if (!algorithmConfig) {\n    throw new Error(`Unknown algorithm: ${algorithmName}`);\n  }\n  return algorithmConfig.dynamicEnum;\n}\n\n/**\n * Helper function to convert Dynamic SDK enum values to our internal algorithm names\n */\nexport function fromDynamicSigningAlgorithm(\n  dynamicAlgorithm: SigningAlgorithm\n): SigningAlgorithmName {\n  const algorithmConfig = ALGORITHMS[dynamicAlgorithm];\n  if (!algorithmConfig) {\n    throw new Error(`Unknown Dynamic SDK algorithm: ${dynamicAlgorithm}`);\n  }\n  return algorithmConfig.name;\n}\n\n/**\n * Union schema derived from algorithm instances (no more manual schema generation!)\n */\nexport const SignatureAlgoSchema = ALL_SIGNING_ALGORITHM_SCHEMA;\n\n/**\n * Export the union type for external use\n */\nexport type { AllSigningAlgorithmSchemas as SigningAlgorithmSchemas };\n"]}

package/dist/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './algorithms';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/constants/index.js

@@ -0,0 +1,2 @@
+export * from './algorithms';
+//# sourceMappingURL=index.js.map

package/dist/constants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC","sourcesContent":["export * from './algorithms';\n"]}

package/dist/crypto/decapsulate.d.ts

@@ -0,0 +1,2 @@
+export declare const decapsulateMlKem768: (decapsulationKey: Uint8Array, cipherText: Uint8Array) => Uint8Array;
+//# sourceMappingURL=decapsulate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decapsulate.d.ts","sourceRoot":"","sources":["../../src/crypto/decapsulate.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,GAC9B,kBAAkB,UAAU,EAC5B,YAAY,UAAU,KACrB,UAEF,CAAC"}

package/dist/crypto/decapsulate.js

@@ -0,0 +1,5 @@
+import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';
+export const decapsulateMlKem768 = (decapsulationKey, cipherText) => {
+    return ml_kem768.decapsulate(cipherText, decapsulationKey);
+};
+//# sourceMappingURL=decapsulate.js.map

package/dist/crypto/decapsulate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decapsulate.js","sourceRoot":"","sources":["../../src/crypto/decapsulate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE1D,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,gBAA4B,EAC5B,UAAsB,EACV,EAAE;IACd,OAAO,SAAS,CAAC,WAAW,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC;AAC7D,CAAC,CAAC","sourcesContent":["import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';\n\nexport const decapsulateMlKem768 = (\n  decapsulationKey: Uint8Array,\n  cipherText: Uint8Array\n): Uint8Array => {\n  return ml_kem768.decapsulate(cipherText, decapsulationKey);\n};\n"]}

package/dist/crypto/encapsulate.d.ts

@@ -0,0 +1,5 @@
+export declare const encapsulateMlKem768: (encapsulationKey: Uint8Array) => {
+    cipherText: Uint8Array;
+    sharedSecret: Uint8Array;
+};
+//# sourceMappingURL=encapsulate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encapsulate.d.ts","sourceRoot":"","sources":["../../src/crypto/encapsulate.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,GAC9B,kBAAkB,UAAU,KAC3B;IAAE,UAAU,EAAE,UAAU,CAAC;IAAC,YAAY,EAAE,UAAU,CAAA;CAEpD,CAAC"}

package/dist/crypto/encapsulate.js

@@ -0,0 +1,5 @@
+import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';
+export const encapsulateMlKem768 = (encapsulationKey) => {
+    return ml_kem768.encapsulate(encapsulationKey);
+};
+//# sourceMappingURL=encapsulate.js.map

package/dist/crypto/encapsulate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encapsulate.js","sourceRoot":"","sources":["../../src/crypto/encapsulate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE1D,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,gBAA4B,EAC0B,EAAE;IACxD,OAAO,SAAS,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;AACjD,CAAC,CAAC","sourcesContent":["import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';\n\nexport const encapsulateMlKem768 = (\n  encapsulationKey: Uint8Array\n): { cipherText: Uint8Array; sharedSecret: Uint8Array } => {\n  return ml_kem768.encapsulate(encapsulationKey);\n};\n"]}

package/dist/crypto/generateKeypair.d.ts

@@ -0,0 +1,5 @@
+export declare const generateMlKem768Keypair: () => {
+    encapsulationKey: Uint8Array;
+    decapsulationKey: Uint8Array;
+};
+//# sourceMappingURL=generateKeypair.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateKeypair.d.ts","sourceRoot":"","sources":["../../src/crypto/generateKeypair.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,uBAAuB,QAAO;IACzC,gBAAgB,EAAE,UAAU,CAAC;IAC7B,gBAAgB,EAAE,UAAU,CAAC;CAe9B,CAAC"}

package/dist/crypto/generateKeypair.js

@@ -0,0 +1,17 @@
+import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';
+import { assertNotNull } from '../utils/assertDefined';
+export const generateMlKem768Keypair = () => {
+    try {
+        const keys = ml_kem768.keygen();
+        assertNotNull(keys.publicKey, 'Encapsulation key must be defined');
+        assertNotNull(keys.secretKey, 'Decapsulation key must be defined');
+        return {
+            encapsulationKey: keys.publicKey,
+            decapsulationKey: keys.secretKey,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to generate ML-KEM-768 keypair: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+//# sourceMappingURL=generateKeypair.js.map

package/dist/crypto/generateKeypair.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateKeypair.js","sourceRoot":"","sources":["../../src/crypto/generateKeypair.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAGrC,EAAE;IACF,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC;QAChC,aAAa,CAAC,IAAI,CAAC,SAAS,EAAE,mCAAmC,CAAC,CAAC;QACnE,aAAa,CAAC,IAAI,CAAC,SAAS,EAAE,mCAAmC,CAAC,CAAC;QACnE,OAAO;YACL,gBAAgB,EAAE,IAAI,CAAC,SAAS;YAChC,gBAAgB,EAAE,IAAI,CAAC,SAAS;SACjC,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,0CAA0C,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CACnG,CAAC;IACJ,CAAC;AACH,CAAC,CAAC","sourcesContent":["import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';\nimport { assertNotNull } from '../utils/assertDefined';\n\nexport const generateMlKem768Keypair = (): {\n  encapsulationKey: Uint8Array;\n  decapsulationKey: Uint8Array;\n} => {\n  try {\n    const keys = ml_kem768.keygen();\n    assertNotNull(keys.publicKey, 'Encapsulation key must be defined');\n    assertNotNull(keys.secretKey, 'Decapsulation key must be defined');\n    return {\n      encapsulationKey: keys.publicKey,\n      decapsulationKey: keys.secretKey,\n    };\n  } catch (error) {\n    throw new Error(\n      `Failed to generate ML-KEM-768 keypair: ${error instanceof Error ? error.message : String(error)}`\n    );\n  }\n};\n"]}