@buildonspark/spark-sdk 0.1.44 → 0.1.46

package/src/utils/token-transaction-validation.ts

@@ -1,5 +1,12 @@
 import { InternalValidationError } from "../errors/types.js";
-import { TokenTransaction, TokenOutputToSpend } from "../proto/spark.js";
+import {
+  TokenTransaction as TokenTransactionV0,
+  TokenOutputToSpend as TokenOutputToSpendV0,
+} from "../proto/spark.js";
+import {
+  TokenTransaction as TokenTransaction,
+  TokenOutputToSpend as TokenOutputToSpend,
+} from "../proto/spark_token.js";
 
 function areByteArraysEqual(a: Uint8Array, b: Uint8Array): boolean {
   if (a.length !== b.length) {
@@ -12,6 +19,332 @@ function hasDuplicates<T>(array: T[]): boolean {
   return new Set(array).size !== array.length;
 }
 
+export function validateTokenTransactionV0(
+  finalTokenTransaction: TokenTransactionV0,
+  partialTokenTransaction: TokenTransactionV0,
+  signingOperators: Record<string, any>,
+  keyshareInfo: { ownerIdentifiers: string[]; threshold: number },
+  expectedWithdrawBondSats: number,
+  expectedWithdrawRelativeBlockLocktime: number,
+  expectedThreshold: number,
+) {
+  if (finalTokenTransaction.network !== partialTokenTransaction.network) {
+    throw new InternalValidationError(
+      "Network mismatch in response token transaction",
+      {
+        value: finalTokenTransaction.network,
+        expected: partialTokenTransaction.network,
+      },
+    );
+  }
+
+  if (!finalTokenTransaction.tokenInputs) {
+    throw new InternalValidationError(
+      "Token inputs missing in final transaction",
+      {
+        value: finalTokenTransaction,
+      },
+    );
+  }
+
+  if (!partialTokenTransaction.tokenInputs) {
+    throw new InternalValidationError(
+      "Token inputs missing in partial transaction",
+      {
+        value: partialTokenTransaction,
+      },
+    );
+  }
+
+  if (
+    finalTokenTransaction.tokenInputs.$case !==
+    partialTokenTransaction.tokenInputs.$case
+  ) {
+    throw new InternalValidationError(
+      `Transaction type mismatch: final transaction has ${finalTokenTransaction.tokenInputs.$case}, partial transaction has ${partialTokenTransaction.tokenInputs.$case}`,
+      {
+        value: finalTokenTransaction.tokenInputs.$case,
+        expected: partialTokenTransaction.tokenInputs.$case,
+      },
+    );
+  }
+
+  if (
+    finalTokenTransaction.sparkOperatorIdentityPublicKeys.length !==
+    partialTokenTransaction.sparkOperatorIdentityPublicKeys.length
+  ) {
+    throw new InternalValidationError(
+      "Spark operator identity public keys count mismatch",
+      {
+        value: finalTokenTransaction.sparkOperatorIdentityPublicKeys.length,
+        expected:
+          partialTokenTransaction.sparkOperatorIdentityPublicKeys.length,
+      },
+    );
+  }
+
+  if (
+    partialTokenTransaction.tokenInputs.$case === "mintInput" &&
+    finalTokenTransaction.tokenInputs.$case === "mintInput"
+  ) {
+    const finalMintInput = finalTokenTransaction.tokenInputs.mintInput;
+    const partialMintInput = partialTokenTransaction.tokenInputs.mintInput;
+
+    if (
+      !areByteArraysEqual(
+        finalMintInput.issuerPublicKey,
+        partialMintInput.issuerPublicKey,
+      )
+    ) {
+      throw new InternalValidationError(
+        "Issuer public key mismatch in mint input",
+        {
+          value: finalMintInput.issuerPublicKey.toString(),
+          expected: partialMintInput.issuerPublicKey.toString(),
+        },
+      );
+    }
+  } else if (
+    partialTokenTransaction.tokenInputs.$case === "transferInput" &&
+    finalTokenTransaction.tokenInputs.$case === "transferInput"
+  ) {
+    const finalTransferInput = finalTokenTransaction.tokenInputs.transferInput;
+    const partialTransferInput =
+      partialTokenTransaction.tokenInputs.transferInput;
+
+    if (
+      finalTransferInput.outputsToSpend.length !==
+      partialTransferInput.outputsToSpend.length
+    ) {
+      throw new InternalValidationError(
+        "Outputs to spend count mismatch in transfer input",
+        {
+          value: finalTransferInput.outputsToSpend.length,
+          expected: partialTransferInput.outputsToSpend.length,
+        },
+      );
+    }
+
+    for (let i = 0; i < finalTransferInput.outputsToSpend.length; i++) {
+      const finalOutput = finalTransferInput.outputsToSpend[
+        i
+      ] as TokenOutputToSpendV0;
+      const partialOutput = partialTransferInput.outputsToSpend[
+        i
+      ] as TokenOutputToSpendV0;
+
+      if (!finalOutput) {
+        throw new InternalValidationError(
+          "Token output to spend missing in final transaction",
+          {
+            outputIndex: i,
+            value: finalOutput,
+          },
+        );
+      }
+
+      if (!partialOutput) {
+        throw new InternalValidationError(
+          "Token output to spend missing in partial transaction",
+          {
+            outputIndex: i,
+            value: partialOutput,
+          },
+        );
+      }
+
+      if (
+        !areByteArraysEqual(
+          finalOutput.prevTokenTransactionHash,
+          partialOutput.prevTokenTransactionHash,
+        )
+      ) {
+        throw new InternalValidationError(
+          "Previous token transaction hash mismatch in transfer input",
+          {
+            outputIndex: i,
+            value: finalOutput.prevTokenTransactionHash.toString(),
+            expected: partialOutput.prevTokenTransactionHash.toString(),
+          },
+        );
+      }
+
+      if (
+        finalOutput.prevTokenTransactionVout !==
+        partialOutput.prevTokenTransactionVout
+      ) {
+        throw new InternalValidationError(
+          "Previous token transaction vout mismatch in transfer input",
+          {
+            outputIndex: i,
+            value: finalOutput.prevTokenTransactionVout,
+            expected: partialOutput.prevTokenTransactionVout,
+          },
+        );
+      }
+    }
+  }
+
+  if (
+    finalTokenTransaction.tokenOutputs.length !==
+    partialTokenTransaction.tokenOutputs.length
+  ) {
+    throw new InternalValidationError("Token outputs count mismatch", {
+      value: finalTokenTransaction.tokenOutputs.length,
+      expected: partialTokenTransaction.tokenOutputs.length,
+    });
+  }
+
+  for (let i = 0; i < finalTokenTransaction.tokenOutputs.length; i++) {
+    const finalOutput = finalTokenTransaction.tokenOutputs[i];
+    const partialOutput = partialTokenTransaction.tokenOutputs[i];
+
+    if (!finalOutput) {
+      throw new InternalValidationError(
+        "Token output missing in final transaction",
+        {
+          outputIndex: i,
+          value: finalOutput,
+        },
+      );
+    }
+
+    if (!partialOutput) {
+      throw new InternalValidationError(
+        "Token output missing in partial transaction",
+        {
+          outputIndex: i,
+          value: partialOutput,
+        },
+      );
+    }
+
+    if (
+      !areByteArraysEqual(
+        finalOutput.ownerPublicKey,
+        partialOutput.ownerPublicKey,
+      )
+    ) {
+      throw new InternalValidationError(
+        "Owner public key mismatch in token output",
+        {
+          outputIndex: i,
+          value: finalOutput.ownerPublicKey.toString(),
+          expected: partialOutput.ownerPublicKey.toString(),
+        },
+      );
+    }
+
+    if (
+      finalOutput.tokenPublicKey !== undefined &&
+      partialOutput.tokenPublicKey !== undefined &&
+      !areByteArraysEqual(
+        finalOutput.tokenPublicKey,
+        partialOutput.tokenPublicKey,
+      )
+    ) {
+      throw new InternalValidationError(
+        "Token public key mismatch in token output",
+        {
+          outputIndex: i,
+          value: finalOutput.tokenPublicKey?.toString(),
+          expected: partialOutput.tokenPublicKey?.toString(),
+        },
+      );
+    }
+
+    if (
+      !areByteArraysEqual(finalOutput.tokenAmount, partialOutput.tokenAmount)
+    ) {
+      throw new InternalValidationError(
+        "Token amount mismatch in token output",
+        {
+          outputIndex: i,
+          value: finalOutput.tokenAmount.toString(),
+          expected: partialOutput.tokenAmount.toString(),
+        },
+      );
+    }
+
+    if (finalOutput.withdrawBondSats !== undefined) {
+      if (finalOutput.withdrawBondSats !== expectedWithdrawBondSats) {
+        throw new InternalValidationError(
+          "Withdraw bond sats mismatch in token output",
+          {
+            outputIndex: i,
+            value: finalOutput.withdrawBondSats,
+            expected: expectedWithdrawBondSats,
+          },
+        );
+      }
+    }
+
+    if (finalOutput.withdrawRelativeBlockLocktime !== undefined) {
+      if (
+        finalOutput.withdrawRelativeBlockLocktime !==
+        expectedWithdrawRelativeBlockLocktime
+      ) {
+        throw new InternalValidationError(
+          "Withdraw relative block locktime mismatch in token output",
+          {
+            outputIndex: i,
+            value: finalOutput.withdrawRelativeBlockLocktime,
+            expected: expectedWithdrawRelativeBlockLocktime,
+          },
+        );
+      }
+    }
+
+    if (keyshareInfo.threshold !== expectedThreshold) {
+      throw new InternalValidationError(
+        "Threshold mismatch: expected " +
+          expectedThreshold +
+          " but got " +
+          keyshareInfo.threshold,
+        {
+          field: "threshold",
+          value: keyshareInfo.threshold,
+          expected: expectedThreshold,
+        },
+      );
+    }
+  }
+
+  if (
+    keyshareInfo.ownerIdentifiers.length !==
+    Object.keys(signingOperators).length
+  ) {
+    throw new InternalValidationError(
+      `Keyshare operator count (${keyshareInfo.ownerIdentifiers.length}) does not match signing operator count (${Object.keys(signingOperators).length})`,
+      {
+        keyshareInfo: keyshareInfo.ownerIdentifiers.length,
+        signingOperators: Object.keys(signingOperators).length,
+      },
+    );
+  }
+
+  if (hasDuplicates(keyshareInfo.ownerIdentifiers)) {
+    throw new InternalValidationError(
+      "Duplicate ownerIdentifiers found in keyshareInfo",
+      {
+        keyshareInfo: keyshareInfo.ownerIdentifiers,
+      },
+    );
+  }
+
+  for (const identifier of keyshareInfo.ownerIdentifiers) {
+    if (!signingOperators[identifier]) {
+      throw new InternalValidationError(
+        `Keyshare operator ${identifier} not found in signing operator list`,
+        {
+          keyshareInfo: identifier,
+          signingOperators: Object.keys(signingOperators),
+        },
+      );
+    }
+  }
+}
+
 export function validateTokenTransaction(
   finalTokenTransaction: TokenTransaction,
   partialTokenTransaction: TokenTransaction,
@@ -229,17 +562,19 @@ export function validateTokenTransaction(
     }
 
     if (
+      finalOutput.tokenPublicKey !== undefined &&
+      partialOutput.tokenPublicKey !== undefined &&
       !areByteArraysEqual(
-        finalOutput.tokenPublicKey,
-        partialOutput.tokenPublicKey,
+        finalOutput.tokenPublicKey!,
+        partialOutput.tokenPublicKey!,
       )
     ) {
       throw new InternalValidationError(
         "Token public key mismatch in token output",
         {
           outputIndex: i,
-          value: finalOutput.tokenPublicKey.toString(),
-          expected: partialOutput.tokenPublicKey.toString(),
+          value: finalOutput.tokenPublicKey!.toString(),
+          expected: partialOutput.tokenPublicKey!.toString(),
         },
       );
     }
@@ -334,4 +669,14 @@ export function validateTokenTransaction(
       );
     }
   }
+
+  if (
+    finalTokenTransaction.clientCreatedTimestamp!.getTime() !==
+    partialTokenTransaction.clientCreatedTimestamp!.getTime()
+  ) {
+    throw new InternalValidationError("Client created timestamp mismatch", {
+      value: finalTokenTransaction.clientCreatedTimestamp,
+      expected: partialTokenTransaction.clientCreatedTimestamp,
+    });
+  }
 }

