@buildonspark/spark-sdk 0.1.40 → 0.1.41

package/dist/{chunk-57XLH3ZR.js → chunk-ATEHMLKP.js}

@@ -2,27 +2,6 @@ import {
   NetworkError
 } from "./chunk-TWF35O6M.js";
 
-// src/utils/response-validation.ts
-function collectResponses(responses) {
-  const successfulResponses = responses.filter(
-    (result) => result.status === "fulfilled"
-  ).map((result) => result.value);
-  const failedResponses = responses.filter(
-    (result) => result.status === "rejected"
-  );
-  if (failedResponses.length > 0) {
-    const errors = failedResponses.map((result) => result.reason).join("\n");
-    throw new NetworkError(
-      `${failedResponses.length} out of ${responses.length} requests failed, please try again`,
-      {
-        errorCount: failedResponses.length,
-        errors
-      }
-    );
-  }
-  return successfulResponses;
-}
-
 // src/utils/token-transactions.ts
 import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
 function calculateAvailableTokenAmount(outputLeaves) {
@@ -61,9 +40,30 @@ function filterTokenBalanceForTokenPublicKey(tokenBalances, publicKey) {
   };
 }
 
+// src/utils/response-validation.ts
+function collectResponses(responses) {
+  const successfulResponses = responses.filter(
+    (result) => result.status === "fulfilled"
+  ).map((result) => result.value);
+  const failedResponses = responses.filter(
+    (result) => result.status === "rejected"
+  );
+  if (failedResponses.length > 0) {
+    const errors = failedResponses.map((result) => result.reason).join("\n");
+    throw new NetworkError(
+      `${failedResponses.length} out of ${responses.length} requests failed, please try again`,
+      {
+        errorCount: failedResponses.length,
+        errors
+      }
+    );
+  }
+  return successfulResponses;
+}
+
 export {
-  collectResponses,
   calculateAvailableTokenAmount,
   checkIfSelectedOutputsAreAvailable,
-  filterTokenBalanceForTokenPublicKey
+  filterTokenBalanceForTokenPublicKey,
+  collectResponses
 };

package/dist/{chunk-5MNQB2T4.js → chunk-J5W5Q2ZP.js}

@@ -2,10 +2,10 @@ import {
   calculateAvailableTokenAmount,
   checkIfSelectedOutputsAreAvailable,
   collectResponses
-} from "./chunk-57XLH3ZR.js";
+} from "./chunk-ATEHMLKP.js";
 import {
   decodeSparkAddress
-} from "./chunk-2CDJZQN4.js";
+} from "./chunk-TM4TOEOX.js";
 import {
   bigIntToPrivateKey,
   recoverSecret
@@ -326,23 +326,6 @@ function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
   return finalHashObj.digest();
 }
 
