@utexo/rgb-sdk 1.0.5 → 1.0.6

package/dist/index.mjs

@@ -83,7 +83,7 @@ var CryptoError = class _CryptoError extends SDKError {
   }
 };
 var ConfigurationError = class _ConfigurationError extends SDKError {
-  constructor(message, field) {
+  constructor(message, _field) {
     super(message, "CONFIGURATION_ERROR");
     this.name = "ConfigurationError";
     Object.setPrototypeOf(this, _ConfigurationError.prototype);
@@ -192,12 +192,12 @@ var mainnetPreset = {
       // TODO: Update to production network ID
       assets: [
         {
-          assetId: "rgb:WPRv95Nj-icdrgPp-zpQhIp_-2TyJ~Ge-k~FvuMZ-~vVnkA0",
+          assetId: "rgb:nkHbmy97-R4cjRCe-j~VvT~E-0UQ0OW8-jOCCW6O-EqeCq9M",
           // TODO: Update to production asset ID
           tokenName: "tUSD",
           longName: "USDT",
           precision: 6,
-          tokenId: 4
+          tokenId: 3
         }
       ]
     }),
@@ -207,12 +207,12 @@ var mainnetPreset = {
       // TODO: Update to production network ID
       assets: [
         {
-          assetId: "rgb:WPRv95Nj-icdrgPp-zpQhIp_-2TyJ~Ge-k~FvuMZ-~vVnkA0",
+          assetId: "rgb:nkHbmy97-R4cjRCe-j~VvT~E-0UQ0OW8-jOCCW6O-EqeCq9M",
           // TODO: Update to production asset ID
           tokenName: "tUSD",
           longName: "USDT",
           precision: 6,
-          tokenId: 4
+          tokenId: 3
         }
       ]
     }),
@@ -222,12 +222,12 @@ var mainnetPreset = {
       // TODO: Update to production network ID
       assets: [
         {
-          assetId: "rgb:yJW4k8si-~8JdNfl-nM91qFu-r5rH_HS-1hM7jpi-L~lBf90",
+          assetId: "rgb:0yyfySrb-TArdWKB-6Y0yhUX-dbqMpN3-NnjsV2F-2fMhOI4",
           // TODO: Update to production asset ID
           tokenName: "tUSD",
           longName: "USDT",
           precision: 6,
-          tokenId: 4
+          tokenId: 3
         }
       ]
     })
@@ -244,13 +244,18 @@ function getUtxoNetworkConfig(preset) {
 }
 var utexoNetworkMap = testnetPreset.networkMap;
 var utexoNetworkIdMap = testnetPreset.networkIdMap;
