@buildonspark/spark-sdk 0.0.9 → 0.0.10

package/dist/chunk-WLK5POBV.js

@@ -1,527 +0,0 @@
-import {
-  validateResponses
-} from "./chunk-K3Y7DVLD.js";
-import {
-  bigIntToPrivateKey,
-  recoverSecret
-} from "./chunk-HTNOFUHX.js";
-
-// src/services/token-transactions.ts
-import {
-  bytesToHex as bytesToHex2,
-  bytesToNumberBE as bytesToNumberBE2,
-  numberToBytesBE
-} from "@noble/curves/abstract/utils";
-import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
-
-// src/utils/token-hashing.ts
-import { sha256 } from "@scure/btc-signer/utils";
-function hashTokenTransaction(tokenTransaction, partialHash = false) {
-  if (!tokenTransaction) {
-    throw new Error("token transaction cannot be nil");
-  }
-  let allHashes = [];
-  if (tokenTransaction.tokenInput?.$case === "transferInput") {
-    for (const leaf of tokenTransaction.tokenInput.transferInput.leavesToSpend || []) {
-      const hashObj = sha256.create();
-      if (leaf.prevTokenTransactionHash) {
-        hashObj.update(leaf.prevTokenTransactionHash);
-      }
-      const voutBytes = new Uint8Array(4);
-      new DataView(voutBytes.buffer).setUint32(
-        0,
-        leaf.prevTokenTransactionLeafVout,
-        false
-      );
-      hashObj.update(voutBytes);
-      allHashes.push(hashObj.digest());
-    }
-  }
-  if (tokenTransaction.tokenInput?.$case === "mintInput") {
-    const hashObj = sha256.create();
-    if (tokenTransaction.tokenInput.mintInput.issuerPublicKey) {
-      hashObj.update(tokenTransaction.tokenInput.mintInput.issuerPublicKey);
-    }
-    if (tokenTransaction.tokenInput.mintInput.issuerProvidedTimestamp) {
-      const timestampBytes = new Uint8Array(8);
-      new DataView(timestampBytes.buffer).setBigUint64(
-        0,
-        BigInt(tokenTransaction.tokenInput.mintInput.issuerProvidedTimestamp),
-        true
-        // true for little-endian to match Go implementation
-      );
-      hashObj.update(timestampBytes);
-    }
-    allHashes.push(hashObj.digest());
-  }
-  for (const leaf of tokenTransaction.outputLeaves || []) {
-    const hashObj = sha256.create();
-    if (leaf.id && !partialHash) {
-      hashObj.update(new TextEncoder().encode(leaf.id));
-    }
-    if (leaf.ownerPublicKey) {
-      hashObj.update(leaf.ownerPublicKey);
-    }
-    if (leaf.revocationPublicKey && !partialHash) {
-      hashObj.update(leaf.revocationPublicKey);
-    }
-    if (leaf.withdrawBondSats && !partialHash) {
-      const bondBytes = new Uint8Array(8);
-      new DataView(bondBytes.buffer).setBigUint64(
-        0,
-        BigInt(leaf.withdrawBondSats),
-        false
-      );
-      hashObj.update(bondBytes);
-    }
-    if (leaf.withdrawRelativeBlockLocktime && !partialHash) {
-      const locktimeBytes = new Uint8Array(8);
-      new DataView(locktimeBytes.buffer).setBigUint64(
-        0,
-        BigInt(leaf.withdrawRelativeBlockLocktime),
-        false
-      );
-      hashObj.update(locktimeBytes);
-    }
-    if (leaf.tokenPublicKey) {
-      hashObj.update(leaf.tokenPublicKey);
-    }
-    if (leaf.tokenAmount) {
-      hashObj.update(leaf.tokenAmount);
-    }
-    allHashes.push(hashObj.digest());
-  }
-  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 pubKey of sortedPubKeys) {
-    const hashObj = sha256.create();
-    if (pubKey) {
-      hashObj.update(pubKey);
-    }
-    allHashes.push(hashObj.digest());
-  }
-  const finalHashObj = 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 Error("revocation keyshare signable payload cannot be nil");
-  }
-  let allHashes = new Uint8Array(0);
-  const hash1 = sha256(payload.finalTokenTransactionHash || new Uint8Array(0));
-  allHashes = concatenateUint8Arrays(allHashes, hash1);
-  const hash2 = sha256(payload.operatorIdentityPublicKey || new Uint8Array(0));
-  allHashes = concatenateUint8Arrays(allHashes, hash2);
-  return sha256(allHashes);
-}
-function concatenateUint8Arrays(array1, array2) {
-  const result = new Uint8Array(array1.length + array2.length);
-  result.set(array1, 0);
-  result.set(array2, array1.length);
-  return result;
-}
-
-// src/utils/token-keyshares.ts
-import { secp256k1 } from "@noble/curves/secp256k1";
-function recoverPrivateKeyFromKeyshares(keyshares, threshold) {
-  const shares = keyshares.map((keyshare) => ({
-    fieldModulus: BigInt("0x" + secp256k1.CURVE.n.toString(16)),
-    // secp256k1 curve order
-    threshold,
-    index: BigInt(keyshare.index),
-    share: BigInt("0x" + Buffer.from(keyshare.keyshare).toString("hex")),
-    proofs: []
-  }));
-  const recoveredKey = recoverSecret(shares);
-  return bigIntToPrivateKey(recoveredKey);
-}
-
-// src/utils/token-transactions.ts
-import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
-function calculateAvailableTokenAmount(outputLeaves) {
-  return outputLeaves.reduce(
-    (sum, leaf) => sum + BigInt(bytesToNumberBE(leaf.leaf.tokenAmount)),
-    BigInt(0)
-  );
-}
-function checkIfSelectedLeavesAreAvailable(selectedLeaves, tokenLeaves, tokenPublicKey) {
-  const tokenPubKeyHex = bytesToHex(tokenPublicKey);
-  const tokenLeavesAvailable = tokenLeaves.get(tokenPubKeyHex);
-  if (!tokenLeavesAvailable) {
-    return false;
-  }
-  if (selectedLeaves.length === 0 || tokenLeavesAvailable.length < selectedLeaves.length) {
-    return false;
-  }
-  const availableLeafIds = new Set(
-    tokenLeavesAvailable.map((leaf) => leaf.leaf.id)
-  );
-  for (const selectedLeaf of selectedLeaves) {
-    if (!selectedLeaf.leaf?.id || !availableLeafIds.has(selectedLeaf.leaf.id)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// src/services/token-transactions.ts
-var TokenTransactionService = class {
-  config;
-  connectionManager;
-  constructor(config, connectionManager) {
-    this.config = config;
-    this.connectionManager = connectionManager;
-  }
-  async constructTransferTokenTransaction(selectedLeaves, receiverSparkAddress, tokenPublicKey, tokenAmount) {
-    let availableTokenAmount = calculateAvailableTokenAmount(selectedLeaves);
-    if (availableTokenAmount === tokenAmount) {
-      return {
-        tokenInput: {
-          $case: "transferInput",
-          transferInput: {
-            leavesToSpend: selectedLeaves.map((leaf) => ({
-              prevTokenTransactionHash: leaf.previousTransactionHash,
-              prevTokenTransactionLeafVout: leaf.previousTransactionVout
-            }))
-          }
-        },
-        outputLeaves: [
-          {
-            ownerPublicKey: receiverSparkAddress,
-            tokenPublicKey,
-            tokenAmount: numberToBytesBE(tokenAmount, 16)
-          }
-        ],
-        sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys()
-      };
-    } else {
-      const tokenAmountDifference = availableTokenAmount - tokenAmount;
-      return {
-        tokenInput: {
-          $case: "transferInput",
-          transferInput: {
-            leavesToSpend: selectedLeaves.map((leaf) => ({
-              prevTokenTransactionHash: leaf.previousTransactionHash,
-              prevTokenTransactionLeafVout: leaf.previousTransactionVout
-            }))
-          }
-        },
-        outputLeaves: [
-          {
-            ownerPublicKey: receiverSparkAddress,
-            tokenPublicKey,
-            tokenAmount: numberToBytesBE(tokenAmount, 16)
-          },
-          {
-            ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
-            tokenPublicKey,
-            tokenAmount: numberToBytesBE(tokenAmountDifference, 16)
-          }
-        ],
-        sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys()
-      };
-    }
-  }
-  collectOperatorIdentityPublicKeys() {
-    const operatorKeys = [];
-    for (const [_, operator] of Object.entries(
-      this.config.getConfig().signingOperators
-    )) {
-      operatorKeys.push(operator.identityPublicKey);
-    }
-    return operatorKeys;
-  }
-  async broadcastTokenTransaction(tokenTransaction, leafToSpendSigningPublicKeys, leafToSpendRevocationPublicKeys) {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    const signingOperators = this.config.getConfig().signingOperators;
-    const partialTokenTransactionHash = hashTokenTransaction(
-      tokenTransaction,
-      true
-    );
-    const ownerSignatures = [];
-    if (tokenTransaction.tokenInput.$case === "mintInput") {
-      const issuerPublicKey = tokenTransaction.tokenInput.mintInput.issuerPublicKey;
-      if (!issuerPublicKey) {
-        throw new Error("issuer public key cannot be nil");
-      }
-      const ownerSignature = await this.signMessageWithKey(
-        partialTokenTransactionHash,
-        issuerPublicKey
-      );
-      ownerSignatures.push(ownerSignature);
-    } else if (tokenTransaction.tokenInput.$case === "transferInput") {
-      const transferInput = tokenTransaction.tokenInput.transferInput;
-      if (!leafToSpendSigningPublicKeys || !leafToSpendRevocationPublicKeys) {
-        throw new Error(
-          "leafToSpendSigningPublicKeys and leafToSpendRevocationPublicKeys are required"
-        );
-      }
-      for (let i = 0; i < transferInput.leavesToSpend.length; i++) {
-        const key = leafToSpendSigningPublicKeys[i];
-        if (!key) {
-          throw new Error("key not found");
-        }
-        const ownerSignature = await this.signMessageWithKey(
-          partialTokenTransactionHash,
-          key
-        );
-        ownerSignatures.push(ownerSignature);
-      }
-    }
-    const startResponse = await sparkClient.start_token_transaction({
-      identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-      partialTokenTransaction: tokenTransaction,
-      tokenTransactionSignatures: {
-        ownerSignatures
-      }
-    });
-    if (startResponse.keyshareInfo?.ownerIdentifiers.length !== Object.keys(signingOperators).length) {
-      throw new Error(
-        `Keyshare operator count (${startResponse.keyshareInfo?.ownerIdentifiers.length}) does not match signing operator count (${Object.keys(signingOperators).length})`
-      );
-    }
-    for (const identifier of startResponse.keyshareInfo?.ownerIdentifiers || []) {
-      if (!signingOperators[identifier]) {
-        throw new Error(
-          `Keyshare operator ${identifier} not found in signing operator list`
-        );
-      }
-    }
-    const finalTokenTransaction = startResponse.finalTokenTransaction;
-    const finalTokenTransactionHash = hashTokenTransaction(
-      finalTokenTransaction,
-      false
-    );
-    const payload = {
-      finalTokenTransactionHash,
-      operatorIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
-    };
-    const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
-    const operatorSpecificSignatures = [];
-    if (tokenTransaction.tokenInput.$case === "mintInput") {
-      const issuerPublicKey = tokenTransaction.tokenInput.mintInput.issuerPublicKey;
-      if (!issuerPublicKey) {
-        throw new Error("issuer public key cannot be nil");
-      }
-      const ownerSignature = await this.signMessageWithKey(
-        payloadHash,
-        issuerPublicKey
-      );
-      operatorSpecificSignatures.push({
-        ownerPublicKey: issuerPublicKey,
-        ownerSignature,
-        payload
-      });
-    }
-    if (tokenTransaction.tokenInput.$case === "transferInput") {
-      const transferInput = tokenTransaction.tokenInput.transferInput;
-      for (let i = 0; i < transferInput.leavesToSpend.length; i++) {
-        let ownerSignature;
-        if (this.config.getConfig().useTokenTransactionSchnorrSignatures) {
-          ownerSignature = await this.config.signer.signSchnorrWithIdentityKey(payloadHash);
-        } else {
-          ownerSignature = await this.config.signer.signMessageWithIdentityKey(payloadHash);
-        }
-        operatorSpecificSignatures.push({
-          ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
-          ownerSignature,
-          payload
-        });
-      }
-    }
-    const soSignatures = await Promise.allSettled(
-      Object.entries(signingOperators).map(
-        async ([identifier, operator], index) => {
-          const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
-          const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-          const response = await internalSparkClient.sign_token_transaction(
-            {
-              finalTokenTransaction,
-              operatorSpecificSignatures,
-              identityPublicKey
-            },
-            {
-              retry: true,
-              retryMaxAttempts: 5
-            }
-          );
-          return {
-            index,
-            identifier,
-            response
-          };
-        }
-      )
-    );
-    const threshold = startResponse.keyshareInfo.threshold;
-    const successfulSignatures = validateResponses(soSignatures);
-    if (tokenTransaction.tokenInput.$case === "transferInput") {
-      const leavesToSpend = tokenTransaction.tokenInput.transferInput.leavesToSpend;
-      let revocationKeys = [];
-      for (let leafIndex = 0; leafIndex < leavesToSpend.length; leafIndex++) {
-        const leafKeyshares = successfulSignatures.map(
-          ({ identifier, response }) => ({
-            index: parseInt(identifier, 16),
-            keyshare: response.tokenTransactionRevocationKeyshares[leafIndex]
-          })
-        );
-        if (leafKeyshares.length < threshold) {
-          throw new Error(
-            `Insufficient keyshares for leaf ${leafIndex}: got ${leafKeyshares.length}, need ${threshold}`
-          );
-        }
-        const seenIndices = /* @__PURE__ */ new Set();
-        for (const { index } of leafKeyshares) {
-          if (seenIndices.has(index)) {
-            throw new Error(
-              `Duplicate operator index ${index} for leaf ${leafIndex}`
-            );
-          }
-          seenIndices.add(index);
-        }
-        const recoveredPrivateKey = recoverPrivateKeyFromKeyshares(
-          leafKeyshares,
-          threshold
-        );
-        const recoveredPublicKey = secp256k12.getPublicKey(
-          recoveredPrivateKey,
-          true
-        );
-        if (!leafToSpendRevocationPublicKeys || !leafToSpendRevocationPublicKeys[leafIndex] || !recoveredPublicKey.every(
-          (byte, i) => byte === leafToSpendRevocationPublicKeys[leafIndex][i]
-        )) {
-          throw new Error(
-            `Recovered public key does not match expected revocation public key for leaf ${leafIndex}`
-          );
-        }
-        revocationKeys.push(recoveredPrivateKey);
-      }
-      await this.finalizeTokenTransaction(
-        finalTokenTransaction,
-        revocationKeys,
-        threshold
-      );
-    }
-    return bytesToHex2(
-      hashTokenTransaction(startResponse.finalTokenTransaction)
-    );
-  }
-  async finalizeTokenTransaction(finalTokenTransaction, leafToSpendRevocationKeys, threshold) {
-    const signingOperators = this.config.getConfig().signingOperators;
-    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();
-        const response = await internalSparkClient.finalize_token_transaction(
-          {
-            finalTokenTransaction,
-            leafToSpendRevocationKeys,
-            identityPublicKey
-          },
-          {
-            retry: true,
-            retryMaxAttempts: 5
-          }
-        );
-        return {
-          identifier,
-          response
-        };
-      })
-    );
-    validateResponses(soResponses);
-    return finalTokenTransaction;
-  }
-  async fetchOwnedTokenLeaves(ownerPublicKeys, tokenPublicKeys) {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    const result = await sparkClient.get_owned_token_leaves({
-      ownerPublicKeys,
-      tokenPublicKeys
-    });
-    return result.leavesWithPreviousTransactionData;
-  }
-  async syncTokenLeaves(tokenLeaves) {
-    const unsortedTokenLeaves = await this.fetchOwnedTokenLeaves(
-      await this.config.signer.getTrackedPublicKeys(),
-      []
-    );
-    unsortedTokenLeaves.forEach((leaf) => {
-      const tokenKey = bytesToHex2(leaf.leaf.tokenPublicKey);
-      const index = leaf.previousTransactionVout;
-      tokenLeaves.set(tokenKey, [{ ...leaf, previousTransactionVout: index }]);
-    });
-  }
-  selectTokenLeaves(tokenLeaves, tokenAmount) {
-    if (calculateAvailableTokenAmount(tokenLeaves) < tokenAmount) {
-      throw new Error("Insufficient available token amount");
-    }
-    const exactMatch = tokenLeaves.find(
-      (item) => bytesToNumberBE2(item.leaf.tokenAmount) === tokenAmount
-    );
-    if (exactMatch) {
-      return [exactMatch];
-    }
-    tokenLeaves.sort(
-      (a, b) => Number(
-        bytesToNumberBE2(a.leaf.tokenAmount) - bytesToNumberBE2(b.leaf.tokenAmount)
-      )
-    );
-    let remainingAmount = tokenAmount;
-    const selectedLeaves = [];
-    for (const leafInfo of tokenLeaves) {
-      if (remainingAmount <= 0n) break;
-      selectedLeaves.push(leafInfo);
-      remainingAmount -= bytesToNumberBE2(leafInfo.leaf.tokenAmount);
-    }
-    if (remainingAmount > 0n) {
-      throw new Error(
-        "You do not have enough funds to complete the specified operation"
-      );
-    }
-    return selectedLeaves;
-  }
-  // Helper function for deciding if the signer public key is the identity public key
-  async signMessageWithKey(message, publicKey) {
-    if (bytesToHex2(publicKey) === bytesToHex2(await this.config.signer.getIdentityPublicKey())) {
-      if (this.config.getConfig().useTokenTransactionSchnorrSignatures) {
-        return await this.config.signer.signSchnorrWithIdentityKey(message);
-      } else {
-        return await this.config.signer.signMessageWithIdentityKey(message);
-      }
-    } else {
-      if (this.config.getConfig().useTokenTransactionSchnorrSignatures) {
-        return await this.config.signer.signSchnorr(message, publicKey);
-      } else {
-        return await this.config.signer.signMessageWithPublicKey(
-          message,
-          publicKey
-        );
-      }
-    }
-  }
-};
-
-export {
-  calculateAvailableTokenAmount,
-  checkIfSelectedLeavesAreAvailable,
-  TokenTransactionService
-};