@buildonspark/spark-sdk 0.1.41 → 0.1.43

package/dist/services/token-transactions.cjs

@@ -49,13 +49,14 @@ if (typeof window !== "undefined") {
 }
 
 // src/services/token-transactions.ts
-var import_utils5 = require("@noble/curves/abstract/utils");
+var import_utils6 = require("@noble/curves/abstract/utils");
 var import_secp256k14 = require("@noble/curves/secp256k1");
 
 // src/utils/token-hashing.ts
 var import_sha2 = require("@noble/hashes/sha2");
 
 // src/errors/base.ts
+var import_utils = require("@noble/hashes/utils");
 var SparkSDKError = class extends Error {
   context;
   originalError;
@@ -87,12 +88,42 @@ var SparkSDKError = class extends Error {
   }
 };
 function getMessage(message, context = {}, originalError) {
-  const contextStr = Object.entries(context).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+  const contextStr = Object.entries(context).map(([key, value]) => `${key}: ${safeStringify(value)}`).join(", ");
   const originalErrorStr = originalError ? `
 Original Error: ${originalError.message}` : "";
   return `SparkSDKError: ${message}${contextStr ? `
 Context: ${contextStr}` : ""}${originalErrorStr}`;
 }
+function safeStringify(value) {
+  const replacer = (_, v) => {
+    if (typeof v === "bigint") {
+      return v.toString();
+    }
+    if (v instanceof Uint8Array) {
+      return formatUint8Array(v);
+    }
+    return v;
+  };
+  if (typeof value === "bigint") {
+    return `"${value.toString()}"`;
+  }
+  if (value instanceof Uint8Array) {
+    return `"${formatUint8Array(value)}"`;
+  }
+  try {
+    const result = JSON.stringify(value, replacer);
+    return result === void 0 ? String(value) : result;
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return "[Unserializable]";
+    }
+  }
+}
+function formatUint8Array(arr) {
+  return `Uint8Array(0x${(0, import_utils.bytesToHex)(arr)})`;
+}
 
 // src/errors/types.ts
 var NetworkError = class extends SparkSDKError {
@@ -113,6 +144,19 @@ var InternalValidationError = class extends SparkSDKError {
 
 // src/utils/token-hashing.ts
 function hashTokenTransaction(tokenTransaction, partialHash = false) {
+  switch (tokenTransaction.version) {
+    case 0:
+      return hashTokenTransactionV0(tokenTransaction, partialHash);
+    case 1:
+      return hashTokenTransactionV1(tokenTransaction, partialHash);
+    default:
+      throw new ValidationError("invalid token transaction version", {
+        field: "tokenTransaction.version",
+        value: tokenTransaction.version
+      });
+  }
+}
+function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
   if (!tokenTransaction) {
     throw new ValidationError("token transaction cannot be nil", {
       field: "tokenTransaction"
@@ -360,6 +404,275 @@ function hashTokenTransaction(tokenTransaction, partialHash = false) {
   finalHashObj.update(concatenatedHashes);
   return finalHashObj.digest();
 }
+function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
+  if (!tokenTransaction) {
+    throw new ValidationError("token transaction cannot be nil", {
+      field: "tokenTransaction"
+    });
+  }
+  let allHashes = [];
+  const versionHashObj = import_sha2.sha256.create();
+  const versionBytes = new Uint8Array(4);
+  new DataView(versionBytes.buffer).setUint32(
+    0,
+    tokenTransaction.version,
+    false
+    // false for big-endian
+  );
+  versionHashObj.update(versionBytes);
+  allHashes.push(versionHashObj.digest());
+  if (tokenTransaction.tokenInputs?.$case === "transferInput") {
+    if (!tokenTransaction.tokenInputs.transferInput.outputsToSpend) {
+      throw new ValidationError("outputs to spend cannot be null", {
+        field: "tokenInputs.transferInput.outputsToSpend"
+      });
+    }
+    if (tokenTransaction.tokenInputs.transferInput.outputsToSpend.length === 0) {
+      throw new ValidationError("outputs to spend cannot be empty", {
+        field: "tokenInputs.transferInput.outputsToSpend"
+      });
+    }
+    for (const [
+      i,
+      output
+    ] of tokenTransaction.tokenInputs.transferInput.outputsToSpend.entries()) {
+      if (!output) {
+        throw new ValidationError(`output cannot be null at index ${i}`, {
+          field: `tokenInputs.transferInput.outputsToSpend[${i}]`,
+          index: i
+        });
+      }
+      const hashObj2 = import_sha2.sha256.create();
+      if (output.prevTokenTransactionHash) {
+        const prevHash = output.prevTokenTransactionHash;
+        if (output.prevTokenTransactionHash.length !== 32) {
+          throw new ValidationError(
+            `invalid previous transaction hash length at index ${i}`,
+            {
+              field: `tokenInputs.transferInput.outputsToSpend[${i}].prevTokenTransactionHash`,
+              value: prevHash,
+              expectedLength: 32,
+              actualLength: prevHash.length,
+              index: i
+            }
+          );
+        }
+        hashObj2.update(output.prevTokenTransactionHash);
+      }
+      const voutBytes = new Uint8Array(4);
+      new DataView(voutBytes.buffer).setUint32(
+        0,
+        output.prevTokenTransactionVout,
+        false
+      );
+      hashObj2.update(voutBytes);
+      allHashes.push(hashObj2.digest());
+    }
+  }
+  if (tokenTransaction.tokenInputs?.$case === "mintInput") {
+    const hashObj2 = import_sha2.sha256.create();
+    if (tokenTransaction.tokenInputs.mintInput.issuerPublicKey) {
+      const issuerPubKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
+      if (issuerPubKey.length === 0) {
+        throw new ValidationError("issuer public key cannot be empty", {
+          field: "tokenInputs.mintInput.issuerPublicKey",
+          value: issuerPubKey,
+          expectedLength: 1,
+          actualLength: 0
+        });
+      }
+      hashObj2.update(issuerPubKey);
+      if (tokenTransaction.tokenInputs.mintInput.issuerProvidedTimestamp != 0) {
+        const timestampBytes = new Uint8Array(8);
+        new DataView(timestampBytes.buffer).setBigUint64(
+          0,
+          BigInt(
+            tokenTransaction.tokenInputs.mintInput.issuerProvidedTimestamp
+          ),
+          true
+          // true for little-endian to match Go implementation
+        );
+        hashObj2.update(timestampBytes);
+      }
+      allHashes.push(hashObj2.digest());
+    }
+  }
+  if (!tokenTransaction.tokenOutputs) {
+    throw new ValidationError("token outputs cannot be null", {
+      field: "tokenOutputs"
+    });
+  }
+  if (tokenTransaction.tokenOutputs.length === 0) {
+    throw new ValidationError("token outputs cannot be empty", {
+      field: "tokenOutputs"
+    });
+  }
+  for (const [i, output] of tokenTransaction.tokenOutputs.entries()) {
+    if (!output) {
+      throw new ValidationError(`output cannot be null at index ${i}`, {
+        field: `tokenOutputs[${i}]`,
+        index: i
+      });
+    }
+    const hashObj2 = import_sha2.sha256.create();
+    if (output.id && !partialHash) {
+      if (output.id.length === 0) {
+        throw new ValidationError(`output ID at index ${i} cannot be empty`, {
+          field: `tokenOutputs[${i}].id`,
+          index: i
+        });
+      }
+      hashObj2.update(new TextEncoder().encode(output.id));
+    }
+    if (output.ownerPublicKey) {
+      if (output.ownerPublicKey.length === 0) {
+        throw new ValidationError(
+          `owner public key at index ${i} cannot be empty`,
+          {
+            field: `tokenOutputs[${i}].ownerPublicKey`,
+            index: i
+          }
+        );
+      }
+      hashObj2.update(output.ownerPublicKey);
+    }
+    if (!partialHash) {
+      const revPubKey = output.revocationCommitment;
+      if (revPubKey) {
+        if (revPubKey.length === 0) {
+          throw new ValidationError(
+            `revocation commitment at index ${i} cannot be empty`,
+            {
+              field: `tokenOutputs[${i}].revocationCommitment`,
+              index: i
+            }
+          );
+        }
+        hashObj2.update(revPubKey);
+      }
+      const bondBytes = new Uint8Array(8);
+      new DataView(bondBytes.buffer).setBigUint64(
+        0,
+        BigInt(output.withdrawBondSats),
+        false
+      );
+      hashObj2.update(bondBytes);
+      const locktimeBytes = new Uint8Array(8);
+      new DataView(locktimeBytes.buffer).setBigUint64(
+        0,
+        BigInt(output.withdrawRelativeBlockLocktime),
+        false
+      );
+      hashObj2.update(locktimeBytes);
+    }
+    if (output.tokenPublicKey) {
+      if (output.tokenPublicKey.length === 0) {
+        throw new ValidationError(
+          `token public key at index ${i} cannot be empty`,
+          {
+            field: `tokenOutputs[${i}].tokenPublicKey`,
+            index: i
+          }
+        );
+      }
+      hashObj2.update(output.tokenPublicKey);
+    }
+    if (output.tokenAmount) {
+      if (output.tokenAmount.length === 0) {
+        throw new ValidationError(
+          `token amount at index ${i} cannot be empty`,
+          {
+            field: `tokenOutputs[${i}].tokenAmount`,
+            index: i
+          }
+        );
+      }
+      if (output.tokenAmount.length > 16) {
+        throw new ValidationError(
+          `token amount at index ${i} exceeds maximum length`,
+          {
+            field: `tokenOutputs[${i}].tokenAmount`,
+            value: output.tokenAmount,
+            expectedLength: 16,
+            actualLength: output.tokenAmount.length,
+            index: i
+          }
+        );
+      }
+      hashObj2.update(output.tokenAmount);
+    }
+    allHashes.push(hashObj2.digest());
+  }
+  if (!tokenTransaction.sparkOperatorIdentityPublicKeys) {
+    throw new ValidationError(
+      "spark operator identity public keys cannot be null",
+      {}
+    );
+  }
+  const sortedPubKeys = [
+    ...tokenTransaction.sparkOperatorIdentityPublicKeys || []
+  ].sort((a, b) => {
+    for (let i = 0; i < a.length && i < b.length; i++) {
+      if (a[i] !== b[i]) return a[i] - b[i];
+    }
+    return a.length - b.length;
+  });
+  for (const [i, pubKey] of sortedPubKeys.entries()) {
+    if (!pubKey) {
+      throw new ValidationError(
+        `operator public key at index ${i} cannot be null`,
+        {
+          field: `sparkOperatorIdentityPublicKeys[${i}]`,
+          index: i
+        }
+      );
+    }
+    if (pubKey.length === 0) {
+      throw new ValidationError(
+        `operator public key at index ${i} cannot be empty`,
+        {
+          field: `sparkOperatorIdentityPublicKeys[${i}]`,
+          index: i
+        }
+      );
+    }
+    const hashObj2 = import_sha2.sha256.create();
+    hashObj2.update(pubKey);
+    allHashes.push(hashObj2.digest());
+  }
+  const hashObj = import_sha2.sha256.create();
+  let networkBytes = new Uint8Array(4);
+  new DataView(networkBytes.buffer).setUint32(
+    0,
+    tokenTransaction.network.valueOf(),
+    false
+    // false for big-endian
+  );
+  hashObj.update(networkBytes);
+  allHashes.push(hashObj.digest());
+  const expiryHashObj = import_sha2.sha256.create();
+  const validityDurationBytes = new Uint8Array(8);
+  const expiryUnixTime = tokenTransaction.expiryTime ? Math.floor(tokenTransaction.expiryTime.getTime() / 1e3) : 0;
+  new DataView(validityDurationBytes.buffer).setBigUint64(
+    0,
+    BigInt(expiryUnixTime),
+    false
+    // false for big-endian
+  );
+  expiryHashObj.update(validityDurationBytes);
+  allHashes.push(expiryHashObj.digest());
+  const finalHashObj = import_sha2.sha256.create();
+  const concatenatedHashes = new Uint8Array(
+    allHashes.reduce((sum, hash) => sum + hash.length, 0)
+  );
+  let offset = 0;
+  for (const hash of allHashes) {
+    concatenatedHashes.set(hash, offset);
+    offset += hash.length;
+  }
+  finalHashObj.update(concatenatedHashes);
+  return finalHashObj.digest();
+}
 function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
   if (!payload) {
     throw new ValidationError(
@@ -410,15 +723,15 @@ function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
 }
 
 // src/utils/token-transactions.ts
-var import_utils = require("@noble/curves/abstract/utils");
+var import_utils2 = require("@noble/curves/abstract/utils");
 function calculateAvailableTokenAmount(outputLeaves) {
   return outputLeaves.reduce(
-    (sum, output) => sum + BigInt((0, import_utils.bytesToNumberBE)(output.output.tokenAmount)),
+    (sum, output) => sum + BigInt((0, import_utils2.bytesToNumberBE)(output.output.tokenAmount)),
     BigInt(0)
   );
 }
 function checkIfSelectedOutputsAreAvailable(selectedOutputs, tokenOutputs, tokenPublicKey) {
-  const tokenPubKeyHex = (0, import_utils.bytesToHex)(tokenPublicKey);
+  const tokenPubKeyHex = (0, import_utils2.bytesToHex)(tokenPublicKey);
   const tokenOutputsAvailable = tokenOutputs.get(tokenPubKeyHex);
   if (!tokenOutputsAvailable) {
     return false;
@@ -693,11 +1006,11 @@ function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction
 }
 
 // src/services/token-transactions.ts
-var import_utils6 = require("@noble/hashes/utils");
+var import_utils7 = require("@noble/hashes/utils");
 
 // src/address/address.ts
 var import_secp256k1 = require("@noble/curves/secp256k1");
-var import_utils2 = require("@noble/hashes/utils");
+var import_utils3 = require("@noble/hashes/utils");
 var import_base2 = require("@scure/base");
 
 // src/proto/spark.ts
@@ -908,7 +1221,7 @@ function isSet(value) {
 
 // src/address/address.ts
 var import_uuidv7 = require("uuidv7");
-var import_utils3 = require("@noble/curves/abstract/utils");
+var import_utils4 = require("@noble/curves/abstract/utils");
 var AddressNetwork = {
   MAINNET: "sp",
   TESTNET: "spt",
@@ -927,7 +1240,7 @@ function decodeSparkAddress(address, network) {
       });
     }
     const payload = SparkAddress.decode(import_base2.bech32m.fromWords(decoded.words));
-    const publicKey = (0, import_utils2.bytesToHex)(payload.identityPublicKey);
+    const publicKey = (0, import_utils3.bytesToHex)(payload.identityPublicKey);
     isValidPublicKey(publicKey);
     const paymentIntentFields = payload.paymentIntentFields;
     return {
@@ -935,8 +1248,8 @@ function decodeSparkAddress(address, network) {
       network,
       paymentIntentFields: paymentIntentFields && {
         id: import_uuidv7.UUID.ofInner(paymentIntentFields.id).toString(),
-        assetIdentifier: paymentIntentFields.assetIdentifier ? (0, import_utils2.bytesToHex)(paymentIntentFields.assetIdentifier) : void 0,
-        assetAmount: (0, import_utils3.bytesToNumberBE)(paymentIntentFields.assetAmount),
+        assetIdentifier: paymentIntentFields.assetIdentifier ? (0, import_utils3.bytesToHex)(paymentIntentFields.assetIdentifier) : void 0,
+        assetAmount: (0, import_utils4.bytesToNumberBE)(paymentIntentFields.assetAmount),
         memo: paymentIntentFields.memo
       }
     };
@@ -995,7 +1308,7 @@ function collectResponses(responses) {
 var import_secp256k13 = require("@noble/curves/secp256k1");
 
 // src/utils/secret-sharing.ts
-var import_utils4 = require("@noble/curves/abstract/utils");
+var import_utils5 = require("@noble/curves/abstract/utils");
 var import_secp256k12 = require("@noble/curves/secp256k1");
 
 // src/utils/crypto.ts
@@ -1137,7 +1450,7 @@ var TokenTransactionService = class {
       if (!checkIfSelectedOutputsAreAvailable(
         outputsToUse,
         tokenOutputs,
-        (0, import_utils6.hexToBytes)(receiverOutputs[0].tokenPublicKey)
+        (0, import_utils7.hexToBytes)(receiverOutputs[0].tokenPublicKey)
       )) {
         throw new ValidationError(
           "One or more selected TTXOs are not available",
@@ -1178,8 +1491,8 @@ var TokenTransactionService = class {
         this.config.getNetworkType()
       );
       return {
-        receiverSparkAddress: (0, import_utils6.hexToBytes)(receiverAddress.identityPublicKey),
-        tokenPublicKey: (0, import_utils6.hexToBytes)(transfer.tokenPublicKey),
+        receiverSparkAddress: (0, import_utils7.hexToBytes)(receiverAddress.identityPublicKey),
+        tokenPublicKey: (0, import_utils7.hexToBytes)(transfer.tokenPublicKey),
         tokenAmount: transfer.tokenAmount
       };
     });
@@ -1211,7 +1524,7 @@ var TokenTransactionService = class {
     const tokenOutputs = tokenOutputData.map((output) => ({
       ownerPublicKey: output.receiverSparkAddress,
       tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: (0, import_utils5.numberToBytesBE)(output.tokenAmount, 16)
+      tokenAmount: (0, import_utils6.numberToBytesBE)(output.tokenAmount, 16)
     }));
     if (availableTokenAmount > totalRequestedAmount) {
       const changeAmount = availableTokenAmount - totalRequestedAmount;
@@ -1219,7 +1532,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils5.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils6.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -1246,7 +1559,7 @@ var TokenTransactionService = class {
     const tokenOutputs = tokenOutputData.map((output) => ({
       ownerPublicKey: output.receiverSparkAddress,
       tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: (0, import_utils5.numberToBytesBE)(output.tokenAmount, 16)
+      tokenAmount: (0, import_utils6.numberToBytesBE)(output.tokenAmount, 16)
     }));
     if (availableTokenAmount > totalRequestedAmount) {
       const changeAmount = availableTokenAmount - totalRequestedAmount;
@@ -1254,7 +1567,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils5.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils6.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -1279,7 +1592,7 @@ var TokenTransactionService = class {
     for (const [_, operator] of Object.entries(
       this.config.getSigningOperators()
     )) {
-      operatorKeys.push((0, import_utils6.hexToBytes)(operator.identityPublicKey));
+      operatorKeys.push((0, import_utils7.hexToBytes)(operator.identityPublicKey));
     }
     return operatorKeys;
   }
@@ -1363,7 +1676,7 @@ var TokenTransactionService = class {
               {
                 field: "revocationCommitment",
                 value: derivedRevocationCommitment,
-                expected: (0, import_utils5.bytesToHex)(outputsToSpendCommitments[outputIndex]),
+                expected: (0, import_utils6.bytesToHex)(outputsToSpendCommitments[outputIndex]),
                 outputIndex
               }
             )
@@ -1389,7 +1702,7 @@ var TokenTransactionService = class {
         threshold
       );
     }
-    return (0, import_utils5.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils6.bytesToHex)(finalTokenTransactionHash);
   }
   async broadcastTokenTransactionV1(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
@@ -1403,13 +1716,13 @@ var TokenTransactionService = class {
       finalTokenTransactionHash,
       signingOperators
     );
-    return (0, import_utils5.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils6.bytesToHex)(finalTokenTransactionHash);
   }
   async startTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const partialTokenTransactionHash = hashTokenTransaction(
+    const partialTokenTransactionHash = hashTokenTransactionV0(
       tokenTransaction,
       true
     );
@@ -1490,7 +1803,7 @@ var TokenTransactionService = class {
       this.config.getThreshold()
     );
     const finalTokenTransaction = startResponse.finalTokenTransaction;
-    const finalTokenTransactionHash = hashTokenTransaction(
+    const finalTokenTransactionHash = hashTokenTransactionV0(
       finalTokenTransaction,
       false
     );
@@ -1558,7 +1871,9 @@ var TokenTransactionService = class {
     const startResponse = await sparkClient.start_transaction(
       {
         identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        partialTokenTransaction: tokenTransaction
+        partialTokenTransaction: tokenTransaction,
+        validityDurationSeconds: await this.config.getTokenValidityDurationSeconds(),
+        partialTokenTransactionOwnerSignatures: ownerSignaturesWithIndex
       },
       {
         retry: true,
@@ -1600,7 +1915,7 @@ var TokenTransactionService = class {
           const identityPublicKey = await this.config.signer.getIdentityPublicKey();
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils6.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils7.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let operatorSpecificSignatures = [];
@@ -1757,7 +2072,7 @@ var TokenTransactionService = class {
       []
     );
     unsortedTokenOutputs.forEach((output) => {
-      const tokenKey = (0, import_utils5.bytesToHex)(output.output.tokenPublicKey);
+      const tokenKey = (0, import_utils6.bytesToHex)(output.output.tokenPublicKey);
       const index = output.previousTransactionVout;
       tokenOutputs.set(tokenKey, [
         { ...output, previousTransactionVout: index }
@@ -1773,7 +2088,7 @@ var TokenTransactionService = class {
       });
     }
     const exactMatch = tokenOutputs.find(
-      (item) => (0, import_utils5.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
+      (item) => (0, import_utils6.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
     );
     if (exactMatch) {
       return [exactMatch];
@@ -1784,7 +2099,7 @@ var TokenTransactionService = class {
     for (const outputWithPreviousTransactionData of tokenOutputs) {
       if (remainingAmount <= 0n) break;
       selectedOutputs.push(outputWithPreviousTransactionData);
-      remainingAmount -= (0, import_utils5.bytesToNumberBE)(
+      remainingAmount -= (0, import_utils6.bytesToNumberBE)(
         outputWithPreviousTransactionData.output.tokenAmount
       );
     }
@@ -1800,13 +2115,13 @@ var TokenTransactionService = class {
     if (strategy === "SMALL_FIRST") {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils5.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils5.bytesToNumberBE)(b.output.tokenAmount)
+          (0, import_utils6.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils6.bytesToNumberBE)(b.output.tokenAmount)
         );
       });
     } else {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils5.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils5.bytesToNumberBE)(a.output.tokenAmount)
+          (0, import_utils6.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils6.bytesToNumberBE)(a.output.tokenAmount)
         );
       });
     }
@@ -1814,7 +2129,7 @@ var TokenTransactionService = class {
   // Helper function for deciding if the signer public key is the identity public key
   async signMessageWithKey(message, publicKey) {
     const tokenSignatures = this.config.getTokenSignatures();
-    if ((0, import_utils5.bytesToHex)(publicKey) === (0, import_utils5.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
+    if ((0, import_utils6.bytesToHex)(publicKey) === (0, import_utils6.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
       if (tokenSignatures === "SCHNORR") {
         return await this.config.signer.signSchnorrWithIdentityKey(message);
       } else {
@@ -1890,7 +2205,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils6.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils7.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -1906,7 +2221,7 @@ var TokenTransactionService = class {
         for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils6.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils7.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let ownerSignature;
@@ -1923,7 +2238,7 @@ var TokenTransactionService = class {
       }
       inputTtxoSignaturesPerOperator.push({
         ttxoSignatures,
-        operatorIdentityPublicKey: (0, import_utils6.hexToBytes)(operator.identityPublicKey)
+        operatorIdentityPublicKey: (0, import_utils7.hexToBytes)(operator.identityPublicKey)
       });
     }
     return inputTtxoSignaturesPerOperator;

package/dist/services/token-transactions.d.cts

@@ -1,17 +1,18 @@
 import { WalletConfigService } from './config.cjs';
-import { j as OutputWithPreviousTransactionData, f as TokenTransaction } from '../spark-DjR1b3TC.cjs';
+import { j as OutputWithPreviousTransactionData, T as TokenTransaction } from '../spark-CDm4gqS6.cjs';
 import { ConnectionManager } from './connection.cjs';
 import { TokenTransaction as TokenTransaction$1 } from '../proto/spark_token.cjs';
 import './wallet-config.cjs';
 import '@buildonspark/lrc20-sdk';
-import '../RequestLightningSendInput-DXcLoiCe.cjs';
+import '../RequestLightningSendInput-Na1mHdWg.cjs';
 import '@lightsparkdev/core';
 import '../BitcoinNetwork-TnABML0T.cjs';
-import '../signer-BhLS7SYR.cjs';
+import '../signer-IO3oMRNj.cjs';
 import '@scure/bip32';
 import '@scure/btc-signer';
 import 'bitcoinjs-lib';
-import '../network-BiwBmoOg.cjs';
+import '@buildonspark/lrc20-sdk/lrc/types';
+import '../network-D5lKssVl.cjs';
 import '@bufbuild/protobuf/wire';
 import 'nice-grpc-common';
 import 'nice-grpc';

package/dist/services/token-transactions.d.ts

@@ -1,17 +1,18 @@
 import { WalletConfigService } from './config.js';
-import { j as OutputWithPreviousTransactionData, f as TokenTransaction } from '../spark-DjR1b3TC.js';
+import { j as OutputWithPreviousTransactionData, T as TokenTransaction } from '../spark-CDm4gqS6.js';
 import { ConnectionManager } from './connection.js';
 import { TokenTransaction as TokenTransaction$1 } from '../proto/spark_token.js';
 import './wallet-config.js';
 import '@buildonspark/lrc20-sdk';
-import '../RequestLightningSendInput-mXUWn_cp.js';
+import '../RequestLightningSendInput-D7fZdT4A.js';
 import '@lightsparkdev/core';
 import '../BitcoinNetwork-TnABML0T.js';
-import '../signer-CylxIujU.js';
+import '../signer-wqesWifN.js';
 import '@scure/bip32';
 import '@scure/btc-signer';
 import 'bitcoinjs-lib';
-import '../network-BF2GYPye.js';
+import '@buildonspark/lrc20-sdk/lrc/types';
+import '../network-xkBSpaTn.js';
 import '@bufbuild/protobuf/wire';
 import 'nice-grpc-common';
 import 'nice-grpc';

package/dist/services/token-transactions.js

@@ -1,13 +1,13 @@
 import {
   TokenTransactionService
-} from "../chunk-J5W5Q2ZP.js";
-import "../chunk-ATEHMLKP.js";
+} from "../chunk-DQYKQJRZ.js";
+import "../chunk-6AFUC5M2.js";
 import "../chunk-L3EHBOUX.js";
-import "../chunk-TM4TOEOX.js";
-import "../chunk-MGPRLH6Q.js";
-import "../chunk-VTUGIIWI.js";
-import "../chunk-TWF35O6M.js";
+import "../chunk-O4RYNJNB.js";
 import "../chunk-M6A4KFIG.js";
+import "../chunk-QNNSEJ4P.js";
+import "../chunk-VTUGIIWI.js";
+import "../chunk-GSI4OLXZ.js";
 import "../chunk-MVRQ5US7.js";
 export {
   TokenTransactionService