-// src/utils/token-keyshares.ts
-import { secp256k1 } from "@noble/curves/secp256k1";
-function recoverRevocationSecretFromKeyshares(keyshares, threshold) {
-  const shares = keyshares.map((keyshare) => ({
-    fieldModulus: BigInt("0x" + secp256k1.CURVE.n.toString(16)),
-    // secp256k1 curve order
-    threshold,
-    index: BigInt(keyshare.operatorIndex),
-    share: BigInt(
-      "0x" + Buffer.from(keyshare.keyshare.keyshare).toString("hex")
-    ),
-    proofs: []
-  }));
-  const recoveredSecret = recoverSecret(shares);
-  return bigIntToPrivateKey(recoveredSecret);
-}
-
 // src/utils/token-transaction-validation.ts
 function areByteArraysEqual(a, b) {
   if (a.length !== b.length) {
@@ -600,6 +583,25 @@ function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction
 
 // src/services/token-transactions.ts
 import { hexToBytes } from "@noble/hashes/utils";
+
+// src/utils/token-keyshares.ts
+import { secp256k1 } from "@noble/curves/secp256k1";
+function recoverRevocationSecretFromKeyshares(keyshares, threshold) {
+  const shares = keyshares.map((keyshare) => ({
+    fieldModulus: BigInt("0x" + secp256k1.CURVE.n.toString(16)),
+    // secp256k1 curve order
+    threshold,
+    index: BigInt(keyshare.operatorIndex),
+    share: BigInt(
+      "0x" + Buffer.from(keyshare.keyshare.keyshare).toString("hex")
+    ),
+    proofs: []
+  }));
+  const recoveredSecret = recoverSecret(shares);
+  return bigIntToPrivateKey(recoveredSecret);
+}
+
+// src/services/token-transactions.ts
 var MAX_TOKEN_OUTPUTS = 500;
 var TokenTransactionService = class {
   config;
@@ -667,15 +669,23 @@ var TokenTransactionService = class {
         this.config.getNetworkType()
       );
       return {
-        receiverSparkAddress: hexToBytes(receiverAddress),
+        receiverSparkAddress: hexToBytes(receiverAddress.identityPublicKey),
         tokenPublicKey: hexToBytes(transfer.tokenPublicKey),
         tokenAmount: transfer.tokenAmount
       };
     });
-    const tokenTransaction = await this.constructTransferTokenTransaction(
-      outputsToUse,
-      tokenOutputData
-    );
+    let tokenTransaction;
+    if (this.config.getTokenTransactionVersion() === "V0") {
+      tokenTransaction = await this.constructTransferTokenTransactionV0(
+        outputsToUse,
+        tokenOutputData
+      );
+    } else {
+      tokenTransaction = await this.constructTransferTokenTransaction(
+        outputsToUse,
+        tokenOutputData
+      );
+    }
     const txId = await this.broadcastTokenTransaction(
       tokenTransaction,
       outputsToUse.map((output) => output.output.ownerPublicKey),
@@ -683,7 +693,7 @@ var TokenTransactionService = class {
     );
     return txId;
   }
-  async constructTransferTokenTransaction(selectedOutputs, tokenOutputData) {
+  async constructTransferTokenTransactionV0(selectedOutputs, tokenOutputData) {
     const availableTokenAmount = calculateAvailableTokenAmount(selectedOutputs);
     const totalRequestedAmount = tokenOutputData.reduce(
       (sum, output) => sum + output.tokenAmount,
@@ -718,6 +728,43 @@ var TokenTransactionService = class {
       sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys()
     };
   }
+  async constructTransferTokenTransaction(selectedOutputs, tokenOutputData) {
+    const availableTokenAmount = calculateAvailableTokenAmount(selectedOutputs);
+    const totalRequestedAmount = tokenOutputData.reduce(
+      (sum, output) => sum + output.tokenAmount,
+      0n
+    );
+    const tokenOutputs = tokenOutputData.map((output) => ({
+      ownerPublicKey: output.receiverSparkAddress,
+      tokenPublicKey: output.tokenPublicKey,
+      tokenAmount: numberToBytesBE(output.tokenAmount, 16)
+    }));
+    if (availableTokenAmount > totalRequestedAmount) {
+      const changeAmount = availableTokenAmount - totalRequestedAmount;
+      const firstTokenPublicKey = tokenOutputData[0].tokenPublicKey;
+      tokenOutputs.push({
+        ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
+        tokenPublicKey: firstTokenPublicKey,
+        tokenAmount: numberToBytesBE(changeAmount, 16)
+      });
+    }
+    return {
+      version: 1,
+      network: this.config.getNetworkProto(),
+      tokenInputs: {
+        $case: "transferInput",
+        transferInput: {
+          outputsToSpend: selectedOutputs.map((output) => ({
+            prevTokenTransactionHash: output.previousTransactionHash,
+            prevTokenTransactionVout: output.previousTransactionVout
+          }))
+        }
+      },
+      tokenOutputs,
+      sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys(),
+      expiryTime: void 0
+    };
+  }
   collectOperatorIdentityPublicKeys() {
     const operatorKeys = [];
     for (const [_, operator] of Object.entries(
@@ -729,13 +776,30 @@ var TokenTransactionService = class {
   }
   async broadcastTokenTransaction(tokenTransaction, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const signingOperators = this.config.getSigningOperators();
-    const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
+    if (!isTokenTransaction(tokenTransaction)) {
+      return this.broadcastTokenTransactionV0(
+        tokenTransaction,
+        signingOperators,
+        outputsToSpendSigningPublicKeys,
+        outputsToSpendCommitments
+      );
+    } else {
+      return this.broadcastTokenTransactionV1(
+        tokenTransaction,
+        signingOperators,
+        outputsToSpendSigningPublicKeys,
+        outputsToSpendCommitments
+      );
+    }
+  }
+  async broadcastTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
+    const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransactionV0(
       tokenTransaction,
       signingOperators,
       outputsToSpendSigningPublicKeys,
       outputsToSpendCommitments
     );
-    const { successfulSignatures } = await this.signTokenTransaction(
+    const { successfulSignatures } = await this.signTokenTransactionV0(
       finalTokenTransaction,
       finalTokenTransactionHash,
       signingOperators
@@ -818,7 +882,21 @@ var TokenTransactionService = class {
     }
     return bytesToHex(finalTokenTransactionHash);
   }
-  async startTokenTransaction(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
+  async broadcastTokenTransactionV1(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
+    const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
+      tokenTransaction,
+      signingOperators,
+      outputsToSpendSigningPublicKeys,
+      outputsToSpendCommitments
+    );
+    await this.signTokenTransaction(
+      finalTokenTransaction,
+      finalTokenTransactionHash,
+      signingOperators
+    );
+    return bytesToHex(finalTokenTransactionHash);
+  }
+  async startTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
@@ -913,7 +991,99 @@ var TokenTransactionService = class {
       threshold: startResponse.keyshareInfo.threshold
     };
   }
-  async signTokenTransaction(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
+  async startTokenTransaction(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
+    const sparkClient = await this.connectionManager.createSparkTokenClient(
+      this.config.getCoordinatorAddress()
+    );
+    const partialTokenTransactionHash = hashTokenTransaction(
+      tokenTransaction,
+      true
+    );
+    const ownerSignaturesWithIndex = [];
+    if (tokenTransaction.tokenInputs.$case === "mintInput") {
+      const issuerPublicKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
+      if (!issuerPublicKey) {
+        throw new ValidationError("Invalid mint input", {
+          field: "issuerPublicKey",
+          value: null,
+          expected: "Non-null issuer public key"
+        });
+      }
+      const ownerSignature = await this.signMessageWithKey(
+        partialTokenTransactionHash,
+        issuerPublicKey
+      );
+      ownerSignaturesWithIndex.push({
+        signature: ownerSignature,
+        inputIndex: 0
+      });
+    } else if (tokenTransaction.tokenInputs.$case === "transferInput") {
+      if (!outputsToSpendSigningPublicKeys || !outputsToSpendCommitments) {
+        throw new ValidationError("Invalid transfer input", {
+          field: "outputsToSpend",
+          value: {
+            signingPublicKeys: outputsToSpendSigningPublicKeys,
+            revocationPublicKeys: outputsToSpendCommitments
+          },
+          expected: "Non-null signing and revocation public keys"
+        });
+      }
+      for (const [i, key] of outputsToSpendSigningPublicKeys.entries()) {
+        if (!key) {
+          throw new ValidationError("Invalid signing key", {
+            field: "outputsToSpendSigningPublicKeys",
+            value: i,
+            expected: "Non-null signing key"
+          });
+        }
+        const ownerSignature = await this.signMessageWithKey(
+          partialTokenTransactionHash,
+          key
+        );
+        ownerSignaturesWithIndex.push({
+          signature: ownerSignature,
+          inputIndex: i
+        });
+      }
+    }
+    const startResponse = await sparkClient.start_transaction(
+      {
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        partialTokenTransaction: tokenTransaction
+      },
+      {
+        retry: true,
+        retryableStatuses: ["UNKNOWN", "UNAVAILABLE", "CANCELLED", "INTERNAL"],
+        retryMaxAttempts: 3
+      }
+    );
+    if (!startResponse.finalTokenTransaction) {
+      throw new Error("Final token transaction missing in start response");
+    }
+    if (!startResponse.keyshareInfo) {
+      throw new Error("Keyshare info missing in start response");
+    }
+    validateTokenTransaction(
+      startResponse.finalTokenTransaction,
+      tokenTransaction,
+      signingOperators,
+      startResponse.keyshareInfo,
+      this.config.getExpectedWithdrawBondSats(),
+      this.config.getExpectedWithdrawRelativeBlockLocktime(),
+      this.config.getThreshold()
+    );
+    const finalTokenTransaction = startResponse.finalTokenTransaction;
+    const finalTokenTransactionHash = hashTokenTransaction(
+      finalTokenTransaction,
+      false
+    );
+    return {
+      finalTokenTransaction,
+      finalTokenTransactionHash,
+      threshold: startResponse.keyshareInfo.threshold
+    };
+  }
+  async signTokenTransactionV0(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
     const soSignatures = await Promise.allSettled(
       Object.entries(signingOperators).map(
         async ([identifier, operator], index) => {
@@ -1010,49 +1180,44 @@ var TokenTransactionService = class {
       successfulSignatures
     };
   }
-  async finalizeTokenTransaction(finalTokenTransaction, revocationSecrets, threshold) {
-    const signingOperators = this.config.getSigningOperators();
-    const soResponses = await Promise.allSettled(
-      Object.entries(signingOperators).map(async ([identifier, operator]) => {
-        const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
-        const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-        try {
-          const response = await internalSparkClient.finalize_token_transaction(
-            {
-              finalTokenTransaction,
-              revocationSecrets,
-              identityPublicKey
-            },
-            {
-              retry: true,
-              retryableStatuses: [
-                "UNKNOWN",
-                "UNAVAILABLE",
-                "CANCELLED",
-                "INTERNAL"
-              ],
-              retryMaxAttempts: 3
-            }
-          );
-          return {
-            identifier,
-            response
-          };
-        } catch (error) {
-          throw new NetworkError(
-            "Failed to finalize token transaction",
-            {
-              operation: "finalize_token_transaction",
-              errorCount: 1,
-              errors: error instanceof Error ? error.message : String(error)
-            },
-            error
-          );
-        }
-      })
+  async signTokenTransaction(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
+    const coordinatorClient = await this.connectionManager.createSparkTokenClient(
+      this.config.getCoordinatorAddress()
     );
-    collectResponses(soResponses);
-    return finalTokenTransaction;
+    const inputTtxoSignaturesPerOperator = await this.createSignaturesForOperators(
+      finalTokenTransaction,
+      finalTokenTransactionHash,
+      signingOperators
+    );
+    try {
+      await coordinatorClient.commit_transaction(
+        {
+          finalTokenTransaction,
+          inputTtxoSignaturesPerOperator,
+          ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
+        },
+        {
+          retry: true,
+          retryableStatuses: [
+            "UNKNOWN",
+            "UNAVAILABLE",
+            "CANCELLED",
+            "INTERNAL"
+          ],
+          retryMaxAttempts: 3
+        }
+      );
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to sign token transaction",
+        {
+          operation: "sign_token_transaction",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
   }
   async fetchOwnedTokenOutputs(ownerPublicKeys, tokenPublicKeys) {
     const sparkClient = await this.connectionManager.createSparkClient(
@@ -1157,7 +1322,107 @@ var TokenTransactionService = class {
       }
     }
   }
+  async finalizeTokenTransaction(finalTokenTransaction, revocationSecrets, threshold) {
+    const signingOperators = this.config.getSigningOperators();
+    const soResponses = await Promise.allSettled(
+      Object.entries(signingOperators).map(async ([identifier, operator]) => {
+        const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
+        const identityPublicKey = await this.config.signer.getIdentityPublicKey();
+        try {
+          const response = await internalSparkClient.finalize_token_transaction(
+            {
+              finalTokenTransaction,
+              revocationSecrets,
+              identityPublicKey
+            },
+            {
+              retry: true,
+              retryableStatuses: [
+                "UNKNOWN",
+                "UNAVAILABLE",
+                "CANCELLED",
+                "INTERNAL"
+              ],
+              retryMaxAttempts: 3
+            }
+          );
+          return {
+            identifier,
+            response
+          };
+        } catch (error) {
+          throw new NetworkError(
+            "Failed to finalize token transaction",
+            {
+              operation: "finalize_token_transaction",
+              errorCount: 1,
+              errors: error instanceof Error ? error.message : String(error)
+            },
+            error
+          );
+        }
+      })
+    );
+    collectResponses(soResponses);
+    return finalTokenTransaction;
+  }
+  async createSignaturesForOperators(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
+    const inputTtxoSignaturesPerOperator = [];
+    for (const [_, operator] of Object.entries(signingOperators)) {
+      let ttxoSignatures = [];
+      if (finalTokenTransaction.tokenInputs.$case === "mintInput") {
+        const issuerPublicKey = finalTokenTransaction.tokenInputs.mintInput.issuerPublicKey;
+        if (!issuerPublicKey) {
+          throw new ValidationError("Invalid mint input", {
+            field: "issuerPublicKey",
+            value: null,
+            expected: "Non-null issuer public key"
+          });
+        }
+        const payload = {
+          finalTokenTransactionHash,
+          operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
+        };
+        const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
+        const ownerSignature = await this.signMessageWithKey(
+          payloadHash,
+          issuerPublicKey
+        );
+        ttxoSignatures.push({
+          signature: ownerSignature,
+          inputIndex: 0
+        });
+      } else if (finalTokenTransaction.tokenInputs.$case === "transferInput") {
+        const transferInput = finalTokenTransaction.tokenInputs.transferInput;
+        for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
+          const payload = {
+            finalTokenTransactionHash,
+            operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
+          };
+          const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
+          let ownerSignature;
+          if (this.config.getTokenSignatures() === "SCHNORR") {
+            ownerSignature = await this.config.signer.signSchnorrWithIdentityKey(payloadHash);
+          } else {
+            ownerSignature = await this.config.signer.signMessageWithIdentityKey(payloadHash);
+          }
+          ttxoSignatures.push({
+            signature: ownerSignature,
+            inputIndex: i
+          });
+        }
+      }
+      inputTtxoSignaturesPerOperator.push({
+        ttxoSignatures,
+        operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
+      });
+    }
+    return inputTtxoSignaturesPerOperator;
+  }
 };
+function isTokenTransaction(tokenTransaction) {
+  return "version" in tokenTransaction && "expiryTime" in tokenTransaction;
+}
 
 export {
   TokenTransactionService