@buildonspark/spark-sdk 0.1.45 → 0.1.47

package/src/signer/types.ts

@@ -0,0 +1,52 @@
+import type { HDKey } from "@scure/bip32";
+import type {
+  IKeyPackage,
+  ISigningCommitment,
+} from "../spark_bindings/types.js";
+
+export { MultisigReceiptInput } from "@buildonspark/lrc20-sdk/lrc/types";
+
+export type SigningNonce = {
+  binding: Uint8Array;
+  hiding: Uint8Array;
+};
+
+export type SigningCommitment = {
+  binding: Uint8Array;
+  hiding: Uint8Array;
+};
+
+export type SignFrostParams = {
+  message: Uint8Array;
+  privateAsPubKey: Uint8Array;
+  publicKey: Uint8Array;
+  verifyingKey: Uint8Array;
+  selfCommitment: ISigningCommitment;
+  statechainCommitments?: { [key: string]: ISigningCommitment } | undefined;
+  adaptorPubKey?: Uint8Array | undefined;
+};
+
+export type AggregateFrostParams = Omit<SignFrostParams, "privateAsPubKey"> & {
+  selfSignature: Uint8Array;
+  statechainSignatures?: { [key: string]: Uint8Array } | undefined;
+  statechainPublicKeys?: { [key: string]: Uint8Array } | undefined;
+};
+
+export type SplitSecretWithProofsParams = {
+  secret: Uint8Array;
+  curveOrder: bigint;
+  threshold: number;
+  numShares: number;
+  isSecretPubkey?: boolean;
+};
+
+export type DerivedHDKey = {
+  hdKey: HDKey;
+  privateKey: Uint8Array;
+  publicKey: Uint8Array;
+};
+
+export type KeyPair = {
+  privateKey: Uint8Array;
+  publicKey: Uint8Array;
+};

package/src/spark-wallet/spark-wallet.ts

@@ -54,7 +54,6 @@ import { ConnectionManager } from "../services/connection.js";
 import { CoopExitService } from "../services/coop-exit.js";
 import { DepositService } from "../services/deposit.js";
 import { LightningService } from "../services/lightning.js";
-import { Lrc20ConnectionManager } from "../services/lrc-connection.js";
 import { TokenTransactionService } from "../services/token-transactions.js";
 import type { LeafKeyTweak } from "../services/transfer.js";
 import { TransferService } from "../services/transfer.js";
@@ -88,7 +87,7 @@ import {
   NetworkToProto,
   NetworkType,
 } from "../utils/network.js";
-import { calculateAvailableTokenAmount } from "../utils/token-transactions.js";
+import { sumAvailableTokens } from "../utils/token-transactions.js";
 import { getNextTransactionSequence } from "../utils/transaction.js";
 
 import { LRCWallet } from "@buildonspark/lrc20-sdk";