package/src/utils/token-transactions.ts

@@ -1,5 +1,6 @@
 import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
 import { OutputWithPreviousTransactionData } from "../proto/spark.js";
+import { TokenBalanceMap } from "../spark-wallet/types.js";
 
 export function calculateAvailableTokenAmount(
   outputLeaves: OutputWithPreviousTransactionData[],
@@ -45,20 +46,23 @@ export function checkIfSelectedOutputsAreAvailable(
 }
 
 export function filterTokenBalanceForTokenPublicKey(
-  tokenBalances: Map<
-    string,
-    {
-      balance: bigint;
-    }
-  >,
+  tokenBalances: TokenBalanceMap,
   publicKey: string,
 ): { balance: bigint } {
-  if (!tokenBalances || !tokenBalances.has(publicKey)) {
+  if (!tokenBalances) {
+    return { balance: 0n };
+  }
+
+  const tokenBalance = [...tokenBalances.entries()].find(
+    ([, info]) => info.tokenMetadata.tokenPublicKey === publicKey,
+  );
+
+  if (!tokenBalance) {
     return {
       balance: 0n,
     };
   }
   return {
-    balance: tokenBalances.get(publicKey)!.balance,
+    balance: tokenBalance[1].balance,
   };
 }

package/src/utils/transaction.ts

@@ -87,15 +87,9 @@ export function getNextTransactionSequence(
   nextSequence: number;
   needRefresh: boolean;
 } {
-  // Check if the previous sequence is valid. If not, the user could lose funds.
-  checkIfValidSequence(currSequence);
-
   const currentTimelock = getCurrentTimelock(currSequence);
   const nextTimelock = currentTimelock - TIME_LOCK_INTERVAL;
 
-  // Confirm that the next sequence is valid. This should never happen since bit 17-31 should all be 0.
-  checkIfValidSequence(nextTimelock);
-
   if (forRefresh && nextTimelock <= 100 && currentTimelock > 0) {
     return {
       nextSequence: (1 << 30) | nextTimelock,