@utexo/rgb-sdk 1.0.0-beta.8

package/dist/index.mjs

@@ -0,0 +1,1018 @@
+import * as path3 from 'path';
+import path3__default from 'path';
+import * as fs2 from 'fs';
+import fs2__default from 'fs';
+import { WalletError, ValidationError, validateMnemonic, bip39, normalizeNetwork, CryptoError, normalizeSeedInput, generateKeys, BaseWalletManager, buildVssConfigFromMnemonic, DEFAULT_VSS_SERVER_URL, getUtxoNetworkConfig, UTEXOWalletCore, validatePsbt, bip32Factory, normalizeSeedBuffer, getNetworkVersions, calculateMasterFingerprint, detectPsbtType, DEFAULT_TRANSPORT_ENDPOINTS, DEFAULT_INDEXER_URLS, logger, signMessage, verifyMessage, getBackupStoreId, deriveDescriptors } from '@utexo/rgb-sdk-core';
+export { BIP32_VERSIONS, BadRequestError, COIN_BITCOIN_MAINNET, COIN_BITCOIN_TESTNET, COIN_RGB_MAINNET, COIN_RGB_TESTNET, ConfigurationError, ConflictError, CryptoError, DEFAULT_API_TIMEOUT, DEFAULT_LOG_LEVEL, DEFAULT_MAX_RETRIES, DEFAULT_NETWORK, DEFAULT_VSS_SERVER_URL, DERIVATION_ACCOUNT, DERIVATION_PURPOSE, KEYCHAIN_BTC, KEYCHAIN_RGB, LightningProtocol, LogLevel, NETWORK_MAP, NetworkError, NotFoundError, OnchainProtocol, RgbNodeError, SDKError, UTEXOProtocol, ValidationError, WalletError, accountXpubsFromMnemonic, bip39, configureLogging, deriveKeysFromMnemonic, deriveKeysFromMnemonicOrSeed, deriveKeysFromSeed, deriveKeysFromXpriv, deriveVssSigningKeyFromMnemonic, generateKeys, getDestinationAsset, getUtxoNetworkConfig, getXprivFromMnemonic, getXpubFromXpriv, isNetwork, logger, normalizeNetwork, restoreKeys, signMessage, utexoNetworkIdMap, utexoNetworkMap, validateBase64, validateHex, validateMnemonic, validateNetwork, validatePsbt, validateRequired, validateString, verifyMessage } from '@utexo/rgb-sdk-core';
+import rgblib from '@utexo/rgb-lib';
+import { Psbt } from 'bitcoinjs-lib';
+import * as bdkNode from '@bitcoindevkit/bdk-wallet-node';
+
+// src/binding/NodeRgbLibBinding.ts
+function mapNetworkToRgbLib(network) {
+  const networkMap = {
+    mainnet: "Mainnet",
+    testnet: "Testnet",
+    testnet4: "Testnet4",
+    signet: "Signet",
+    utexo: "Signet",
+    regtest: "Regtest"
+  };
+  const networkStr = String(network).toLowerCase();
+  return networkMap[networkStr] || "Regtest";
+}
+var restoreWallet = (params) => {
+  const { backupFilePath, password, dataDir } = params;
+  if (!fs2.existsSync(backupFilePath)) {
+    throw new ValidationError("Backup file not found", "backup");
+  }
+  if (!fs2.existsSync(dataDir)) {
+    throw new ValidationError(
+      `Restore directory does not exist: ${dataDir}`,
+      "restoreDir"
+    );
+  }
+  rgblib.restoreBackup(backupFilePath, password, dataDir);
+  return {
+    message: "Wallet restored successfully"
+  };
+};
+var restoreFromVss = (params) => {
+  const anyLib = rgblib;
+  if (typeof anyLib.restoreFromVss !== "function") {
+    throw new WalletError(
+      "VSS restore is not available in the current rgb-lib build."
+    );
+  }
+  if (!params.targetDir) {
+    throw new ValidationError("targetDir is required", "targetDir");
+  }
+  const { config, targetDir } = params;
+  const mappedConfig = {
+    server_url: config.serverUrl,
+    store_id: config.storeId,
+    signing_key: config.signingKey
+  };
+  const walletPath = anyLib.restoreFromVss(mappedConfig, targetDir);
+  return {
+    message: "Wallet restored from VSS successfully",
+    walletPath
+  };
+};
+var NodeRgbLibBinding = class {
+  constructor(params) {
+    this.online = null;
+    this.xpubVan = params.xpubVan;
+    this.xpubCol = params.xpubCol;
+    this.masterFingerprint = params.masterFingerprint;
+    this.originalNetwork = params.network;
+    this.network = normalizeNetwork(this.originalNetwork);
+    this.dataDir = params.dataDir;
+    this.transportEndpoint = params.transportEndpoint || DEFAULT_TRANSPORT_ENDPOINTS[this.network] || DEFAULT_TRANSPORT_ENDPOINTS.signet;
+    if (params.indexerUrl) {
+      this.indexerUrl = params.indexerUrl;
+    } else {
+      this.indexerUrl = DEFAULT_INDEXER_URLS[this.network] || DEFAULT_INDEXER_URLS.signet;
+    }
+    if (!fs2.existsSync(this.dataDir)) {
+      fs2.mkdirSync(this.dataDir, { recursive: true });
+    }
+    const walletData = {
+      dataDir: this.dataDir,
+      bitcoinNetwork: mapNetworkToRgbLib(this.originalNetwork),
+      databaseType: rgblib.DatabaseType.Sqlite,
+      accountXpubVanilla: this.xpubVan,
+      accountXpubColored: this.xpubCol,
+      masterFingerprint: this.masterFingerprint,
+      maxAllocationsPerUtxo: "1",
+      vanillaKeychain: "0",
+      supportedSchemas: [
+        rgblib.AssetSchema.Cfa,
+        rgblib.AssetSchema.Nia,
+        rgblib.AssetSchema.Uda
+      ]
+    };
+    try {
+      this.wallet = new rgblib.Wallet(new rgblib.WalletData(walletData));
+    } catch (error) {
+      throw new WalletError(
+        "Failed to initialize rgb-lib wallet",
+        void 0,
+        error
+      );
+    }
+  }
+  /**
+   * Ensure online connection is established
+   */
+  ensureOnline() {
+    if (this.online) {
+      return;
+    }
+    try {
+      this.online = this.wallet.goOnline(false, this.indexerUrl);
+    } catch (error) {
+      throw new WalletError(
+        "Failed to establish online connection",
+        void 0,
+        error
+      );
+    }
+  }
+  /**
+   * Get online object, creating it if needed
+   */
+  getOnline() {
+    this.ensureOnline();
+    return this.online;
+  }
+  registerWallet() {
+    const online = this.getOnline();
+    const address = this.wallet.getAddress();
+    const btcBalance = this.wallet.getBtcBalance(online, false);
+    return {
+      address,
+      btcBalance
+    };
+  }
+  async getBtcBalance() {
+    const online = this.getOnline();
+    return this.wallet.getBtcBalance(online, false);
+  }
+  async getAddress() {
+    return this.wallet.getAddress();
+  }
+  listUnspents() {
+    const online = this.getOnline();
+    const raw = this.wallet.listUnspents(online, false, false);
+    return Promise.resolve(
+      raw.map((unspent) => ({
+        utxo: {
+          ...unspent.utxo,
+          exists: unspent.utxo.exists ?? true
+        },
+        rgbAllocations: unspent.rgbAllocations.map((allocation) => {
+          const assignmentKeys = Object.keys(allocation.assignment);
+          const assignmentType = assignmentKeys[0];
+          const assignment = {
+            type: assignmentType ?? "Any",
+            amount: assignmentType && allocation.assignment[assignmentType] ? Number(allocation.assignment[assignmentType]) : void 0
+          };
+          return {
+            assetId: allocation.assetId,
+            assignment,
+            settled: allocation.settled
+          };
+        }),
+        pendingBlinded: unspent.pendingBlinded ?? 0
+      }))
+    );
+  }
+  async createUtxosBegin(params) {
+    const online = this.getOnline();
+    const upTo = params.upTo ?? false;
+    const num = params.num !== void 0 ? String(params.num) : null;
+    const size = params.size !== void 0 ? String(params.size) : null;
+    const feeRate = params.feeRate ? String(params.feeRate) : "1";
+    const skipSync = false;
+    return this.wallet.createUtxosBegin(
+      online,
+      upTo,
+      num,
+      size,
+      feeRate,
+      skipSync
+    );
+  }
+  async createUtxosEnd(params) {
+    const online = this.getOnline();
+    const signedPsbt = params.signedPsbt;
+    const skipSync = params.skipSync ?? false;
+    return this.wallet.createUtxosEnd(online, signedPsbt, skipSync);
+  }
+  async sendBegin(params) {
+    const online = this.getOnline();
+    const feeRate = String(params.feeRate ?? 1);
+    const minConfirmations = String(params.minConfirmations ?? 1);
+    const donation = params.donation ?? false;
+    let assetId = params.assetId;
+    let amount = params.amount;
+    let recipientId;
+    let transportEndpoints = [];
+    let witnessData = null;
+    if (params.witnessData && params.witnessData.amountSat) {
+      witnessData = {
+        amountSat: String(params.witnessData.amountSat),
+        blinding: params.witnessData.blinding ? Number(params.witnessData.blinding) : null
+      };
+    }
+    if (params.invoice) {
+      const invoiceData = this.decodeRGBInvoiceRaw({ invoice: params.invoice });
+      recipientId = invoiceData.recipientId;
+      transportEndpoints = invoiceData.transportEndpoints;
+    }
+    if (transportEndpoints.length === 0) {
+      transportEndpoints = [this.transportEndpoint];
+    }
+    if (!assetId) {
+      throw new ValidationError(
+        "asset_id is required for send operation",
+        "asset_id"
+      );
+    }
+    if (!recipientId) {
+      throw new ValidationError(
+        "Could not extract recipient_id from invoice",
+        "invoice"
+      );
+    }
+    if (!amount) {
+      throw new ValidationError(
+        "amount is required for send operation",
+        "amount"
+      );
+    }
+    const assignment = { Fungible: amount };
+    const recipientMap = {
+      [assetId]: [
+        {
+          recipientId,
+          witnessData,
+          assignment,
+          transportEndpoints
+        }
+      ]
+    };
+    const psbt = this.wallet.sendBegin(
+      online,
+      recipientMap,
+      donation,
+      feeRate,
+      minConfirmations
+    );
+    return psbt;
+  }
+  /**
+   * Batch send: accepts an already-built recipientMap and calls sendBegin.
+   */
+  async sendBeginBatch(params) {
+    const online = this.getOnline();
+    const feeRate = String(params.feeRate ?? 1);
+    const minConfirmations = String(params.minConfirmations ?? 1);
+    const donation = params.donation ?? true;
+    const { recipientMap } = params;
+    if (!recipientMap || typeof recipientMap !== "object") {
+      throw new ValidationError(
+        "recipientMap is required and must be a non-empty object",
+        "recipientMap"
+      );
+    }
+    const assetIds = Object.keys(recipientMap);
+    if (assetIds.length === 0) {
+      throw new ValidationError(
+        "recipientMap must contain at least one asset id",
+        "recipientMap"
+      );
+    }
+    for (const assetId of assetIds) {
+      const recipients = recipientMap[assetId];
+      if (!Array.isArray(recipients) || recipients.length === 0) {
+        throw new ValidationError(
+          `recipientMap["${assetId}"] must be a non-empty array of recipients`,
+          "recipientMap"
+        );
+      }
+    }
+    const psbt = this.wallet.sendBegin(
+      online,
+      recipientMap,
+      donation,
+      feeRate,
+      minConfirmations
+    );
+    return psbt;
+  }
+  async sendEnd(params) {
+    const online = this.getOnline();
+    const signedPsbt = params.signedPsbt;
+    const skipSync = params.skipSync ?? false;
+    return this.wallet.sendEnd(online, signedPsbt, skipSync);
+  }
+  async sendBtcBegin(params) {
+    const online = this.getOnline();
+    const address = params.address;
+    const amount = String(params.amount);
+    const feeRate = String(params.feeRate);
+    const skipSync = params.skipSync ?? false;
+    return this.wallet.sendBtcBegin(online, address, amount, feeRate, skipSync);
+  }
+  async sendBtcEnd(params) {
+    const online = this.getOnline();
+    const signedPsbt = params.signedPsbt;
+    const skipSync = params.skipSync ?? false;
+    return this.wallet.sendBtcEnd(online, signedPsbt, skipSync);
+  }
+  async getFeeEstimation(params) {
+    const online = this.getOnline();
+    const blocks = String(params.blocks);
+    try {
+      const result = this.wallet.getFeeEstimation(online, blocks);
+      if (typeof result === "string") {
+        try {
+          return JSON.parse(result);
+        } catch {
+          return result;
+        }
+      }
+      return result;
+    } catch (_error) {
+      logger.warn(
+        "rgb-lib estimation fee are not available, using default fee rate 2"
+      );
+      return 2;
+    }
+  }
+  async blindReceive(params) {
+    const assetId = params.assetId || null;
+    const assignment = `{"Fungible":${params.amount}}`;
+    const durationSeconds = String(params.durationSeconds ?? 2e3);
+    const transportEndpoints = [this.transportEndpoint];
+    const minConfirmations = String(params.minConfirmations ?? 3);
+    const raw = this.wallet.blindReceive(
+      assetId,
+      assignment,
+      durationSeconds,
+      transportEndpoints,
+      minConfirmations
+    );
+    return {
+      invoice: raw.invoice,
+      recipientId: raw.recipientId,
+      expirationTimestamp: raw.expirationTimestamp ?? null,
+      batchTransferIdx: raw.batchTransferIdx
+    };
+  }
+  async witnessReceive(params) {
+    const assetId = params.assetId || null;
+    const assignment = `{"Fungible":${params.amount}}`;
+    const durationSeconds = String(params.durationSeconds ?? 2e3);
+    const transportEndpoints = [this.transportEndpoint];
+    const minConfirmations = String(params.minConfirmations ?? 3);
+    const raw = this.wallet.witnessReceive(
+      assetId,
+      assignment,
+      durationSeconds,
+      transportEndpoints,
+      minConfirmations
+    );
+    return {
+      invoice: raw.invoice,
+      recipientId: raw.recipientId,
+      expirationTimestamp: raw.expirationTimestamp ?? null,
+      batchTransferIdx: raw.batchTransferIdx
+    };
+  }
+  async getAssetBalance(asset_id) {
+    const balance = this.wallet.getAssetBalance(asset_id);
+    return {
+      settled: balance.settled ?? 0,
+      future: balance.future ?? 0,
+      spendable: balance.spendable ?? 0,
+      offchainOutbound: balance.offchainOutbound ?? 0,
+      offchainInbound: balance.offchainInbound ?? 0
+    };
+  }
+  async issueAssetNia(params) {
+    const ticker = params.ticker;
+    const name = params.name;
+    const precision = String(params.precision);
+    const amounts = params.amounts.map((a) => String(a));
+    return this.wallet.issueAssetNIA(ticker, name, precision, amounts);
+  }
+  async issueAssetIfa(_params) {
+    throw new ValidationError(
+      "issueAssetIfa is not fully supported in rgb-lib. Use RGB Node server for IFA assets.",
+      "asset"
+    );
+  }
+  async inflateBegin(_params) {
+    throw new ValidationError(
+      "inflateBegin is not fully supported in rgb-lib. Use RGB Node server for inflation operations.",
+      "asset"
+    );
+  }
+  async inflateEnd(_params) {
+    throw new ValidationError(
+      "inflateEnd is not fully supported in rgb-lib. Use RGB Node server for inflation operations.",
+      "asset"
+    );
+  }
+  async listAssets() {
+    const filterAssetSchemas = [];
+    return this.wallet.listAssets(filterAssetSchemas);
+  }
+  decodeRGBInvoiceRaw(params) {
+    const invoice = new rgblib.Invoice(params.invoice);
+    try {
+      return invoice.invoiceData();
+    } finally {
+      invoice.drop();
+    }
+  }
+  async decodeRGBInvoice(params) {
+    const raw = this.decodeRGBInvoiceRaw(params);
+    const assignmentKeys = Object.keys(raw.assignment);
+    const assignmentType = assignmentKeys[0];
+    const assignment = {
+      type: assignmentType ?? "Any",
+      amount: assignmentType && raw.assignment[assignmentType] ? Number(raw.assignment[assignmentType]) : void 0
+    };
+    return {
+      invoice: params.invoice,
+      recipientId: raw.recipientId,
+      assetSchema: raw.assetSchema,
+      assetId: raw.assetId,
+      network: raw.network,
+      assignment,
+      assignmentName: raw.assignmentName,
+      expirationTimestamp: raw.expirationTimestamp ?? null,
+      transportEndpoints: raw.transportEndpoints
+    };
+  }
+  refreshWallet() {
+    const online = this.getOnline();
+    const assetId = null;
+    const filter = [];
+    const skipSync = false;
+    return this.wallet.refresh(online, assetId, filter, skipSync);
+  }
+  dropWallet() {
+    if (this.online) {
+      rgblib.dropOnline(this.online);
+      this.online = null;
+    }
+    if (this.wallet) {
+      this.wallet.drop();
+      this.wallet = null;
+    }
+  }
+  async listTransactions() {
+    const online = this.getOnline();
+    const skipSync = false;
+    return this.wallet.listTransactions(online, skipSync);
+  }
+  async listTransfers(asset_id) {
+    return this.wallet.listTransfers(asset_id ? asset_id : null);
+  }
+  async failTransfers(params) {
+    const online = this.getOnline();
+    const batchTransferIdx = params.batchTransferIdx !== void 0 ? params.batchTransferIdx : null;
+    const noAssetOnly = params.noAssetOnly ?? false;
+    const skipSync = params.skipSync ?? false;
+    return this.wallet.failTransfers(
+      online,
+      batchTransferIdx,
+      noAssetOnly,
+      skipSync
+    );
+  }
+  deleteTransfers(params) {
+    const batchTransferIdx = params.batchTransferIdx !== void 0 ? params.batchTransferIdx : null;
+    const noAssetOnly = params.noAssetOnly ?? false;
+    return this.wallet.deleteTransfers(batchTransferIdx, noAssetOnly);
+  }
+  syncWallet() {
+    const online = this.getOnline();
+    this.wallet.sync(online);
+  }
+  async createBackup(params) {
+    if (!params.backupPath) {
+      throw new ValidationError("backupPath is required", "backupPath");
+    }
+    if (!params.password) {
+      throw new ValidationError("password is required", "password");
+    }
+    if (!fs2.existsSync(params.backupPath)) {
+      throw new ValidationError(
+        `Backup directory does not exist: ${params.backupPath}`,
+        "backupPath"
+      );
+    }
+    const fullBackupPath = path3.join(
+      params.backupPath,
+      `${this.masterFingerprint}.backup`
+    );
+    this.wallet.backup(fullBackupPath, params.password);
+    return {
+      message: "Backup created successfully",
+      backupPath: fullBackupPath
+    };
+  }
+  /**
+   * Ensure VSS backup support is available in the underlying rgb-lib bindings.
+   * Returns the wallet instance and rgb-lib namespace as `any` for internal use.
+   */
+  getVssBindingsOrThrow(methodName) {
+    const walletAny = this.wallet;
+    const anyLib = rgblib;
+    if (!walletAny || typeof anyLib.VssBackupClient !== "function" || typeof walletAny[methodName] !== "function") {
+      throw new WalletError(
+        "VSS backup is not available in the current rgb-lib build."
+      );
+    }
+    return { walletAny, anyLib };
+  }
+  /**
+   * Configure VSS cloud backup for this wallet.
+   */
+  configureVssBackup(config) {
+    const walletAny = this.wallet;
+    if (!walletAny || typeof walletAny.configureVssBackup !== "function") {
+      throw new WalletError(
+        "VSS backup is not available in the current rgb-lib build."
+      );
+    }
+    const mappedConfig = {
+      server_url: config.serverUrl,
+      store_id: config.storeId,
+      signing_key: config.signingKey
+    };
+    if (config.encryptionEnabled !== void 0) {
+      mappedConfig.encryptionEnabled = config.encryptionEnabled;
+    }
+    if (config.autoBackup !== void 0) {
+      mappedConfig.autoBackup = config.autoBackup;
+    }
+    if (config.backupMode !== void 0) {
+      mappedConfig.backupMode = config.backupMode;
+    }
+    walletAny.configureVssBackup(mappedConfig);
+  }
+  /**
+   * Disable automatic VSS backup for this wallet.
+   */
+  disableVssAutoBackup() {
+    const walletAny = this.wallet;
+    if (!walletAny || typeof walletAny.disableVssAutoBackup !== "function") {
+      throw new WalletError(
+        "VSS backup is not available in the current rgb-lib build."
+      );
+    }
+    walletAny.disableVssAutoBackup();
+  }
+  /**
+   * Trigger a VSS backup immediately using a one-off client created from config.
+   * Returns the server version of the stored backup.
+   */
+  async vssBackup(config) {
+    const { walletAny, anyLib } = this.getVssBindingsOrThrow("vssBackup");
+    const client = new anyLib.VssBackupClient({
+      server_url: config.serverUrl,
+      store_id: config.storeId,
+      signing_key: config.signingKey
+    });
+    try {
+      const version = walletAny.vssBackup(client);
+      return version;
+    } finally {
+      if (typeof client.drop === "function") {
+        client.drop();
+      }
+    }
+  }
+  /**
+   * Get VSS backup status information for this wallet using a one-off client.
+   */
+  async vssBackupInfo(config) {
+    const { walletAny, anyLib } = this.getVssBindingsOrThrow("vssBackupInfo");
+    const client = new anyLib.VssBackupClient({
+      server_url: config.serverUrl,
+      store_id: config.storeId,
+      signing_key: config.signingKey
+    });
+    try {
+      const info = walletAny.vssBackupInfo(client);
+      return {
+        backupExists: Boolean(info.backupExists ?? info.backup_exists),
+        serverVersion: info.serverVersion ?? info.server_version ?? null,
+        backupRequired: Boolean(info.backupRequired ?? info.backup_required)
+      };
+    } finally {
+      if (typeof client.drop === "function") {
+        client.drop();
+      }
+    }
+  }
+  /**
+   * Cleanup resources
+   */
+  dispose() {
+    this.dropWallet();
+  }
+};
+var bdk = bdkNode;
+async function signPsbtFromSeedInternal(seed, psbtBase64, network, options) {
+  validatePsbt(psbtBase64, "psbtBase64");
+  let rootNode;
+  try {
+    rootNode = bip32Factory().fromSeed(
+      normalizeSeedBuffer(seed),
+      getNetworkVersions(network)
+    );
+  } catch (error) {
+    throw new CryptoError(
+      "Failed to derive root node from seed",
+      error
+    );
+  }
+  const fp = await calculateMasterFingerprint(rootNode);
+  const psbtType = detectPsbtType(psbtBase64);
+  const bdkNetwork = network === "utexo" ? "signet" : network;
+  const trySign = (type) => {
+    const { external, internal } = deriveDescriptors(
+      rootNode,
+      fp,
+      bdkNetwork,
+      type
+    );
+    let wallet2;
+    try {
+      wallet2 = bdk.Wallet.create(bdkNetwork, external, internal);
+    } catch (error) {
+      throw new CryptoError("Failed to create BDK wallet", error);
+    }
+    const pstb2 = bdk.Psbt.from_string(psbtBase64.trim());
+    wallet2.sign(pstb2, options.signOptions || new bdk.SignOptions());
+    return pstb2;
+  };
+  let pstb;
+  try {
+    pstb = trySign(psbtType);
+  } catch {
+    const fallback = psbtType === "create_utxo" ? "send" : "create_utxo";
+    try {
+      pstb = trySign(fallback);
+    } catch (error) {
+      throw new CryptoError(
+        "Failed to sign PSBT \u2014 both descriptor types failed",
+        error
+      );
+    }
+  }
+  return pstb.toString().trim();
+}
+async function signPsbt(mnemonic, psbtBase64, network = "testnet", options = {}) {
+  try {
+    validateMnemonic(mnemonic, "mnemonic");
+    let seed;
+    try {
+      seed = bip39.mnemonicToSeedSync(mnemonic);
+    } catch {
+      throw new ValidationError("Invalid mnemonic format", "mnemonic");
+    }
+    const normalizedNetwork = normalizeNetwork(network);
+    return await signPsbtFromSeedInternal(
+      seed,
+      psbtBase64,
+      normalizedNetwork,
+      options
+    );
+  } catch (error) {
+    if (error instanceof ValidationError || error instanceof CryptoError)
+      throw error;
+    throw new CryptoError(
+      "Unexpected error during PSBT signing",
+      error
+    );
+  }
+}
+async function signPsbtFromSeed(seed, psbtBase64, network = "testnet", options = {}) {
+  const normalizedSeed = normalizeSeedInput(seed);
+  const normalizedNetwork = normalizeNetwork(network);
+  return signPsbtFromSeedInternal(
+    normalizedSeed,
+    psbtBase64,
+    normalizedNetwork,
+    options
+  );
+}
+async function estimatePsbt(psbtBase64) {
+  if (!psbtBase64) throw new ValidationError("psbt is required", "psbt");
+  try {
+    const psbt = Psbt.fromBase64(psbtBase64.trim());
+    return {
+      fee: psbt.getFee(),
+      feeRate: psbt.getFeeRate(),
+      vbytes: psbt.extractTransaction().virtualSize()
+    };
+  } catch {
+    throw new ValidationError("Invalid PSBT provided", "psbt");
+  }
+}
+
+// src/signer/NodeSigner.ts
+var NodeSigner = class {
+  async signPsbtWithMnemonic(mnemonic, psbt, network) {
+    return signPsbt(mnemonic, psbt, network);
+  }
+  async signPsbtWithSeed(seed, psbt, network) {
+    return signPsbtFromSeed(seed, psbt, network);
+  }
+  async signMessage(params) {
+    return signMessage(params);
+  }
+  async verifyMessage(params) {
+    return verifyMessage(params);
+  }
+  async estimateFee(psbt) {
+    return estimatePsbt(psbt);
+  }
+};
+var restoreFromBackup = (params) => {
+  const { backupFilePath, password, dataDir } = params;
+  if (!backupFilePath) {
+    throw new ValidationError("backup file is required", "backup");
+  }
+  if (!password) {
+    throw new ValidationError("password is required", "password");
+  }
+  if (!dataDir) {
+    throw new ValidationError("restore directory is required", "restoreDir");
+  }
+  return restoreWallet({ backupFilePath, password, dataDir });
+};
+var createWallet = async (network = "regtest") => {
+  return await generateKeys(network);
+};
+var WalletManager = class extends BaseWalletManager {
+  constructor(params) {
+    const dataDir = params.dataDir ?? path3__default.join(
+      process.cwd(),
+      ".rgb-wallet",
+      String(params.network ?? "regtest"),
+      params.masterFingerprint
+    );
+    const client = new NodeRgbLibBinding({
+      xpubVan: params.xpubVan,
+      xpubCol: params.xpubCol,
+      masterFingerprint: params.masterFingerprint,
+      network: String(params.network ?? "regtest"),
+      transportEndpoint: params.transportEndpoint,
+      indexerUrl: params.indexerUrl,
+      dataDir
+    });
+    super(params, client, new NodeSigner());
+    this.client = client;
+  }
+  async initialize() {
+  }
+  async goOnline(_indexerUrl, _skipConsistencyCheck) {
+    this.client.getOnline();
+  }
+  /**
+   * Register wallet with the network — Node-specific convenience method.
+   * Not part of IWalletManager; used directly by UTEXOWallet and callers
+   * that need the initial address + balance snapshot.
+   */
+  registerWallet() {
+    return this.client.registerWallet();
+  }
+};
+function createWalletManager(params) {
+  return new WalletManager(params);
+}
+var wallet = new Proxy({}, {
+  get(target, prop) {
+    {
+      throw new WalletError(
+        "The legacy singleton wallet instance is deprecated. Please use `new WalletManager(params)` or `createWalletManager(params)` instead. Example: const wallet = new WalletManager({ xpubVan, xpubCol, masterFingerprint, network, transportEndpoint, indexerUrl })"
+      );
+    }
+  }
+});
+var BACKUP_FILE_SUFFIX = ".backup";
+var LAYER1_BACKUP_SUFFIX = "_layer1.backup";
+var UTEXO_BACKUP_SUFFIX = "_utexo.backup";
+var UTEXO_BACKUP_TMP_LAYER1 = ".layer1";
+var UTEXO_BACKUP_TMP_UTEXO = ".utexo";
+function prepareUtxoBackupDirs(backupPath, masterFingerprint) {
+  const storeId = getBackupStoreId(masterFingerprint);
+  if (!fs2__default.existsSync(backupPath)) {
+    fs2__default.mkdirSync(backupPath, { recursive: true });
+  }
+  const layer1TmpDir = path3__default.join(backupPath, UTEXO_BACKUP_TMP_LAYER1);
+  const utexoTmpDir = path3__default.join(backupPath, UTEXO_BACKUP_TMP_UTEXO);
+  fs2__default.mkdirSync(layer1TmpDir, { recursive: true });
+  fs2__default.mkdirSync(utexoTmpDir, { recursive: true });
+  return {
+    storeId,
+    layer1TmpDir,
+    utexoTmpDir,
+    layer1FinalPath: path3__default.join(
+      backupPath,
+      `${storeId}_layer1${BACKUP_FILE_SUFFIX}`
+    ),
+    utexoFinalPath: path3__default.join(
+      backupPath,
+      `${storeId}_utexo${BACKUP_FILE_SUFFIX}`
+    )
+  };
+}
+function finalizeUtxoBackupPaths(params) {
+  const {
+    layer1BackupPath,
+    utexoBackupPath,
+    layer1FinalPath,
+    utexoFinalPath,
+    layer1TmpDir,
+    utexoTmpDir
+  } = params;
+  fs2__default.renameSync(layer1BackupPath, layer1FinalPath);
+  fs2__default.renameSync(utexoBackupPath, utexoFinalPath);
+  fs2__default.rmdirSync(layer1TmpDir);
+  fs2__default.rmdirSync(utexoTmpDir);
+}
+async function restoreUtxoWalletFromVss(params) {
+  const {
+    mnemonic,
+    targetDir,
+    config: providedConfig,
+    networkPreset = "testnet",
+    vssServerUrl
+  } = params;
+  if (!mnemonic || !mnemonic.trim()) {
+    throw new ValidationError("mnemonic is required", "mnemonic");
+  }
+  if (!targetDir) {
+    throw new ValidationError("targetDir is required", "targetDir");
+  }
+  const serverUrl = vssServerUrl ?? DEFAULT_VSS_SERVER_URL;
+  const config = providedConfig ?? await buildVssConfigFromMnemonic(
+    mnemonic.trim(),
+    serverUrl,
+    networkPreset
+  );
+  const presetConfig = getUtxoNetworkConfig(networkPreset);
+  const layer1Network = String(presetConfig.networkMap.mainnet);
+  const utexoNetwork = String(presetConfig.networkMap.utexo);
+  const masterFingerprint = config.storeId.replace(/^wallet_/, "") || config.storeId;
+  const layer1Config = {
+    ...config,
+    storeId: `${config.storeId}_layer1`
+  };
+  const utexoConfig = {
+    ...config,
+    storeId: `${config.storeId}_utexo`
+  };
+  const { walletPath: layer1Path } = restoreFromVss({
+    config: layer1Config,
+    targetDir: path3__default.join(targetDir, layer1Network, masterFingerprint)
+  });
+  const { walletPath: utexoPath } = restoreFromVss({
+    config: utexoConfig,
+    targetDir: path3__default.join(targetDir, utexoNetwork, masterFingerprint)
+  });
+  return { layer1Path, utexoPath, targetDir };
+}
+function restoreUtxoWalletFromBackup(params) {
+  const { backupPath, password, targetDir, networkPreset = "testnet" } = params;
+  if (!backupPath || !password || !targetDir) {
+    throw new ValidationError(
+      "backupPath, password, and targetDir are required",
+      "restoreUtxoWalletFromBackup"
+    );
+  }
+  if (!fs2__default.existsSync(backupPath) || !fs2__default.statSync(backupPath).isDirectory()) {
+    throw new ValidationError(
+      "backupPath must be an existing directory",
+      "backupPath"
+    );
+  }
+  const files = fs2__default.readdirSync(backupPath);
+  const layer1File = files.find((f) => f.endsWith(LAYER1_BACKUP_SUFFIX));
+  const utexoFile = files.find((f) => f.endsWith(UTEXO_BACKUP_SUFFIX));
+  if (!layer1File || !utexoFile) {
+    throw new ValidationError(
+      `backupPath must contain wallet_<fp>_layer1.backup and wallet_<fp>_utexo.backup (from createBackup)`,
+      "backupPath"
+    );
+  }
+  const masterFingerprint = layer1File.slice(0, -LAYER1_BACKUP_SUFFIX.length).replace(/^wallet_/, "");
+  const expectedUtexoFile = `wallet_${masterFingerprint}${UTEXO_BACKUP_SUFFIX}`;
+  if (utexoFile !== expectedUtexoFile) {
+    throw new ValidationError(
+      `Layer1 and utexo backup filenames must share the same wallet id (expected ${expectedUtexoFile})`,
+      "backupPath"
+    );
+  }
+  const layer1BackupFile = path3__default.join(backupPath, layer1File);
+  const utexoBackupFile = path3__default.join(backupPath, utexoFile);
+  if (!fs2__default.existsSync(layer1BackupFile) || !fs2__default.existsSync(utexoBackupFile)) {
+    throw new ValidationError("Backup files not found", "backupPath");
+  }
+  const presetConfig = getUtxoNetworkConfig(networkPreset);
+  const layer1Network = String(presetConfig.networkMap.mainnet);
+  const utexoNetwork = String(presetConfig.networkMap.utexo);
+  const layer1DataDir = path3__default.join(targetDir, layer1Network, masterFingerprint);
+  const utexoDataDir = path3__default.join(targetDir, utexoNetwork, masterFingerprint);
+  for (const dir of [layer1DataDir, utexoDataDir]) {
+    if (!fs2__default.existsSync(path3__default.dirname(dir))) {
+      fs2__default.mkdirSync(path3__default.dirname(dir), { recursive: true });
+    }
+    if (!fs2__default.existsSync(dir)) {
+      fs2__default.mkdirSync(dir, { recursive: true });
+    }
+  }
+  restoreWallet({
+    backupFilePath: layer1BackupFile,
+    password,
+    dataDir: layer1DataDir
+  });
+  restoreWallet({
+    backupFilePath: utexoBackupFile,
+    password,
+    dataDir: utexoDataDir
+  });
+  return {
+    layer1Path: layer1DataDir,
+    utexoPath: utexoDataDir,
+    targetDir
+  };
+}
+var UTEXOWallet = class extends UTEXOWalletCore {
+  constructor() {
+    super(...arguments);
+    this._masterFingerprint = null;
+  }
+  async initialize() {
+    const layer1Keys = await this.derivePublicKeys(this.networkMap.mainnet);
+    const utexoKeys = await this.derivePublicKeys(this.networkMap.utexo);
+    this._masterFingerprint = utexoKeys.masterFingerprint;
+    const fp = utexoKeys.masterFingerprint;
+    const dataDir = this.options.dataDir;
+    this.utexoWallet = new WalletManager({
+      xpubVan: utexoKeys.accountXpubVanilla,
+      xpubCol: utexoKeys.accountXpubColored,
+      masterFingerprint: utexoKeys.masterFingerprint,
+      network: this.networkMap.utexo,
+      mnemonic: this.mnemonicOrSeed,
+      dataDir: dataDir ? path3__default.join(dataDir, String(this.networkMap.utexo), fp) : void 0
+    });
+    this.layer1Wallet = new WalletManager({
+      xpubVan: layer1Keys.accountXpubVanilla,
+      xpubCol: layer1Keys.accountXpubColored,
+      masterFingerprint: layer1Keys.masterFingerprint,
+      network: this.networkMap.mainnet,
+      mnemonic: this.mnemonicOrSeed,
+      dataDir: dataDir ? path3__default.join(dataDir, String(this.networkMap.mainnet), fp) : void 0
+    });
+  }
+  /**
+   * Create backup for both layer1 and utexo stores in one folder.
+   * Writes backupPath/wallet_{masterFingerprint}_layer1.backup and
+   * backupPath/wallet_{masterFingerprint}_utexo.backup
+   */
+  async createBackup(params) {
+    this.ensureInitialized();
+    const { backupPath, password } = params;
+    if (!backupPath || !password) {
+      throw new ValidationError(
+        "backupPath and password are required",
+        "createBackup"
+      );
+    }
+    const fp = this._masterFingerprint;
+    const { layer1TmpDir, utexoTmpDir, layer1FinalPath, utexoFinalPath } = prepareUtxoBackupDirs(backupPath, fp);
+    const layer1Result = await this.layer1Wallet.createBackup({
+      backupPath: layer1TmpDir,
+      password
+    });
+    const utexoResult = await this.utexoWallet.createBackup({
+      backupPath: utexoTmpDir,
+      password
+    });
+    finalizeUtxoBackupPaths({
+      layer1BackupPath: layer1Result.backupPath,
+      utexoBackupPath: utexoResult.backupPath,
+      layer1FinalPath,
+      utexoFinalPath,
+      layer1TmpDir,
+      utexoTmpDir
+    });
+    return {
+      message: "Backup created successfully (layer1 + utexo)",
+      backupPath,
+      layer1BackupPath: layer1FinalPath,
+      utexoBackupPath: utexoFinalPath
+    };
+  }
+};
+
+// src/utils/environment.ts
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+
+export { UTEXOWallet, WalletManager, createWallet, createWalletManager, estimatePsbt, isNode, restoreFromBackup, restoreFromVss, restoreUtxoWalletFromBackup, restoreUtxoWalletFromVss, signPsbt, signPsbtFromSeed, wallet };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map