@buildonspark/spark-sdk 0.1.38 → 0.1.40

package/dist/chunk-E5SL7XTO.js

@@ -1,301 +0,0 @@
-import {
-  getNetwork,
-  getNetworkFromAddress
-} from "./chunk-VJTDG4BQ.js";
-import {
-  ELECTRS_CREDENTIALS,
-  getElectrsUrl
-} from "./chunk-ZUVYYR5T.js";
-import {
-  BitcoinNetwork_default
-} from "./chunk-HMLOC6TE.js";
-import {
-  ValidationError
-} from "./chunk-TWF35O6M.js";
-
-// src/utils/bitcoin.ts
-import {
-  bytesToHex,
-  bytesToNumberBE,
-  hexToBytes
-} from "@noble/curves/abstract/utils";
-import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
-import { sha256 } from "@noble/hashes/sha2";
-import * as btc from "@scure/btc-signer";
-function computeTaprootKeyNoScript(pubkey) {
-  if (pubkey.length !== 32) {
-    throw new ValidationError("Public key must be 32 bytes", {
-      field: "pubkey",
-      value: pubkey.length,
-      expected: 32
-    });
-  }
-  const taggedHash = schnorr.utils.taggedHash("TapTweak", pubkey);
-  const tweak = bytesToNumberBE(taggedHash);
-  const P = schnorr.utils.lift_x(schnorr.utils.bytesToNumberBE(pubkey));
-  const Q = P.add(secp256k1.ProjectivePoint.fromPrivateKey(tweak));
-  return Q.toRawBytes();
-}
-function getP2TRScriptFromPublicKey(pubKey, network) {
-  if (pubKey.length !== 33) {
-    throw new ValidationError("Public key must be 33 bytes", {
-      field: "pubKey",
-      value: pubKey.length,
-      expected: 33
-    });
-  }
-  const internalKey = secp256k1.ProjectivePoint.fromHex(pubKey);
-  const script = btc.p2tr(
-    internalKey.toRawBytes().slice(1, 33),
-    void 0,
-    getNetwork(network)
-  ).script;
-  if (!script) {
-    throw new ValidationError("Failed to get P2TR script", {
-      field: "script",
-      value: "null"
-    });
-  }
-  return script;
-}
-function getP2TRAddressFromPublicKey(pubKey, network) {
-  if (pubKey.length !== 33) {
-    throw new ValidationError("Public key must be 33 bytes", {
-      field: "pubKey",
-      value: pubKey.length,
-      expected: 33
-    });
-  }
-  const internalKey = secp256k1.ProjectivePoint.fromHex(pubKey);
-  const address = btc.p2tr(
-    internalKey.toRawBytes().slice(1, 33),
-    void 0,
-    getNetwork(network)
-  ).address;
-  if (!address) {
-    throw new ValidationError("Failed to get P2TR address", {
-      field: "address",
-      value: "null"
-    });
-  }
-  return address;
-}
-function getP2TRAddressFromPkScript(pkScript, network) {
-  if (pkScript.length !== 34 || pkScript[0] !== 81 || pkScript[1] !== 32) {
-    throw new ValidationError("Invalid pkscript", {
-      field: "pkScript",
-      value: bytesToHex(pkScript),
-      expected: "34 bytes starting with 0x51 0x20"
-    });
-  }
-  const parsedScript = btc.OutScript.decode(pkScript);
-  return btc.Address(getNetwork(network)).encode(parsedScript);
-}
-function getP2WPKHAddressFromPublicKey(pubKey, network) {
-  if (pubKey.length !== 33) {
-    throw new ValidationError("Public key must be 33 bytes", {
-      field: "pubKey",
-      value: pubKey.length,
-      expected: 33
-    });
-  }
-  const address = btc.p2wpkh(pubKey, getNetwork(network)).address;
-  if (!address) {
-    throw new ValidationError("Failed to get P2WPKH address", {
-      field: "address",
-      value: "null"
-    });
-  }
-  return address;
-}
-function getTxFromRawTxHex(rawTxHex) {
-  const txBytes = hexToBytes(rawTxHex);
-  const tx = btc.Transaction.fromRaw(txBytes, {
-    allowUnknownOutputs: true
-  });
-  if (!tx) {
-    throw new ValidationError("Failed to parse transaction", {
-      field: "tx",
-      value: "null"
-    });
-  }
-  return tx;
-}
-function getTxFromRawTxBytes(rawTxBytes) {
-  const tx = btc.Transaction.fromRaw(rawTxBytes, {
-    allowUnknownOutputs: true
-  });
-  if (!tx) {
-    throw new ValidationError("Failed to parse transaction", {
-      field: "tx",
-      value: "null"
-    });
-  }
-  return tx;
-}
-function getSigHashFromTx(tx, inputIndex, prevOutput) {
-  const prevScript = prevOutput.script;
-  if (!prevScript) {
-    throw new ValidationError("No script found in prevOutput", {
-      field: "prevScript",
-      value: "null"
-    });
-  }
-  const amount = prevOutput.amount;
-  if (!amount) {
-    throw new ValidationError("No amount found in prevOutput", {
-      field: "amount",
-      value: "null"
-    });
-  }
-  return tx.preimageWitnessV1(
-    inputIndex,
-    new Array(tx.inputsLength).fill(prevScript),
-    btc.SigHash.DEFAULT,
-    new Array(tx.inputsLength).fill(amount)
-  );
-}
-function getTxId(tx) {
-  return bytesToHex(sha256(sha256(tx.toBytes(true))).reverse());
-}
-function getTxIdNoReverse(tx) {
-  return bytesToHex(sha256(sha256(tx.toBytes(true))));
-}
-
-// src/utils/mempool.ts
-async function getLatestDepositTxId(address) {
-  const network = getNetworkFromAddress(address);
-  const baseUrl = network === BitcoinNetwork_default.REGTEST ? getElectrsUrl("REGTEST") : getElectrsUrl("MAINNET");
-  const headers = {};
-  if (network === BitcoinNetwork_default.REGTEST) {
-    const auth = btoa(
-      `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
-    );
-    headers["Authorization"] = `Basic ${auth}`;
-  }
-  const response = await fetch(`${baseUrl}/address/${address}/txs`, {
-    headers
-  });
-  const addressTxs = await response.json();
-  if (addressTxs && addressTxs.length > 0) {
-    const latestTx = addressTxs[0];
-    const outputIndex = latestTx.vout.findIndex(
-      (output) => output.scriptpubkey_address === address
-    );
-    if (outputIndex === -1) {
-      return null;
-    }
-    return latestTx.txid;
-  }
-  return null;
-}
-
-// src/utils/proof.ts
-import { sha256 as sha2562 } from "@noble/hashes/sha2";
-function proofOfPossessionMessageHashForDepositAddress(userPubkey, operatorPubkey, depositAddress) {
-  const encoder = new TextEncoder();
-  const depositAddressBytes = encoder.encode(depositAddress);
-  const proofMsg = new Uint8Array([
-    ...userPubkey,
-    ...operatorPubkey,
-    ...depositAddressBytes
-  ]);
-  return sha2562(proofMsg);
-}
-
-// src/utils/transfer_package.ts
-import { hexToBytes as hexToBytes2 } from "@noble/curves/abstract/utils";
-import { sha256 as sha2563 } from "@noble/hashes/sha2";
-function getTransferPackageSigningPayload(transferID, transferPackage) {
-  const encryptedPayload = transferPackage.keyTweakPackage;
-  const pairs = Object.entries(
-    encryptedPayload
-  ).map(([key, value]) => ({ key, value }));
-  pairs.sort((a, b) => a.key.localeCompare(b.key));
-  const encoder = new TextEncoder();
-  let message = hexToBytes2(transferID.replaceAll("-", ""));
-  for (const pair of pairs) {
-    const keyPart = encoder.encode(pair.key + ":");
-    const separator = encoder.encode(";");
-    message = new Uint8Array([
-      ...message,
-      ...keyPart,
-      ...pair.value,
-      ...separator
-    ]);
-  }
-  return sha2563(message);
-}
-
-// src/utils/transaction.ts
-import { Transaction as Transaction2 } from "@scure/btc-signer";
-var TIME_LOCK_INTERVAL = 100;
-function createRefundTx(sequence, nodeOutPoint, amountSats, receivingPubkey, network) {
-  const newRefundTx = new Transaction2({ allowUnknownOutputs: true });
-  newRefundTx.addInput({
-    ...nodeOutPoint,
-    sequence
-  });
-  const refundPkScript = getP2TRScriptFromPublicKey(receivingPubkey, network);
-  newRefundTx.addOutput({
-    script: refundPkScript,
-    amount: amountSats
-  });
-  newRefundTx.addOutput(getEphemeralAnchorOutput());
-  return newRefundTx;
-}
-function getCurrentTimelock(currSequence) {
-  return (currSequence || 0) & 65535;
-}
-function getTransactionSequence(currSequence) {
-  const timelock = getCurrentTimelock(currSequence);
-  return 1 << 30 | timelock;
-}
-function getNextTransactionSequence(currSequence, forRefresh) {
-  const currentTimelock = getCurrentTimelock(currSequence);
-  const nextTimelock = currentTimelock - TIME_LOCK_INTERVAL;
-  if (forRefresh && nextTimelock <= 100 && currentTimelock > 0) {
-    return {
-      nextSequence: 1 << 30 | nextTimelock,
-      needRefresh: true
-    };
-  }
-  if (nextTimelock <= 0) {
-    throw new ValidationError("timelock interval is less than or equal to 0", {
-      field: "nextTimelock",
-      value: nextTimelock
-    });
-  }
-  return {
-    nextSequence: 1 << 30 | nextTimelock,
-    needRefresh: nextTimelock <= 100
-  };
-}
-function getEphemeralAnchorOutput() {
-  return {
-    script: new Uint8Array([81, 2, 78, 115]),
-    // Pay-to-anchor (P2A) ephemeral anchor output
-    amount: 0n
-  };
-}
-
-export {
-  computeTaprootKeyNoScript,
-  getP2TRScriptFromPublicKey,
-  getP2TRAddressFromPublicKey,
-  getP2TRAddressFromPkScript,
-  getP2WPKHAddressFromPublicKey,
-  getTxFromRawTxHex,
-  getTxFromRawTxBytes,
-  getSigHashFromTx,
-  getTxId,
-  getTxIdNoReverse,
-  createRefundTx,
-  getCurrentTimelock,
-  getTransactionSequence,
-  getNextTransactionSequence,
-  getEphemeralAnchorOutput,
-  getTransferPackageSigningPayload,
-  proofOfPossessionMessageHashForDepositAddress,
-  getLatestDepositTxId
-};

package/dist/{chunk-LIP2K6KR.js → chunk-2CDJZQN4.js}

@@ -1,9 +1,9 @@
-import {
-  SparkAddress
-} from "./chunk-C5LTJBI7.js";
 import {
   ValidationError
 } from "./chunk-TWF35O6M.js";
+import {
+  SparkAddress
+} from "./chunk-C5LTJBI7.js";
 
 // src/address/address.ts
 import { secp256k1 } from "@noble/curves/secp256k1";

package/dist/{chunk-RGWBSZIO.js → chunk-I4JI6TYN.js}

@@ -1,7 +1,3 @@
-import {
-  Empty,
-  SparkServiceDefinition
-} from "./chunk-C5LTJBI7.js";
 import {
   isBun,
   isReactNative
@@ -10,6 +6,10 @@ import {
   AuthenticationError,
   NetworkError
 } from "./chunk-TWF35O6M.js";
+import {
+  Empty,
+  SparkServiceDefinition
+} from "./chunk-C5LTJBI7.js";
 
 // src/services/connection.ts
 import { isNode } from "@lightsparkdev/core";