-function getDestinationAsset(senderNetwork, destinationNetwork, assetIdSender) {
-  const destinationConfig = utexoNetworkIdMap[destinationNetwork];
+function getDestinationAsset(senderNetwork, destinationNetwork, assetIdSender, networkIdMap) {
+  const config = networkIdMap ?? utexoNetworkIdMap;
+  const destinationConfig = config[destinationNetwork];
   if (assetIdSender == null) return destinationConfig.assets[0];
-  const senderConfig = utexoNetworkIdMap[senderNetwork];
-  const senderAsset = senderConfig.assets.find((a) => a.assetId === assetIdSender);
+  const senderConfig = config[senderNetwork];
+  const senderAsset = senderConfig.assets.find(
+    (a) => a.assetId === assetIdSender
+  );
   if (!senderAsset) return void 0;
-  return destinationConfig.assets.find((a) => a.tokenId === senderAsset.tokenId);
+  return destinationConfig.assets.find(
+    (a) => a.tokenId === senderAsset.tokenId
+  );
 }
 
 // src/constants/network.ts
@@ -300,7 +305,13 @@ var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_LOG_LEVEL = 3;
 
 // src/utils/validation.ts
-var VALID_NETWORKS = ["mainnet", "testnet", "testnet4", "signet", "regtest"];
+var VALID_NETWORKS = [
+  "mainnet",
+  "testnet",
+  "testnet4",
+  "signet",
+  "regtest"
+];
 function validateNetwork(network) {
   const key = String(network);
   const normalized = NETWORK_MAP[key];
@@ -339,6 +350,7 @@ function validateBase64(base64, field = "data") {
   try {
     Buffer.from(base64.trim(), "base64");
   } catch (error) {
+    console.error(error);
     throw new ValidationError(`Invalid base64 encoding for ${field}`, field);
   }
 }
@@ -346,7 +358,10 @@ function validatePsbt(psbt, field = "psbt") {
   validateBase64(psbt, field);
   const psbtString = String(psbt).trim();
   if (psbtString.length < 50) {
-    throw new ValidationError(`${field} appears to be too short to be a valid PSBT`, field);
+    throw new ValidationError(
+      `${field} appears to be too short to be a valid PSBT`,
+      field
+    );
   }
 }
 function validateHex(hex, field = "data") {
@@ -370,11 +385,11 @@ function validateString(value, field) {
 }
 function mapNetworkToRgbLib(network) {
   const networkMap = {
-    "mainnet": "Mainnet",
-    "testnet": "Testnet",
-    "testnet4": "Testnet4",
-    "signet": "Signet",
-    "regtest": "Regtest"
+    mainnet: "Mainnet",
+    testnet: "Testnet",
+    testnet4: "Testnet4",
+    signet: "Signet",
+    regtest: "Regtest"
   };
   const networkStr = String(network).toLowerCase();
   return networkMap[networkStr] || "Regtest";
@@ -385,7 +400,10 @@ var restoreWallet = (params) => {
     throw new ValidationError("Backup file not found", "backup");
   }
   if (!fs2.existsSync(dataDir)) {
-    throw new ValidationError(`Restore directory does not exist: ${dataDir}`, "restoreDir");
+    throw new ValidationError(
+      `Restore directory does not exist: ${dataDir}`,
+      "restoreDir"
+    );
   }
   rgblib.restoreBackup(backupFilePath, password, dataDir);
   return {
@@ -395,7 +413,9 @@ var restoreWallet = (params) => {
 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.");
+    throw new WalletError(
+      "VSS restore is not available in the current rgb-lib build."
+    );
   }
   if (!params.targetDir) {
     throw new ValidationError("targetDir is required", "targetDir");
@@ -438,7 +458,7 @@ var RGBLibClient = class {
       accountXpubColored: this.xpubCol,
       masterFingerprint: this.masterFingerprint,
       maxAllocationsPerUtxo: "1",
-      vanillaKeychain: "1",
+      vanillaKeychain: "0",
       supportedSchemas: [
         rgblib.AssetSchema.Cfa,
         rgblib.AssetSchema.Nia,
@@ -449,7 +469,11 @@ var RGBLibClient = class {
       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);
+      throw new WalletError(
+        "Failed to initialize rgb-lib wallet",
+        void 0,
+        error
+      );
     }
   }
   /**
@@ -462,7 +486,11 @@ var RGBLibClient = class {
     try {
       this.online = this.wallet.goOnline(false, this.indexerUrl);
     } catch (error) {
-      throw new WalletError("Failed to establish online connection", void 0, error);
+      throw new WalletError(
+        "Failed to establish online connection",
+        void 0,
+        error
+      );
     }
   }
   /**
@@ -499,7 +527,14 @@ var RGBLibClient = class {
     const size = params.size !== void 0 ? String(params.size) : null;
     const feeRate = params.feeRate ? String(params.feeRate) : "1";
     const skipSync = false;
-    return this.wallet.createUtxosBegin(online, upTo, num, size, feeRate, skipSync);
+    return this.wallet.createUtxosBegin(
+      online,
+      upTo,
+      num,
+      size,
+      feeRate,
+      skipSync
+    );
   }
   createUtxosEnd(params) {
     const online = this.getOnline();
@@ -533,22 +568,33 @@ var RGBLibClient = class {
       transportEndpoints = [this.transportEndpoint];
     }
     if (!assetId) {
-      throw new ValidationError("asset_id is required for send operation", "asset_id");
+      throw new ValidationError(
+        "asset_id is required for send operation",
+        "asset_id"
+      );
     }
     if (!recipientId) {
-      throw new ValidationError("Could not extract recipient_id from invoice", "invoice");
+      throw new ValidationError(
+        "Could not extract recipient_id from invoice",
+        "invoice"
+      );
     }
     if (!amount) {
-      throw new ValidationError("amount is required for send operation", "amount");
+      throw new ValidationError(
+        "amount is required for send operation",
+        "amount"
+      );
     }
     const assignment = { Fungible: amount };
     const recipientMap = {
-      [assetId]: [{
-        recipientId,
-        witnessData,
-        assignment,
-        transportEndpoints
-      }]
+      [assetId]: [
+        {
+          recipientId,
+          witnessData,
+          assignment,
+          transportEndpoints
+        }
+      ]
     };
     const psbt = this.wallet.sendBegin(
       online,
@@ -569,16 +615,25 @@ var RGBLibClient = class {
     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");
+      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");
+      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");
+        throw new ValidationError(
+          `recipientMap["${assetId}"] must be a non-empty array of recipients`,
+          "recipientMap"
+        );
       }
     }
     const psbt = this.wallet.sendBegin(
@@ -623,8 +678,10 @@ var RGBLibClient = class {
         }
       }
       return result;
-    } catch (error) {
-      console.warn("rgb-lib estimation fee are not available, using default fee rate 2");
+    } catch (_error) {
+      console.warn(
+        "rgb-lib estimation fee are not available, using default fee rate 2"
+      );
       return 2;
     }
   }
@@ -666,14 +723,29 @@ var RGBLibClient = class {
     const amounts = params.amounts.map((a) => String(a));
     return this.wallet.issueAssetNIA(ticker, name, precision, amounts);
   }
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   issueAssetIfa(params) {
-    throw new ValidationError("issueAssetIfa is not fully supported in rgb-lib. Use RGB Node server for IFA assets.", "asset");
+    throw new ValidationError(
+      "issueAssetIfa is not fully supported in rgb-lib. Use RGB Node server for IFA assets.",
+      "asset"
+    );
   }
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   inflateBegin(params) {
-    throw new ValidationError("inflateBegin is not fully supported in rgb-lib. Use RGB Node server for inflation operations.", "asset");
+    throw new ValidationError(
+      "inflateBegin is not fully supported in rgb-lib. Use RGB Node server for inflation operations.",
+      "asset"
+    );
   }
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   inflateEnd(params) {
-    throw new ValidationError("inflateEnd is not fully supported in rgb-lib. Use RGB Node server for inflation operations.", "asset");
+    throw new ValidationError(
+      "inflateEnd is not fully supported in rgb-lib. Use RGB Node server for inflation operations.",
+      "asset"
+    );
   }
   listAssets() {
     const filterAssetSchemas = [];
@@ -719,7 +791,12 @@ var RGBLibClient = class {
     const batchTransferIdx = params.batchTransferIdx !== void 0 ? params.batchTransferIdx : null;
     const noAssetOnly = params.noAssetOnly ?? false;
     const skipSync = params.skipSync ?? false;
-    return this.wallet.failTransfers(online, batchTransferIdx, noAssetOnly, skipSync);
+    return this.wallet.failTransfers(
+      online,
+      batchTransferIdx,
+      noAssetOnly,
+      skipSync
+    );
   }
   deleteTransfers(params) {
     const batchTransferIdx = params.batchTransferIdx !== void 0 ? params.batchTransferIdx : null;
@@ -738,9 +815,15 @@ var RGBLibClient = class {
       throw new ValidationError("password is required", "password");
     }
     if (!fs2.existsSync(params.backupPath)) {
-      throw new ValidationError(`Backup directory does not exist: ${params.backupPath}`, "backupPath");
+      throw new ValidationError(
+        `Backup directory does not exist: ${params.backupPath}`,
+        "backupPath"
+      );
     }
-    const fullBackupPath = path3.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",
@@ -755,7 +838,9 @@ var RGBLibClient = class {
     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.");
+      throw new WalletError(
+        "VSS backup is not available in the current rgb-lib build."
+      );
     }
     return { walletAny, anyLib };
   }
@@ -765,7 +850,9 @@ var RGBLibClient = class {
   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.");
+      throw new WalletError(
+        "VSS backup is not available in the current rgb-lib build."
+      );
     }
     const mappedConfig = {
       server_url: config.serverUrl,
@@ -789,7 +876,9 @@ var RGBLibClient = class {
   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.");
+      throw new WalletError(
+        "VSS backup is not available in the current rgb-lib build."
+      );
     }
     walletAny.disableVssAutoBackup();
   }
@@ -884,14 +973,18 @@ function convertToArrayBuffer(data) {
       const uint8 = new Uint8Array(data);
       return uint8.buffer;
     } catch (error) {
-      throw new Error(`convertToArrayBuffer: Failed to convert data to ArrayBuffer: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(
+        `convertToArrayBuffer: Failed to convert data to ArrayBuffer: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   try {
     const uint8 = new Uint8Array(data);
     return uint8.buffer;
   } catch (error) {
-    throw new Error(`convertToArrayBuffer: Failed to convert data to ArrayBuffer: ${error instanceof Error ? error.message : String(error)}`);
+    throw new Error(
+      `convertToArrayBuffer: Failed to convert data to ArrayBuffer: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
 }
 async function sha256(data) {
@@ -1013,14 +1106,18 @@ function normalizeSeedBuffer(seed) {
         try {
           seedBuffer = new Uint8Array(seed);
         } catch (error) {
-          throw new CryptoError(`Failed to convert seed to Uint8Array (buffer property invalid): ${error instanceof Error ? error.message : String(error)}`);
+          throw new CryptoError(
+            `Failed to convert seed to Uint8Array (buffer property invalid): ${error instanceof Error ? error.message : String(error)}`
+          );
         }
       }
     } else {
       try {
         seedBuffer = new Uint8Array(seed);
       } catch (error) {
-        throw new CryptoError(`Failed to convert seed to Uint8Array: ${error instanceof Error ? error.message : String(error)}`);
+        throw new CryptoError(
+          `Failed to convert seed to Uint8Array: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
     }
   } else {
@@ -1050,7 +1147,9 @@ async function loadBaseDependencies() {
     const { createRequire } = await import(nodeModule);
     const requireFromModule = createRequire(import.meta.url);
     const bip392 = requireFromModule("bip39");
-    const eccModule2 = requireFromModule("@bitcoinerlab/secp256k1");
+    const eccModule2 = requireFromModule(
+      "@bitcoinerlab/secp256k1"
+    );
     const ecc2 = eccModule2 && typeof eccModule2 === "object" && "default" in eccModule2 ? eccModule2.default : eccModule2;
     const bip322 = requireFromModule("bip32");
     return {
@@ -1101,7 +1200,9 @@ async function loadSignerDependencies() {
     const Psbt2 = bitcoinjs.Psbt;
     const payments2 = bitcoinjs.payments;
     const networks2 = bitcoinjs.networks;
-    const bip3412 = requireFromModule("bitcoinjs-lib/src/payments/bip341.js");
+    const bip3412 = requireFromModule(
+      "bitcoinjs-lib/src/payments/bip341.js"
+    );
     const toXOnly2 = bip3412.toXOnly || ((pubkey) => Buffer.from(pubkey.slice(1)));
     return {
       ...base,
@@ -1154,14 +1255,23 @@ function normalizeSeedInput(seed, field = "seed") {
   if (typeof seed === "string") {
     const trimmed = seed.trim();
     if (!trimmed) {
-      throw new ValidationError(`${field} must be a non-empty hex string`, field);
+      throw new ValidationError(
+        `${field} must be a non-empty hex string`,
+        field
+      );
     }
     const hex = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
     if (hex.length % 2 !== 0) {
-      throw new ValidationError(`${field} hex string must have even length`, field);
+      throw new ValidationError(
+        `${field} hex string must have even length`,
+        field
+      );
     }
     if (hex.length !== 128) {
-      throw new ValidationError(`${field} must be 64 bytes (128 hex characters)`, field);
+      throw new ValidationError(
+        `${field} must be 64 bytes (128 hex characters)`,
+        field
+      );
     }
     if (!/^[0-9a-fA-F]+$/.test(hex)) {
       throw new ValidationError(`${field} must be a valid hex string`, field);
@@ -1179,7 +1289,10 @@ function normalizeSeedInput(seed, field = "seed") {
     }
     return new Uint8Array(seed);
   }
-  throw new ValidationError(`${field} must be a 64-byte hex string or Uint8Array`, field);
+  throw new ValidationError(
+    `${field} must be a 64-byte hex string or Uint8Array`,
+    field
+  );
 }
 function getCoinType(bitcoinNetwork, rgb) {
   const net = toNetworkName(bitcoinNetwork);
@@ -1275,7 +1388,10 @@ async function buildKeysOutputFromSeed(seed, bitcoinNetwork) {
   try {
     root = bip32.fromSeed(seedBuffer, versions);
   } catch (error) {
-    throw new CryptoError("Failed to create BIP32 root node from seed", error);
+    throw new CryptoError(
+      "Failed to create BIP32 root node from seed",
+      error
+    );
   }
   return buildGeneratedKeysFromRoot(root, normalizedNetwork, "");
 }
@@ -1295,7 +1411,9 @@ async function generateKeys2(bitcoinNetwork = "regtest") {
   try {
     const { bip39 } = await ensureBaseDependencies();
     if (!bip39 || typeof bip39.generateMnemonic !== "function") {
-      throw new Error("bip39 not loaded. Dependencies may not have initialized correctly.");
+      throw new Error(
+        "bip39 not loaded. Dependencies may not have initialized correctly."
+      );
     }
     const mnemonic = bip39.generateMnemonic(128);
     return await buildKeysOutput(mnemonic, bitcoinNetwork);
@@ -1304,8 +1422,10 @@ async function generateKeys2(bitcoinNetwork = "regtest") {
       throw new CryptoError("Failed to load dependencies", error);
     }
     const errorMessage = error instanceof Error ? error.message : String(error);
-    error instanceof Error ? error.stack : void 0;
-    throw new CryptoError(`Failed to generate mnemonic: ${errorMessage}`, error);
+    throw new CryptoError(
+      `Failed to generate mnemonic: ${errorMessage}`,
+      error
+    );
   }
 }
 async function deriveKeysFromMnemonic(bitcoinNetwork = "regtest", mnemonic) {
@@ -1315,14 +1435,20 @@ async function deriveKeysFromMnemonic(bitcoinNetwork = "regtest", mnemonic) {
     const { bip39 } = await ensureBaseDependencies();
     const trimmedMnemonic = mnemonic.trim();
     if (!bip39 || !bip39.validateMnemonic(trimmedMnemonic)) {
-      throw new ValidationError("Invalid mnemonic format - failed BIP39 validation", "mnemonic");
+      throw new ValidationError(
+        "Invalid mnemonic format - failed BIP39 validation",
+        "mnemonic"
+      );
     }
     return await buildKeysOutput(trimmedMnemonic, normalizedNetwork);
   } catch (error) {
     if (error instanceof ValidationError) {
       throw error;
     }
-    throw new CryptoError("Failed to derive keys from mnemonic", error);
+    throw new CryptoError(
+      "Failed to derive keys from mnemonic",
+      error
+    );
   }
 }
 async function deriveKeysFromSeed(bitcoinNetwork = "regtest", seed) {
@@ -1370,7 +1496,10 @@ async function getXprivFromMnemonic(bitcoinNetwork = "regtest", mnemonic) {
     if (error instanceof ValidationError) {
       throw error;
     }
-    throw new CryptoError("Failed to derive xpriv from mnemonic", error);
+    throw new CryptoError(
+      "Failed to derive xpriv from mnemonic",
+      error
+    );
   }
 }
 async function getXpubFromXpriv(xpriv, bitcoinNetwork) {
@@ -1405,17 +1534,31 @@ async function accountXpubsFromMnemonic(bitcoinNetwork = "regtest", mnemonic) {
   try {
     const { bip39 } = await ensureBaseDependencies();
     if (!bip39 || !bip39.validateMnemonic(mnemonic)) {
-      throw new ValidationError("Invalid mnemonic format - failed BIP39 validation", "mnemonic");
+      throw new ValidationError(
+        "Invalid mnemonic format - failed BIP39 validation",
+        "mnemonic"
+      );
     }
     return {
-      account_xpub_vanilla: await getAccountXpub(mnemonic, bitcoinNetwork, false),
-      account_xpub_colored: await getAccountXpub(mnemonic, bitcoinNetwork, true)
+      account_xpub_vanilla: await getAccountXpub(
+        mnemonic,
+        bitcoinNetwork,
+        false
+      ),
+      account_xpub_colored: await getAccountXpub(
+        mnemonic,
+        bitcoinNetwork,
+        true
+      )
     };
   } catch (error) {
     if (error instanceof ValidationError) {
       throw error;
     }
-    throw new CryptoError("Failed to derive account xpubs from mnemonic", error);
+    throw new CryptoError(
+      "Failed to derive account xpubs from mnemonic",
+      error
+    );
   }
 }
 
@@ -1475,7 +1618,10 @@ function preprocessPsbtForBDK(psbtBase64, rootNode, fp, network, deps) {
           }
           const pubkeyBuffer = pubkey instanceof Buffer ? pubkey : Buffer.from(pubkey);
           const xOnly = toXOnly(pubkeyBuffer);
-          const p2tr = payments.p2tr({ internalPubkey: xOnly, network: bjsNet });
+          const p2tr = payments.p2tr({
+            internalPubkey: xOnly,
+            network: bjsNet
+          });
           const expectedScript = p2tr.output;
           if (!expectedScript) {
             return;
@@ -1503,7 +1649,7 @@ function preprocessPsbtForBDK(psbtBase64, rootNode, fp, network, deps) {
           if (!deriv.pubkey || !deriv.pubkey.equals(xOnly)) {
             deriv.pubkey = xOnly;
           }
-        } catch (e) {
+        } catch (_e) {
         }
       });
     }
@@ -1535,7 +1681,7 @@ function detectPsbtType(psbtBase64, deps) {
       }
     }
     return "create_utxo";
-  } catch (e) {
+  } catch (_e) {
     return "create_utxo";
   }
 }
@@ -1585,12 +1731,20 @@ async function signPsbtFromSeedInternal(seed, psbtBase64, network, options = {},
   try {
     rootNode = bip32.fromSeed(seedBuffer, versions);
   } catch (error) {
-    throw new CryptoError("Failed to derive root node from seed", error);
+    throw new CryptoError(
+      "Failed to derive root node from seed",
+      error
+    );
   }
   const fp = await getMasterFingerprint(rootNode);
   const psbtType = detectPsbtType(psbtBase64, deps);
   const needsPreprocessing = psbtType === "send";
-  const { external, internal } = deriveDescriptors(rootNode, fp, network, psbtType);
+  const { external, internal } = deriveDescriptors(
+    rootNode,
+    fp,
+    network,
+    psbtType
+  );
   let wallet2;
   try {
     wallet2 = bdk.Wallet.create(network, external, internal);
@@ -1600,7 +1754,13 @@ async function signPsbtFromSeedInternal(seed, psbtBase64, network, options = {},
   let processedPsbt = psbtBase64.trim();
   if (needsPreprocessing || options.preprocess) {
     try {
-      processedPsbt = preprocessPsbtForBDK(psbtBase64, rootNode, fp, network, deps);
+      processedPsbt = preprocessPsbtForBDK(
+        psbtBase64,
+        rootNode,
+        fp,
+        network,
+        deps
+      );
     } catch (error) {
       throw new CryptoError("Failed to preprocess PSBT", error);
     }
@@ -1629,17 +1789,26 @@ async function signPsbt(mnemonic, psbtBase64, network = "testnet", options = {})
     let seed;
     try {
       seed = bip39.mnemonicToSeedSync(mnemonic);
-    } catch (error) {
+    } catch (_error) {
       throw new ValidationError("Invalid mnemonic format", "mnemonic");
     }
     const normalizedNetwork = normalizeNetwork(network);
     const deps = await ensureSignerDependencies();
-    return await signPsbtFromSeedInternal(seed, psbtBase64, normalizedNetwork, options, deps);
+    return await signPsbtFromSeedInternal(
+      seed,
+      psbtBase64,
+      normalizedNetwork,
+      options,
+      deps
+    );
   } catch (error) {
     if (error instanceof ValidationError || error instanceof CryptoError) {
       throw error;
     }
-    throw new CryptoError("Unexpected error during PSBT signing", error);
+    throw new CryptoError(
+      "Unexpected error during PSBT signing",
+      error
+    );
   }
 }
 async function signPsbtSync(mnemonic, psbtBase64, network = "testnet", options = {}) {
@@ -1649,7 +1818,13 @@ async function signPsbtFromSeed(seed, psbtBase64, network = "testnet", options =
   const normalizedSeed = normalizeSeedInput(seed);
   const normalizedNetwork = normalizeNetwork(network);
   const deps = await ensureSignerDependencies();
-  return signPsbtFromSeedInternal(normalizedSeed, psbtBase64, normalizedNetwork, options, deps);
+  return signPsbtFromSeedInternal(
+    normalizedSeed,
+    psbtBase64,
+    normalizedNetwork,
+    options,
+    deps
+  );
 }
 function ensureMessageInput(message) {
   if (typeof message === "string") {
@@ -1664,7 +1839,10 @@ function ensureMessageInput(message) {
     }
     return Buffer.from(message);
   }
-  throw new ValidationError("message must be a string or Uint8Array", "message");
+  throw new ValidationError(
+    "message must be a string or Uint8Array",
+    "message"
+  );
 }
 async function deriveRootFromSeedInput(seed, network) {
   const { ecc, factory } = await ensureBaseDependencies();
@@ -1674,7 +1852,10 @@ async function deriveRootFromSeedInput(seed, network) {
   try {
     return bip32.fromSeed(normalizedSeed, versions);
   } catch (error) {
-    throw new CryptoError("Failed to create BIP32 root node from seed", error);
+    throw new CryptoError(
+      "Failed to create BIP32 root node from seed",
+      error
+    );
   }
 }
 var DEFAULT_RELATIVE_PATH = "0/0";
@@ -1699,7 +1880,9 @@ async function signMessage(params) {
     throw new CryptoError("Schnorr signing not supported by ECC module");
   }
   const messageHash = await sha256(messageBytes);
-  const signature = Buffer.from(ecc.signSchnorr(messageHash, privateKey)).toString("base64");
+  const signature = Buffer.from(
+    ecc.signSchnorr(messageHash, privateKey)
+  ).toString("base64");
   return signature;
 }
 async function verifyMessage(params) {
@@ -1716,7 +1899,7 @@ async function verifyMessage(params) {
   let accountNode;
   try {
     accountNode = factory(ecc).fromBase58(accountXpub, versions);
-  } catch (error) {
+  } catch (_error) {
     throw new ValidationError("Invalid account xpub provided", "accountXpub");
   }
   const child = accountNode.derivePath(relativePath);
@@ -1759,11 +1942,7 @@ function deriveVssSigningKeyFromMnemonic(mnemonic) {
   return Array.from(digest).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 var restoreFromBackup = (params) => {
-  const {
-    backupFilePath,
-    password,
-    dataDir
-  } = params;
+  const { backupFilePath, password, dataDir } = params;
   if (!backupFilePath) {
     throw new ValidationError("backup file is required", "backup");
   }
@@ -1792,7 +1971,10 @@ var WalletManager = class {
       throw new ValidationError("xpubCol is required", "xpubCol");
     }
     if (!params.masterFingerprint) {
-      throw new ValidationError("masterFingerprint is required", "masterFingerprint");
+      throw new ValidationError(
+        "masterFingerprint is required",
+        "masterFingerprint"
+      );
     }
     this.network = normalizeNetwork(params.network ?? "regtest");
     this.xpubVan = params.xpubVan;
@@ -1801,7 +1983,12 @@ var WalletManager = class {
     this.mnemonic = params.mnemonic ?? null;
     this.xpub = params.xpub ?? null;
     this.masterFingerprint = params.masterFingerprint;
-    this.dataDir = params.dataDir ?? path3__default.join(process.cwd(), ".rgb-wallet", this.network, 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,
@@ -1815,7 +2002,7 @@ var WalletManager = class {
   async initialize() {
     console.log("initializing is not reqire");
   }
-  async goOnline(indexerUrl, skipConsistencyCheck) {
+  async goOnline() {
     this.client.getOnline();
   }
   /**
@@ -2098,7 +2285,9 @@ var WalletManager = class {
     if (this.seed) {
       return await signPsbtFromSeed(this.seed, psbt, this.network);
     }
-    throw new WalletError("mnemonic is required. Provide it as parameter or initialize wallet with mnemonic.");
+    throw new WalletError(
+      "mnemonic is required. Provide it as parameter or initialize wallet with mnemonic."
+    );
   }
   /**
    * Complete send operation: begin → sign → end
@@ -2111,7 +2300,12 @@ var WalletManager = class {
     const signedPsbt = await this.signPsbt(psbt, mnemonic);
     return await this.sendEnd({ signedPsbt });
   }
-  async createUtxos({ upTo, num, size, feeRate }) {
+  async createUtxos({
+    upTo,
+    num,
+    size,
+    feeRate
+  }) {
     this.ensureNotDisposed();
     const psbt = await this.createUtxosBegin({ upTo, num, size, feeRate });
     const signedPsbt = await this.signPsbt(psbt);
@@ -2126,7 +2320,9 @@ var WalletManager = class {
       throw new ValidationError("message is required", "message");
     }
     if (!this.seed) {
-      throw new WalletError("Wallet seed is required for message signing. Initialize the wallet with a seed.");
+      throw new WalletError(
+        "Wallet seed is required for message signing. Initialize the wallet with a seed."
+      );
     }
     return signMessage({
       message,
@@ -2144,7 +2340,7 @@ var WalletManager = class {
     return verifyMessage({
       message,
       signature,
-      accountXpub: this.xpubVan,
+      accountXpub: accountXpub ?? this.xpubVan,
       network: this.network
     });
   }
@@ -2164,25 +2360,25 @@ var wallet = new Proxy({}, {
 
 // src/utexo/utexo-protocol.ts
 var LightningProtocol = class {
-  async createLightningInvoice(params) {
+  async createLightningInvoice(_params) {
     throw new Error("createLightningInvoice not implemented");
   }
-  async getLightningReceiveRequest(id) {
+  async getLightningReceiveRequest(_id) {
     throw new Error("getLightningReceiveRequest not implemented");
   }
-  async getLightningSendRequest(id) {
+  async getLightningSendRequest(_id) {
     throw new Error("getLightningSendRequest not implemented");
   }
-  async getLightningSendFeeEstimate(params) {
+  async getLightningSendFeeEstimate(_params) {
     throw new Error("getLightningSendFeeEstimate not implemented");
   }
-  async payLightningInvoiceBegin(params) {
+  async payLightningInvoiceBegin(_params) {
     throw new Error("payLightningInvoiceBegin not implemented");
   }
-  async payLightningInvoiceEnd(params) {
+  async payLightningInvoiceEnd(_params) {
     throw new Error("payLightningInvoiceEnd not implemented");
   }
-  async payLightningInvoice(params, mnemonic) {
+  async payLightningInvoice(_params, _mnemonic) {
     throw new Error("payLightningInvoice not implemented");
   }
   async listLightningPayments() {
@@ -2190,22 +2386,22 @@ var LightningProtocol = class {
   }
 };
 var OnchainProtocol = class {
-  async onchainReceive(params) {
+  async onchainReceive(_params) {
     throw new Error("onchainReceive not implemented");
   }
-  async onchainSendBegin(params) {
+  async onchainSendBegin(_params) {
     throw new Error("onchainSendBegin not implemented");
   }
-  async onchainSendEnd(params) {
+  async onchainSendEnd(_params) {
     throw new Error("onchainSendEnd not implemented");
   }
-  async onchainSend(params, mnemonic) {
+  async onchainSend(_params, _mnemonic) {
     throw new Error("onchainSend not implemented");
   }
-  async getOnchainSendStatus(send_id) {
+  async getOnchainSendStatus(_send_id) {
     throw new Error("getOnchainSendStatus not implemented");
   }
-  async listOnchainTransfers(asset_id) {
+  async listOnchainTransfers(_asset_id) {
     throw new Error("listOnchainTransfers not implemented");
   }
 };
@@ -2236,7 +2432,7 @@ var UTEXOProtocol = class extends LightningProtocol {
 
 // src/utexo/config/gateway.ts
 var DEFAULT_GATEWAY_BASE_URLS = {
-  mainnet: "https://gateway.utexo.tricorn.network/",
+  mainnet: "https://gateway.utexo.utexo.com/",
   testnet: "https://dev.gateway.utexo.tricorn.network/"
 };
 
@@ -2261,19 +2457,19 @@ var encodeTransferStatus = (transferStatus) => {
 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);
    * ```
    */
@@ -2283,7 +2479,7 @@ var UtexoBridgeApiClient = class {
   }
   /**
    * 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
@@ -2306,7 +2502,7 @@ var UtexoBridgeApiClient = class {
   }
   /**
    * 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
@@ -2320,7 +2516,7 @@ var UtexoBridgeApiClient = class {
   }
   /**
    * 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
@@ -2330,7 +2526,7 @@ var UtexoBridgeApiClient = class {
   }
   /**
    * Gets receiver invoice by transfer ID and network ID
-   * 
+   *
    * @param transferId - Transfer ID
    * @param networkId - Network ID
    * @returns Promise resolving to invoice string
@@ -2343,21 +2539,21 @@ var UtexoBridgeApiClient = class {
     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"
-        }
+    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);
+    const withdrawTransfer = data.transfers.map((transfer) => ({
+      ...transfer,
+      status: TransferStatuses[encodeTransferStatus(transfer.status)]
+    })).find((transfer) => transfer.recipient.address === invoice);
     if (!withdrawTransfer) {
       return null;
     }
@@ -2365,7 +2561,7 @@ var UtexoBridgeApiClient = class {
   }
   /**
    * Gets transfer information by mainnet invoice
-   * 
+   *
    * @param mainnetInvoice - Mainnet invoice string
    * @param networkId - Network ID
    * @returns Promise resolving to transfer information
@@ -2383,10 +2579,13 @@ var UtexoBridgeApiClient = class {
         }
       );
       if (data) {
-        return { ...data, status: TransferStatuses[encodeTransferStatus(data.status)] };
+        return {
+          ...data,
+          status: TransferStatuses[encodeTransferStatus(data.status)]
+        };
       }
       return data;
-    } catch (error) {
+    } catch (_error) {
       console.log("Mainnet invoice not found");
       return null;
     }
@@ -2456,12 +2655,25 @@ function prepareUtxoBackupDirs(backupPath, masterFingerprint) {
     storeId,
     layer1TmpDir,
     utexoTmpDir,
-    layer1FinalPath: path3__default.join(backupPath, `${storeId}_layer1${BACKUP_FILE_SUFFIX}`),
-    utexoFinalPath: path3__default.join(backupPath, `${storeId}_utexo${BACKUP_FILE_SUFFIX}`)
+    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;
+  const {
+    layer1BackupPath,
+    utexoBackupPath,
+    layer1FinalPath,
+    utexoFinalPath,
+    layer1TmpDir,
+    utexoTmpDir
+  } = params;
   fs2__default.renameSync(layer1BackupPath, layer1FinalPath);
   fs2__default.renameSync(utexoBackupPath, utexoFinalPath);
   fs2__default.rmdirSync(layer1TmpDir);
@@ -2477,7 +2689,13 @@ async function buildVssConfigFromMnemonic(mnemonic, serverUrl, networkPreset = "
   };
 }
 async function restoreUtxoWalletFromVss(params) {
-  const { mnemonic, targetDir, config: providedConfig, networkPreset = "testnet", vssServerUrl } = params;
+  const {
+    mnemonic,
+    targetDir,
+    config: providedConfig,
+    networkPreset = "testnet",
+    vssServerUrl
+  } = params;
   if (!mnemonic || !mnemonic.trim()) {
     throw new ValidationError("mnemonic is required", "mnemonic");
   }
@@ -2485,13 +2703,23 @@ async function restoreUtxoWalletFromVss(params) {
     throw new ValidationError("targetDir is required", "targetDir");
   }
   const serverUrl = vssServerUrl ?? DEFAULT_VSS_SERVER_URL;
-  const config = providedConfig ?? await buildVssConfigFromMnemonic(mnemonic.trim(), serverUrl, networkPreset);
+  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 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)
@@ -2505,10 +2733,16 @@ async function restoreUtxoWalletFromVss(params) {
 function restoreUtxoWalletFromBackup(params) {
   const { backupPath, password, targetDir, networkPreset = "testnet" } = params;
   if (!backupPath || !password || !targetDir) {
-    throw new ValidationError("backupPath, password, and targetDir are required", "restoreUtxoWalletFromBackup");
+    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");
+    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));
@@ -2545,8 +2779,16 @@ function restoreUtxoWalletFromBackup(params) {
       fs2__default.mkdirSync(dir, { recursive: true });
     }
   }
-  restoreWallet({ backupFilePath: layer1BackupFile, password, dataDir: layer1DataDir });
-  restoreWallet({ backupFilePath: utexoBackupFile, password, dataDir: utexoDataDir });
+  restoreWallet({
+    backupFilePath: layer1BackupFile,
+    password,
+    dataDir: layer1DataDir
+  });
+  restoreWallet({
+    backupFilePath: utexoBackupFile,
+    password,
+    dataDir: utexoDataDir
+  });
   return {
     layer1Path: layer1DataDir,
     utexoPath: utexoDataDir,
@@ -2569,7 +2811,7 @@ var UTEXOWallet = class extends UTEXOProtocol {
     this.utexoRGBWallet = null;
     this.mnemonicOrSeed = mnemonicOrSeed;
     this.options = options;
-    const preset = options.network ?? "testnet";
+    const preset = options.network ?? "mainnet";
     const networkConfig = getUtxoNetworkConfig(preset);
     this.networkMap = networkConfig.networkMap;
     this.networkIdMap = networkConfig.networkIdMap;
@@ -2590,7 +2832,7 @@ var UTEXOWallet = class extends UTEXOProtocol {
     });
     this.layer1RGBWallet = new WalletManager({
       xpubVan: this.layer1Keys.accountXpubVanilla,
-      xpubCol: this.layer1Keys.accountXpubVanilla,
+      xpubCol: this.layer1Keys.accountXpubColored,
       masterFingerprint: this.layer1Keys.masterFingerprint,
       network: this.networkMap.mainnet,
       mnemonic: this.mnemonicOrSeed,
@@ -2599,12 +2841,15 @@ var UTEXOWallet = class extends UTEXOProtocol {
   }
   /**
    * Derive public keys from mnemonic or seed
-   * @param network - BitcoinNetwork identifier 
+   * @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 generatedKeys = await deriveKeysFromMnemonicOrSeed(
+      network,
+      this.mnemonicOrSeed
+    );
     const { xpub, accountXpubVanilla, accountXpubColored, masterFingerprint } = generatedKeys;
     return { xpub, accountXpubVanilla, accountXpubColored, masterFingerprint };
   }
@@ -2626,7 +2871,7 @@ var UTEXOWallet = class extends UTEXOProtocol {
   // ==========================================
   // IWalletManager Implementation
   // ==========================================
-  async goOnline(indexerUrl, skipConsistencyCheck) {
+  async goOnline() {
     this.ensureInitialized();
     throw new Error("goOnline not implemented");
   }
@@ -2778,12 +3023,21 @@ var UTEXOWallet = class extends UTEXOProtocol {
     this.ensureInitialized();
     const { backupPath, password } = params;
     if (!backupPath || !password) {
-      throw new ValidationError("backupPath and password are required", "createBackup");
+      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 });
+    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,
@@ -2833,7 +3087,11 @@ var UTEXOWallet = class extends UTEXOProtocol {
       }
       const serverUrl = this.options.vssServerUrl ?? DEFAULT_VSS_SERVER_URL;
       const preset = this.options.network ?? "mainnet";
-      vssConfig = await buildVssConfigFromMnemonic(mnemonicToUse.trim(), serverUrl, preset);
+      vssConfig = await buildVssConfigFromMnemonic(
+        mnemonicToUse.trim(),
+        serverUrl,
+        preset
+      );
     }
     const { layer1, utexo } = getVssConfigs(vssConfig);
     await this.layer1RGBWallet.vssBackup(layer1);
@@ -2852,11 +3110,18 @@ var UTEXOWallet = class extends UTEXOProtocol {
     } else {
       const mnemonicToUse = mnemonic ?? (typeof this.mnemonicOrSeed === "string" ? this.mnemonicOrSeed : null);
       if (!mnemonicToUse) {
-        throw new ValidationError("config or mnemonic required for vssBackupInfo", "config");
+        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);
+      vssConfig = await buildVssConfigFromMnemonic(
+        mnemonicToUse.trim(),
+        serverUrl,
+        preset
+      );
     }
     const { utexo } = getVssConfigs(vssConfig);
     return this.utexoRGBWallet.vssBackupInfo(utexo);
@@ -2874,23 +3139,26 @@ var UTEXOWallet = class extends UTEXOProtocol {
     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
-  */
+   * 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");
+      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
@@ -2898,9 +3166,14 @@ var UTEXOWallet = class extends UTEXOProtocol {
   async extractInvoiceAndAsset(bridgeTransfer) {
     const utexoInvoice = bridgeTransfer.recipient.address;
     const invoiceData = await this.decodeRGBInvoice({ invoice: utexoInvoice });
-    const destinationAsset = this.networkIdMap.utexo.getAssetById(bridgeTransfer.recipientToken.id);
+    const destinationAsset = this.networkIdMap.utexo.getAssetById(
+      bridgeTransfer.recipientToken.id
+    );
     if (!destinationAsset) {
-      throw new ValidationError("Destination asset is not supported", "assetId");
+      throw new ValidationError(
+        "Destination asset is not supported",
+        "assetId"
+      );
     }
     return { utexoInvoice, invoiceData, destinationAsset };
   }
@@ -2909,9 +3182,17 @@ var UTEXOWallet = class extends UTEXOProtocol {
    */
   async onchainReceive(params) {
     this.ensureInitialized();
-    const destinationAsset = getDestinationAsset("mainnet", "utexo", params.assetId ?? null);
+    const destinationAsset = getDestinationAsset(
+      "mainnet",
+      "utexo",
+      params.assetId ?? null,
+      this.networkIdMap
+    );
     if (!destinationAsset) {
-      throw new ValidationError("Destination asset is not supported", "assetId");
+      throw new ValidationError(
+        "Destination asset is not supported",
+        "assetId"
+      );
     }
     if (!params.amount) {
       throw new ValidationError("Amount is required", "amount");
@@ -2945,7 +3226,10 @@ var UTEXOWallet = class extends UTEXOProtocol {
   }
   async onchainSendBegin(params) {
     this.ensureInitialized();
-    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(params.invoice, this.networkIdMap.mainnet.networkId);
+    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);
@@ -2953,9 +3237,14 @@ var UTEXOWallet = class extends UTEXOProtocol {
     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);
+    const destinationAsset = this.networkIdMap.utexo.getAssetById(
+      bridgeTransfer.recipientToken.id
+    );
     if (!destinationAsset) {
-      throw new ValidationError("Destination asset is not supported", "assetId");
+      throw new ValidationError(
+        "Destination asset is not supported",
+        "assetId"
+      );
     }
     const amount = toUnitsNumber(bridgeAmount, destinationAsset.precision);
     const isWitness = invoiceData.recipientId.includes("wvout:");
@@ -2976,27 +3265,46 @@ var UTEXOWallet = class extends UTEXOProtocol {
   }
   async onchainSendEnd(params) {
     this.ensureInitialized();
-    const sendResult = await this.utexoRGBWallet.sendEnd({ signedPsbt: params.signedPsbt });
+    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 });
+    return await this.onchainSendEnd({
+      signedPsbt: signed_psbt,
+      invoice: params.invoice
+    });
   }
   async getOnchainSendStatus(invoice) {
-    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(invoice, this.networkIdMap.mainnet.networkId);
+    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(
+      invoice,
+      this.networkIdMap.mainnet.networkId
+    );
     if (!bridgeTransfer) {
-      const withdrawTransfer = await this.bridge.getWithdrawTransfer(invoice, this.networkIdMap.utexo.networkId);
+      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);
+    const assets = await this.utexoRGBWallet.listAssets();
+    const walletAsset = assets.nia.find(
+      (a) => a.assetId === destinationAsset.assetId
+    );
+    const transfers = await this.utexoRGBWallet.listTransfers(
+      walletAsset?.assetId
+    );
+    const transfer = transfers.find(
+      (transfer2) => transfer2.recipientId === invoiceData.recipientId
+    );
     if (transfer) {
       return transfer.status;
     }
@@ -3021,9 +3329,17 @@ var UTEXOWallet = class extends UTEXOProtocol {
     if (!asset.amount) {
       throw new ValidationError("Amount is required", "amount");
     }
-    const destinationAsset = getDestinationAsset("mainnet", "utexo", asset.assetId);
+    const destinationAsset = getDestinationAsset(
+      "mainnet",
+      "utexo",
+      asset.assetId,
+      this.networkIdMap
+    );
     if (!destinationAsset) {
-      throw new ValidationError("Destination asset is not supported", "assetId");
+      throw new ValidationError(
+        "Destination asset is not supported",
+        "assetId"
+      );
     }
     const destinationInvoice = await this.utexoRGBWallet.witnessReceive({
       assetId: "",
@@ -3052,7 +3368,10 @@ var UTEXOWallet = class extends UTEXOProtocol {
   }
   async payLightningInvoiceBegin(params) {
     this.ensureInitialized();
-    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(params.lnInvoice, this.networkIdMap.mainnetLightning.networkId);
+    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);
@@ -3077,70 +3396,119 @@ var UTEXOWallet = class extends UTEXOProtocol {
   }
   async payLightningInvoiceEnd(params) {
     this.ensureInitialized();
-    const sendResult = await this.utexoRGBWallet.sendEnd({ signedPsbt: params.signedPsbt });
+    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 });
+    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);
+    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(
+      lnInvoice,
+      this.networkIdMap.mainnetLightning.networkId
+    );
     if (!bridgeTransfer) {
-      const withdrawTransfer = await this.bridge.getWithdrawTransfer(lnInvoice, this.networkIdMap.utexo.networkId);
+      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;
+    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);
+    const bridgeTransfer = await this.bridge.getTransferByMainnetInvoice(
+      lnInvoice,
+      this.networkIdMap.mainnetLightning.networkId
+    );
     if (!bridgeTransfer) {
-      const withdrawTransfer = await this.bridge.getWithdrawTransfer(lnInvoice, this.networkIdMap.utexo.networkId);
+      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;
+    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 });
+    const invoiceData = await this.decodeRGBInvoice({
+      invoice: params.invoice
+    });
     if (!params.assetId && !invoiceData.assetId) {
-      throw new ValidationError("Asset ID is required for external invoice", "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);
+    const utexoAsset = getDestinationAsset(
+      "mainnet",
+      "utexo",
+      assetId ?? null,
+      this.networkIdMap
+    );
     if (!utexoAsset) {
       throw new ValidationError("UTEXO asset is not supported", "assetId");
     }
-    const destinationAsset = this.networkIdMap.mainnet.getAssetById(utexoAsset?.tokenId ?? 0);
+    const destinationAsset = this.networkIdMap.mainnet.getAssetById(
+      utexoAsset?.tokenId ?? 0
+    );
     if (!destinationAsset) {
-      throw new ValidationError("Destination asset is not supported", "assetId");
+      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");
+      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);
+      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));
+    await this.validateBalance(
+      utexoAsset.assetId,
+      toUnitsNumber(amount.toString(), utexoAsset.precision)
+    );
     const payload = {
       sender: {
         address: "rgb-address",
@@ -3177,22 +3545,44 @@ var UTEXOWallet = class extends UTEXOProtocol {
   async UtexoToMainnetLightning(params) {
     this.ensureInitialized();
     if (!params.assetId) {
-      throw new ValidationError("Asset ID is required for external invoice", "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);
+    const utexoAsset = getDestinationAsset(
+      "mainnet",
+      "utexo",
+      assetId ?? null,
+      this.networkIdMap
+    );
+    const destinationAsset = this.networkIdMap.mainnet.getAssetById(
+      utexoAsset?.tokenId ?? 0
+    );
     if (!destinationAsset) {
-      throw new ValidationError("Destination asset is not supported", "assetId");
+      throw new ValidationError(
+        "Destination asset is not supported",
+        "assetId"
+      );
     }
     if (!utexoAsset) {
-      throw new ValidationError("Destination asset is not supported", "assetId");
+      throw new ValidationError(
+        "Destination asset is not supported",
+        "assetId"
+      );
     }
     if (!params.amount) {
-      throw new ValidationError("Amount is required for external invoice", "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));
+    await this.validateBalance(
+      utexoAsset.assetId,
+      toUnitsNumber(amount.toString(), utexoAsset.precision)
+    );
     const bridgeOutTransfer = await this.bridge.getBridgeInSignature({
       sender: {
         address: "rgb-address",