@utexo/rgb-sdk 1.0.4 → 1.0.5

package/dist/index.cjs

@@ -1,10 +1,12 @@
 'use strict';
 
-var path = require('path');
-var fs = require('fs');
+var path3 = require('path');
+var fs2 = require('fs');
 var rgblib = require('@utexo/rgb-lib');
 var noble = require('@noble/hashes/legacy.js');
-var os = require('os');
+var hmac_js = require('@noble/hashes/hmac.js');
+var sha2_js = require('@noble/hashes/sha2.js');
+var axios = require('axios');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -27,14 +29,30 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
+var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
 var rgblib__default = /*#__PURE__*/_interopDefault(rgblib);
 var noble__namespace = /*#__PURE__*/_interopNamespace(noble);
-var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
 
 // src/client/rgb-lib-client.ts
 
+// src/client/network-config.ts
+var DEFAULT_TRANSPORT_ENDPOINTS = {
+  mainnet: "rpcs://rgb-proxy-mainnet.utexo.com/json-rpc",
+  testnet: "rpcs://rgb-proxy-testnet3.utexo.com/json-rpc",
+  testnet4: "rpcs://proxy.iriswallet.com/0.2/json-rpc",
+  signet: "rpcs://rgb-proxy-utexo.utexo.com/json-rpc",
+  regtest: "rpcs://proxy.iriswallet.com/0.2/json-rpc"
+};
+var DEFAULT_INDEXER_URLS = {
+  mainnet: "ssl://electrum.iriswallet.com:50003",
+  testnet: "ssl://electrum.iriswallet.com:50013",
+  testnet4: "ssl://electrum.iriswallet.com:50053",
+  signet: "https://esplora-api.utexo.com",
+  regtest: "tcp://regtest.thunderstack.org:50001"
+};
+
 // src/errors/index.ts
 var SDKError = class _SDKError extends Error {
   constructor(message, code, statusCode, cause) {
@@ -133,6 +151,135 @@ var DERIVATION_ACCOUNT = 0;
 var KEYCHAIN_RGB = 0;
 var KEYCHAIN_BTC = 0;
 
+// src/utexo/config/utexo-presets.ts
+function withGetAssetById(config) {
+  return {
+    ...config,
+    getAssetById(tokenId) {
+      return config.assets.find((a) => a.tokenId === tokenId);
+    }
+  };
+}
+var testnetPreset = {
+  networkMap: {
+    mainnet: "testnet",
+    utexo: "signet"
+  },
+  networkIdMap: {
+    mainnet: withGetAssetById({
+      networkName: "RGB",
+      networkId: 36,
+      assets: [
+        {
+          assetId: "rgb:WPRv95Nj-icdrgPp-zpQhIp_-2TyJ~Ge-k~FvuMZ-~vVnkA0",
+          tokenName: "tUSD",
+          longName: "USDT",
+          precision: 6,
+          tokenId: 4
+        }
+      ]
+    }),
+    mainnetLightning: withGetAssetById({
+      networkName: "RGB Lightning",
+      networkId: 94,
+      assets: [
+        {
+          assetId: "rgb:WPRv95Nj-icdrgPp-zpQhIp_-2TyJ~Ge-k~FvuMZ-~vVnkA0",
+          tokenName: "tUSD",
+          longName: "USDT",
+          precision: 6,
+          tokenId: 4
+        }
+      ]
+    }),
+    utexo: withGetAssetById({
+      networkName: "UTEXO",
+      networkId: 96,
+      assets: [
+        {
+          assetId: "rgb:yJW4k8si-~8JdNfl-nM91qFu-r5rH_HS-1hM7jpi-L~lBf90",
+          tokenName: "tUSD",
+          longName: "USDT",
+          precision: 6,
+          tokenId: 4
+        }
+      ]
+    })
+  }
+};
+var mainnetPreset = {
+  networkMap: {
+    mainnet: "mainnet",
+    utexo: "signet"
+  },
+  networkIdMap: {
+    mainnet: withGetAssetById({
+      networkName: "RGB",
+      networkId: 36,
+      // TODO: Update to production network ID
+      assets: [
+        {
+          assetId: "rgb:WPRv95Nj-icdrgPp-zpQhIp_-2TyJ~Ge-k~FvuMZ-~vVnkA0",
+          // TODO: Update to production asset ID
+          tokenName: "tUSD",
+          longName: "USDT",
+          precision: 6,
+          tokenId: 4
+        }
+      ]
+    }),
+    mainnetLightning: withGetAssetById({
+      networkName: "RGB Lightning",
+      networkId: 94,
+      // TODO: Update to production network ID
+      assets: [
+        {
+          assetId: "rgb:WPRv95Nj-icdrgPp-zpQhIp_-2TyJ~Ge-k~FvuMZ-~vVnkA0",
+          // TODO: Update to production asset ID
+          tokenName: "tUSD",
+          longName: "USDT",
+          precision: 6,
+          tokenId: 4
+        }
+      ]
+    }),
+    utexo: withGetAssetById({
+      networkName: "UTEXO",
+      networkId: 96,
+      // TODO: Update to production network ID
+      assets: [
+        {
+          assetId: "rgb:yJW4k8si-~8JdNfl-nM91qFu-r5rH_HS-1hM7jpi-L~lBf90",
+          // TODO: Update to production asset ID
+          tokenName: "tUSD",
+          longName: "USDT",
+          precision: 6,
+          tokenId: 4
+        }
+      ]
+    })
+  }
+};
+
+// src/utexo/utils/network.ts
+var NETWORK_PRESETS = {
+  mainnet: mainnetPreset,
+  testnet: testnetPreset
+};
+function getUtxoNetworkConfig(preset) {
+  return NETWORK_PRESETS[preset];
+}
+var utexoNetworkMap = testnetPreset.networkMap;
+var utexoNetworkIdMap = testnetPreset.networkIdMap;
+function getDestinationAsset(senderNetwork, destinationNetwork, assetIdSender) {
+  const destinationConfig = utexoNetworkIdMap[destinationNetwork];
+  if (assetIdSender == null) return destinationConfig.assets[0];
+  const senderConfig = utexoNetworkIdMap[senderNetwork];
+  const senderAsset = senderConfig.assets.find((a) => a.assetId === assetIdSender);
+  if (!senderAsset) return void 0;
+  return destinationConfig.assets.find((a) => a.tokenId === senderAsset.tokenId);
+}
+
 // src/constants/network.ts
 var COIN_RGB_MAINNET = 827166;
 var COIN_RGB_TESTNET = 827167;
@@ -248,7 +395,6 @@ function validateString(value, field) {
     throw new ValidationError(`${field} must be a non-empty string`, field);
   }
 }
-var DEFAULT_TRANSPORT_ENDPOINT = "rpcs://proxy.iriswallet.com/0.2/json-rpc";
 function mapNetworkToRgbLib(network) {
   const networkMap = {
     "mainnet": "Mainnet",
@@ -262,10 +408,10 @@ function mapNetworkToRgbLib(network) {
 }
 var restoreWallet = (params) => {
   const { backupFilePath, password, dataDir } = params;
-  if (!fs__namespace.existsSync(backupFilePath)) {
+  if (!fs2__namespace.existsSync(backupFilePath)) {
     throw new ValidationError("Backup file not found", "backup");
   }
-  if (!fs__namespace.existsSync(dataDir)) {
+  if (!fs2__namespace.existsSync(dataDir)) {
     throw new ValidationError(`Restore directory does not exist: ${dataDir}`, "restoreDir");
   }
   rgblib__default.default.restoreBackup(backupFilePath, password, dataDir);
@@ -273,6 +419,26 @@ var restoreWallet = (params) => {
     message: "Wallet restored successfully"
   };
 };
+var restoreFromVss = (params) => {
+  const anyLib = rgblib__default.default;
+  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 RGBLibClient = class {
   constructor(params) {
     this.online = null;
@@ -282,21 +448,14 @@ var RGBLibClient = class {
     this.originalNetwork = params.network;
     this.network = normalizeNetwork(this.originalNetwork);
     this.dataDir = params.dataDir;
-    this.transportEndpoint = params.transportEndpoint || DEFAULT_TRANSPORT_ENDPOINT;
+    this.transportEndpoint = params.transportEndpoint || DEFAULT_TRANSPORT_ENDPOINTS[this.network] || DEFAULT_TRANSPORT_ENDPOINTS.signet;
     if (params.indexerUrl) {
       this.indexerUrl = params.indexerUrl;
     } else {
-      const defaultIndexerUrls = {
-        "mainnet": "ssl://electrum.iriswallet.com:50003",
-        "testnet": "ssl://electrum.iriswallet.com:50013",
-        "testnet4": "ssl://electrum.iriswallet.com:50053",
-        "signet": "tcp://46.224.75.237:50001",
-        "regtest": "tcp://regtest.thunderstack.org:50001"
-      };
-      this.indexerUrl = defaultIndexerUrls[this.network] || defaultIndexerUrls["regtest"];
+      this.indexerUrl = DEFAULT_INDEXER_URLS[this.network] || DEFAULT_INDEXER_URLS.signet;
     }
-    if (!fs__namespace.existsSync(this.dataDir)) {
-      fs__namespace.mkdirSync(this.dataDir, { recursive: true });
+    if (!fs2__namespace.existsSync(this.dataDir)) {
+      fs2__namespace.mkdirSync(this.dataDir, { recursive: true });
     }
     const walletData = {
       dataDir: this.dataDir,
@@ -316,6 +475,7 @@ var RGBLibClient = class {
     try {
       this.wallet = new rgblib__default.default.Wallet(new rgblib__default.default.WalletData(walletData));
     } catch (error) {
+      console.log("error", error);
       throw new WalletError("Failed to initialize rgb-lib wallet", void 0, error);
     }
   }
@@ -327,7 +487,6 @@ var RGBLibClient = class {
       return;
     }
     try {
-      console.log("indexerUrl", this.indexerUrl);
       this.online = this.wallet.goOnline(false, this.indexerUrl);
     } catch (error) {
       throw new WalletError("Failed to establish online connection", void 0, error);
@@ -377,10 +536,9 @@ var RGBLibClient = class {
   }
   sendBegin(params) {
     const online = this.getOnline();
-    console.log("sendBegin params", params);
     const feeRate = String(params.feeRate ?? 1);
     const minConfirmations = String(params.minConfirmations ?? 1);
-    const donation = false;
+    const donation = params.donation ?? false;
     let assetId = params.assetId;
     let amount = params.amount;
     let recipientId;
@@ -428,6 +586,37 @@ var RGBLibClient = class {
     );
     return psbt;
   }
+  /**
+   * Batch send: accepts an already-built recipientMap and calls sendBegin.
+   */
+  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;
+  }
   sendEnd(params) {
     const online = this.getOnline();
     const signedPsbt = params.signedPsbt;
@@ -531,7 +720,8 @@ var RGBLibClient = class {
     const assetId = null;
     const filter = [];
     const skipSync = false;
-    this.wallet.refresh(online, assetId, filter, skipSync);
+    const result = this.wallet.refresh(online, assetId, filter, skipSync);
+    console.log("refresh state:", JSON.stringify(result, null, 2));
   }
   dropWallet() {
     if (this.online) {
@@ -574,16 +764,105 @@ var RGBLibClient = class {
     if (!params.password) {
       throw new ValidationError("password is required", "password");
     }
-    if (!fs__namespace.existsSync(params.backupPath)) {
+    if (!fs2__namespace.existsSync(params.backupPath)) {
       throw new ValidationError(`Backup directory does not exist: ${params.backupPath}`, "backupPath");
     }
-    const fullBackupPath = path__namespace.join(params.backupPath, `${this.masterFingerprint}.backup`);
+    const fullBackupPath = path3__namespace.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__default.default;
+    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.
+   */
+  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.
+   */
+  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
    */
@@ -960,8 +1239,8 @@ async function mnemonicToRoot(mnemonic, bitcoinNetwork) {
 }
 async function getAccountXpub(mnemonic, bitcoinNetwork, rgb) {
   const root = await mnemonicToRoot(mnemonic, bitcoinNetwork);
-  const path3 = accountDerivationPath(bitcoinNetwork, rgb);
-  const acct = root.derivePath(path3);
+  const path5 = accountDerivationPath(bitcoinNetwork, rgb);
+  const acct = root.derivePath(path5);
   return acct.neutered().toBase58();
 }
 async function getMasterXpriv(mnemonic, bitcoinNetwork) {
@@ -1085,6 +1364,27 @@ async function deriveKeysFromSeed(bitcoinNetwork = "regtest", seed) {
     throw new CryptoError("Failed to derive keys from seed", error);
   }
 }
+async function deriveKeysFromMnemonicOrSeed(bitcoinNetwork = "regtest", mnemonicOrSeed) {
+  if (typeof mnemonicOrSeed === "string") {
+    const trimmed = mnemonicOrSeed.trim();
+    const words = trimmed.split(/\s+/);
+    const isLikelyMnemonic = trimmed.includes(" ") && words.length >= 12 && words.length <= 24;
+    if (isLikelyMnemonic) {
+      try {
+        return await deriveKeysFromMnemonic(bitcoinNetwork, trimmed);
+      } catch (error) {
+        if (error instanceof ValidationError) {
+          return await deriveKeysFromSeed(bitcoinNetwork, trimmed);
+        }
+        throw error;
+      }
+    } else {
+      return await deriveKeysFromSeed(bitcoinNetwork, trimmed);
+    }
+  } else {
+    return await deriveKeysFromSeed(bitcoinNetwork, mnemonicOrSeed);
+  }
+}
 async function restoreKeys(bitcoinNetwork = "regtest", mnemonic) {
   return deriveKeysFromMnemonic(bitcoinNetwork, mnemonic);
 }
@@ -1147,28 +1447,28 @@ async function accountXpubsFromMnemonic(bitcoinNetwork = "regtest", mnemonic) {
 }
 
 // src/crypto/signer.ts
-function normalizePath(path3) {
-  if (typeof path3 === "string") {
-    if (path3.startsWith("m/m/")) {
-      return path3.replace(/^m\/m\//, "m/");
-    }
-    return path3;
-  } else if (Array.isArray(path3)) {
-    if (path3.length > 0 && path3[0] === 0 && path3.length > 1) {
-      const second = path3[1];
+function normalizePath(path5) {
+  if (typeof path5 === "string") {
+    if (path5.startsWith("m/m/")) {
+      return path5.replace(/^m\/m\//, "m/");
+    }
+    return path5;
+  } else if (Array.isArray(path5)) {
+    if (path5.length > 0 && path5[0] === 0 && path5.length > 1) {
+      const second = path5[1];
       if (typeof second === "number" && second >= 2147483648) {
-        return path3.slice(1);
+        return path5.slice(1);
       }
     }
-    return path3;
+    return path5;
   }
-  return path3;
+  return path5;
 }
-function pathToString(path3) {
-  if (typeof path3 === "string") {
-    return path3;
-  } else if (Array.isArray(path3)) {
-    return path3.map((p) => {
+function pathToString(path5) {
+  if (typeof path5 === "string") {
+    return path5;
+  } else if (Array.isArray(path5)) {
+    return path5.map((p) => {
       if (typeof p === "number") {
         return p >= 2147483648 ? `${p & 2147483647}'` : `${p}`;
       }
@@ -1477,6 +1777,14 @@ async function estimatePsbt(psbtBase64) {
     throw new ValidationError("Invalid PSBT provided", "psbt");
   }
 }
+var VSS_SIGNING_KEY_DOMAIN = "rgb-lib-vss-backup-encryption-v1";
+function deriveVssSigningKeyFromMnemonic(mnemonic) {
+  validateMnemonic(mnemonic, "mnemonic");
+  const keyBytes = new TextEncoder().encode(VSS_SIGNING_KEY_DOMAIN);
+  const messageBytes = new TextEncoder().encode(mnemonic.trim());
+  const digest = hmac_js.hmac(sha2_js.sha256, keyBytes, messageBytes);
+  return Array.from(digest).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
 var restoreFromBackup = (params) => {
   const {
     backupFilePath,
@@ -1520,7 +1828,7 @@ var WalletManager = class {
     this.mnemonic = params.mnemonic ?? null;
     this.xpub = params.xpub ?? null;
     this.masterFingerprint = params.masterFingerprint;
-    this.dataDir = params.dataDir ?? path__namespace.default.join(os__namespace.tmpdir(), "rgb-wallet", this.masterFingerprint);
+    this.dataDir = params.dataDir ?? path3__namespace.default.join(process.cwd(), ".rgb-wallet", this.network, this.masterFingerprint);
     this.client = new RGBLibClient({
       xpubVan: params.xpubVan,
       xpubCol: params.xpubCol,
@@ -1531,6 +1839,12 @@ var WalletManager = class {
       dataDir: params.dataDir ?? this.dataDir
     });
   }
+  async initialize() {
+    console.log("initializing is not reqire");
+  }
+  async goOnline(indexerUrl, skipConsistencyCheck) {
+    this.client.getOnline();
+  }
   /**
    * Get wallet's extended public keys
    */
@@ -1551,7 +1865,7 @@ var WalletManager = class {
    * Clears mnemonic and seed from memory
    * Idempotent - safe to call multiple times
    */
-  dispose() {
+  async dispose() {
     if (this.disposed) {
       return;
     }
@@ -1583,73 +1897,160 @@ var WalletManager = class {
   registerWallet() {
     return this.client.registerWallet();
   }
-  getBtcBalance() {
+  async getBtcBalance() {
     return this.client.getBtcBalance();
   }
-  getAddress() {
+  async getAddress() {
     return this.client.getAddress();
   }
-  listUnspents() {
-    return this.client.listUnspents();
-  }
-  listAssets() {
-    return this.client.listAssets();
-  }
-  getAssetBalance(asset_id) {
-    return this.client.getAssetBalance(asset_id);
+  async listUnspents() {
+    const unspents = this.client.listUnspents();
+    return unspents.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 listAssets() {
+    const assets = this.client.listAssets();
+    return assets;
+  }
+  async getAssetBalance(asset_id) {
+    const balance = this.client.getAssetBalance(asset_id);
+    return {
+      settled: balance.settled ?? 0,
+      future: balance.future ?? 0,
+      spendable: balance.spendable ?? 0,
+      offchainOutbound: balance.offchainOutbound ?? 0,
+      offchainInbound: balance.offchainInbound ?? 0
+    };
   }
-  createUtxosBegin(params) {
+  async createUtxosBegin(params) {
     return this.client.createUtxosBegin(params);
   }
-  createUtxosEnd(params) {
+  async createUtxosEnd(params) {
     return this.client.createUtxosEnd(params);
   }
-  sendBegin(params) {
+  async sendBegin(params) {
     return this.client.sendBegin(params);
   }
-  sendEnd(params) {
+  /**
+   * Batch send begin: accepts already-built recipientMap.
+   * Returns unsigned PSBT (use signPsbt then sendEnd to complete).
+   */
+  async sendBeginBatch(params) {
+    return this.client.sendBeginBatch(params);
+  }
+  /**
+   * Complete batch send: sendBeginBatch → sign PSBT → sendEnd.
+   */
+  async sendBatch(params, mnemonic) {
+    this.ensureNotDisposed();
+    const psbt = await this.sendBeginBatch(params);
+    const signedPsbt = await this.signPsbt(psbt, mnemonic);
+    return await this.sendEnd({ signedPsbt });
+  }
+  async sendEnd(params) {
     return this.client.sendEnd(params);
   }
-  sendBtcBegin(params) {
+  async sendBtcBegin(params) {
     return this.client.sendBtcBegin(params);
   }
-  sendBtcEnd(params) {
+  async sendBtcEnd(params) {
     return this.client.sendBtcEnd(params);
   }
-  estimateFeeRate(blocks) {
+  async estimateFeeRate(blocks) {
     if (!Number.isFinite(blocks)) {
       throw new ValidationError("blocks must be a finite number", "blocks");
     }
     if (!Number.isInteger(blocks) || blocks <= 0) {
       throw new ValidationError("blocks must be a positive integer", "blocks");
     }
-    return this.client.getFeeEstimation({ blocks });
+    const feeEstimation = await this.client.getFeeEstimation({ blocks });
+    return feeEstimation;
   }
   async estimateFee(psbtBase64) {
     return await estimatePsbt(psbtBase64);
   }
   async sendBtc(params) {
     this.ensureNotDisposed();
-    const psbt = this.sendBtcBegin(params);
+    const psbt = await this.sendBtcBegin(params);
     const signed = await this.signPsbt(psbt);
-    return this.sendBtcEnd({ signedPsbt: signed });
+    return await this.sendBtcEnd({ signedPsbt: signed });
   }
-  blindReceive(params) {
-    return this.client.blindReceive(params);
+  async blindReceive(params) {
+    const invoice = await this.client.blindReceive({
+      ...params,
+      assetId: params.assetId ?? "",
+      amount: params.amount ?? 0
+    });
+    return {
+      invoice: invoice.invoice,
+      recipientId: invoice.recipientId,
+      expirationTimestamp: invoice.expirationTimestamp ?? null,
+      batchTransferIdx: invoice.batchTransferIdx
+    };
   }
-  witnessReceive(params) {
-    return this.client.witnessReceive(params);
+  async witnessReceive(params) {
+    const invoice = await this.client.witnessReceive({
+      ...params,
+      assetId: params.assetId ?? "",
+      amount: params.amount ?? 0
+    });
+    return {
+      invoice: invoice.invoice,
+      recipientId: invoice.recipientId,
+      expirationTimestamp: invoice.expirationTimestamp ?? null,
+      batchTransferIdx: invoice.batchTransferIdx
+    };
   }
-  issueAssetNia(params) {
-    return this.client.issueAssetNia(params);
+  async decodeRGBInvoice(params) {
+    const invoiceData = await this.client.decodeRGBInvoice(params);
+    const assignmentKeys = Object.keys(invoiceData.assignment);
+    const assignmentType = assignmentKeys[0];
+    const assignment = {
+      type: assignmentType ?? "Any",
+      amount: assignmentType && invoiceData.assignment[assignmentType] ? Number(invoiceData.assignment[assignmentType]) : void 0
+    };
+    return {
+      invoice: params.invoice,
+      recipientId: invoiceData.recipientId,
+      assetSchema: invoiceData.assetSchema,
+      assetId: invoiceData.assetId,
+      network: invoiceData.network,
+      assignment,
+      assignmentName: invoiceData.assignmentName,
+      expirationTimestamp: invoiceData.expirationTimestamp ?? null,
+      transportEndpoints: invoiceData.transportEndpoints
+    };
   }
-  issueAssetIfa(params) {
-    return this.client.issueAssetIfa(params);
+  async issueAssetNia(params) {
+    const asset = await this.client.issueAssetNia(params);
+    return asset;
   }
-  inflateBegin(params) {
+  async issueAssetIfa(params) {
+    const asset = await this.client.issueAssetIfa(params);
+    return asset;
+  }
+  async inflateBegin(params) {
     return this.client.inflateBegin(params);
   }
-  inflateEnd(params) {
+  async inflateEnd(params) {
     return this.client.inflateEnd(params);
   }
   /**
@@ -1665,24 +2066,51 @@ var WalletManager = class {
       signedPsbt
     });
   }
-  refreshWallet() {
+  async refreshWallet() {
     this.client.refreshWallet();
   }
-  listTransactions() {
-    return this.client.listTransactions();
+  async listTransactions() {
+    const transactions = this.client.listTransactions();
+    return transactions;
   }
-  listTransfers(asset_id) {
-    return this.client.listTransfers(asset_id);
+  async listTransfers(asset_id) {
+    const transfers = this.client.listTransfers(asset_id);
+    return transfers;
   }
-  failTransfers(params) {
+  async failTransfers(params) {
     return this.client.failTransfers(params);
   }
-  decodeRGBInvoice(params) {
-    return this.client.decodeRGBInvoice(params);
-  }
-  createBackup(params) {
+  async createBackup(params) {
     return this.client.createBackup(params);
   }
+  /**
+   * Configure VSS cloud backup for this wallet.
+   */
+  async configureVssBackup(config) {
+    this.ensureNotDisposed();
+    this.client.configureVssBackup(config);
+  }
+  /**
+   * Disable automatic VSS backup.
+   */
+  async disableVssAutoBackup() {
+    this.ensureNotDisposed();
+    this.client.disableVssAutoBackup();
+  }
+  /**
+   * Trigger a VSS backup immediately and return the server version.
+   */
+  async vssBackup(config) {
+    this.ensureNotDisposed();
+    return this.client.vssBackup(config);
+  }
+  /**
+   * Get VSS backup info for this wallet.
+   */
+  async vssBackupInfo(config) {
+    this.ensureNotDisposed();
+    return this.client.vssBackupInfo(config);
+  }
   /**
    * Sign a PSBT using the wallet's mnemonic or a provided mnemonic
    * @param psbt - Base64 encoded PSBT
@@ -1708,16 +2136,15 @@ var WalletManager = class {
     this.ensureNotDisposed();
     const psbt = await this.sendBegin(invoiceTransfer);
     const signedPsbt = await this.signPsbt(psbt, mnemonic);
-    console.log("send signedPsbt", signedPsbt);
     return await this.sendEnd({ signedPsbt });
   }
   async createUtxos({ upTo, num, size, feeRate }) {
     this.ensureNotDisposed();
-    const psbt = this.createUtxosBegin({ upTo, num, size, feeRate });
+    const psbt = await this.createUtxosBegin({ upTo, num, size, feeRate });
     const signedPsbt = await this.signPsbt(psbt);
     return this.createUtxosEnd({ signedPsbt });
   }
-  syncWallet() {
+  async syncWallet() {
     this.client.syncWallet();
   }
   async signMessage(message) {
@@ -1762,33 +2189,1081 @@ var wallet = new Proxy({}, {
   }
 });
 
-// src/types/rgb-model.ts
-var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
-  TransactionType2[TransactionType2["RGB_SEND"] = 0] = "RGB_SEND";
-  TransactionType2[TransactionType2["DRAIN"] = 1] = "DRAIN";
-  TransactionType2[TransactionType2["CREATE_UTXOS"] = 2] = "CREATE_UTXOS";
-  TransactionType2[TransactionType2["USER"] = 3] = "USER";
-  return TransactionType2;
-})(TransactionType || {});
-var TransferStatus = /* @__PURE__ */ ((TransferStatus2) => {
-  TransferStatus2[TransferStatus2["WAITING_COUNTERPARTY"] = 0] = "WAITING_COUNTERPARTY";
-  TransferStatus2[TransferStatus2["WAITING_CONFIRMATIONS"] = 1] = "WAITING_CONFIRMATIONS";
-  TransferStatus2[TransferStatus2["SETTLED"] = 2] = "SETTLED";
-  TransferStatus2[TransferStatus2["FAILED"] = 3] = "FAILED";
-  return TransferStatus2;
-})(TransferStatus || {});
-var AssetIface = /* @__PURE__ */ ((AssetIface2) => {
-  AssetIface2["RGB20"] = "RGB20";
-  AssetIface2["RGB21"] = "RGB21";
-  AssetIface2["RGB25"] = "RGB25";
-  return AssetIface2;
-})(AssetIface || {});
-var AssetSchema = /* @__PURE__ */ ((AssetSchema2) => {
-  AssetSchema2["Nia"] = "Nia";
-  AssetSchema2["Uda"] = "Uda";
-  AssetSchema2["Cfa"] = "Cfa";
-  return AssetSchema2;
-})(AssetSchema || {});
+// src/utexo/utexo-protocol.ts
+var LightningProtocol = class {
+  async createLightningInvoice(params) {
+    throw new Error("createLightningInvoice not implemented");
+  }
+  async getLightningReceiveRequest(id) {
+    throw new Error("getLightningReceiveRequest not implemented");
+  }
+  async getLightningSendRequest(id) {
+    throw new Error("getLightningSendRequest not implemented");
+  }
+  async getLightningSendFeeEstimate(params) {
+    throw new Error("getLightningSendFeeEstimate not implemented");
+  }
+  async payLightningInvoiceBegin(params) {
+    throw new Error("payLightningInvoiceBegin not implemented");
+  }
+  async payLightningInvoiceEnd(params) {
+    throw new Error("payLightningInvoiceEnd not implemented");
+  }
+  async payLightningInvoice(params, mnemonic) {
+    throw new Error("payLightningInvoice not implemented");
+  }
+  async listLightningPayments() {
+    throw new Error("listLightningPayments not implemented");
+  }
+};
+var OnchainProtocol = class {
+  async onchainReceive(params) {
+    throw new Error("onchainReceive not implemented");
+  }
+  async onchainSendBegin(params) {
+    throw new Error("onchainSendBegin not implemented");
+  }
+  async onchainSendEnd(params) {
+    throw new Error("onchainSendEnd not implemented");
+  }
+  async onchainSend(params, mnemonic) {
+    throw new Error("onchainSend not implemented");
+  }
+  async getOnchainSendStatus(send_id) {
+    throw new Error("getOnchainSendStatus not implemented");
+  }
+  async listOnchainTransfers(asset_id) {
+    throw new Error("listOnchainTransfers not implemented");
+  }
+};
+var UTEXOProtocol = class extends LightningProtocol {
+  constructor() {
+    super(...arguments);
+    this.onchainProtocol = new OnchainProtocol();
+  }
+  async onchainReceive(params) {
+    return this.onchainProtocol.onchainReceive(params);
+  }
+  async onchainSendBegin(params) {
+    return this.onchainProtocol.onchainSendBegin(params);
+  }
+  async onchainSendEnd(params) {
+    return this.onchainProtocol.onchainSendEnd(params);
+  }
+  async onchainSend(params, mnemonic) {
+    return this.onchainProtocol.onchainSend(params, mnemonic);
+  }
+  async getOnchainSendStatus(send_id) {
+    return this.onchainProtocol.getOnchainSendStatus(send_id);
+  }
+  async listOnchainTransfers(asset_id) {
+    return this.onchainProtocol.listOnchainTransfers(asset_id);
+  }
+};
+
+// src/utexo/config/gateway.ts
+var DEFAULT_GATEWAY_BASE_URLS = {
+  mainnet: "https://gateway.utexo.tricorn.network/",
+  testnet: "https://dev.gateway.utexo.tricorn.network/"
+};
+
+// src/utexo/bridge/types.ts
+var TransferStatuses = /* @__PURE__ */ ((TransferStatuses2) => {
+  TransferStatuses2[TransferStatuses2["Unspecified"] = 0] = "Unspecified";
+  TransferStatuses2[TransferStatuses2["Confirming"] = 1] = "Confirming";
+  TransferStatuses2[TransferStatuses2["Canceled"] = 2] = "Canceled";
+  TransferStatuses2[TransferStatuses2["Finished"] = 3] = "Finished";
+  TransferStatuses2[TransferStatuses2["Waiting"] = 4] = "Waiting";
+  TransferStatuses2[TransferStatuses2["Cancelling"] = 5] = "Cancelling";
+  TransferStatuses2[TransferStatuses2["Failed"] = 6] = "Failed";
+  TransferStatuses2[TransferStatuses2["Fetching"] = 7] = "Fetching";
+  return TransferStatuses2;
+})(TransferStatuses || {});
+
+// src/utexo/bridge/api.ts
+var encodeTransferStatus = (transferStatus) => {
+  const textEncoder = new TextEncoder();
+  return textEncoder.encode(transferStatus.toString())[0];
+};
+var UtexoBridgeApiClient = class {
+  /**
+   * Creates a new UtexoBridgeApiClient instance
+   * 
+   * @param axiosInstance - Axios instance to use for HTTP requests (required)
+   * @param basePath - Base path for API endpoints (defaults to '/v1/utexo/bridge')
+   * 
+   * @example
+   * ```typescript
+   * import axios from 'axios';
+   * import { UtexoBridgeApiClient } from './utexoBridge';
+   * 
+   * const axiosInstance = axios.create({
+   *   baseURL: 'https://api.example.com'
+   * });
+   * 
+   * const client = new UtexoBridgeApiClient(axiosInstance);
+   * ```
+   */
+  constructor(axiosInstance, basePath = "/v1/utexo/bridge") {
+    this.axios = axiosInstance;
+    this.basePath = basePath;
+  }
+  /**
+   * Gets bridge-in signature for a transfer
+   * 
+   * @param request - Bridge-in signature request data
+   * @returns Promise resolving to bridge-in signature response
+   * @throws {ApiError} If the request fails
+   */
+  async getBridgeInSignature(request) {
+    try {
+      const { data } = await this.axios.post(
+        `${this.basePath}/bridge-in-signature`,
+        request
+      );
+      return data;
+    } catch (error) {
+      const responseData = error.response?.data;
+      if (responseData !== void 0) {
+        const message = typeof responseData === "string" ? responseData : JSON.stringify(responseData);
+        throw new Error(message);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Submits a signed transaction to the blockchain
+   * 
+   * @param request - Submit transaction request data
+   * @returns Promise resolving to transaction hash
+   * @throws {ApiError} If the request fails
+   */
+  async submitTransaction(request) {
+    const { data } = await this.axios.post(
+      `${this.basePath}/submit-transaction`,
+      request
+    );
+    return data.txHash;
+  }
+  /**
+   * Verifies a bridge-in transaction after it has been sent
+   * 
+   * @param request - Verify bridge-in request data
+   * @returns Promise that resolves when verification is complete
+   * @throws {ApiError} If the request fails
+   */
+  async verifyBridgeIn(request) {
+    await this.axios.post(`${this.basePath}/verify-bridge-in`, request);
+  }
+  /**
+   * Gets receiver invoice by transfer ID and network ID
+   * 
+   * @param transferId - Transfer ID
+   * @param networkId - Network ID
+   * @returns Promise resolving to invoice string
+   * @throws {ApiError} If the request fails
+   */
+  async getReceiverInvoice(transferId, networkId) {
+    const { data } = await this.axios.get(
+      `${this.basePath}/receiver-invoice/${transferId}/${networkId}`
+    );
+    return data.invoice;
+  }
+  async getWithdrawTransfer(invoice, networkId) {
+    const { data } = await this.axios.get(
+      `${this.basePath}/transfers/history`,
+      {
+        params: {
+          "network_id": String(networkId),
+          "offset": String(0),
+          "limit": String(10),
+          "address": "rgb-address"
+        }
+      }
+    );
+    if (data.transfers.length === 0) {
+      return null;
+    }
+    const withdrawTransfer = data.transfers.map((transfer) => ({ ...transfer, status: TransferStatuses[encodeTransferStatus(transfer.status)] })).find((transfer) => transfer.recipient.address === invoice);
+    if (!withdrawTransfer) {
+      return null;
+    }
+    return withdrawTransfer;
+  }
+  /**
+   * Gets transfer information by mainnet invoice
+   * 
+   * @param mainnetInvoice - Mainnet invoice string
+   * @param networkId - Network ID
+   * @returns Promise resolving to transfer information
+   * @throws {ApiError} If the request fails
+   */
+  async getTransferByMainnetInvoice(mainnetInvoice, networkId) {
+    try {
+      const { data } = await this.axios.get(
+        `${this.basePath}/transfer-by-mainnet-invoice`,
+        {
+          params: {
+            mainnet_invoice: mainnetInvoice,
+            network_id: networkId
+          }
+        }
+      );
+      if (data) {
+        return { ...data, status: TransferStatuses[encodeTransferStatus(data.status)] };
+      }
+      return data;
+    } catch (error) {
+      console.log("Mainnet invoice not found");
+      return null;
+    }
+  }
+};
+function getBridgeAPI(network = "mainnet") {
+  const axiosInstance = axios__default.default.create({
+    baseURL: DEFAULT_GATEWAY_BASE_URLS[network]
+  });
+  return new UtexoBridgeApiClient(axiosInstance);
+}
+
+// src/utexo/utils/helpers.ts
+var UTXO_PATH_INDEX = 2;
+function toUnitsNumber(value, precision) {
+  const s = String(value).trim();
+  const neg = s.startsWith("-");
+  const [iRaw, fRaw = ""] = (neg ? s.slice(1) : s).split(".");
+  const frac = (fRaw + "0".repeat(precision)).slice(0, precision);
+  const unitsStr = (iRaw || "0") + frac;
+  const units = Number(unitsStr);
+  if (!Number.isSafeInteger(units)) {
+    throw new Error(
+      `Amount exceeds MAX_SAFE_INTEGER. Use BigInt instead. got=${unitsStr}`
+    );
+  }
+  return neg ? -units : units;
+}
+function fromUnitsNumber(units, precision) {
+  const neg = units < 0;
+  const base = 10 ** precision;
+  const value = Math.abs(units) / base;
+  return neg ? -value : value;
+}
+function decodeBridgeInvoice(hexInvoice) {
+  const hex = hexInvoice.startsWith("0x") ? hexInvoice.slice(UTXO_PATH_INDEX) : hexInvoice;
+  return Buffer.from(hex, "hex").toString("utf-8");
+}
+
+// src/utexo/config/vss.ts
+var DEFAULT_VSS_SERVER_URL = "https://vss-server.utexo.com/vss";
+function getVssConfigs(config) {
+  const base = { ...config };
+  return {
+    layer1: { ...base, storeId: `${config.storeId}_layer1` },
+    utexo: { ...base, storeId: `${config.storeId}_utexo` }
+  };
+}
+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 getBackupStoreId(masterFingerprint) {
+  return `wallet_${masterFingerprint}`;
+}
+function prepareUtxoBackupDirs(backupPath, masterFingerprint) {
+  const storeId = getBackupStoreId(masterFingerprint);
+  if (!fs2__namespace.default.existsSync(backupPath)) {
+    fs2__namespace.default.mkdirSync(backupPath, { recursive: true });
+  }
+  const layer1TmpDir = path3__namespace.default.join(backupPath, UTEXO_BACKUP_TMP_LAYER1);
+  const utexoTmpDir = path3__namespace.default.join(backupPath, UTEXO_BACKUP_TMP_UTEXO);
+  fs2__namespace.default.mkdirSync(layer1TmpDir, { recursive: true });
+  fs2__namespace.default.mkdirSync(utexoTmpDir, { recursive: true });
+  return {
+    storeId,
+    layer1TmpDir,
+    utexoTmpDir,
+    layer1FinalPath: path3__namespace.default.join(backupPath, `${storeId}_layer1${BACKUP_FILE_SUFFIX}`),
+    utexoFinalPath: path3__namespace.default.join(backupPath, `${storeId}_utexo${BACKUP_FILE_SUFFIX}`)
+  };
+}
+function finalizeUtxoBackupPaths(params) {
+  const { layer1BackupPath, utexoBackupPath, layer1FinalPath, utexoFinalPath, layer1TmpDir, utexoTmpDir } = params;
+  fs2__namespace.default.renameSync(layer1BackupPath, layer1FinalPath);
+  fs2__namespace.default.renameSync(utexoBackupPath, utexoFinalPath);
+  fs2__namespace.default.rmdirSync(layer1TmpDir);
+  fs2__namespace.default.rmdirSync(utexoTmpDir);
+}
+async function buildVssConfigFromMnemonic(mnemonic, serverUrl, networkPreset = "testnet") {
+  const keys = await deriveKeysFromMnemonic(networkPreset, mnemonic.trim());
+  return {
+    serverUrl,
+    storeId: `wallet_${keys.masterFingerprint}`,
+    signingKey: deriveVssSigningKeyFromMnemonic(mnemonic.trim()),
+    backupMode: "Blocking"
+  };
+}
+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__namespace.default.join(targetDir, layer1Network, masterFingerprint)
+  });
+  const { walletPath: utexoPath } = restoreFromVss({
+    config: utexoConfig,
+    targetDir: path3__namespace.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__namespace.default.existsSync(backupPath) || !fs2__namespace.default.statSync(backupPath).isDirectory()) {
+    throw new ValidationError("backupPath must be an existing directory", "backupPath");
+  }
+  const files = fs2__namespace.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__namespace.default.join(backupPath, layer1File);
+  const utexoBackupFile = path3__namespace.default.join(backupPath, utexoFile);
+  if (!fs2__namespace.default.existsSync(layer1BackupFile) || !fs2__namespace.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__namespace.default.join(targetDir, layer1Network, masterFingerprint);
+  const utexoDataDir = path3__namespace.default.join(targetDir, utexoNetwork, masterFingerprint);
+  for (const dir of [layer1DataDir, utexoDataDir]) {
+    if (!fs2__namespace.default.existsSync(path3__namespace.default.dirname(dir))) {
+      fs2__namespace.default.mkdirSync(path3__namespace.default.dirname(dir), { recursive: true });
+    }
+    if (!fs2__namespace.default.existsSync(dir)) {
+      fs2__namespace.default.mkdirSync(dir, { recursive: true });
+    }
+  }
+  restoreWallet({ backupFilePath: layer1BackupFile, password, dataDir: layer1DataDir });
+  restoreWallet({ backupFilePath: utexoBackupFile, password, dataDir: utexoDataDir });
+  return {
+    layer1Path: layer1DataDir,
+    utexoPath: utexoDataDir,
+    targetDir
+  };
+}
+
+// src/utexo/utexo-wallet.ts
+var UTEXOWallet = class extends UTEXOProtocol {
+  /**
+   * Creates a new UTEXOWallet instance
+   * @param mnemonicOrSeed - Either a mnemonic phrase (string) or seed (Uint8Array)
+   * @param options - Optional configuration options (defaults to { network: 'mainnet' })
+   */
+  constructor(mnemonicOrSeed, options = {}) {
+    super();
+    this.layer1Keys = null;
+    this.utexoKeys = null;
+    this.layer1RGBWallet = null;
+    this.utexoRGBWallet = null;
+    this.mnemonicOrSeed = mnemonicOrSeed;
+    this.options = options;
+    const preset = options.network ?? "testnet";
+    const networkConfig = getUtxoNetworkConfig(preset);
+    this.networkMap = networkConfig.networkMap;
+    this.networkIdMap = networkConfig.networkIdMap;
+    this.bridge = getBridgeAPI(preset);
+  }
+  async initialize() {
+    this.layer1Keys = await this.derivePublicKeys(this.networkMap.mainnet);
+    this.utexoKeys = await this.derivePublicKeys(this.networkMap.utexo);
+    const fp = this.utexoKeys.masterFingerprint;
+    const dataDir = this.options.dataDir;
+    this.utexoRGBWallet = new WalletManager({
+      xpubVan: this.utexoKeys.accountXpubVanilla,
+      xpubCol: this.utexoKeys.accountXpubColored,
+      masterFingerprint: this.utexoKeys.masterFingerprint,
+      network: this.networkMap.utexo,
+      mnemonic: this.mnemonicOrSeed,
+      dataDir: dataDir ? path3__namespace.default.join(dataDir, String(this.networkMap.utexo), fp) : void 0
+    });
+    this.layer1RGBWallet = new WalletManager({
+      xpubVan: this.layer1Keys.accountXpubVanilla,
+      xpubCol: this.layer1Keys.accountXpubVanilla,
+      masterFingerprint: this.layer1Keys.masterFingerprint,
+      network: this.networkMap.mainnet,
+      mnemonic: this.mnemonicOrSeed,
+      dataDir: dataDir ? path3__namespace.default.join(dataDir, String(this.networkMap.mainnet), fp) : void 0
+    });
+  }
+  /**
+   * Derive public keys from mnemonic or seed
+   * @param network - BitcoinNetwork identifier 
+   * @returns Promise resolving to PublicKeys containing xpub, accountXpubVanilla, accountXpubColored, and masterFingerprint
+   * @throws {ValidationError} If mnemonic is invalid
+   */
+  async derivePublicKeys(network) {
+    const generatedKeys = await deriveKeysFromMnemonicOrSeed(network, this.mnemonicOrSeed);
+    const { xpub, accountXpubVanilla, accountXpubColored, masterFingerprint } = generatedKeys;
+    return { xpub, accountXpubVanilla, accountXpubColored, masterFingerprint };
+  }
+  async getPubKeys() {
+    if (!this.layer1Keys) {
+      throw new ValidationError("Public keys are not set", "publicKeys");
+    }
+    return this.layer1Keys;
+  }
+  /**
+   * Guard method to ensure wallet is initialized
+   * @throws {WalletError} if wallet is not initialized
+   */
+  ensureInitialized() {
+    if (!this.utexoRGBWallet) {
+      throw new WalletError("Wallet not initialized. Call initialize() first.");
+    }
+  }
+  // ==========================================
+  // IWalletManager Implementation
+  // ==========================================
+  async goOnline(indexerUrl, skipConsistencyCheck) {
+    this.ensureInitialized();
+    throw new Error("goOnline not implemented");
+  }
+  getXpub() {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.getXpub();
+  }
+  getNetwork() {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.getNetwork();
+  }
+  async dispose() {
+    if (this.layer1RGBWallet) {
+      await this.layer1RGBWallet.dispose();
+    }
+    if (this.utexoRGBWallet) {
+      await this.utexoRGBWallet.dispose();
+    }
+  }
+  isDisposed() {
+    if (!this.utexoRGBWallet) {
+      return false;
+    }
+    return this.utexoRGBWallet.isDisposed();
+  }
+  async getBtcBalance() {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.getBtcBalance();
+  }
+  async getAddress() {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.getAddress();
+  }
+  async listUnspents() {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.listUnspents();
+  }
+  async createUtxosBegin(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.createUtxosBegin(params);
+  }
+  async createUtxosEnd(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.createUtxosEnd(params);
+  }
+  async createUtxos(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.createUtxos(params);
+  }
+  async listAssets() {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.listAssets();
+  }
+  async getAssetBalance(asset_id) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.getAssetBalance(asset_id);
+  }
+  async issueAssetNia(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.issueAssetNia(params);
+  }
+  async issueAssetIfa(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.issueAssetIfa(params);
+  }
+  async inflateBegin(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.inflateBegin(params);
+  }
+  async inflateEnd(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.inflateEnd(params);
+  }
+  async inflate(params, mnemonic) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.inflate(params, mnemonic);
+  }
+  async sendBegin(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.sendBegin(params);
+  }
+  async sendEnd(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.sendEnd(params);
+  }
+  async send(invoiceTransfer, mnemonic) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.send(invoiceTransfer, mnemonic);
+  }
+  async sendBtcBegin(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.sendBtcBegin(params);
+  }
+  async sendBtcEnd(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.sendBtcEnd(params);
+  }
+  async sendBtc(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.sendBtc(params);
+  }
+  async blindReceive(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.blindReceive(params);
+  }
+  async witnessReceive(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.witnessReceive(params);
+  }
+  async decodeRGBInvoice(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.decodeRGBInvoice(params);
+  }
+  async listTransactions() {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.listTransactions();
+  }
+  async listTransfers(asset_id) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.listTransfers(asset_id);
+  }
+  async failTransfers(params) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.failTransfers(params);
+  }
+  async refreshWallet() {
+    this.ensureInitialized();
+    this.utexoRGBWallet.refreshWallet();
+  }
+  async syncWallet() {
+    this.ensureInitialized();
+    this.utexoRGBWallet.syncWallet();
+  }
+  async estimateFeeRate(blocks) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.estimateFeeRate(blocks);
+  }
+  async estimateFee(psbtBase64) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.estimateFee(psbtBase64);
+  }
+  /**
+   * Create backup for both layer1 and utexo stores in one folder.
+   * Writes backupPath/wallet_{masterFingerprint}_layer1.backup and backupPath/wallet_{masterFingerprint}_utexo.backup
+   * (same naming convention as VSS: storeId_layer1, storeId_utexo with storeId = wallet_<fp>).
+   * Use restoreUtxoWalletFromBackup with the same backupPath to restore both.
+   */
+  async createBackup(params) {
+    this.ensureInitialized();
+    const { backupPath, password } = params;
+    if (!backupPath || !password) {
+      throw new ValidationError("backupPath and password are required", "createBackup");
+    }
+    const fp = this.utexoKeys.masterFingerprint;
+    const { layer1TmpDir, utexoTmpDir, layer1FinalPath, utexoFinalPath } = prepareUtxoBackupDirs(backupPath, fp);
+    const layer1Result = await this.layer1RGBWallet.createBackup({ backupPath: layer1TmpDir, password });
+    const utexoResult = await this.utexoRGBWallet.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
+    };
+  }
+  async configureVssBackup(config) {
+    this.ensureInitialized();
+    const { layer1, utexo } = getVssConfigs(config);
+    await this.layer1RGBWallet.configureVssBackup(layer1);
+    await this.utexoRGBWallet.configureVssBackup(utexo);
+  }
+  async disableVssAutoBackup() {
+    this.ensureInitialized();
+    await this.layer1RGBWallet.disableVssAutoBackup();
+    await this.utexoRGBWallet.disableVssAutoBackup();
+  }
+  /**
+   * Run VSS backup for both layer1 and utexo stores.
+   * Config is optional: when omitted, builds config from mnemonic (option param or wallet mnemonic)
+   * and options.vssServerUrl (or DEFAULT_VSS_SERVER_URL if not set).
+   *
+   * @param config - Optional; when omitted, built from mnemonic and vssServerUrl
+   * @param mnemonic - Optional; when omitted, uses wallet mnemonic (only if wallet was created with mnemonic string)
+   */
+  async vssBackup(config, mnemonic) {
+    this.ensureInitialized();
+    let vssConfig;
+    if (config) {
+      vssConfig = config;
+    } else {
+      const mnemonicToUse = mnemonic ?? (typeof this.mnemonicOrSeed === "string" ? this.mnemonicOrSeed : null);
+      if (!mnemonicToUse) {
+        throw new ValidationError(
+          "mnemonic is required for VSS backup when config is not passed (wallet was created with seed)",
+          "mnemonic"
+        );
+      }
+      const serverUrl = this.options.vssServerUrl ?? DEFAULT_VSS_SERVER_URL;
+      const preset = this.options.network ?? "mainnet";
+      vssConfig = await buildVssConfigFromMnemonic(mnemonicToUse.trim(), serverUrl, preset);
+    }
+    const { layer1, utexo } = getVssConfigs(vssConfig);
+    await this.layer1RGBWallet.vssBackup(layer1);
+    const version = await this.utexoRGBWallet.vssBackup(utexo);
+    return version;
+  }
+  /**
+   * Get VSS backup info. Config is optional; when omitted, built from mnemonic (param or wallet)
+   * and options.vssServerUrl (or DEFAULT_VSS_SERVER_URL if not set).
+   */
+  async vssBackupInfo(config, mnemonic) {
+    this.ensureInitialized();
+    let vssConfig;
+    if (config) {
+      vssConfig = config;
+    } else {
+      const mnemonicToUse = mnemonic ?? (typeof this.mnemonicOrSeed === "string" ? this.mnemonicOrSeed : null);
+      if (!mnemonicToUse) {
+        throw new ValidationError("config or mnemonic required for vssBackupInfo", "config");
+      }
+      const serverUrl = this.options.vssServerUrl ?? DEFAULT_VSS_SERVER_URL;
+      const preset = this.options.network ?? "mainnet";
+      vssConfig = await buildVssConfigFromMnemonic(mnemonicToUse.trim(), serverUrl, preset);
+    }
+    const { utexo } = getVssConfigs(vssConfig);
+    return this.utexoRGBWallet.vssBackupInfo(utexo);
+  }
+  async signPsbt(psbt, mnemonic) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.signPsbt(psbt, mnemonic);
+  }
+  async signMessage(message) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.signMessage(message);
+  }
+  async verifyMessage(message, signature, accountXpub) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.verifyMessage(message, signature, accountXpub);
+  }
+  /**
+  * Validates that the wallet has sufficient spendable balance for the given asset and amount.
+  * @param assetId - Asset ID to check balance for
+  * @param amount - Required amount (in asset units)
+  * @throws {ValidationError} If balance is not found or insufficient
+  */
+  async validateBalance(assetId, amount) {
+    const assetBalance = await this.getAssetBalance(assetId);
+    if (!assetBalance || !assetBalance.spendable) {
+      throw new ValidationError("Asset balance is not found", "assetBalance");
+    }
+    if (assetBalance.spendable < amount) {
+      throw new ValidationError(`Insufficient balance ${assetBalance.spendable} < ${amount}`, "amount");
+    }
+  }
+  /**
+   * Extracts invoice data and destination asset from a bridge transfer.
+   * 
+   * @param bridgeTransfer - Bridge transfer response containing recipient invoice and token info
+   * @returns Object containing invoice string, decoded invoice data, and destination asset
+   * @throws {ValidationError} If destination asset is not supported
+   */
+  async extractInvoiceAndAsset(bridgeTransfer) {
+    const utexoInvoice = bridgeTransfer.recipient.address;
+    const invoiceData = await this.decodeRGBInvoice({ invoice: utexoInvoice });
+    const destinationAsset = this.networkIdMap.utexo.getAssetById(bridgeTransfer.recipientToken.id);
+    if (!destinationAsset) {
+      throw new ValidationError("Destination asset is not supported", "assetId");
+    }
+    return { utexoInvoice, invoiceData, destinationAsset };
+  }
+  /**
+   * IUTEXOProtocol Implementation
+   */
+  async onchainReceive(params) {
+    this.ensureInitialized();
+    const destinationAsset = getDestinationAsset("mainnet", "utexo", params.assetId ?? null);
+    if (!destinationAsset) {
+      throw new ValidationError("Destination asset is not supported", "assetId");
+    }
+    if (!params.amount) {
+      throw new ValidationError("Amount is required", "amount");
+    }
+    const destinationInvoice = await this.utexoRGBWallet.witnessReceive({
+      assetId: "",
+      //invoice can receive any asset
+      amount: params.amount,
+      minConfirmations: params.minConfirmations,
+      durationSeconds: params.durationSeconds
+    });
+    const bridgeTransfer = await this.bridge.getBridgeInSignature({
+      sender: {
+        address: "rgb-address",
+        networkName: this.networkIdMap.mainnet.networkName,
+        networkId: this.networkIdMap.mainnet.networkId
+      },
+      tokenId: destinationAsset.tokenId,
+      amount: params.amount.toString(),
+      destination: {
+        address: destinationInvoice.invoice,
+        networkName: this.networkIdMap.utexo.networkName,
+        networkId: this.networkIdMap.utexo.networkId
+      },
+      additionalAddresses: []
+    });
+    const decodedInvoice = decodeBridgeInvoice(bridgeTransfer.signature);
+    return {
+      invoice: decodedInvoice
+    };
+  }
+  async onchainSendBegin(params) {
+    this.ensureInitialized();
+    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(params.invoice, this.networkIdMap.mainnet.networkId);
+    if (!bridgeTransfer) {
+      console.log("External invoice UTEXO -> Mainnet initiated");
+      return this.UTEXOToMainnetRGB(params);
+    }
+    const utexoInvoice = bridgeTransfer.recipient.address;
+    const invoiceData = await this.decodeRGBInvoice({ invoice: utexoInvoice });
+    const bridgeAmount = bridgeTransfer.recipientAmount;
+    const destinationAsset = this.networkIdMap.utexo.getAssetById(bridgeTransfer.recipientToken.id);
+    if (!destinationAsset) {
+      throw new ValidationError("Destination asset is not supported", "assetId");
+    }
+    const amount = toUnitsNumber(bridgeAmount, destinationAsset.precision);
+    const isWitness = invoiceData.recipientId.includes("wvout:");
+    await this.validateBalance(destinationAsset.assetId, amount);
+    const psbt = await this.utexoRGBWallet.sendBegin({
+      invoice: utexoInvoice,
+      amount,
+      assetId: destinationAsset.assetId,
+      donation: true,
+      ...isWitness && {
+        witnessData: {
+          amountSat: 1e3,
+          blinding: 0
+        }
+      }
+    });
+    return psbt;
+  }
+  async onchainSendEnd(params) {
+    this.ensureInitialized();
+    const sendResult = await this.utexoRGBWallet.sendEnd({ signedPsbt: params.signedPsbt });
+    return sendResult;
+  }
+  async onchainSend(params, mnemonic) {
+    this.ensureInitialized();
+    const psbt = await this.onchainSendBegin(params);
+    const signed_psbt = await this.utexoRGBWallet.signPsbt(psbt, mnemonic);
+    return await this.onchainSendEnd({ signedPsbt: signed_psbt, invoice: params.invoice });
+  }
+  async getOnchainSendStatus(invoice) {
+    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(invoice, this.networkIdMap.mainnet.networkId);
+    if (!bridgeTransfer) {
+      const withdrawTransfer = await this.bridge.getWithdrawTransfer(invoice, this.networkIdMap.utexo.networkId);
+      if (!withdrawTransfer) {
+        return null;
+      }
+      return withdrawTransfer.status;
+    }
+    const { invoiceData, destinationAsset } = await this.extractInvoiceAndAsset(bridgeTransfer);
+    const transfers = await this.utexoRGBWallet.listTransfers(destinationAsset.assetId);
+    const transfer = transfers.find((transfer2) => transfer2.recipientId === invoiceData.recipientId);
+    if (transfer) {
+      return transfer.status;
+    }
+    if (bridgeTransfer) {
+      return bridgeTransfer.status;
+    }
+    return null;
+  }
+  async listOnchainTransfers(asset_id) {
+    this.ensureInitialized();
+    return this.utexoRGBWallet.listTransfers(asset_id);
+  }
+  async createLightningInvoice(params) {
+    this.ensureInitialized();
+    const asset = params.asset;
+    if (!asset) {
+      throw new ValidationError("Asset is required", "asset");
+    }
+    if (!asset.assetId) {
+      throw new ValidationError("Asset ID is required", "assetId");
+    }
+    if (!asset.amount) {
+      throw new ValidationError("Amount is required", "amount");
+    }
+    const destinationAsset = getDestinationAsset("mainnet", "utexo", asset.assetId);
+    if (!destinationAsset) {
+      throw new ValidationError("Destination asset is not supported", "assetId");
+    }
+    const destinationInvoice = await this.utexoRGBWallet.witnessReceive({
+      assetId: "",
+      //invoice can receive any asset
+      amount: asset.amount
+    });
+    const bridgeTransfer = await this.bridge.getBridgeInSignature({
+      sender: {
+        address: "rgb-address",
+        networkName: this.networkIdMap.mainnetLightning.networkName,
+        networkId: this.networkIdMap.mainnetLightning.networkId
+      },
+      tokenId: destinationAsset.tokenId,
+      amount: asset.amount.toString(),
+      destination: {
+        address: destinationInvoice.invoice,
+        networkName: this.networkIdMap.utexo.networkName,
+        networkId: this.networkIdMap.utexo.networkId
+      },
+      additionalAddresses: []
+    });
+    const decodedLnInvoice = decodeBridgeInvoice(bridgeTransfer.signature);
+    return {
+      lnInvoice: decodedLnInvoice
+    };
+  }
+  async payLightningInvoiceBegin(params) {
+    this.ensureInitialized();
+    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(params.lnInvoice, this.networkIdMap.mainnetLightning.networkId);
+    if (!bridgeTransfer) {
+      console.log("External invoice UTEXO -> Mainnet Lightning initiated");
+      return this.UtexoToMainnetLightning(params);
+    }
+    const bridgeAmount = bridgeTransfer.recipientAmount;
+    const { utexoInvoice, invoiceData, destinationAsset } = await this.extractInvoiceAndAsset(bridgeTransfer);
+    const amount = toUnitsNumber(bridgeAmount, destinationAsset.precision);
+    const isWitness = invoiceData.recipientId.includes("wvout:");
+    const psbt = await this.utexoRGBWallet.sendBegin({
+      invoice: utexoInvoice,
+      amount,
+      assetId: destinationAsset.assetId,
+      donation: true,
+      ...isWitness && {
+        witnessData: {
+          amountSat: 1e3,
+          blinding: 0
+        }
+      }
+    });
+    return psbt;
+  }
+  async payLightningInvoiceEnd(params) {
+    this.ensureInitialized();
+    const sendResult = await this.utexoRGBWallet.sendEnd({ signedPsbt: params.signedPsbt });
+    return sendResult;
+  }
+  async payLightningInvoice(params, mnemonic) {
+    this.ensureInitialized();
+    const psbt = await this.payLightningInvoiceBegin(params);
+    const signed_psbt = await this.utexoRGBWallet.signPsbt(psbt, mnemonic);
+    return await this.payLightningInvoiceEnd({ signedPsbt: signed_psbt, lnInvoice: params.lnInvoice });
+  }
+  async getLightningSendRequest(lnInvoice) {
+    this.ensureInitialized();
+    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(lnInvoice, this.networkIdMap.mainnetLightning.networkId);
+    if (!bridgeTransfer) {
+      const withdrawTransfer = await this.bridge.getWithdrawTransfer(lnInvoice, this.networkIdMap.utexo.networkId);
+      if (!withdrawTransfer) {
+        return null;
+      }
+      return withdrawTransfer.status;
+    }
+    const { invoiceData, destinationAsset } = await this.extractInvoiceAndAsset(bridgeTransfer);
+    const transfers = await this.utexoRGBWallet.listTransfers(destinationAsset.assetId);
+    return transfers.length > 0 ? transfers.find((transfer) => transfer.recipientId === invoiceData.recipientId)?.status ?? null : null;
+  }
+  async getLightningReceiveRequest(lnInvoice) {
+    this.ensureInitialized();
+    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(lnInvoice, this.networkIdMap.mainnetLightning.networkId);
+    if (!bridgeTransfer) {
+      const withdrawTransfer = await this.bridge.getWithdrawTransfer(lnInvoice, this.networkIdMap.utexo.networkId);
+      if (!withdrawTransfer) {
+        return null;
+      }
+      return withdrawTransfer.status;
+    }
+    const { invoiceData, destinationAsset } = await this.extractInvoiceAndAsset(bridgeTransfer);
+    const transfers = await this.utexoRGBWallet.listTransfers(destinationAsset.assetId);
+    return transfers.length > 0 ? transfers.find((transfer) => transfer.recipientId === invoiceData.recipientId)?.status ?? null : null;
+  }
+  async UTEXOToMainnetRGB(params) {
+    this.ensureInitialized();
+    const invoiceData = await this.decodeRGBInvoice({ invoice: params.invoice });
+    if (!params.assetId && !invoiceData.assetId) {
+      throw new ValidationError("Asset ID is required for external invoice", "assetId");
+    }
+    const assetId = params.assetId ?? invoiceData.assetId;
+    const utexoAsset = getDestinationAsset("mainnet", "utexo", assetId ?? null);
+    if (!utexoAsset) {
+      throw new ValidationError("UTEXO asset is not supported", "assetId");
+    }
+    const destinationAsset = this.networkIdMap.mainnet.getAssetById(utexoAsset?.tokenId ?? 0);
+    if (!destinationAsset) {
+      throw new ValidationError("Destination asset is not supported", "assetId");
+    }
+    if (!params.amount && !invoiceData.assignment.amount) {
+      throw new ValidationError("Amount is required for external invoice", "amount");
+    }
+    let amount;
+    if (params.amount) {
+      amount = params.amount;
+    } else if (invoiceData.assignment.amount) {
+      amount = fromUnitsNumber(invoiceData.assignment.amount, destinationAsset.precision);
+    } else {
+      throw new ValidationError("Amount is required", "amount");
+    }
+    await this.validateBalance(utexoAsset.assetId, toUnitsNumber(amount.toString(), utexoAsset.precision));
+    const payload = {
+      sender: {
+        address: "rgb-address",
+        networkName: this.networkIdMap.utexo.networkName,
+        networkId: this.networkIdMap.utexo.networkId
+      },
+      tokenId: destinationAsset.tokenId,
+      amount: amount.toString(),
+      destination: {
+        address: params.invoice,
+        networkName: this.networkIdMap.mainnet.networkName,
+        networkId: this.networkIdMap.mainnet.networkId
+      },
+      additionalAddresses: []
+    };
+    console.log("payload", payload);
+    const bridgeOutTransfer = await this.bridge.getBridgeInSignature(payload);
+    const decodedInvoice = decodeBridgeInvoice(bridgeOutTransfer.signature);
+    const isWitness = decodedInvoice.includes("wvout:");
+    const psbt = await this.utexoRGBWallet.sendBegin({
+      invoice: decodedInvoice,
+      amount: Number(bridgeOutTransfer.amount),
+      assetId: utexoAsset.assetId,
+      donation: true,
+      ...isWitness && {
+        witnessData: {
+          amountSat: 1e3,
+          blinding: 0
+        }
+      }
+    });
+    return psbt;
+  }
+  async UtexoToMainnetLightning(params) {
+    this.ensureInitialized();
+    if (!params.assetId) {
+      throw new ValidationError("Asset ID is required for external invoice", "assetId");
+    }
+    const assetId = params.assetId;
+    const utexoAsset = getDestinationAsset("mainnet", "utexo", assetId ?? null);
+    const destinationAsset = this.networkIdMap.mainnet.getAssetById(utexoAsset?.tokenId ?? 0);
+    if (!destinationAsset) {
+      throw new ValidationError("Destination asset is not supported", "assetId");
+    }
+    if (!utexoAsset) {
+      throw new ValidationError("Destination asset is not supported", "assetId");
+    }
+    if (!params.amount) {
+      throw new ValidationError("Amount is required for external invoice", "amount");
+    }
+    const amount = params.amount;
+    await this.validateBalance(utexoAsset.assetId, toUnitsNumber(amount.toString(), utexoAsset.precision));
+    const bridgeOutTransfer = await this.bridge.getBridgeInSignature({
+      sender: {
+        address: "rgb-address",
+        networkName: this.networkIdMap.utexo.networkName,
+        networkId: this.networkIdMap.utexo.networkId
+      },
+      tokenId: destinationAsset.tokenId,
+      amount: amount.toString(),
+      destination: {
+        address: params.lnInvoice,
+        networkName: this.networkIdMap.mainnetLightning.networkName,
+        networkId: this.networkIdMap.mainnetLightning.networkId
+      },
+      additionalAddresses: []
+    });
+    const decodedInvoice = decodeBridgeInvoice(bridgeOutTransfer.signature);
+    const isWitness = decodedInvoice.includes("wvout:");
+    const psbt = await this.utexoRGBWallet.sendBegin({
+      invoice: decodedInvoice,
+      amount: Number(bridgeOutTransfer.amount),
+      assetId: utexoAsset.assetId,
+      donation: true,
+      ...isWitness && {
+        witnessData: {
+          amountSat: 1e3,
+          blinding: 0
+        }
+      }
+    });
+    return psbt;
+  }
+  // TODO: Implement remaining methods as needed:
+  // - createLightningInvoice() - will use utexoRGBWallet
+  // - getLightningReceiveRequest() - will use utexoRGBWallet
+  // - getLightningSendRequest() - will use utexoRGBWallet
+  // - getLightningSendFeeEstimate() - will use utexoRGBWallet
+  // - payLightningInvoiceBegin() - will use utexoRGBWallet
+  // - payLightningInvoiceEnd() - will use utexoRGBWallet
+  // - onchainSendBegin() - will use layer1RGBWallet or utexoRGBWallet
+  // - onchainSendEnd() - will use layer1RGBWallet or utexoRGBWallet
+  // - getOnchainSendStatus() - will use layer1RGBWallet or utexoRGBWallet
+  // - listOnchainTransfers() - will use layer1RGBWallet or utexoRGBWallet
+  // - listLightningPayments() - will use utexoRGBWallet
+};
 
 // src/utils/logger.ts
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
@@ -1853,8 +3328,6 @@ function configureLogging(level) {
   logger.setLevel(level);
 }
 
-exports.AssetIface = AssetIface;
-exports.AssetSchema = AssetSchema;
 exports.BIP32_VERSIONS = BIP32_VERSIONS;
 exports.BadRequestError = BadRequestError;
 exports.COIN_BITCOIN_MAINNET = COIN_BITCOIN_MAINNET;
@@ -1868,18 +3341,21 @@ exports.DEFAULT_API_TIMEOUT = DEFAULT_API_TIMEOUT;
 exports.DEFAULT_LOG_LEVEL = DEFAULT_LOG_LEVEL;
 exports.DEFAULT_MAX_RETRIES = DEFAULT_MAX_RETRIES;
 exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
+exports.DEFAULT_VSS_SERVER_URL = DEFAULT_VSS_SERVER_URL;
 exports.DERIVATION_ACCOUNT = DERIVATION_ACCOUNT;
 exports.DERIVATION_PURPOSE = DERIVATION_PURPOSE;
 exports.KEYCHAIN_BTC = KEYCHAIN_BTC;
 exports.KEYCHAIN_RGB = KEYCHAIN_RGB;
+exports.LightningProtocol = LightningProtocol;
 exports.LogLevel = LogLevel;
 exports.NETWORK_MAP = NETWORK_MAP;
 exports.NetworkError = NetworkError;
 exports.NotFoundError = NotFoundError;
+exports.OnchainProtocol = OnchainProtocol;
 exports.RgbNodeError = RgbNodeError;
 exports.SDKError = SDKError;
-exports.TransactionType = TransactionType;
-exports.TransferStatus = TransferStatus;
+exports.UTEXOProtocol = UTEXOProtocol;
+exports.UTEXOWallet = UTEXOWallet;
 exports.ValidationError = ValidationError;
 exports.WalletError = WalletError;
 exports.WalletManager = WalletManager;
@@ -1888,10 +3364,14 @@ exports.configureLogging = configureLogging;
 exports.createWallet = createWallet;
 exports.createWalletManager = createWalletManager;
 exports.deriveKeysFromMnemonic = deriveKeysFromMnemonic;
+exports.deriveKeysFromMnemonicOrSeed = deriveKeysFromMnemonicOrSeed;
 exports.deriveKeysFromSeed = deriveKeysFromSeed;
 exports.deriveKeysFromXpriv = deriveKeysFromXpriv;
+exports.deriveVssSigningKeyFromMnemonic = deriveVssSigningKeyFromMnemonic;
 exports.generateKeys = generateKeys2;
+exports.getDestinationAsset = getDestinationAsset;
 exports.getEnvironment = getEnvironment;
+exports.getUtxoNetworkConfig = getUtxoNetworkConfig;
 exports.getXprivFromMnemonic = getXprivFromMnemonic;
 exports.getXpubFromXpriv = getXpubFromXpriv;
 exports.isBrowser = isBrowser;
@@ -1899,11 +3379,16 @@ exports.isNode = isNode;
 exports.logger = logger;
 exports.normalizeNetwork = normalizeNetwork;
 exports.restoreFromBackup = restoreFromBackup;
+exports.restoreFromVss = restoreFromVss;
 exports.restoreKeys = restoreKeys;
+exports.restoreUtxoWalletFromBackup = restoreUtxoWalletFromBackup;
+exports.restoreUtxoWalletFromVss = restoreUtxoWalletFromVss;
 exports.signMessage = signMessage;
 exports.signPsbt = signPsbt;
 exports.signPsbtFromSeed = signPsbtFromSeed;
 exports.signPsbtSync = signPsbtSync;
+exports.utexoNetworkIdMap = utexoNetworkIdMap;
+exports.utexoNetworkMap = utexoNetworkMap;
 exports.validateBase64 = validateBase64;
 exports.validateHex = validateHex;
 exports.validateMnemonic = validateMnemonic;