@dynamic-labs-wallet/forward-mpc-shared 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -84,7 +84,7 @@ var Uint32ArrayCodec = new ioTs.Type(
     return utils_js.bytesToHex(uint8Array);
   }
 );
-var EncryptedKeyshareCodec = ioTs.type({
+var EncryptedPayloadCodec = ioTs.type({
   salt: Uint8ArrayCodec,
   encryptedPayload: Uint8ArrayCodec
 });
@@ -191,7 +191,7 @@ function createSimpleMessage(config) {
       ...data
     }), "encodeData"),
     decodeData: /* @__PURE__ */ __name((decoded) => {
-      const { type: type7, version, ...data } = decoded;
+      const { type: type8, version, ...data } = decoded;
       return data;
     }, "decodeData")
   });
@@ -470,7 +470,7 @@ var Uint8ArrayOrHexCodec = new ioTs.Type(
 // src/messages/SignMessageV1Request.ts
 var SignMessageRequestSchema = buildMessageSchema("signMessage", 1, {
   relayDomain: DomainCodec,
-  keyshare: EncryptedKeyshareCodec,
+  keyshare: EncryptedPayloadCodec,
   message: Uint8ArrayOrHexCodec,
   roomUuid: ioTs.string,
   userId: OptionalStringCodec,
@@ -485,7 +485,7 @@ var SignMessageV1RequestMessage = createStandardMessage({
     signingAlgo: /* @__PURE__ */ __name((value) => fromDynamicSigningAlgorithm(value), "signingAlgo"),
     derivationPath: /* @__PURE__ */ __name((value) => Uint32ArrayCodec.encode(value), "derivationPath"),
     tweak: /* @__PURE__ */ __name((value) => Uint8ArrayCodec.encode(value), "tweak"),
-    keyshare: /* @__PURE__ */ __name((value) => EncryptedKeyshareCodec.encode(value), "keyshare"),
+    keyshare: /* @__PURE__ */ __name((value) => EncryptedPayloadCodec.encode(value), "keyshare"),
     message: /* @__PURE__ */ __name((value) => Uint8ArrayOrHexCodec.encode(value), "message")
   }),
   decodeData: createStandardDecoder((decoded) => ({
@@ -555,6 +555,139 @@ var ConnectionAckV1ResponseMessage = createSimpleMessage({
   version: 1,
   schema: ConnectionAckResponseSchema
 });
+var BaseKeygenParamsCodec = ioTs.type({
+  relayDomain: DomainCodec,
+  roomUuid: ioTs.string,
+  numParties: ioTs.number,
+  threshold: ioTs.number,
+  keygenInit: EncryptedPayloadCodec,
+  keygenIds: ioTs.array(ioTs.string),
+  userId: OptionalStringCodec,
+  environmentId: OptionalStringCodec,
+  traceContext: TraceContextCodec
+});
+var EcdsaKeygenParamsCodec = ioTs.type({
+  ...BaseKeygenParamsCodec.props,
+  signingAlgo: ioTs.literal("ecdsa")
+});
+var BIP340KeygenParamsCodec = ioTs.type({
+  ...BaseKeygenParamsCodec.props,
+  signingAlgo: ioTs.literal("bip340")
+});
+var KeygenAlgoParamsCodec = ioTs.union([
+  EcdsaKeygenParamsCodec,
+  BIP340KeygenParamsCodec
+]);
+var KeygenRequestSchema = buildMessageSchema("keygen", 1, {
+  relayDomain: DomainCodec,
+  roomUuid: ioTs.string,
+  numParties: ioTs.number,
+  threshold: ioTs.number,
+  keygenInit: EncryptedPayloadCodec,
+  keygenIds: ioTs.array(ioTs.string),
+  userId: OptionalStringCodec,
+  environmentId: OptionalStringCodec,
+  traceContext: TraceContextCodec
+}, KeygenAlgoParamsCodec);
+var KeygenV1RequestMessage = createStandardMessage({
+  messageType: "keygen",
+  version: 1,
+  schema: KeygenRequestSchema,
+  encodeData: createComplexEncoder("keygen", 1, {
+    signingAlgo: /* @__PURE__ */ __name((value) => fromDynamicSigningAlgorithm(value), "signingAlgo"),
+    keygenInit: /* @__PURE__ */ __name((value) => EncryptedPayloadCodec.encode(value), "keygenInit")
+  }),
+  decodeData: createStandardDecoder((decoded) => ({
+    relayDomain: decoded.relayDomain,
+    signingAlgo: decoded.signingAlgo,
+    roomUuid: decoded.roomUuid,
+    numParties: decoded.numParties,
+    threshold: decoded.threshold,
+    keygenInit: decoded.keygenInit,
+    keygenIds: decoded.keygenIds,
+    userId: decoded.userId,
+    environmentId: decoded.environmentId,
+    traceContext: decoded.traceContext
+  }))
+});
+var KeygenResponseSchema = buildMessageSchema("keygen_response", 1, {
+  keygenResult: ioTs.union([
+    EncryptedPayloadCodec,
+    ioTs.undefined
+  ]),
+  error: ioTs.union([
+    WebSocketErrorCodec,
+    ioTs.undefined
+  ])
+});
+var KeygenV1ResponseMessage = createStandardMessage({
+  messageType: "keygen_response",
+  version: 1,
+  schema: KeygenResponseSchema,
+  encodeData: createComplexEncoder("keygen_response", 1, {
+    keygenResult: /* @__PURE__ */ __name((value) => EncryptedPayloadCodec.encode(value), "keygenResult")
+  }),
+  decodeData: createStandardDecoder((decoded) => ({
+    keygenResult: decoded.keygenResult,
+    error: decoded.error
+  }))
+});
+var ReceiveKeyRequestSchema = buildMessageSchema("receiveKey", 1, {
+  relayDomain: DomainCodec,
+  signingAlgo: ioTs.literal("ed25519"),
+  roomUuid: ioTs.string,
+  numParties: ioTs.number,
+  threshold: ioTs.number,
+  keygenInit: EncryptedPayloadCodec,
+  keygenIds: ioTs.array(ioTs.string),
+  userId: OptionalStringCodec,
+  environmentId: OptionalStringCodec,
+  traceContext: TraceContextCodec
+});
+var ReceiveKeyV1RequestMessage = createStandardMessage({
+  messageType: "receiveKey",
+  version: 1,
+  schema: ReceiveKeyRequestSchema,
+  encodeData: /* @__PURE__ */ __name((data) => ReceiveKeyRequestSchema.encode({
+    type: "receiveKey",
+    version: 1,
+    ...data
+  }), "encodeData"),
+  decodeData: createStandardDecoder((decoded) => ({
+    relayDomain: decoded.relayDomain,
+    signingAlgo: decoded.signingAlgo,
+    roomUuid: decoded.roomUuid,
+    numParties: decoded.numParties,
+    threshold: decoded.threshold,
+    keygenInit: decoded.keygenInit,
+    keygenIds: decoded.keygenIds,
+    userId: decoded.userId,
+    environmentId: decoded.environmentId,
+    traceContext: decoded.traceContext
+  }))
+});
+var ReceiveKeyResponseSchema = buildMessageSchema("receiveKey_response", 1, {
+  keygenResult: ioTs.union([
+    EncryptedPayloadCodec,
+    ioTs.undefined
+  ]),
+  error: ioTs.union([
+    WebSocketErrorCodec,
+    ioTs.undefined
+  ])
+});
+var ReceiveKeyV1ResponseMessage = createStandardMessage({
+  messageType: "receiveKey_response",
+  version: 1,
+  schema: ReceiveKeyResponseSchema,
+  encodeData: createComplexEncoder("receiveKey_response", 1, {
+    keygenResult: /* @__PURE__ */ __name((value) => EncryptedPayloadCodec.encode(value), "keygenResult")
+  }),
+  decodeData: createStandardDecoder((decoded) => ({
+    keygenResult: decoded.keygenResult,
+    error: decoded.error
+  }))
+});
 
 // src/messages/allMessages.ts
 var ALL_MESSAGE_CLASSES = {
@@ -563,37 +696,41 @@ var ALL_MESSAGE_CLASSES = {
   "signMessage@1": SignMessageV1RequestMessage,
   "signMessage_response@1": SignMessageV1ResponseMessage,
   "connection_ack@1": ConnectionAckV1RequestMessage,
-  "connection_ack_response@1": ConnectionAckV1ResponseMessage
+  "connection_ack_response@1": ConnectionAckV1ResponseMessage,
+  "keygen@1": KeygenV1RequestMessage,
+  "keygen_response@1": KeygenV1ResponseMessage,
+  "receiveKey@1": ReceiveKeyV1RequestMessage,
+  "receiveKey_response@1": ReceiveKeyV1ResponseMessage
 };
 var ALL_MESSAGE_KEYS = Object.keys(ALL_MESSAGE_CLASSES);
-function getMessageClass(type7, version) {
-  const key = `${type7}@${version}`;
+function getMessageClass(type8, version) {
+  const key = `${type8}@${version}`;
   const MessageClass = ALL_MESSAGE_CLASSES[key];
   if (!MessageClass) {
-    throw new Error(`Unknown message type: ${type7} version ${version}`);
+    throw new Error(`Unknown message type: ${type8} version ${version}`);
   }
   return MessageClass;
 }
 __name(getMessageClass, "getMessageClass");
-function isValidMessageType(type7, version) {
-  const key = `${type7}@${version}`;
+function isValidMessageType(type8, version) {
+  const key = `${type8}@${version}`;
   return key in ALL_MESSAGE_CLASSES;
 }
 __name(isValidMessageType, "isValidMessageType");
 function getAllSupportedMessages() {
   return ALL_MESSAGE_KEYS.map((key) => {
-    const [type7, versionStr] = key.split("@");
+    const [type8, versionStr] = key.split("@");
     return {
-      type: type7,
+      type: type8,
       version: parseInt(versionStr, 10)
     };
   });
 }
 __name(getAllSupportedMessages, "getAllSupportedMessages");
 function parseMessageKey(key) {
-  const [type7, versionStr] = key.split("@");
+  const [type8, versionStr] = key.split("@");
   return {
-    type: type7,
+    type: type8,
     version: parseInt(versionStr, 10)
   };
 }
@@ -616,9 +753,9 @@ var MessageRegistry = class _MessageRegistry {
   /**
   * Get a message class by type and version (derived from single source)
   */
-  getMessageClass(type7, version) {
+  getMessageClass(type8, version) {
     try {
-      return getMessageClass(type7, version);
+      return getMessageClass(type8, version);
     } catch {
       return void 0;
     }
@@ -633,18 +770,18 @@ var MessageRegistry = class _MessageRegistry {
         left: "Invalid wire data: must be an object"
       };
     }
-    const { type: type7, version } = wireData;
-    if (!type7 || !version) {
+    const { type: type8, version } = wireData;
+    if (!type8 || !version) {
       return {
         _tag: "Left",
         left: "Invalid wire data: missing type or version"
       };
     }
-    const MessageClass = this.getMessageClass(type7, version);
+    const MessageClass = this.getMessageClass(type8, version);
     if (!MessageClass) {
       return {
         _tag: "Left",
-        left: `Unknown message type: ${type7}@${version}`
+        left: `Unknown message type: ${type8}@${version}`
       };
     }
     const result = MessageClass.decode(wireData);
@@ -669,7 +806,7 @@ var MessageRegistry = class _MessageRegistry {
   * Get all registered message types (derived from single source)
   */
   getRegisteredTypes() {
-    return getAllSupportedMessages().map(({ type: type7, version }) => `${type7}@${version}`);
+    return getAllSupportedMessages().map(({ type: type8, version }) => `${type8}@${version}`);
   }
 };
 var messageRegistry = MessageRegistry.getInstance();
@@ -717,6 +854,13 @@ var AES_256_GCM_KEY_SIZE = 32;
 var AES_256_GCM_NONCE_SIZE = 12;
 var AES_256_GCM_TAG_SIZE = 16;
 var HKDF_SALT_SIZE = 32;
+var EncryptionPurpose = /* @__PURE__ */ (function(EncryptionPurpose2) {
+  EncryptionPurpose2["KEYSHARE"] = "keyshare";
+  EncryptionPurpose2["KEYGEN_INIT"] = "keygen_init";
+  EncryptionPurpose2["KEYGEN_RESULT"] = "keygen_result";
+  EncryptionPurpose2["TEST"] = "test";
+  return EncryptionPurpose2;
+})({});
 function deriveAESKey(sharedSecret, salt, info) {
   const infoBytes = new TextEncoder().encode(info);
   return hkdf_js.hkdf(sha2_js.sha256, sharedSecret, salt, infoBytes, AES_256_GCM_KEY_SIZE);
@@ -726,19 +870,23 @@ function createKeyDerivationInfo(purpose, connectionId, version = 1) {
   return `forward-mpc-${purpose}-v${version}-${connectionId}`;
 }
 __name(createKeyDerivationInfo, "createKeyDerivationInfo");
-async function encryptKeyshare(keyshare, sharedSecret, connectionId, signingAlgorithm) {
-  const salt = utils_js.randomBytes(32);
-  const keyshareInfo = createKeyDerivationInfo("keyshare", connectionId);
-  const aesKey = deriveAESKey(sharedSecret, salt, keyshareInfo);
-  const keyshareData = {
-    keyshare,
-    signingAlgorithm,
-    timestamp: Date.now(),
-    nonce: utils_js.bytesToHex(utils_js.randomBytes(16))
-  };
-  const nonce = utils_js.randomBytes(12);
+var HKDF_SALT_SIZE2 = 32;
+var AES_GCM_NONCE_SIZE = 12;
+var MIN_SHARED_SECRET_SIZE = 32;
+function encryptPayload(options) {
+  const { payload, sharedSecret, connectionId, purpose } = options;
+  if (!sharedSecret || sharedSecret.length < MIN_SHARED_SECRET_SIZE) {
+    throw new Error(`Invalid shared secret: must be at least ${MIN_SHARED_SECRET_SIZE} bytes`);
+  }
+  if (!connectionId || connectionId.trim().length === 0) {
+    throw new Error("Invalid connectionId: must be non-empty string");
+  }
+  const salt = utils_js.randomBytes(HKDF_SALT_SIZE2);
+  const info = createKeyDerivationInfo(purpose, connectionId);
+  const aesKey = deriveAESKey(sharedSecret, salt, info);
+  const nonce = utils_js.randomBytes(AES_GCM_NONCE_SIZE);
   const aes256Gcm = aes.gcm(aesKey, nonce);
-  const plaintext = new TextEncoder().encode(JSON.stringify(keyshareData));
+  const plaintext = new TextEncoder().encode(JSON.stringify(payload));
   const ciphertext = aes256Gcm.encrypt(plaintext);
   const encryptedPayload = new Uint8Array(nonce.length + ciphertext.length);
   encryptedPayload.set(nonce, 0);
@@ -749,8 +897,82 @@ async function encryptKeyshare(keyshare, sharedSecret, connectionId, signingAlgo
     encryptedPayload
   };
 }
+__name(encryptPayload, "encryptPayload");
+function decryptPayload(options) {
+  const { encrypted, sharedSecret, connectionId, purpose } = options;
+  if (!sharedSecret || sharedSecret.length < MIN_SHARED_SECRET_SIZE) {
+    throw new Error(`Invalid shared secret: must be at least ${MIN_SHARED_SECRET_SIZE} bytes`);
+  }
+  if (!connectionId || connectionId.trim().length === 0) {
+    throw new Error("Invalid connectionId: must be non-empty string");
+  }
+  if (!encrypted.encryptedPayload || encrypted.encryptedPayload.length < AES_GCM_NONCE_SIZE) {
+    throw new Error(`Invalid encrypted payload: must be at least ${AES_GCM_NONCE_SIZE} bytes`);
+  }
+  const info = createKeyDerivationInfo(purpose, connectionId);
+  const aesKey = deriveAESKey(sharedSecret, encrypted.salt, info);
+  const nonce = encrypted.encryptedPayload.slice(0, AES_GCM_NONCE_SIZE);
+  const ciphertext = encrypted.encryptedPayload.slice(AES_GCM_NONCE_SIZE);
+  const aes256Gcm = aes.gcm(aesKey, nonce);
+  const plaintext = aes256Gcm.decrypt(ciphertext);
+  const decryptedText = new TextDecoder().decode(plaintext);
+  const data = JSON.parse(decryptedText);
+  aesKey.fill(0);
+  return data;
+}
+__name(decryptPayload, "decryptPayload");
+function encryptKeyshare(keyshare, sharedSecret, connectionId, signingAlgorithm) {
+  const keyshareData = {
+    keyshare,
+    signingAlgorithm,
+    timestamp: Date.now(),
+    nonce: utils_js.bytesToHex(utils_js.randomBytes(16))
+  };
+  return encryptPayload({
+    payload: keyshareData,
+    sharedSecret,
+    connectionId,
+    purpose: EncryptionPurpose.KEYSHARE
+  });
+}
 __name(encryptKeyshare, "encryptKeyshare");
 
+// src/crypto/keygenEncryption.ts
+function encryptKeygenInit(keygenInit, sharedSecret, connectionId) {
+  if (!keygenInit.keygenId || keygenInit.keygenId.trim().length === 0) {
+    throw new Error("Invalid keygenInit: keygenId must be non-empty string");
+  }
+  if (!keygenInit.keygenSecret || keygenInit.keygenSecret.trim().length === 0) {
+    throw new Error("Invalid keygenInit: keygenSecret must be non-empty string");
+  }
+  return encryptPayload({
+    payload: keygenInit,
+    sharedSecret,
+    connectionId,
+    purpose: EncryptionPurpose.KEYGEN_INIT
+  });
+}
+__name(encryptKeygenInit, "encryptKeygenInit");
+function decryptKeygenResult(encrypted, sharedSecret, connectionId) {
+  const data = decryptPayload({
+    encrypted,
+    sharedSecret,
+    connectionId,
+    purpose: EncryptionPurpose.KEYGEN_RESULT
+  });
+  if (!data.pubkey || !Array.isArray(data.pubkey)) {
+    throw new Error("Invalid keygen result: pubkey must be an array");
+  }
+  if (!data.secretShare || typeof data.secretShare !== "string" || data.secretShare.trim().length === 0) {
+    throw new Error("Invalid keygen result: secretShare must be non-empty string");
+  }
+  return {
+    pubkey: new Uint8Array(data.pubkey),
+    secretShare: data.secretShare
+  };
+}
+__name(decryptKeygenResult, "decryptKeygenResult");
+
 // src/signing/registry.ts
 var SigningAlgorithmRegistry = class SigningAlgorithmRegistry2 {
   static {
@@ -804,14 +1026,23 @@ exports.ConnectionAckV1RequestMessage = ConnectionAckV1RequestMessage;
 exports.ConnectionAckV1ResponseMessage = ConnectionAckV1ResponseMessage;
 exports.EcdsaSigningAlgorithm = EcdsaSigningAlgorithm;
 exports.Ed25519SigningAlgorithm = Ed25519SigningAlgorithm;
-exports.EncryptedKeyshareCodec = EncryptedKeyshareCodec;
+exports.EncryptedPayloadCodec = EncryptedPayloadCodec;
+exports.EncryptionPurpose = EncryptionPurpose;
 exports.HKDF_SALT_SIZE = HKDF_SALT_SIZE;
 exports.HandshakeRequestSchema = HandshakeRequestSchema;
 exports.HandshakeResponseSchema = HandshakeResponseSchema;
 exports.HandshakeV1RequestMessage = HandshakeV1RequestMessage;
 exports.HandshakeV1ResponseMessage = HandshakeV1ResponseMessage;
+exports.KeygenRequestSchema = KeygenRequestSchema;
+exports.KeygenResponseSchema = KeygenResponseSchema;
+exports.KeygenV1RequestMessage = KeygenV1RequestMessage;
+exports.KeygenV1ResponseMessage = KeygenV1ResponseMessage;
 exports.MessageRegistry = MessageRegistry;
 exports.OptionalStringCodec = OptionalStringCodec;
+exports.ReceiveKeyRequestSchema = ReceiveKeyRequestSchema;
+exports.ReceiveKeyResponseSchema = ReceiveKeyResponseSchema;
+exports.ReceiveKeyV1RequestMessage = ReceiveKeyV1RequestMessage;
+exports.ReceiveKeyV1ResponseMessage = ReceiveKeyV1ResponseMessage;
 exports.SIGNING_ALGORITHM_CLASSES = SIGNING_ALGORITHM_CLASSES;
 exports.SIGNING_ALGORITHM_INSTANCES = SIGNING_ALGORITHM_INSTANCES;
 exports.SignMessageRequestSchema = SignMessageRequestSchema;
@@ -828,9 +1059,13 @@ exports.assertNotNull = assertNotNull;
 exports.createKeyDerivationInfo = createKeyDerivationInfo;
 exports.createKeygenResultFromSecretShare = createKeygenResultFromSecretShare;
 exports.decapsulateMlKem768 = decapsulateMlKem768;
+exports.decryptKeygenResult = decryptKeygenResult;
+exports.decryptPayload = decryptPayload;
 exports.deriveAESKey = deriveAESKey;
 exports.encapsulateMlKem768 = encapsulateMlKem768;
+exports.encryptKeygenInit = encryptKeygenInit;
 exports.encryptKeyshare = encryptKeyshare;
+exports.encryptPayload = encryptPayload;
 exports.fromDynamicSigningAlgorithm = fromDynamicSigningAlgorithm;
 exports.generateMlKem768Keypair = generateMlKem768Keypair;
 exports.getAllSupportedMessages = getAllSupportedMessages;