@buildonspark/spark-sdk 0.5.0 → 0.5.1

package/src/services/transfer.ts

@@ -16,7 +16,6 @@ import {
   QueryTransfersResponse,
   RenewNodeZeroTimelockSigningJob,
   RenewRefundTimelockSigningJob,
-  SecretProof,
   SendLeafKeyTweak,
   SendLeafKeyTweaks,
   SigningJob,
@@ -45,6 +44,7 @@ import {
   createInitialTimelockNodeTx,
   createInitialTimelockRefundTxs,
   createZeroTimelockNodeTx,
+  getCurrentTimelock,
 } from "../utils/transaction.js";
 import { getTransferPackageSigningPayload } from "../utils/transfer_package.js";
 import { WalletConfigService } from "./config.js";
@@ -297,27 +297,29 @@ export class BaseTransferService {
     );
 
     const sparkFrost = getSparkFrost();
-    const encryptedKeyTweaks: { [key: string]: Uint8Array } = {};
-    for (const [key, value] of keyTweakInputMap) {
-      const protoToEncrypt: SendLeafKeyTweaks = {
-        leavesToSend: value,
-      };
+    const encryptedKeyTweaksEntries = await Promise.all(
+      Array.from(keyTweakInputMap.entries()).map(async ([key, value]) => {
+        const protoToEncrypt: SendLeafKeyTweaks = {
+          leavesToSend: value,
+        };
 
-      const protoToEncryptBinary =
-        SendLeafKeyTweaks.encode(protoToEncrypt).finish();
+        const protoToEncryptBinary =
+          SendLeafKeyTweaks.encode(protoToEncrypt).finish();
 
-      const operator = this.config.getSigningOperators()[key];
-      if (!operator) {
-        throw new SparkValidationError("Operator not found");
-      }
+        const operator = this.config.getSigningOperators()[key];
+        if (!operator) {
+          throw new SparkValidationError("Operator not found");
+        }
 
-      const encryptedProto = await sparkFrost.encryptEcies(
-        protoToEncryptBinary,
-        hexToBytes(operator.identityPublicKey),
-      );
-      encryptedKeyTweaks[key] = Uint8Array.from(encryptedProto);
-    }
+        const encryptedProto = await sparkFrost.encryptEcies(
+          protoToEncryptBinary,
+          hexToBytes(operator.identityPublicKey),
+        );
 
+        return [key, Uint8Array.from(encryptedProto)] as const;
+      }),
+    );
+    const encryptedKeyTweaks = Object.fromEntries(encryptedKeyTweaksEntries);
     const transferPackage: TransferPackage = {
       leavesToSend: cpfpLeafSigningJobs,
       keyTweakPackage: encryptedKeyTweaks,
@@ -376,26 +378,29 @@ export class BaseTransferService {
     );
 
     const sparkFrost = getSparkFrost();
-    const encryptedKeyTweaks: { [key: string]: Uint8Array } = {};
-    for (const [key, value] of keyTweakInputMap) {
-      const protoToEncrypt: SendLeafKeyTweaks = {
-        leavesToSend: value,
-      };
+    const encryptedKeyTweaksEntries = await Promise.all(
+      Array.from(keyTweakInputMap.entries()).map(async ([key, value]) => {
+        const protoToEncrypt: SendLeafKeyTweaks = {
+          leavesToSend: value,
+        };
 
-      const protoToEncryptBinary =
-        SendLeafKeyTweaks.encode(protoToEncrypt).finish();
+        const protoToEncryptBinary =
+          SendLeafKeyTweaks.encode(protoToEncrypt).finish();
 
-      const operator = this.config.getSigningOperators()[key];
-      if (!operator) {
-        throw new SparkValidationError("Operator not found");
-      }
+        const operator = this.config.getSigningOperators()[key];
+        if (!operator) {
+          throw new SparkValidationError("Operator not found");
+        }
 
-      const encryptedProto = await sparkFrost.encryptEcies(
-        protoToEncryptBinary,
-        hexToBytes(operator.identityPublicKey),
-      );
-      encryptedKeyTweaks[key] = Uint8Array.from(encryptedProto);
-    }
+        const encryptedProto = await sparkFrost.encryptEcies(
+          protoToEncryptBinary,
+          hexToBytes(operator.identityPublicKey),
+        );
+
+        return [key, Uint8Array.from(encryptedProto)] as const;
+      }),
+    );
+    const encryptedKeyTweaks = Object.fromEntries(encryptedKeyTweaksEntries);
 
     const transferPackage: TransferPackage = {
       leavesToSend: cpfpLeafSigningJobs,
@@ -581,21 +586,27 @@ export class BaseTransferService {
   ): Promise<Map<string, SendLeafKeyTweak[]>> {
     const leavesTweaksMap = new Map<string, SendLeafKeyTweak[]>();
 
-    for (const leaf of leaves) {
-      const cpfpRefundSignature = cpfpRefundSignatureMap.get(leaf.leaf.id);
-      const directRefundSignature = directRefundSignatureMap.get(leaf.leaf.id);
-      const directFromCpfpRefundSignature =
-        directFromCpfpRefundSignatureMap.get(leaf.leaf.id);
-
-      const leafTweaksMap = await this.prepareSingleSendTransferKeyTweak(
-        transferID,
-        leaf,
-        receiverIdentityPubkey,
-        cpfpRefundSignature,
-        directRefundSignature,
-        directFromCpfpRefundSignature,
-      );
-      for (const [identifier, leafTweak] of leafTweaksMap) {
+    const results = await Promise.all(
+      leaves.map(async (leaf) => {
+        const cpfpRefundSignature = cpfpRefundSignatureMap.get(leaf.leaf.id);
+        const directRefundSignature = directRefundSignatureMap.get(
+          leaf.leaf.id,
+        );
+        const directFromCpfpRefundSignature =
+          directFromCpfpRefundSignatureMap.get(leaf.leaf.id);
+
+        return await this.prepareSingleSendTransferKeyTweak(
+          transferID,
+          leaf,
+          receiverIdentityPubkey,
+          cpfpRefundSignature,
+          directRefundSignature,
+          directFromCpfpRefundSignature,
+        );
+      }),
+    );
+    for (const result of results) {
+      for (const [identifier, leafTweak] of result) {
         leavesTweaksMap.set(identifier, [
           ...(leavesTweaksMap.get(identifier) || []),
           leafTweak,
@@ -714,15 +725,10 @@ export class TransferService extends BaseTransferService {
   }
 
   async claimTransfer(transfer: Transfer, leaves: LeafKeyTweak[]) {
-    let proofMap: Map<string, Uint8Array[]> | undefined;
     if (transfer.status === TransferStatus.TRANSFER_STATUS_SENDER_KEY_TWEAKED) {
-      proofMap = await this.claimTransferTweakKeys(transfer, leaves);
+      await this.claimTransferTweakKeys(transfer, leaves);
     }
-    const signatures = await this.claimTransferSignRefunds(
-      transfer,
-      leaves,
-      proofMap,
-    );
+    const signatures = await this.claimTransferSignRefunds(transfer, leaves);
     return await this.finalizeNodeSignatures(signatures);
   }
 
@@ -786,39 +792,41 @@ export class TransferService extends BaseTransferService {
     transfer: Transfer,
   ): Promise<Map<string, Uint8Array>> {
     const leafPubKeyMap = new Map<string, Uint8Array>();
-    for (const leaf of transfer.leaves) {
-      if (!leaf.leaf) {
-        throw new Error("Leaf is undefined");
-      }
+    await Promise.all(
+      transfer.leaves.map(async (leaf) => {
+        if (!leaf.leaf) {
+          throw new Error("Leaf is undefined");
+        }
 
-      const encoder = new TextEncoder();
-      const leafIdBytes = encoder.encode(leaf.leaf.id);
-      const transferIdBytes = encoder.encode(transfer.id);
+        const encoder = new TextEncoder();
+        const leafIdBytes = encoder.encode(leaf.leaf.id);
+        const transferIdBytes = encoder.encode(transfer.id);
 
-      const payload = new Uint8Array([
-        ...leafIdBytes,
-        ...transferIdBytes,
-        ...leaf.secretCipher,
-      ]);
+        const payload = new Uint8Array([
+          ...leafIdBytes,
+          ...transferIdBytes,
+          ...leaf.secretCipher,
+        ]);
 
-      const payloadHash = sha256(payload);
+        const payloadHash = sha256(payload);
 
-      if (
-        !secp256k1.verify(
-          leaf.signature,
-          payloadHash,
-          transfer.senderIdentityPublicKey,
-        )
-      ) {
-        throw new Error("Signature verification failed");
-      }
+        if (
+          !secp256k1.verify(
+            leaf.signature,
+            payloadHash,
+            transfer.senderIdentityPublicKey,
+          )
+        ) {
+          throw new Error("Signature verification failed");
+        }
 
-      const leafSecret = await this.config.signer.decryptEcies(
-        leaf.secretCipher,
-      );
+        const leafSecret = await this.config.signer.decryptEcies(
+          leaf.secretCipher,
+        );
 
-      leafPubKeyMap.set(leaf.leaf.id, leafSecret);
-    }
+        leafPubKeyMap.set(leaf.leaf.id, leafSecret);
+      }),
+    );
     return leafPubKeyMap;
   }
 
@@ -919,45 +927,47 @@ export class TransferService extends BaseTransferService {
   }> {
     const transferId = uuidv7();
     const leafDataMap = new Map<string, LeafRefundSigningData>();
-    for (const leaf of leaves) {
-      const signingNonceCommitment =
-        await this.config.signer.getRandomSigningCommitment();
-      const directSigningNonceCommitment =
-        await this.config.signer.getRandomSigningCommitment();
-      const directFromCpfpRefundSigningNonceCommitment =
-        await this.config.signer.getRandomSigningCommitment();
-
-      const tx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const refundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
-
-      const directTx =
-        leaf.leaf.directTx.length > 0
-          ? getTxFromRawTxBytes(leaf.leaf.directTx)
-          : undefined;
-
-      const directRefundTx =
-        leaf.leaf.directRefundTx.length > 0
-          ? getTxFromRawTxBytes(leaf.leaf.directRefundTx)
-          : undefined;
-      const directFromCpfpRefundTx =
-        leaf.leaf.directFromCpfpRefundTx.length > 0
-          ? getTxFromRawTxBytes(leaf.leaf.directFromCpfpRefundTx)
-          : undefined;
-
-      leafDataMap.set(leaf.leaf.id, {
-        keyDerivation: leaf.keyDerivation,
-        receivingPubkey: receiverIdentityPubkey,
-        signingNonceCommitment,
-        directSigningNonceCommitment,
-        tx,
-        directTx,
-        refundTx,
-        directRefundTx,
-        directFromCpfpRefundTx,
-        directFromCpfpRefundSigningNonceCommitment,
-        vout: leaf.leaf.vout,
-      });
-    }
+    await Promise.all(
+      leaves.map(async (leaf) => {
+        const signingNonceCommitment =
+          await this.config.signer.getRandomSigningCommitment();
+        const directSigningNonceCommitment =
+          await this.config.signer.getRandomSigningCommitment();
+        const directFromCpfpRefundSigningNonceCommitment =
+          await this.config.signer.getRandomSigningCommitment();
+
+        const tx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+        const refundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+
+        const directTx =
+          leaf.leaf.directTx.length > 0
+            ? getTxFromRawTxBytes(leaf.leaf.directTx)
+            : undefined;
+
+        const directRefundTx =
+          leaf.leaf.directRefundTx.length > 0
+            ? getTxFromRawTxBytes(leaf.leaf.directRefundTx)
+            : undefined;
+        const directFromCpfpRefundTx =
+          leaf.leaf.directFromCpfpRefundTx.length > 0
+            ? getTxFromRawTxBytes(leaf.leaf.directFromCpfpRefundTx)
+            : undefined;
+
+        leafDataMap.set(leaf.leaf.id, {
+          keyDerivation: leaf.keyDerivation,
+          receivingPubkey: receiverIdentityPubkey,
+          signingNonceCommitment,
+          directSigningNonceCommitment,
+          tx,
+          directTx,
+          refundTx,
+          directRefundTx,
+          directFromCpfpRefundTx,
+          directFromCpfpRefundSigningNonceCommitment,
+          vout: leaf.leaf.vout,
+        });
+      }),
+    );
 
     const signingJobs = await this.prepareRefundSoSigningJobs(
       leaves,
@@ -1033,82 +1043,92 @@ export class TransferService extends BaseTransferService {
     isForClaim?: boolean,
   ): Promise<LeafRefundTxSigningJob[]> {
     const signingJobs: LeafRefundTxSigningJob[] = [];
-    for (const leaf of leaves) {
-      const refundSigningData = leafDataMap.get(leaf.leaf.id);
-      if (!refundSigningData) {
-        throw new Error(`Leaf data not found for leaf ${leaf.leaf.id}`);
-      }
+    const results = await Promise.all(
+      leaves.map(async (leaf) => {
+        const refundSigningData = leafDataMap.get(leaf.leaf.id);
+        if (!refundSigningData) {
+          throw new Error(`Leaf data not found for leaf ${leaf.leaf.id}`);
+        }
 
-      const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+        const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
 
-      let directNodeTx: Transaction | undefined;
-      if (leaf.leaf.directTx.length > 0) {
-        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
-      }
+        let directNodeTx: Transaction | undefined;
+        if (leaf.leaf.directTx.length > 0) {
+          directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
+        }
 
-      const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+        const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
 
-      const currentSequence = currRefundTx.getInput(0).sequence;
-      if (!currentSequence) {
-        throw new SparkValidationError("Invalid refund transaction", {
-          field: "sequence",
-          value: currRefundTx.getInput(0),
-          expected: "Non-null sequence",
-        });
-      }
+        const currentSequence = currRefundTx.getInput(0).sequence;
+        if (!currentSequence) {
+          throw new SparkValidationError("Invalid refund transaction", {
+            field: "sequence",
+            value: currRefundTx.getInput(0),
+            expected: "Non-null sequence",
+          });
+        }
 
-      const refundTxsParams = {
-        nodeTx: nodeTx,
-        directNodeTx: directNodeTx,
-        sequence: currentSequence,
-        receivingPubkey: refundSigningData.receivingPubkey,
-        network: this.config.getNetwork(),
-      };
+        const refundTxsParams = {
+          nodeTx: nodeTx,
+          directNodeTx: directNodeTx,
+          sequence: currentSequence,
+          receivingPubkey: refundSigningData.receivingPubkey,
+          network: this.config.getNetwork(),
+        };
 
-      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } =
-        isForClaim
-          ? createCurrentTimelockRefundTxs(refundTxsParams)
-          : createDecrementedTimelockRefundTxs(refundTxsParams);
-
-      refundSigningData.refundTx = cpfpRefundTx;
-      refundSigningData.directRefundTx = directRefundTx;
-      refundSigningData.directFromCpfpRefundTx = directFromCpfpRefundTx;
-
-      const cpfpRefundNonceCommitmentProto =
-        refundSigningData.signingNonceCommitment;
-      const directRefundNonceCommitmentProto =
-        refundSigningData.directSigningNonceCommitment;
-      const directFromCpfpRefundNonceCommitmentProto =
-        refundSigningData.directFromCpfpRefundSigningNonceCommitment;
-
-      const signingPublicKey =
-        await this.config.signer.getPublicKeyFromDerivation(
-          refundSigningData.keyDerivation,
-        );
-      signingJobs.push({
-        leafId: leaf.leaf.id,
-        refundTxSigningJob: {
-          signingPublicKey,
-          rawTx: cpfpRefundTx.toBytes(),
-          signingNonceCommitment: cpfpRefundNonceCommitmentProto.commitment,
-        },
-        directRefundTxSigningJob: directRefundTx
-          ? {
-              signingPublicKey,
-              rawTx: directRefundTx.toBytes(),
-              signingNonceCommitment:
-                directRefundNonceCommitmentProto.commitment,
-            }
-          : undefined,
-        directFromCpfpRefundTxSigningJob: directFromCpfpRefundTx
-          ? {
-              signingPublicKey,
-              rawTx: directFromCpfpRefundTx.toBytes(),
-              signingNonceCommitment:
-                directFromCpfpRefundNonceCommitmentProto.commitment,
-            }
-          : undefined,
-      });
+        const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } =
+          isForClaim
+            ? createCurrentTimelockRefundTxs(refundTxsParams)
+            : createDecrementedTimelockRefundTxs(refundTxsParams);
+
+        const isZeroNode = !getCurrentTimelock(nodeTx.getInput(0).sequence);
+
+        refundSigningData.refundTx = cpfpRefundTx;
+        refundSigningData.directRefundTx =
+          directRefundTx && !isZeroNode ? directRefundTx : undefined;
+        refundSigningData.directFromCpfpRefundTx = directFromCpfpRefundTx;
+
+        const cpfpRefundNonceCommitmentProto =
+          refundSigningData.signingNonceCommitment;
+        const directRefundNonceCommitmentProto =
+          refundSigningData.directSigningNonceCommitment;
+        const directFromCpfpRefundNonceCommitmentProto =
+          refundSigningData.directFromCpfpRefundSigningNonceCommitment;
+
+        const signingPublicKey =
+          await this.config.signer.getPublicKeyFromDerivation(
+            refundSigningData.keyDerivation,
+          );
+        return {
+          leafId: leaf.leaf.id,
+          refundTxSigningJob: {
+            signingPublicKey,
+            rawTx: cpfpRefundTx.toBytes(),
+            signingNonceCommitment: cpfpRefundNonceCommitmentProto.commitment,
+          },
+          directRefundTxSigningJob:
+            directRefundTx && !isZeroNode
+              ? {
+                  signingPublicKey,
+                  rawTx: directRefundTx.toBytes(),
+                  signingNonceCommitment:
+                    directRefundNonceCommitmentProto.commitment,
+                }
+              : undefined,
+          directFromCpfpRefundTxSigningJob: directFromCpfpRefundTx
+            ? {
+                signingPublicKey,
+                rawTx: directFromCpfpRefundTx.toBytes(),
+                signingNonceCommitment:
+                  directFromCpfpRefundNonceCommitmentProto.commitment,
+              }
+            : undefined,
+        };
+      }),
+    );
+
+    for (const result of results) {
+      signingJobs.push(result);
     }
 
     return signingJobs;
@@ -1117,9 +1137,8 @@ export class TransferService extends BaseTransferService {
   async claimTransferTweakKeys(
     transfer: Transfer,
     leaves: LeafKeyTweak[],
-  ): Promise<Map<string, Uint8Array[]>> {
-    const { leafDataMap: leavesTweaksMap, proofMap } =
-      await this.prepareClaimLeavesKeyTweaks(leaves);
+  ): Promise<void> {
+    const leavesTweaksMap = await this.prepareClaimLeavesKeyTweaks(leaves);
 
     const errors: Error[] = [];
 
@@ -1164,21 +1183,18 @@ export class TransferService extends BaseTransferService {
     if (errors.length > 0) {
       throw errors[0];
     }
-
-    return proofMap;
   }
 
-  private async prepareClaimLeavesKeyTweaks(leaves: LeafKeyTweak[]): Promise<{
-    leafDataMap: Map<string, ClaimLeafKeyTweak[]>;
-    proofMap: Map<string, Uint8Array[]>;
-  }> {
+  private async prepareClaimLeavesKeyTweaks(
+    leaves: LeafKeyTweak[],
+  ): Promise<Map<string, ClaimLeafKeyTweak[]>> {
     const leafDataMap = new Map<string, ClaimLeafKeyTweak[]>();
-    const proofMap = new Map<string, Uint8Array[]>();
-    for (const leaf of leaves) {
-      const { leafKeyTweaks: leafData, proofs } =
-        await this.prepareClaimLeafKeyTweaks(leaf);
-      proofMap.set(leaf.leaf.id, proofs);
 
+    const results = await Promise.all(
+      leaves.map((leaf) => this.prepareClaimLeafKeyTweaks(leaf)),
+    );
+
+    for (const { leafKeyTweaks: leafData } of results) {
       for (const [identifier, leafTweak] of leafData) {
         leafDataMap.set(identifier, [
           ...(leafDataMap.get(identifier) || []),
@@ -1186,7 +1202,8 @@ export class TransferService extends BaseTransferService {
         ]);
       }
     }
-    return { leafDataMap, proofMap };
+
+    return leafDataMap;
   }
 
   private async prepareClaimLeafKeyTweaks(leaf: LeafKeyTweak): Promise<{
@@ -1249,32 +1266,33 @@ export class TransferService extends BaseTransferService {
   async claimTransferSignRefunds(
     transfer: Transfer,
     leafKeys: LeafKeyTweak[],
-    proofMap?: Map<string, Uint8Array[]>,
   ): Promise<NodeSignatures[]> {
     const leafDataMap: Map<string, LeafRefundSigningData> = new Map();
-    for (const leafKey of leafKeys) {
-      const tx = getTxFromRawTxBytes(leafKey.leaf.nodeTx);
-      const directTx =
-        leafKey.leaf.directTx.length > 0
-          ? getTxFromRawTxBytes(leafKey.leaf.directTx)
-          : undefined;
-
-      leafDataMap.set(leafKey.leaf.id, {
-        keyDerivation: leafKey.newKeyDerivation,
-        receivingPubkey: await this.config.signer.getPublicKeyFromDerivation(
-          leafKey.newKeyDerivation,
-        ),
-        signingNonceCommitment:
-          await this.config.signer.getRandomSigningCommitment(),
-        directSigningNonceCommitment:
-          await this.config.signer.getRandomSigningCommitment(),
-        directFromCpfpRefundSigningNonceCommitment:
-          await this.config.signer.getRandomSigningCommitment(),
-        tx,
-        directTx,
-        vout: leafKey.leaf.vout,
-      });
-    }
+    await Promise.all(
+      leafKeys.map(async (leafKey) => {
+        const tx = getTxFromRawTxBytes(leafKey.leaf.nodeTx);
+        const directTx =
+          leafKey.leaf.directTx.length > 0
+            ? getTxFromRawTxBytes(leafKey.leaf.directTx)
+            : undefined;
+
+        leafDataMap.set(leafKey.leaf.id, {
+          keyDerivation: leafKey.newKeyDerivation,
+          receivingPubkey: await this.config.signer.getPublicKeyFromDerivation(
+            leafKey.newKeyDerivation,
+          ),
+          signingNonceCommitment:
+            await this.config.signer.getRandomSigningCommitment(),
+          directSigningNonceCommitment:
+            await this.config.signer.getRandomSigningCommitment(),
+          directFromCpfpRefundSigningNonceCommitment:
+            await this.config.signer.getRandomSigningCommitment(),
+          tx,
+          directTx,
+          vout: leafKey.leaf.vout,
+        });
+      }),
+    );
 
     const signingJobs = await this.prepareRefundSoSigningJobs(
       leafKeys,
@@ -1287,14 +1305,6 @@ export class TransferService extends BaseTransferService {
     );
     let resp: ClaimTransferSignRefundsResponse;
 
-    const secretProofMap: { [key: string]: SecretProof } = {};
-    if (proofMap) {
-      for (const [leafId, proof] of proofMap.entries()) {
-        secretProofMap[leafId] = {
-          proofs: proof,
-        };
-      }
-    }
     try {
       resp = await sparkClient.claim_transfer_sign_refunds_v2({
         transferId: transfer.id,