@utexo/rgb-sdk 1.0.3 → 1.0.5

package/dist/index.mjs

@@ -1,12 +1,31 @@
-import * as path from 'path';
-import path__default from 'path';
-import * as fs from 'fs';
+import * as path3 from 'path';
+import path3__default from 'path';
+import * as fs2 from 'fs';
+import fs2__default from 'fs';
 import rgblib from '@utexo/rgb-lib';
 import * as noble from '@noble/hashes/legacy.js';
-import * as os from 'os';
+import { hmac } from '@noble/hashes/hmac.js';
+import { sha256 as sha256$1 } from '@noble/hashes/sha2.js';
+import axios from '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) {
@@ -105,6 +124,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;
@@ -220,7 +368,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",
@@ -234,10 +381,10 @@ function mapNetworkToRgbLib(network) {
 }
 var restoreWallet = (params) => {
   const { backupFilePath, password, dataDir } = params;
-  if (!fs.existsSync(backupFilePath)) {
+  if (!fs2.existsSync(backupFilePath)) {
     throw new ValidationError("Backup file not found", "backup");
   }
-  if (!fs.existsSync(dataDir)) {
+  if (!fs2.existsSync(dataDir)) {
     throw new ValidationError(`Restore directory does not exist: ${dataDir}`, "restoreDir");
   }
   rgblib.restoreBackup(backupFilePath, password, dataDir);
@@ -245,6 +392,26 @@ var restoreWallet = (params) => {
     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 RGBLibClient = class {
   constructor(params) {
     this.online = null;
@@ -254,21 +421,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.existsSync(this.dataDir)) {
-      fs.mkdirSync(this.dataDir, { recursive: true });
+    if (!fs2.existsSync(this.dataDir)) {
+      fs2.mkdirSync(this.dataDir, { recursive: true });
     }
     const walletData = {
       dataDir: this.dataDir,
@@ -288,6 +448,7 @@ var RGBLibClient = class {
     try {
       this.wallet = new rgblib.Wallet(new rgblib.WalletData(walletData));
     } catch (error) {
+      console.log("error", error);
       throw new WalletError("Failed to initialize rgb-lib wallet", void 0, error);
     }
   }
@@ -299,7 +460,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);
@@ -349,10 +509,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;
@@ -400,6 +559,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;
@@ -503,7 +693,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) {
@@ -546,16 +737,105 @@ var RGBLibClient = class {
     if (!params.password) {
       throw new ValidationError("password is required", "password");
     }
-    if (!fs.existsSync(params.backupPath)) {
+    if (!fs2.existsSync(params.backupPath)) {
       throw new ValidationError(`Backup directory does not exist: ${params.backupPath}`, "backupPath");
     }
-    const fullBackupPath = path.join(params.backupPath, `${this.masterFingerprint}.backup`);
+    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.
+   */
+  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
    */
@@ -932,8 +1212,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) {
@@ -1057,6 +1337,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);
 }
@@ -1119,28 +1420,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}`;
       }
@@ -1449,6 +1750,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(sha256$1, keyBytes, messageBytes);
+  return Array.from(digest).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
 var restoreFromBackup = (params) => {
   const {
     backupFilePath,
@@ -1492,7 +1801,7 @@ var WalletManager = class {
     this.mnemonic = params.mnemonic ?? null;
     this.xpub = params.xpub ?? null;
     this.masterFingerprint = params.masterFingerprint;
-    this.dataDir = params.dataDir ?? path__default.join(os.tmpdir(), "rgb-wallet", this.masterFingerprint);
+    this.dataDir = params.dataDir ?? path3__default.join(process.cwd(), ".rgb-wallet", this.network, this.masterFingerprint);
     this.client = new RGBLibClient({
       xpubVan: params.xpubVan,
       xpubCol: params.xpubCol,
@@ -1503,6 +1812,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
    */
@@ -1523,7 +1838,7 @@ var WalletManager = class {
    * Clears mnemonic and seed from memory
    * Idempotent - safe to call multiple times
    */
-  dispose() {
+  async dispose() {
     if (this.disposed) {
       return;
     }
@@ -1555,73 +1870,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);
   }
   /**
@@ -1637,24 +2039,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
@@ -1680,16 +2109,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) {
@@ -1734,33 +2162,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.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__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 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__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
+  };
+}
+
+// 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__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__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) => {
@@ -1825,6 +3301,6 @@ function configureLogging(level) {
   logger.setLevel(level);
 }
 
-export { AssetIface, AssetSchema, 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, DERIVATION_ACCOUNT, DERIVATION_PURPOSE, KEYCHAIN_BTC, KEYCHAIN_RGB, LogLevel, NETWORK_MAP, NetworkError, NotFoundError, RgbNodeError, SDKError, TransactionType, TransferStatus, ValidationError, WalletError, WalletManager, accountXpubsFromMnemonic, configureLogging, createWallet, createWalletManager, deriveKeysFromMnemonic, deriveKeysFromSeed, deriveKeysFromXpriv, generateKeys2 as generateKeys, getEnvironment, getXprivFromMnemonic, getXpubFromXpriv, isBrowser, isNode, logger, normalizeNetwork, restoreFromBackup, restoreKeys, signMessage, signPsbt, signPsbtFromSeed, signPsbtSync, validateBase64, validateHex, validateMnemonic, validateNetwork, validatePsbt, validateRequired, validateString, verifyMessage, wallet };
+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, UTEXOWallet, ValidationError, WalletError, WalletManager, accountXpubsFromMnemonic, configureLogging, createWallet, createWalletManager, deriveKeysFromMnemonic, deriveKeysFromMnemonicOrSeed, deriveKeysFromSeed, deriveKeysFromXpriv, deriveVssSigningKeyFromMnemonic, generateKeys2 as generateKeys, getDestinationAsset, getEnvironment, getUtxoNetworkConfig, getXprivFromMnemonic, getXpubFromXpriv, isBrowser, isNode, logger, normalizeNetwork, restoreFromBackup, restoreFromVss, restoreKeys, restoreUtxoWalletFromBackup, restoreUtxoWalletFromVss, signMessage, signPsbt, signPsbtFromSeed, signPsbtSync, utexoNetworkIdMap, utexoNetworkMap, validateBase64, validateHex, validateMnemonic, validateNetwork, validatePsbt, validateRequired, validateString, verifyMessage, wallet };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map