@@ -99,7 +98,7 @@ import {
   encodeSparkAddress,
   isValidPublicKey,
   SparkAddressFormat,
-} from "../address/index.js";
+} from "../utils/address.js";
 import { isReactNative } from "../constants.js";
 import { Network as NetworkProto, networkToJSON } from "../proto/spark.js";
 import {
@@ -124,12 +123,15 @@ import type {
   InitWalletResponse,
   PayLightningInvoiceParams,
   SparkWalletProps,
-  TokenMetadata,
+  UserTokenMetadata,
   TransferParams,
   TokenBalanceMap,
 } from "./types.js";
 import { encodeHumanReadableTokenIdentifier } from "../utils/token-identifier.js";
-import { TokenTransactionWithStatus } from "../proto/spark_token.js";
+import {
+  TokenTransactionWithStatus,
+  TokenMetadata,
+} from "../proto/spark_token.js";
 
 /**
  * The SparkWallet class is the primary interface for interacting with the Spark network.
@@ -140,7 +142,6 @@ export class SparkWallet extends EventEmitter {
   protected config: WalletConfigService;
 
   protected connectionManager: ConnectionManager;
-  protected lrc20ConnectionManager: Lrc20ConnectionManager;
   protected lrc20Wallet: LRCWallet | undefined;
   protected transferService: TransferService;
   protected tracerId = "spark-sdk";
@@ -169,6 +170,7 @@ export class SparkWallet extends EventEmitter {
 
   protected tokenOutputs: Map<string, OutputWithPreviousTransactionData[]> =
     new Map();
+  protected tokenMetadata: Map<string, TokenMetadata> = new Map();
 
   // Add this property near the top of the class with other private properties
   private claimTransfersInterval: NodeJS.Timeout | null = null;
@@ -188,7 +190,6 @@ export class SparkWallet extends EventEmitter {
     this.config = new WalletConfigService(options, signer);
     this.connectionManager = new ConnectionManager(this.config);
     this.signingService = new SigningService(this.config);
-    this.lrc20ConnectionManager = new Lrc20ConnectionManager(this.config);
     this.depositService = new DepositService(
       this.config,
       this.connectionManager,
@@ -1214,34 +1215,70 @@ export class SparkWallet extends EventEmitter {
     };
   }
 
+  private async getTokenMetadata(): Promise<Map<string, UserTokenMetadata>> {
+    let metadataToFetch = new Array<string>();
+    for (const issuerPublicKey of this.tokenOutputs.keys()) {
+      if (!this.tokenMetadata.has(issuerPublicKey)) {
+        metadataToFetch.push(issuerPublicKey);
+      }
+    }
+
+    if (metadataToFetch.length > 0) {
+      const sparkTokenClient =
+        await this.connectionManager.createSparkTokenClient(
+          this.config.getCoordinatorAddress(),
+        );
+
+      try {
+        const response = await sparkTokenClient.query_token_metadata({
+          issuerPublicKeys: metadataToFetch.map(hexToBytes),
+        });
+
+        for (const metadata of response.tokenMetadata) {
+          this.tokenMetadata.set(
+            bytesToHex(metadata.issuerPublicKey),
+            metadata,
+          );
+        }
+      } catch (error) {
+        throw new NetworkError("Failed to fetch token metadata", {
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    let tokenMetadataMap = new Map<string, UserTokenMetadata>();
+
+    for (const [issuerPublicKey, metadata] of this.tokenMetadata) {
+      tokenMetadataMap.set(issuerPublicKey, {
+        tokenPublicKey: bytesToHex(metadata.issuerPublicKey),
+        rawTokenIdentifier: metadata.tokenIdentifier,
+        tokenName: metadata.tokenName,
+        tokenTicker: metadata.tokenTicker,
+        decimals: metadata.decimals,
+        maxSupply: bytesToNumberBE(metadata.maxSupply),
+      });
+    }
+
+    return tokenMetadataMap;
+  }
+
   private async getTokenBalance(): Promise<TokenBalanceMap> {
-    const sparkTokenClient =
-      await this.connectionManager.createSparkTokenClient(
-        this.config.getCoordinatorAddress(),
-      );
+    const tokenMetadataMap = await this.getTokenMetadata();
 
-    const tokenMetadata = await sparkTokenClient.query_token_metadata({
-      issuerPublicKeys: Array.from(this.tokenOutputs.keys()).map(hexToBytes),
-    });
     const result: TokenBalanceMap = new Map();
+    for (const [issuerPublicKey, tokenMetadata] of tokenMetadataMap) {
+      const outputs = this.tokenOutputs.get(issuerPublicKey);
 
-    for (const metadata of tokenMetadata.tokenMetadata) {
-      const tokenPublicKey = bytesToHex(metadata.issuerPublicKey);
-      const leaves = this.tokenOutputs.get(tokenPublicKey);
       const humanReadableTokenIdentifier = encodeHumanReadableTokenIdentifier({
-        tokenIdentifier: metadata.tokenIdentifier,
+        tokenIdentifier: tokenMetadata.rawTokenIdentifier,
         network: this.config.getNetworkType(),
       });
+
       result.set(humanReadableTokenIdentifier, {
-        balance: leaves ? calculateAvailableTokenAmount(leaves) : BigInt(0),
-        tokenMetadata: {
-          tokenPublicKey,
-          rawTokenIdentifier: metadata.tokenIdentifier,
-          tokenName: metadata.tokenName,
-          tokenTicker: metadata.tokenTicker,
-          decimals: metadata.decimals,
-          maxSupply: bytesToNumberBE(metadata.maxSupply),
-        },
+        balance: outputs ? sumAvailableTokens(outputs) : BigInt(0),
+        tokenMetadata: tokenMetadata,
       });
     }
 
@@ -3303,7 +3340,7 @@ export class SparkWallet extends EventEmitter {
   }
 
   /**
-   * Retrieves token transaction history for specified tokens owned by the wallet.
+   * Retrieves token transaction history for specified tokens
    * Can optionally filter by specific transaction hashes.
    *
    * @param ownerPublicKeys - Optional array of owner public keys to query transactions for
@@ -3313,13 +3350,20 @@ export class SparkWallet extends EventEmitter {
    * @param outputIds - Optional array of output IDs to filter by
    * @returns Promise resolving to array of token transactions with their current status
    */
-  public async queryTokenTransactions(
-    ownerPublicKeys?: string[],
-    issuerPublicKeys?: string[],
-    tokenTransactionHashes?: string[],
-    tokenIdentifiers?: string[],
-    outputIds?: string[],
-  ): Promise<TokenTransactionWithStatus[]> {
+
+  public async queryTokenTransactions({
+    ownerPublicKeys,
+    issuerPublicKeys,
+    tokenTransactionHashes,
+    tokenIdentifiers,
+    outputIds,
+  }: {
+    ownerPublicKeys?: string[];
+    issuerPublicKeys?: string[];
+    tokenTransactionHashes?: string[];
+    tokenIdentifiers?: string[];
+    outputIds?: string[];
+  }): Promise<TokenTransactionWithStatus[]> {
     return this.tokenTransactionService.queryTokenTransactions({
       ownerPublicKeys,
       issuerPublicKeys,
@@ -3849,7 +3893,6 @@ export class SparkWallet extends EventEmitter {
   public async cleanupConnections() {
     this.cleanup();
     await this.connectionManager.closeConnections();
-    await this.lrc20ConnectionManager.closeConnection();
   }
 
   // Add this new method to start periodic claiming

package/src/spark-wallet/types.ts

@@ -41,7 +41,7 @@ export type DepositParams = {
  *
  * @example
  * ```typescript
- * const tokenMetadata: TokenMetadata = {
+ * const tokenMetadata: UserTokenMetadata = {
  *   rawTokenIdentifier: new Uint8Array([1, 2, 3]),
  *   tokenPublicKey: "0348fbb...",
  *   tokenName: "SparkToken",
@@ -51,10 +51,10 @@ export type DepositParams = {
  * };
  * ```
  */
-export type TokenMetadata = {
+export type UserTokenMetadata = {
   /** Raw binary token identifier - This is used to encode the human readable token identifier */
   rawTokenIdentifier: Uint8Array;
-  /** Hex-encoded public key of the token issuer - Same as issuerPublicKey */
+  /** Public key of the token issuer - Same as issuerPublicKey */
   tokenPublicKey: string;
   /** Human-readable name of the token (e.g., SparkToken)*/
   tokenName: string;
@@ -70,7 +70,7 @@ export type TokenBalanceMap = Map<
   HumanReadableTokenIdentifier,
   {
     balance: bigint;
-    tokenMetadata: TokenMetadata;
+    tokenMetadata: UserTokenMetadata;
   }
 >;
 

package/src/tests/integration/coop-exit.test.ts

@@ -19,9 +19,10 @@ import {
   getTxIdNoReverse,
 } from "../../utils/bitcoin.js";
 import { getNetwork, Network } from "../../utils/network.js";
-import { createNewTree } from "../test-util.js";
+import { createNewTree } from "../test-utils.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "../utils/test-faucet.js";
+
 describe("coop exit", () => {
   const brokenTestFn = process.env.GITHUB_ACTIONS ? it.skip : it;
 

package/src/tests/integration/lightning.test.ts

@@ -15,7 +15,7 @@ import {
   CurrencyUnit,
   LightningReceiveRequestStatus,
 } from "../../types/index.js";
-import { createNewTree, getTestWalletConfig } from "../test-util.js";
+import { createNewTree, getTestWalletConfig } from "../test-utils.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "../utils/test-faucet.js";
 
@@ -476,7 +476,7 @@ describe("LightningService", () => {
     );
 
     expect(transfer.status).toEqual(
-      TransferStatus.TRANSFER_STATUS_SENDER_INITIATED_COORDINATOR,
+      TransferStatus.TRANSFER_STATUS_SENDER_KEY_TWEAK_PENDING,
     );
 
     const refunds =

package/src/tests/integration/swap.test.ts

@@ -16,7 +16,7 @@ import {
   computeTaprootKeyNoScript,
   getSigHashFromTx,
 } from "../../utils/bitcoin.js";
-import { createNewTree } from "../test-util.js";
+import { createNewTree } from "../test-utils.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "../utils/test-faucet.js";
 

package/src/tests/integration/transfer.test.ts

@@ -16,9 +16,9 @@ import { TransferService } from "../../services/transfer.js";
 import {
   ConfigOptions,
   getLocalSigningOperators,
-  LOCAL_WALLET_CONFIG,
+  WalletConfig,
 } from "../../services/wallet-config.js";
-import { createNewTree } from "../../tests/test-util.js";
+import { createNewTree } from "../test-utils.js";
 import { NetworkType } from "../../utils/network.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "../utils/test-faucet.js";
@@ -423,7 +423,7 @@ describe("Transfer", () => {
         ),
       );
       const missingOperatorOptions = {
-        ...LOCAL_WALLET_CONFIG,
+        ...WalletConfig.LOCAL,
         signingOperators,
       };
       const mnemonic = generateMnemonic(wordlist);
@@ -493,7 +493,7 @@ describe("Transfer", () => {
       ]);
 
       const receiverOptions = {
-        ...LOCAL_WALLET_CONFIG,
+        ...WalletConfig.LOCAL,
       };
 
       const { wallet: receiverWalletWithAllOperators } =
@@ -521,7 +521,7 @@ describe("Transfer", () => {
       const { wallet: receiverWalletWithMissingOperatorAsCoordinator } =
         await SparkWalletTesting.initialize({
           options: {
-            ...LOCAL_WALLET_CONFIG,
+            ...WalletConfig.LOCAL,
             coodinatorIdentifier: soToRemove,
           },
           mnemonicOrSeed: mnemonic,

package/src/tests/integration/tree-creation.test.ts

@@ -6,7 +6,7 @@ import { ValidationError } from "../../errors/types.js";
 import { getTxFromRawTxBytes, getTxId } from "../../utils/bitcoin.js";
 import { Network } from "../../utils/network.js";
 import { DEFAULT_FEE_SATS } from "../../utils/transaction.js";
-import { createNewTreeWithLevels } from "../test-util.js";
+import { createNewTreeWithLevels } from "../test-utils.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "../utils/test-faucet.js";
 

package/src/tests/integration/wallet.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "@jest/globals";
 import { ConfigOptions } from "../../services/wallet-config.js";
 import { NetworkType } from "../../utils/network.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
+
 describe("wallet", () => {
   it("should initialize a wallet", async () => {
     const seedOrMnemonics = [

package/src/tests/isHermeticTest.ts

@@ -1,24 +1,3 @@
-import { isNode } from "@lightsparkdev/core";
-import fs from "fs";
-
-/**
- * Checks if the current environment is a hermetic test environment.
- * A hermetic test environment is identified by either:
- * 1. The existence of a marker file at /tmp/spark_hermetic (Node.js only)
- * 2. The HERMETIC_TEST environment variable being set to "true"
- *
- * @returns {boolean} True if running in a hermetic test environment, false otherwise
- */
-export function isHermeticTest() {
-  if (isNode) {
-    return (
-      (fs?.existsSync?.("/tmp/spark_hermetic") ?? false) ||
-      process.env.HERMETIC_TEST === "true"
-    );
-  }
-
-  return (
-    (typeof process !== "undefined" && process.env?.HERMETIC_TEST === "true") ||
-    false
-  );
-}
+export const isHermeticTest = Boolean(
+  typeof process !== "undefined" && process?.env?.HERMETIC_TEST === "true",
+);

package/src/tests/{test-util.ts → test-utils.ts}

@@ -6,17 +6,13 @@ import { TreeNode } from "../proto/spark.js";
 import { WalletConfigService } from "../services/config.js";
 import { ConnectionManager } from "../services/connection.js";
 import { DepositService } from "../services/deposit.js";
-import {
-  ConfigOptions,
-  LOCAL_WALLET_CONFIG,
-} from "../services/wallet-config.js";
+import { ConfigOptions, WalletConfig } from "../services/wallet-config.js";
 import { getP2TRAddressFromPublicKey } from "../utils/bitcoin.js";
-import { getCrypto } from "../utils/crypto.js";
 import { getNetwork, Network } from "../utils/network.js";
 import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "./utils/test-faucet.js";
 
-const crypto = getCrypto();
+export { BitcoinFaucet };
 
 export function getTestWalletConfig() {
   const identityPrivateKey = secp256k1.utils.randomPrivateKey();
@@ -27,7 +23,7 @@ export function getTestWalletConfigWithIdentityKey(
   identityPrivateKey: Uint8Array,
 ) {
   return {
-    ...LOCAL_WALLET_CONFIG,
+    ...WalletConfig.LOCAL,
     identityPrivateKey,
   } as ConfigOptions;
 }

package/src/tests/wrapWithOtelSpan.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "@jest/globals";
 import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
-import { getTestWalletConfig } from "./test-util.js";
+import { getTestWalletConfig } from "./test-utils.js";
 import { BasicTracerProvider } from "@opentelemetry/sdk-trace-base";
 import { trace } from "@opentelemetry/api";
 

package/src/{address → utils}/address.ts

@@ -2,7 +2,7 @@ import { secp256k1 } from "@noble/curves/secp256k1";
 import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
 import { bech32m } from "@scure/base";
 import { PaymentIntentFields, SparkAddress } from "../proto/spark.js";
-import { NetworkType } from "../utils/network.js";
+import { NetworkType } from "./network.js";
 import { ValidationError } from "../errors/index.js";
 
 import { UUID, uuidv7 } from "uuidv7";

package/src/utils/crypto.ts

@@ -1,12 +1,22 @@
-import nodeCrypto from "crypto";
+export interface SparkCrypto {
+  // Browser
+  getRandomValues<T extends ArrayBufferView | null>(array: T): T;
+  // Node.js
+  getRandomValues<T extends ArrayBuffer | ArrayBufferView>(array: T): T;
+}
 
-export const getCrypto = (): Crypto => {
-  let cryptoImpl: any =
-    typeof window !== "undefined"
-      ? window.crypto
-      : typeof global !== "undefined" && global.crypto
-        ? global.crypto
-        : nodeCrypto;
+let cryptoImpl: SparkCrypto | null = globalThis.crypto ?? null;
 
-  return cryptoImpl as Crypto;
+export const getCrypto = () => {
+  if (!cryptoImpl) {
+    throw new Error(
+      "Crypto implementation is not set. Please set it using setCrypto().",
+    );
+  }
+
+  return cryptoImpl;
+};
+
+export const setCrypto = (cryptoImplParam: SparkCrypto | null): void => {
+  cryptoImpl = cryptoImplParam;
 };

package/src/utils/index.ts

@@ -1,3 +1,4 @@
+export * from "./address.js";
 export * from "./adaptor-signature.js";
 export * from "./bitcoin.js";
 export * from "./keys.js";
@@ -7,6 +8,7 @@ export * from "./proof.js";
 export * from "./response-validation.js";
 export * from "./secret-sharing.js";
 export * from "./signing.js";
+export * from "./token-identifier.js";
 export * from "./token-transactions.js";
 export * from "./transfer_package.js";
 export * from "./transaction.js";

package/src/utils/network.ts

@@ -23,6 +23,23 @@ export const NetworkToProto: Record<Network, NetworkProto> = {
   [Network.LOCAL]: NetworkProto.REGTEST,
 };
 
+export const protoToNetwork = (
+  protoNetwork: NetworkProto,
+): Network | undefined => {
+  switch (protoNetwork) {
+    case NetworkProto.MAINNET:
+      return Network.MAINNET;
+    case NetworkProto.TESTNET:
+      return Network.TESTNET;
+    case NetworkProto.SIGNET:
+      return Network.SIGNET;
+    case NetworkProto.REGTEST:
+      return Network.REGTEST;
+    default:
+      return undefined;
+  }
+};
+
 const NetworkConfig: Record<Network, typeof btc.NETWORK> = {
   [Network.MAINNET]: btc.NETWORK,
   [Network.TESTNET]: btc.TEST_NETWORK,

package/src/utils/secret-sharing.ts

@@ -3,8 +3,6 @@ import { secp256k1 } from "@noble/curves/secp256k1";
 import { getCrypto } from "./crypto.js";
 import { ValidationError } from "../errors/index.js";
 
-const crypto = getCrypto();
-
 type Polynomial = {
   fieldModulus: bigint;
   coefficients: bigint[];
@@ -28,6 +26,7 @@ export function getRandomBigInt(max: bigint): bigint {
 
   const mask = (1n << BigInt(max.toString(2).length)) - 1n;
   while (true) {
+    const crypto = getCrypto();
     const randBytes = crypto.getRandomValues(new Uint8Array(byteLength + 1));
 
     const randValue = BigInt("0x" + bytesToHex(randBytes)) & mask;

package/src/utils/signing.ts

@@ -1,6 +1,6 @@
 import { secp256k1 } from "@noble/curves/secp256k1";
 import { ValidationError } from "../errors/index.js";
-import type { SigningCommitment, SigningNonce } from "../signer/signer.js";
+import type { SigningCommitment, SigningNonce } from "../signer/types.js";
 
 export function getRandomSigningNonce(): SigningNonce {
   const binding = secp256k1.utils.randomPrivateKey();

package/src/utils/token-transactions.ts

@@ -2,10 +2,10 @@ import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
 import { OutputWithPreviousTransactionData } from "../proto/spark.js";
 import { TokenBalanceMap } from "../spark-wallet/types.js";
 
-export function calculateAvailableTokenAmount(
-  outputLeaves: OutputWithPreviousTransactionData[],
+export function sumAvailableTokens(
+  outputs: OutputWithPreviousTransactionData[],
 ): bigint {
-  return outputLeaves.reduce(
+  return outputs.reduce(
     (sum, output) => sum + BigInt(bytesToNumberBE(output.output!.tokenAmount!)),
     BigInt(0),
   );

package/src/utils/unilateral-exit.ts

@@ -493,6 +493,38 @@ export async function constructUnilateralExitFeeBumpPackages(
           undefined,
         );
 
+        const feeBumpTx = btc.Transaction.fromPSBT(
+          hexToBytes(refundFeeBump.feeBumpPsbt),
+        );
+
+        var feeBumpOut: psbt.TransactionOutput | null =
+          feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
+        var feeBumpOutPubKey: string | null = null;
+
+        // Remove used UTXOs from the available list
+        for (const usedUtxo of usedUtxos) {
+          if (feeBumpOut && bytesToHex(feeBumpOut.script!) == usedUtxo.script) {
+            feeBumpOutPubKey = usedUtxo.publicKey;
+          }
+          const index = availableUtxos.findIndex(
+            (u) => u.txid === usedUtxo.txid && u.vout === usedUtxo.vout,
+          );
+          if (index !== -1) {
+            availableUtxos.splice(index, 1);
+          }
+        }
+
+        if (feeBumpOut)
+          // Add to end instead of the beginning in case there are other available UTXOs we can use first
+          // We don't want to wait on leaf 1 to be broadcasted to broadcast leaf 2 if we can use a different available UTXO
+          availableUtxos.push({
+            txid: getTxId(feeBumpTx),
+            vout: 0,
+            value: feeBumpOut.amount!,
+            script: bytesToHex(feeBumpOut.script!),
+            publicKey: feeBumpOutPubKey!,
+          });
+
         txPackages.push({
           tx: refundTxHex,
           feeBumpPsbt: refundFeeBump.feeBumpPsbt,

package/src/utils/xchain-address.ts

@@ -1,4 +1,4 @@
-import { encodeSparkAddress, SparkAddressFormat } from "../address/address.js";
+import { encodeSparkAddress, SparkAddressFormat } from "./address.js";
 import * as btc from "@scure/btc-signer";
 import { ValidationError } from "../errors/index.js";
 

package/dist/BitcoinNetwork-TnABML0T.d.cts

@@ -1,18 +0,0 @@
-/** This is an enum identifying a particular Bitcoin Network. **/
-declare enum BitcoinNetwork {
-    /**
-     * This is an enum value that represents values that could be added in the future.
-     * Clients should support unknown values as more of them could be added without notice.
-     */
-    FUTURE_VALUE = "FUTURE_VALUE",
-    /** The production version of the Bitcoin Blockchain. **/
-    MAINNET = "MAINNET",
-    /** A test version of the Bitcoin Blockchain, maintained by Lightspark. **/
-    REGTEST = "REGTEST",
-    /** A test version of the Bitcoin Blockchain, maintained by a centralized organization. Not in use at Lightspark. **/
-    SIGNET = "SIGNET",
-    /** A test version of the Bitcoin Blockchain, publicly available. **/
-    TESTNET = "TESTNET"
-}
-
-export { BitcoinNetwork as B };

package/dist/BitcoinNetwork-TnABML0T.d.ts

@@ -1,18 +0,0 @@
-/** This is an enum identifying a particular Bitcoin Network. **/
-declare enum BitcoinNetwork {
-    /**
-     * This is an enum value that represents values that could be added in the future.
-     * Clients should support unknown values as more of them could be added without notice.
-     */
-    FUTURE_VALUE = "FUTURE_VALUE",
-    /** The production version of the Bitcoin Blockchain. **/
-    MAINNET = "MAINNET",
-    /** A test version of the Bitcoin Blockchain, maintained by Lightspark. **/
-    REGTEST = "REGTEST",
-    /** A test version of the Bitcoin Blockchain, maintained by a centralized organization. Not in use at Lightspark. **/
-    SIGNET = "SIGNET",
-    /** A test version of the Bitcoin Blockchain, publicly available. **/
-    TESTNET = "TESTNET"
-}
-
-export { BitcoinNetwork as B };