@buildonspark/spark-sdk 0.2.4 → 0.2.6

package/dist/tests/test-utils.cjs

@@ -15995,7 +15995,7 @@ function getLocalFrostSignerAddress() {
 var BASE_CONFIG = {
   network: "LOCAL",
   lrc20Address: getLrc20Url("LOCAL"),
-  coodinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
+  coordinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
   frostSignerAddress: getLocalFrostSignerAddress(),
   threshold: 2,
   signingOperators: getLocalSigningOperators(),
@@ -16014,6 +16014,9 @@ var BASE_CONFIG = {
     baseUrl: getSspUrl("LOCAL"),
     identityPublicKey: getSspIdentityPublicKey("LOCAL"),
     schemaEndpoint: getSspSchemaEndpoint("LOCAL")
+  },
+  console: {
+    otel: false
   }
 };
 var LOCAL_WALLET_CONFIG = {
@@ -16096,6 +16099,10 @@ function getSigningOperators() {
   };
 }
 function getLocalSigningOperators() {
+  const addresses = Array.from(
+    { length: 5 },
+    (_, i) => isHermeticTest ? `https://${i}.spark.minikube.local` : `https://localhost:${i + 8535}`
+  );
   const pubkeys = [
     "0322ca18fc489ae25418a0e768273c2c61cabb823edfb14feb891e9bec62016510",
     "0341727a6c41b168f07eb50865ab8c397a53c7eef628ac1020956b705e43b6cb27",
@@ -16107,31 +16114,31 @@ function getLocalSigningOperators() {
     "0000000000000000000000000000000000000000000000000000000000000001": {
       id: 0,
       identifier: "0000000000000000000000000000000000000000000000000000000000000001",
-      address: "https://localhost:8535",
+      address: addresses[0],
       identityPublicKey: pubkeys[0]
     },
     "0000000000000000000000000000000000000000000000000000000000000002": {
       id: 1,
       identifier: "0000000000000000000000000000000000000000000000000000000000000002",
-      address: "https://localhost:8536",
+      address: addresses[1],
       identityPublicKey: pubkeys[1]
     },
     "0000000000000000000000000000000000000000000000000000000000000003": {
       id: 2,
       identifier: "0000000000000000000000000000000000000000000000000000000000000003",
-      address: "https://localhost:8537",
+      address: addresses[2],
       identityPublicKey: pubkeys[2]
     },
     "0000000000000000000000000000000000000000000000000000000000000004": {
       id: 3,
       identifier: "0000000000000000000000000000000000000000000000000000000000000004",
-      address: "https://localhost:8538",
+      address: addresses[3],
       identityPublicKey: pubkeys[3]
     },
     "0000000000000000000000000000000000000000000000000000000000000005": {
       id: 4,
       identifier: "0000000000000000000000000000000000000000000000000000000000000005",
-      address: "https://localhost:8539",
+      address: addresses[4],
       identityPublicKey: pubkeys[4]
     }
   };
@@ -16845,10 +16852,11 @@ var import_base3 = require("@scure/base");
 // src/utils/token-transactions.ts
 init_buffer();
 var import_utils9 = require("@noble/curves/abstract/utils");
+var import_utils10 = require("@scure/btc-signer/utils");
 
 // src/utils/transfer_package.ts
 init_buffer();
-var import_utils10 = require("@noble/curves/abstract/utils");
+var import_utils11 = require("@noble/curves/abstract/utils");
 var import_sha23 = require("@noble/hashes/sha2");
 
 // src/utils/transaction.ts
@@ -16980,7 +16988,7 @@ function getEphemeralAnchorOutput() {
 
 // src/utils/unilateral-exit.ts
 init_buffer();
-var import_utils11 = require("@noble/curves/abstract/utils");
+var import_utils12 = require("@noble/curves/abstract/utils");
 var import_legacy = require("@noble/hashes/legacy");
 var import_sha24 = require("@noble/hashes/sha2");
 var btc3 = __toESM(require("@scure/btc-signer"), 1);
@@ -17001,13 +17009,13 @@ var networkByType = {
 init_buffer();
 var import_secp256k17 = require("@bitcoinerlab/secp256k1");
 var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
-var import_utils12 = require("@noble/curves/abstract/utils");
+var import_utils13 = require("@noble/curves/abstract/utils");
 var import_secp256k18 = require("@noble/curves/secp256k1");
 var import_sha25 = require("@noble/hashes/sha2");
 var import_bip32 = require("@scure/bip32");
 var import_bip39 = require("@scure/bip39");
 var import_english = require("@scure/bip39/wordlists/english");
-var import_utils13 = require("@scure/btc-signer/utils");
+var import_utils14 = require("@scure/btc-signer/utils");
 var ecies = __toESM(require("eciesjs"), 1);
 
 // src/constants.ts
@@ -17015,7 +17023,7 @@ init_buffer();
 var import_core8 = require("@lightsparkdev/core");
 var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 var isBun = globalThis.Bun !== void 0;
-var packageVersion = true ? "0.2.4" : "unknown";
+var packageVersion = true ? "0.2.6" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -17124,7 +17132,7 @@ var DefaultSparkSigner = class {
       });
     }
     const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils12.bytesToHex)(this.identityKey.privateKey)
+      (0, import_utils13.bytesToHex)(this.identityKey.privateKey)
     );
     const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
     return privateKey;
@@ -17258,7 +17266,7 @@ var DefaultSparkSigner = class {
     threshold,
     numShares
   }) {
-    const secretAsInt = (0, import_utils12.bytesToNumberBE)(secret);
+    const secretAsInt = (0, import_utils13.bytesToNumberBE)(secret);
     return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
   }
   async signFrost({
@@ -17334,7 +17342,7 @@ var DefaultSparkSigner = class {
   }
   async createSparkWalletFromSeed(seed, accountNumber) {
     if (typeof seed === "string") {
-      seed = (0, import_utils12.hexToBytes)(seed);
+      seed = (0, import_utils13.hexToBytes)(seed);
     }
     const {
       identityKey,
@@ -17346,7 +17354,7 @@ var DefaultSparkSigner = class {
     this.depositKey = depositKey;
     this.signingKey = signingKey.hdKey;
     this.staticDepositKey = staticDepositKey.hdKey;
-    return (0, import_utils12.bytesToHex)(identityKey.publicKey);
+    return (0, import_utils13.bytesToHex)(identityKey.publicKey);
   }
   async signMessageWithIdentityKey(message, compact) {
     if (!this.identityKey?.privateKey) {
@@ -17367,7 +17375,7 @@ var DefaultSparkSigner = class {
       });
     }
     const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils12.bytesToHex)(this.identityKey.privateKey)
+      (0, import_utils13.bytesToHex)(this.identityKey.privateKey)
     );
     const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
     const publicKey = import_secp256k18.secp256k1.getPublicKey(privateKey);
@@ -17419,15 +17427,15 @@ var DefaultSparkSigner = class {
   }
   signTransactionIndex(tx, index, publicKey) {
     let privateKey;
-    if ((0, import_utils12.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+    if ((0, import_utils13.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
       privateKey = this.identityKey?.privateKey;
-    } else if ((0, import_utils12.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+    } else if ((0, import_utils13.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
       privateKey = this.depositKey?.privateKey;
     }
     if (!privateKey) {
       throw new ValidationError("Private key not found for public key", {
         field: "privateKey",
-        value: (0, import_utils12.bytesToHex)(publicKey)
+        value: (0, import_utils13.bytesToHex)(publicKey)
       });
     }
     tx.signIdx(privateKey, index);
@@ -17492,10 +17500,13 @@ var UnsafeStatelessSparkSigner = class extends DefaultSparkSigner {
   }
 };
 
+// src/spark-wallet/spark-wallet.browser.ts
+init_buffer();
+
 // src/spark-wallet/spark-wallet.ts
 init_buffer();
 var import_core12 = require("@lightsparkdev/core");
-var import_utils24 = require("@noble/curves/abstract/utils");
+var import_utils25 = require("@noble/curves/abstract/utils");
 var import_secp256k115 = require("@noble/curves/secp256k1");
 var import_bip392 = require("@scure/bip39");
 var import_english2 = require("@scure/bip39/wordlists/english");
@@ -18034,15 +18045,19 @@ var LightningSendFeeEstimate = `
   ${FRAGMENT13}
 `;
 
-// src/graphql/queries/Transfer.ts
+// src/graphql/queries/Transfers.ts
 init_buffer();
-var GetTransfer = `
-  query Transfer($transfer_spark_id: UUID!) {
-    transfer(transfer_spark_id: $transfer_spark_id) {
+var GetTransfers = `
+  query Transfers($transfer_spark_ids: [UUID!]!) {
+    transfers(transfer_spark_ids: $transfer_spark_ids) {
       ...TransferFragment
+      transfer_user_request: user_request {
+        ...UserRequestFragment
+      }
     }
   }
   ${FRAGMENT2}
+  ${FRAGMENT6}
 `;
 
 // src/graphql/queries/UserRequest.ts
@@ -18084,7 +18099,7 @@ var WalletConfigService = class {
     }
   }
   getCoordinatorAddress() {
-    const coordinator = this.config.signingOperators[this.config.coodinatorIdentifier];
+    const coordinator = this.config.signingOperators[this.config.coordinatorIdentifier];
     if (!coordinator) {
       throw new ConfigurationError(
         "Coordinator not found in signing operators",
@@ -18105,7 +18120,7 @@ var WalletConfigService = class {
     return this.config.threshold;
   }
   getCoordinatorIdentifier() {
-    return this.config.coodinatorIdentifier;
+    return this.config.coordinatorIdentifier;
   }
   getExpectedWithdrawBondSats() {
     return this.config.expectedWithdrawBondSats;
@@ -18146,9 +18161,17 @@ var WalletConfigService = class {
   getElectrsUrl() {
     return this.config.electrsUrl;
   }
+  getSspBaseUrl() {
+    return this.config.sspClientOptions.baseUrl;
+  }
   getSspIdentityPublicKey() {
     return this.config.sspClientOptions.identityPublicKey;
   }
+  getConsoleOptions() {
+    return {
+      ...this.config.console
+    };
+  }
 };
 
 // src/services/connection.ts
@@ -21963,7 +21986,7 @@ var import_uuidv73 = require("uuidv7");
 
 // src/services/transfer.ts
 init_buffer();
-var import_utils14 = require("@noble/curves/abstract/utils");
+var import_utils15 = require("@noble/curves/abstract/utils");
 var import_secp256k19 = require("@noble/curves/secp256k1");
 var import_sha28 = require("@noble/hashes/sha2");
 var import_btc_signer2 = require("@scure/btc-signer");
@@ -21975,9 +21998,9 @@ var DEFAULT_EXPIRY_TIME = 10 * 60 * 1e3;
 init_buffer();
 var import_secp256k110 = require("@noble/curves/secp256k1");
 var import_sha29 = require("@noble/hashes/sha2");
-var import_utils15 = require("@noble/hashes/utils");
+var import_utils16 = require("@noble/hashes/utils");
 var import_btc_signer4 = require("@scure/btc-signer");
-var import_utils16 = require("@scure/btc-signer/utils");
+var import_utils17 = require("@scure/btc-signer/utils");
 var DepositService = class {
   config;
   connectionManager;
@@ -22028,7 +22051,7 @@ var DepositService = class {
       if (operator.identifier === this.config.getCoordinatorIdentifier()) {
         continue;
       }
-      const operatorPubkey2 = (0, import_utils15.hexToBytes)(operator.identityPublicKey);
+      const operatorPubkey2 = (0, import_utils16.hexToBytes)(operator.identityPublicKey);
       const operatorSig = address2.depositAddressProof.addressSignatures[operator.identifier];
       if (!operatorSig) {
         throw new ValidationError("Operator signature not found", {
@@ -22113,7 +22136,7 @@ var DepositService = class {
       });
     }
     const depositOutPoint = {
-      txid: (0, import_utils15.hexToBytes)(getTxId(depositTx)),
+      txid: (0, import_utils16.hexToBytes)(getTxId(depositTx)),
       index: vout
     };
     const depositTxOut = {
@@ -22132,8 +22155,8 @@ var DepositService = class {
     const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
       sequence: INITIAL_SEQUENCE,
       directSequence: INITIAL_DIRECT_SEQUENCE,
-      input: { txid: (0, import_utils15.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
-      directInput: { txid: (0, import_utils15.hexToBytes)(getTxId(directRootTx)), index: 0 },
+      input: { txid: (0, import_utils16.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
+      directInput: { txid: (0, import_utils16.hexToBytes)(getTxId(directRootTx)), index: 0 },
       amountSats: amount,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
@@ -22263,7 +22286,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils16.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils17.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -22427,7 +22450,7 @@ var DepositService = class {
       });
     }
     const depositOutPoint = {
-      txid: (0, import_utils15.hexToBytes)(getTxId(depositTx)),
+      txid: (0, import_utils16.hexToBytes)(getTxId(depositTx)),
       index: vout
     };
     const depositTxOut = {
@@ -22440,7 +22463,7 @@ var DepositService = class {
     const signingPubKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
     const { cpfpRefundTx } = createRefundTxs({
       sequence: INITIAL_SEQUENCE,
-      input: { txid: (0, import_utils15.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
+      input: { txid: (0, import_utils16.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
       amountSats: amount,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
@@ -22510,7 +22533,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils16.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils17.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -22586,7 +22609,7 @@ var DepositService = class {
 
 // src/services/lightning.ts
 init_buffer();
-var import_utils17 = require("@noble/curves/abstract/utils");
+var import_utils18 = require("@noble/curves/abstract/utils");
 var import_secp256k111 = require("@noble/curves/secp256k1");
 var import_sha210 = require("@noble/hashes/sha2");
 var import_uuidv74 = require("uuidv7");
@@ -22597,9 +22620,9 @@ var import_light_bolt11_decoder = require("light-bolt11-decoder");
 
 // src/services/token-transactions.ts
 init_buffer();
-var import_utils18 = require("@noble/curves/abstract/utils");
+var import_utils19 = require("@noble/curves/abstract/utils");
 var import_secp256k113 = require("@noble/curves/secp256k1");
-var import_utils19 = require("@noble/hashes/utils");
+var import_utils20 = require("@noble/hashes/utils");
 
 // src/utils/token-hashing.ts
 init_buffer();
@@ -22614,29 +22637,31 @@ init_buffer();
 
 // src/services/tree-creation.ts
 init_buffer();
-var import_utils20 = require("@noble/curves/abstract/utils");
+var import_utils21 = require("@noble/curves/abstract/utils");
 var import_btc_signer5 = require("@scure/btc-signer");
 
 // src/spark-wallet/spark-wallet.ts
 var import_lrc20_sdk3 = require("@buildonspark/lrc20-sdk");
 var import_sha212 = require("@noble/hashes/sha2");
+var import_api = require("@opentelemetry/api");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
 var import_eventemitter3 = require("eventemitter3");
 
 // src/services/signing.ts
 init_buffer();
-var import_utils21 = require("@noble/curves/abstract/utils");
+var import_utils22 = require("@noble/curves/abstract/utils");
 
 // src/tests/utils/test-faucet.ts
 init_buffer();
-var import_utils22 = require("@noble/curves/abstract/utils");
+var import_utils23 = require("@noble/curves/abstract/utils");
 var import_secp256k114 = require("@noble/curves/secp256k1");
 var btc5 = __toESM(require("@scure/btc-signer"), 1);
 var import_btc_signer6 = require("@scure/btc-signer");
-var import_utils23 = require("@scure/btc-signer/utils");
-var STATIC_FAUCET_KEY = (0, import_utils22.hexToBytes)(
+var import_utils24 = require("@scure/btc-signer/utils");
+var STATIC_FAUCET_KEY = (0, import_utils23.hexToBytes)(
   "deadbeef1337cafe4242424242424242deadbeef1337cafe4242424242424242"
 );
-var STATIC_MINING_KEY = (0, import_utils22.hexToBytes)(
+var STATIC_MINING_KEY = (0, import_utils23.hexToBytes)(
   "1337cafe4242deadbeef4242424242421337cafe4242deadbeef424242424242"
 );
 var SATS_PER_BTC = 1e8;
@@ -22699,7 +22724,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     if (!scanResult.success || scanResult.unspents.length === 0) {
       const blockHash = await this.generateToAddress(1, address2);
       const block = await this.getBlock(blockHash[0]);
-      const fundingTx = import_btc_signer6.Transaction.fromRaw((0, import_utils22.hexToBytes)(block.tx[0].hex), {
+      const fundingTx = import_btc_signer6.Transaction.fromRaw((0, import_utils23.hexToBytes)(block.tx[0].hex), {
         allowUnknownOutputs: true
       });
       await this.generateToAddress(100, this.miningAddress);
@@ -22761,13 +22786,13 @@ var BitcoinFaucet = class _BitcoinFaucet {
       },
       STATIC_MINING_KEY
     );
-    await this.broadcastTx((0, import_utils22.bytesToHex)(signedSplitTx.extract()));
+    await this.broadcastTx((0, import_utils23.bytesToHex)(signedSplitTx.extract()));
     const splitTxId = signedSplitTx.id;
     for (let i = 0; i < numCoinsToCreate; i++) {
       this.coins.push({
         key: STATIC_FAUCET_KEY,
         outpoint: {
-          txid: (0, import_utils22.hexToBytes)(splitTxId),
+          txid: (0, import_utils23.hexToBytes)(splitTxId),
           index: i
         },
         txout: signedSplitTx.getOutput(i)
@@ -22795,7 +22820,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       coinToSend.txout,
       coinToSend.key
     );
-    await this.broadcastTx((0, import_utils22.bytesToHex)(signedTx.extract()));
+    await this.broadcastTx((0, import_utils23.bytesToHex)(signedTx.extract()));
   }
   async signFaucetCoin(unsignedTx, fundingTxOut, key) {
     const pubKey = import_secp256k114.secp256k1.getPublicKey(key);
@@ -22815,7 +22840,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       new Array(unsignedTx.inputsLength).fill(fundingTxOut.amount)
     );
     const merkleRoot = new Uint8Array();
-    const tweakedKey = (0, import_utils23.taprootTweakPrivKey)(key, merkleRoot);
+    const tweakedKey = (0, import_utils24.taprootTweakPrivKey)(key, merkleRoot);
     if (!tweakedKey)
       throw new Error("Invalid private key for taproot tweaking");
     const signature = import_secp256k114.schnorr.sign(sighash, tweakedKey);
@@ -22885,7 +22910,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     const pubKey = import_secp256k114.secp256k1.getPublicKey(key);
     return getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */);
   }
-  async sendToAddress(address2, amount) {
+  async sendToAddress(address2, amount, blocksToGenerate = 1) {
     const coin = await this.fund();
     if (!coin) {
       throw new Error("No coins available");
@@ -22915,7 +22940,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       });
     }
     const signedTx = await this.signFaucetCoin(tx, coin.txout, coin.key);
-    const txHex = (0, import_utils22.bytesToHex)(signedTx.extract());
+    const txHex = (0, import_utils23.bytesToHex)(signedTx.extract());
     await this.broadcastTx(txHex);
     const randomKey = import_secp256k114.secp256k1.utils.randomPrivateKey();
     const randomPubKey = import_secp256k114.secp256k1.getPublicKey(randomKey);
@@ -22923,7 +22948,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       randomPubKey,
       4 /* LOCAL */
     );
-    await this.generateToAddress(1, randomAddress);
+    await this.generateToAddress(blocksToGenerate, randomAddress);
     return signedTx;
   }
   async getRawTransaction(txid) {
@@ -22934,6 +22959,13 @@ var BitcoinFaucet = class _BitcoinFaucet {
 // src/utils/chunkArray.ts
 init_buffer();
 
+// src/spark-wallet/spark-wallet.browser.ts
+var import_sdk_trace_web = require("@opentelemetry/sdk-trace-web");
+var import_instrumentation = require("@opentelemetry/instrumentation");
+var import_instrumentation_fetch = require("@opentelemetry/instrumentation-fetch");
+var import_core13 = require("@opentelemetry/core");
+var import_api2 = require("@opentelemetry/api");
+
 // src/spark-wallet/types.ts
 init_buffer();
 

package/dist/tests/test-utils.d.cts

@@ -1,7 +1,7 @@
-import { Q as QueryTransfersResponse, f as Transfer, d as TreeNode } from '../spark-B_7nZx6T.cjs';
-import { b as ConfigOptions, w as SparkWalletProps } from '../spark-wallet-DG3x2obf.cjs';
-import { S as SparkSigner, D as DefaultSparkSigner } from '../client-KhNkrXz4.cjs';
-import { S as SparkWallet } from '../spark-wallet.node-CN9LoB_O.cjs';
+import { Q as QueryTransfersResponse, c as Transfer, d as TreeNode } from '../spark-Cj4brrP5.cjs';
+import { b as ConfigOptions, x as SparkWalletProps } from '../spark-wallet-BbOf2P2l.cjs';
+import { S as SparkSigner, D as DefaultSparkSigner } from '../client-CusuvuCe.cjs';
+import { S as SparkWalletNodeJS } from '../spark-wallet.node-BBk1sGS2.cjs';
 import { Transaction } from '@scure/btc-signer';
 import { TransactionInput, TransactionOutput } from '@scure/btc-signer/psbt';
 import '@bufbuild/protobuf/wire';
@@ -11,30 +11,12 @@ import 'bitcoinjs-lib';
 import 'nice-grpc';
 import 'nice-grpc-web';
 import '../proto/spark_token.cjs';
+import '@opentelemetry/sdk-trace-base';
 import 'eventemitter3';
-import '../sdk-types-CB9HrW5O.cjs';
 import '@lightsparkdev/core';
 import '@scure/bip32';
 import '../types-BADxR3bm.cjs';
 
-interface ISparkWalletTesting extends SparkWallet {
-    getSigner(): SparkSigner;
-    queryPendingTransfers(): Promise<QueryTransfersResponse>;
-    verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
-}
-declare class SparkWalletTesting extends SparkWallet implements ISparkWalletTesting {
-    private disableEvents;
-    constructor(options?: ConfigOptions, signer?: SparkSigner, disableEvents?: boolean);
-    static initialize(props: SparkWalletProps, disableEvents?: boolean): Promise<{
-        wallet: SparkWalletTesting;
-        mnemonic: string | undefined;
-    }>;
-    protected setupBackgroundStream(): Promise<void>;
-    getSigner(): SparkSigner;
-    queryPendingTransfers(): Promise<QueryTransfersResponse>;
-    verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
-}
-
 type FaucetCoin = {
     key: Uint8Array;
     outpoint: TransactionInput;
@@ -61,10 +43,28 @@ declare class BitcoinFaucet {
     getBlock(blockHash: string): Promise<any>;
     broadcastTx(txHex: string): Promise<any>;
     getNewAddress(): Promise<string>;
-    sendToAddress(address: string, amount: bigint): Promise<Transaction>;
+    sendToAddress(address: string, amount: bigint, blocksToGenerate?: number): Promise<Transaction>;
     getRawTransaction(txid: string): Promise<any>;
 }
 
+interface ISparkWalletTesting extends SparkWalletNodeJS {
+    getSigner(): SparkSigner;
+    queryPendingTransfers(): Promise<QueryTransfersResponse>;
+    verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
+}
+declare class SparkWalletTesting extends SparkWalletNodeJS implements ISparkWalletTesting {
+    private disableEvents;
+    constructor(options?: ConfigOptions, signer?: SparkSigner, disableEvents?: boolean);
+    static initialize(props: SparkWalletProps, disableEvents?: boolean): Promise<{
+        wallet: SparkWalletTesting;
+        mnemonic: string | undefined;
+    }>;
+    protected setupBackgroundStream(): Promise<void>;
+    getSigner(): SparkSigner;
+    queryPendingTransfers(): Promise<QueryTransfersResponse>;
+    verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
+}
+
 declare function getTestWalletConfig(): ConfigOptions;
 declare function getTestWalletConfigWithIdentityKey(identityPrivateKey: Uint8Array): ConfigOptions;
 declare function createNewTree(wallet: SparkWalletTesting, leafId: string, faucet: BitcoinFaucet, amountSats?: bigint): Promise<TreeNode>;

package/dist/tests/test-utils.d.ts

@@ -1,7 +1,7 @@
-import { Q as QueryTransfersResponse, f as Transfer, d as TreeNode } from '../spark-B_7nZx6T.js';
-import { b as ConfigOptions, w as SparkWalletProps } from '../spark-wallet-C1Tr_VKI.js';
-import { S as SparkSigner, D as DefaultSparkSigner } from '../client-BF4cn8F4.js';
-import { S as SparkWallet } from '../spark-wallet.node-CGxoeCpH.js';
+import { Q as QueryTransfersResponse, c as Transfer, d as TreeNode } from '../spark-Cj4brrP5.js';
+import { b as ConfigOptions, x as SparkWalletProps } from '../spark-wallet-B6YthxDI.js';
+import { S as SparkSigner, D as DefaultSparkSigner } from '../client-Dn4Ld8pD.js';
+import { S as SparkWalletNodeJS } from '../spark-wallet.node-Bffethig.js';
 import { Transaction } from '@scure/btc-signer';
 import { TransactionInput, TransactionOutput } from '@scure/btc-signer/psbt';
 import '@bufbuild/protobuf/wire';
@@ -11,30 +11,12 @@ import 'bitcoinjs-lib';
 import 'nice-grpc';
 import 'nice-grpc-web';
 import '../proto/spark_token.js';
+import '@opentelemetry/sdk-trace-base';
 import 'eventemitter3';
-import '../sdk-types-CkRNraXT.js';
 import '@lightsparkdev/core';
 import '@scure/bip32';
 import '../types-BADxR3bm.js';
 
-interface ISparkWalletTesting extends SparkWallet {
-    getSigner(): SparkSigner;
-    queryPendingTransfers(): Promise<QueryTransfersResponse>;
-    verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
-}
-declare class SparkWalletTesting extends SparkWallet implements ISparkWalletTesting {
-    private disableEvents;
-    constructor(options?: ConfigOptions, signer?: SparkSigner, disableEvents?: boolean);
-    static initialize(props: SparkWalletProps, disableEvents?: boolean): Promise<{
-        wallet: SparkWalletTesting;
-        mnemonic: string | undefined;
-    }>;
-    protected setupBackgroundStream(): Promise<void>;
-    getSigner(): SparkSigner;
-    queryPendingTransfers(): Promise<QueryTransfersResponse>;
-    verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
-}
-
 type FaucetCoin = {
     key: Uint8Array;
     outpoint: TransactionInput;
@@ -61,10 +43,28 @@ declare class BitcoinFaucet {
     getBlock(blockHash: string): Promise<any>;
     broadcastTx(txHex: string): Promise<any>;
     getNewAddress(): Promise<string>;
-    sendToAddress(address: string, amount: bigint): Promise<Transaction>;
+    sendToAddress(address: string, amount: bigint, blocksToGenerate?: number): Promise<Transaction>;
     getRawTransaction(txid: string): Promise<any>;
 }
 
+interface ISparkWalletTesting extends SparkWalletNodeJS {
+    getSigner(): SparkSigner;
+    queryPendingTransfers(): Promise<QueryTransfersResponse>;
+    verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
+}
+declare class SparkWalletTesting extends SparkWalletNodeJS implements ISparkWalletTesting {
+    private disableEvents;
+    constructor(options?: ConfigOptions, signer?: SparkSigner, disableEvents?: boolean);
+    static initialize(props: SparkWalletProps, disableEvents?: boolean): Promise<{
+        wallet: SparkWalletTesting;
+        mnemonic: string | undefined;
+    }>;
+    protected setupBackgroundStream(): Promise<void>;
+    getSigner(): SparkSigner;
+    queryPendingTransfers(): Promise<QueryTransfersResponse>;
+    verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
+}
+
 declare function getTestWalletConfig(): ConfigOptions;
 declare function getTestWalletConfigWithIdentityKey(identityPrivateKey: Uint8Array): ConfigOptions;
 declare function createNewTree(wallet: SparkWalletTesting, leafId: string, faucet: BitcoinFaucet, amountSats?: bigint): Promise<TreeNode>;

package/dist/tests/test-utils.js

@@ -1,4 +1,4 @@
-import "../chunk-TVUMSHWA.js";
+import "../chunk-AVI5E5VT.js";
 import "../chunk-BYXBJQAS.js";
 import {
   BitcoinFaucet,
@@ -11,10 +11,10 @@ import {
   WalletConfigService,
   getNetwork,
   getP2TRAddressFromPublicKey
-} from "../chunk-W4ZRBSWM.js";
+} from "../chunk-GUZ3WCB4.js";
 import "../chunk-G4MSZ6DE.js";
-import "../chunk-3SEOTO43.js";
-import "../chunk-WAQKYSDI.js";
+import "../chunk-3SPMJMUX.js";
+import "../chunk-CQY5ML2A.js";
 import "../chunk-AAZWSPUK.js";
 import "../chunk-MVRQ5US7.js";