@utexo/rgb-sdk 1.0.1

package/dist/index.mjs

@@ -0,0 +1,1830 @@
+import * as path from 'path';
+import path__default from 'path';
+import * as fs from 'fs';
+import * as rgblib from 'rgb-lib';
+import * as noble from '@noble/hashes/legacy.js';
+import * as os from 'os';
+
+// src/client/rgb-lib-client.ts
+
+// src/errors/index.ts
+var SDKError = class _SDKError extends Error {
+  constructor(message, code, statusCode, cause) {
+    super(message);
+    this.name = "SDKError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.cause = cause;
+    Object.setPrototypeOf(this, _SDKError.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _SDKError);
+    }
+  }
+  /**
+   * Convert error to JSON for logging
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      statusCode: this.statusCode,
+      cause: this.cause?.message,
+      stack: this.stack
+    };
+  }
+};
+var NetworkError = class _NetworkError extends SDKError {
+  constructor(message, statusCode, cause) {
+    super(message, "NETWORK_ERROR", statusCode, cause);
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends SDKError {
+  constructor(message, field) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+    this.field = field;
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var WalletError = class _WalletError extends SDKError {
+  constructor(message, code, cause) {
+    super(message, code || "WALLET_ERROR", void 0, cause);
+    this.name = "WalletError";
+    Object.setPrototypeOf(this, _WalletError.prototype);
+  }
+};
+var CryptoError = class _CryptoError extends SDKError {
+  constructor(message, cause) {
+    super(message, "CRYPTO_ERROR", void 0, cause);
+    this.name = "CryptoError";
+    Object.setPrototypeOf(this, _CryptoError.prototype);
+  }
+};
+var ConfigurationError = class _ConfigurationError extends SDKError {
+  constructor(message, field) {
+    super(message, "CONFIGURATION_ERROR");
+    this.name = "ConfigurationError";
+    Object.setPrototypeOf(this, _ConfigurationError.prototype);
+  }
+};
+var BadRequestError = class _BadRequestError extends SDKError {
+  constructor(message, cause) {
+    super(message, "BAD_REQUEST", 400, cause);
+    this.name = "BadRequestError";
+    Object.setPrototypeOf(this, _BadRequestError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends SDKError {
+  constructor(message, cause) {
+    super(message, "NOT_FOUND", 404, cause);
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var ConflictError = class _ConflictError extends SDKError {
+  constructor(message, cause) {
+    super(message, "CONFLICT", 409, cause);
+    this.name = "ConflictError";
+    Object.setPrototypeOf(this, _ConflictError.prototype);
+  }
+};
+var RgbNodeError = class _RgbNodeError extends SDKError {
+  constructor(message, statusCode, cause) {
+    super(message, "RGB_NODE_ERROR", statusCode, cause);
+    this.name = "RgbNodeError";
+    Object.setPrototypeOf(this, _RgbNodeError.prototype);
+  }
+};
+
+// src/constants/derivation.ts
+var DERIVATION_PURPOSE = 86;
+var DERIVATION_ACCOUNT = 0;
+var KEYCHAIN_RGB = 0;
+var KEYCHAIN_BTC = 0;
+
+// src/constants/network.ts
+var COIN_RGB_MAINNET = 827166;
+var COIN_RGB_TESTNET = 827167;
+var COIN_BITCOIN_MAINNET = 0;
+var COIN_BITCOIN_TESTNET = 1;
+var NETWORK_MAP = {
+  "0": "mainnet",
+  "1": "testnet",
+  "2": "testnet",
+  // Alternative testnet number (also maps to testnet)
+  "3": "regtest",
+  "signet": "signet",
+  "mainnet": "mainnet",
+  "testnet": "testnet",
+  "testnet4": "testnet4",
+  "regtest": "regtest"
+};
+var BIP32_VERSIONS = {
+  mainnet: {
+    public: 76067358,
+    private: 76066276
+  },
+  testnet: {
+    public: 70617039,
+    private: 70615956
+  },
+  testnet4: {
+    public: 70617039,
+    private: 70615956
+  },
+  signet: {
+    public: 70617039,
+    private: 70615956
+  },
+  regtest: {
+    public: 70617039,
+    private: 70615956
+  }
+};
+
+// src/constants/defaults.ts
+var DEFAULT_NETWORK = "regtest";
+var DEFAULT_API_TIMEOUT = 12e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_LOG_LEVEL = 3;
+
+// src/utils/validation.ts
+var VALID_NETWORKS = ["mainnet", "testnet", "testnet4", "signet", "regtest"];
+function validateNetwork(network) {
+  const key = String(network);
+  const normalized = NETWORK_MAP[key];
+  if (!normalized || !VALID_NETWORKS.includes(normalized)) {
+    throw new ValidationError(
+      `Invalid network: ${network}. Must be one of: ${VALID_NETWORKS.join(", ")}`,
+      "network"
+    );
+  }
+}
+function normalizeNetwork(network) {
+  validateNetwork(network);
+  const key = String(network);
+  return NETWORK_MAP[key];
+}
+function validateMnemonic(mnemonic, field = "mnemonic") {
+  if (!mnemonic || typeof mnemonic !== "string" || mnemonic.trim().length === 0) {
+    throw new ValidationError(`${field} must be a non-empty string`, field);
+  }
+  const words = mnemonic.trim().split(/\s+/);
+  if (words.length !== 12 && words.length !== 24) {
+    throw new ValidationError(
+      `${field} must be 12 or 24 words, got ${words.length} words`,
+      field
+    );
+  }
+}
+function validateBase64(base64, field = "data") {
+  if (!base64 || typeof base64 !== "string" || base64.trim().length === 0) {
+    throw new ValidationError(`${field} must be a non-empty string`, field);
+  }
+  const base64Regex = /^[A-Za-z0-9+/=]+$/;
+  if (!base64Regex.test(base64.trim())) {
+    throw new ValidationError(`Invalid base64 format for ${field}`, field);
+  }
+  try {
+    Buffer.from(base64.trim(), "base64");
+  } catch (error) {
+    throw new ValidationError(`Invalid base64 encoding for ${field}`, field);
+  }
+}
+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);
+  }
+}
+function validateHex(hex, field = "data") {
+  if (!hex || typeof hex !== "string" || hex.trim().length === 0) {
+    throw new ValidationError(`${field} must be a non-empty string`, field);
+  }
+  const hexRegex = /^[0-9a-fA-F]+$/;
+  if (!hexRegex.test(hex.trim())) {
+    throw new ValidationError(`Invalid hex format for ${field}`, field);
+  }
+}
+function validateRequired(value, field) {
+  if (value === null || value === void 0) {
+    throw new ValidationError(`${field} is required`, field);
+  }
+}
+function validateString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    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",
+    "testnet": "Testnet",
+    "testnet4": "Testnet4",
+    "signet": "Signet",
+    "regtest": "Regtest"
+  };
+  const networkStr = String(network).toLowerCase();
+  return networkMap[networkStr] || "Regtest";
+}
+var restoreWallet = (params) => {
+  const { backupFilePath, password, dataDir } = params;
+  if (!fs.existsSync(backupFilePath)) {
+    throw new ValidationError("Backup file not found", "backup");
+  }
+  if (!fs.existsSync(dataDir)) {
+    throw new ValidationError(`Restore directory does not exist: ${dataDir}`, "restoreDir");
+  }
+  rgblib.restoreBackup(backupFilePath, password, dataDir);
+  return {
+    message: "Wallet restored successfully"
+  };
+};
+var RGBLibClient = class {
+  constructor(params) {
+    this.online = null;
+    this.xpubVan = params.xpubVan;
+    this.xpubCol = params.xpubCol;
+    this.masterFingerprint = params.masterFingerprint;
+    this.originalNetwork = params.network;
+    this.network = normalizeNetwork(this.originalNetwork);
+    this.dataDir = params.dataDir;
+    this.transportEndpoint = params.transportEndpoint || DEFAULT_TRANSPORT_ENDPOINT;
+    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"];
+    }
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true });
+    }
+    const walletData = {
+      dataDir: this.dataDir,
+      bitcoinNetwork: mapNetworkToRgbLib(this.originalNetwork),
+      databaseType: rgblib.DatabaseType.Sqlite,
+      accountXpubVanilla: this.xpubVan,
+      accountXpubColored: this.xpubCol,
+      masterFingerprint: this.masterFingerprint,
+      maxAllocationsPerUtxo: "1",
+      vanillaKeychain: "1",
+      supportedSchemas: [
+        rgblib.AssetSchema.Cfa,
+        rgblib.AssetSchema.Nia,
+        rgblib.AssetSchema.Uda
+      ]
+    };
+    try {
+      this.wallet = new rgblib.Wallet(new rgblib.WalletData(walletData));
+    } catch (error) {
+      throw new WalletError("Failed to initialize rgb-lib wallet", void 0, error);
+    }
+  }
+  /**
+   * Ensure online connection is established
+   */
+  ensureOnline() {
+    if (this.online) {
+      return;
+    }
+    try {
+      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);
+    }
+  }
+  /**
+   * Get online object, creating it if needed
+   */
+  getOnline() {
+    this.ensureOnline();
+    return this.online;
+  }
+  registerWallet() {
+    const online = this.getOnline();
+    const address = this.wallet.getAddress();
+    const btcBalance = this.wallet.getBtcBalance(online, false);
+    return {
+      address,
+      btcBalance
+    };
+  }
+  getBtcBalance() {
+    const online = this.getOnline();
+    return this.wallet.getBtcBalance(online, false);
+  }
+  getAddress() {
+    return this.wallet.getAddress();
+  }
+  listUnspents() {
+    const online = this.getOnline();
+    return this.wallet.listUnspents(online, false, false);
+  }
+  createUtxosBegin(params) {
+    const online = this.getOnline();
+    const upTo = params.upTo ?? false;
+    const num = params.num !== void 0 ? String(params.num) : null;
+    const size = params.size !== void 0 ? String(params.size) : null;
+    const feeRate = params.feeRate ? String(params.feeRate) : "1";
+    const skipSync = false;
+    return this.wallet.createUtxosBegin(online, upTo, num, size, feeRate, skipSync);
+  }
+  createUtxosEnd(params) {
+    const online = this.getOnline();
+    const signedPsbt = params.signedPsbt;
+    const skipSync = params.skipSync ?? false;
+    return this.wallet.createUtxosEnd(online, signedPsbt, skipSync);
+  }
+  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;
+    let assetId = params.assetId;
+    let amount = params.amount;
+    let recipientId;
+    let transportEndpoints = [];
+    let witnessData = null;
+    if (params.witnessData && params.witnessData.amountSat) {
+      witnessData = {
+        amountSat: String(params.witnessData.amountSat),
+        blinding: params.witnessData.blinding ? Number(params.witnessData.blinding) : null
+      };
+    }
+    if (params.invoice) {
+      const invoiceStr = params.invoice;
+      const invoiceData = this.decodeRGBInvoice({ invoice: invoiceStr });
+      recipientId = invoiceData.recipientId;
+      transportEndpoints = invoiceData.transportEndpoints;
+    }
+    if (transportEndpoints.length === 0) {
+      transportEndpoints = [this.transportEndpoint];
+    }
+    if (!assetId) {
+      throw new ValidationError("asset_id is required for send operation", "asset_id");
+    }
+    if (!recipientId) {
+      throw new ValidationError("Could not extract recipient_id from invoice", "invoice");
+    }
+    if (!amount) {
+      throw new ValidationError("amount is required for send operation", "amount");
+    }
+    const assignment = { Fungible: amount };
+    const recipientMap = {
+      [assetId]: [{
+        recipientId,
+        witnessData,
+        assignment,
+        transportEndpoints
+      }]
+    };
+    const psbt = this.wallet.sendBegin(
+      online,
+      recipientMap,
+      donation,
+      feeRate,
+      minConfirmations
+    );
+    return psbt;
+  }
+  sendEnd(params) {
+    const online = this.getOnline();
+    const signedPsbt = params.signedPsbt;
+    const skipSync = params.skipSync ?? false;
+    return this.wallet.sendEnd(online, signedPsbt, skipSync);
+  }
+  sendBtcBegin(params) {
+    const online = this.getOnline();
+    const address = params.address;
+    const amount = String(params.amount);
+    const feeRate = String(params.feeRate);
+    const skipSync = params.skipSync ?? false;
+    return this.wallet.sendBtcBegin(online, address, amount, feeRate, skipSync);
+  }
+  sendBtcEnd(params) {
+    const online = this.getOnline();
+    const signedPsbt = params.signedPsbt;
+    const skipSync = params.skipSync ?? false;
+    return this.wallet.sendBtcEnd(online, signedPsbt, skipSync);
+  }
+  getFeeEstimation(params) {
+    const online = this.getOnline();
+    const blocks = String(params.blocks);
+    try {
+      const result = this.wallet.getFeeEstimation(online, blocks);
+      if (typeof result === "string") {
+        try {
+          return JSON.parse(result);
+        } catch {
+          return result;
+        }
+      }
+      return result;
+    } catch (error) {
+      console.warn("rgb-lib estimation fee are not available, using default fee rate 2");
+      return 2;
+    }
+  }
+  blindReceive(params) {
+    const assetId = params.assetId || null;
+    const assignment = `{"Fungible":${params.amount}}`;
+    const durationSeconds = String(params.durationSeconds ?? 2e3);
+    const transportEndpoints = [this.transportEndpoint];
+    const minConfirmations = String(params.minConfirmations ?? 3);
+    return this.wallet.blindReceive(
+      assetId,
+      assignment,
+      durationSeconds,
+      transportEndpoints,
+      minConfirmations
+    );
+  }
+  witnessReceive(params) {
+    const assetId = params.assetId || null;
+    const assignment = `{"Fungible":${params.amount}}`;
+    const durationSeconds = String(params.durationSeconds ?? 2e3);
+    const transportEndpoints = [this.transportEndpoint];
+    const minConfirmations = String(params.minConfirmations ?? 3);
+    return this.wallet.witnessReceive(
+      assetId,
+      assignment,
+      durationSeconds,
+      transportEndpoints,
+      minConfirmations
+    );
+  }
+  getAssetBalance(asset_id) {
+    return this.wallet.getAssetBalance(asset_id);
+  }
+  issueAssetNia(params) {
+    const ticker = params.ticker;
+    const name = params.name;
+    const precision = String(params.precision);
+    const amounts = params.amounts.map((a) => String(a));
+    return this.wallet.issueAssetNIA(ticker, name, precision, amounts);
+  }
+  issueAssetIfa(params) {
+    throw new ValidationError("issueAssetIfa is not fully supported in rgb-lib. Use RGB Node server for IFA assets.", "asset");
+  }
+  inflateBegin(params) {
+    throw new ValidationError("inflateBegin is not fully supported in rgb-lib. Use RGB Node server for inflation operations.", "asset");
+  }
+  inflateEnd(params) {
+    throw new ValidationError("inflateEnd is not fully supported in rgb-lib. Use RGB Node server for inflation operations.", "asset");
+  }
+  listAssets() {
+    const filterAssetSchemas = [];
+    return this.wallet.listAssets(filterAssetSchemas);
+  }
+  decodeRGBInvoice(params) {
+    const invoiceString = params.invoice;
+    const invoice = new rgblib.Invoice(invoiceString);
+    try {
+      return invoice.invoiceData();
+    } finally {
+      invoice.drop();
+    }
+  }
+  refreshWallet() {
+    const online = this.getOnline();
+    const assetId = null;
+    const filter = [];
+    const skipSync = false;
+    this.wallet.refresh(online, assetId, filter, skipSync);
+  }
+  dropWallet() {
+    if (this.online) {
+      rgblib.dropOnline(this.online);
+      this.online = null;
+    }
+    if (this.wallet) {
+      this.wallet.drop();
+      this.wallet = null;
+    }
+  }
+  listTransactions() {
+    const online = this.getOnline();
+    const skipSync = false;
+    return this.wallet.listTransactions(online, skipSync);
+  }
+  listTransfers(asset_id) {
+    return this.wallet.listTransfers(asset_id ? asset_id : null);
+  }
+  failTransfers(params) {
+    const online = this.getOnline();
+    const batchTransferIdx = params.batchTransferIdx !== void 0 ? params.batchTransferIdx : null;
+    const noAssetOnly = params.noAssetOnly ?? false;
+    const skipSync = params.skipSync ?? false;
+    return this.wallet.failTransfers(online, batchTransferIdx, noAssetOnly, skipSync);
+  }
+  deleteTransfers(params) {
+    const batchTransferIdx = params.batchTransferIdx !== void 0 ? params.batchTransferIdx : null;
+    const noAssetOnly = params.noAssetOnly ?? false;
+    return this.wallet.deleteTransfers(batchTransferIdx, noAssetOnly);
+  }
+  syncWallet() {
+    const online = this.getOnline();
+    this.wallet.sync(online);
+  }
+  createBackup(params) {
+    if (!params.backupPath) {
+      throw new ValidationError("backupPath is required", "backupPath");
+    }
+    if (!params.password) {
+      throw new ValidationError("password is required", "password");
+    }
+    if (!fs.existsSync(params.backupPath)) {
+      throw new ValidationError(`Backup directory does not exist: ${params.backupPath}`, "backupPath");
+    }
+    const fullBackupPath = path.join(params.backupPath, `${this.masterFingerprint}.backup`);
+    this.wallet.backup(fullBackupPath, params.password);
+    return {
+      message: "Backup created successfully",
+      backupPath: fullBackupPath
+    };
+  }
+  /**
+   * Cleanup resources
+   */
+  dispose() {
+    this.dropWallet();
+  }
+};
+
+// src/utils/environment.ts
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+function isBare() {
+  return typeof globalThis !== "undefined" && globalThis.Bare;
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+function getEnvironment() {
+  if (isNode()) return "node";
+  if (isBrowser()) return "browser";
+  return "unknown";
+}
+
+// src/utils/crypto-helpers.ts
+function convertToArrayBuffer(data) {
+  if (!data) {
+    throw new Error("convertToArrayBuffer: data is undefined or null");
+  }
+  if (data instanceof Uint8Array) {
+    return data.buffer;
+  }
+  if (data && typeof data === "object" && "byteLength" in data && Object.prototype.toString.call(data) === "[object ArrayBuffer]") {
+    return data;
+  }
+  if (data && typeof data === "object") {
+    if ("buffer" in data && data.buffer) {
+      const buffer = data.buffer;
+      if (buffer instanceof ArrayBuffer) {
+        return buffer;
+      }
+      const uint8 = new Uint8Array(data);
+      return uint8.buffer;
+    }
+    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)}`);
+    }
+  }
+  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)}`);
+  }
+}
+async function sha256(data) {
+  if (isNode() || isBare()) {
+    const nodeCrypto2 = "node:crypto";
+    const { createHash } = await import(nodeCrypto2);
+    return createHash("sha256").update(data).digest();
+  } else {
+    if (!data) {
+      throw new Error("sha256: data is undefined or null");
+    }
+    const arrayBuffer = convertToArrayBuffer(data);
+    return new Uint8Array(await crypto.subtle.digest("SHA-256", arrayBuffer));
+  }
+}
+async function ripemd1602(data) {
+  if (isNode()) {
+    const nodeCrypto2 = "node:crypto";
+    const { createHash } = await import(nodeCrypto2);
+    return createHash("ripemd160").update(data).digest();
+  } else if (isBare()) {
+    return new Uint8Array(await noble.ripemd160(data));
+  } else {
+    const ripemd160Module = await import('ripemd160');
+    const RIPEMD160 = ripemd160Module.default || ripemd160Module;
+    const BufferPolyfill = globalThis.Buffer || (await import('buffer')).Buffer;
+    const hasher = new RIPEMD160();
+    hasher.update(BufferPolyfill.from(data));
+    return new Uint8Array(hasher.digest());
+  }
+}
+var nodeCrypto = null;
+async function getNodeCrypto() {
+  if (!isNode()) {
+    throw new Error("Node.js crypto is only available in Node.js environment");
+  }
+  if (!nodeCrypto) {
+    const nodeCryptoPath = "node:crypto";
+    nodeCrypto = await import(nodeCryptoPath);
+  }
+  return nodeCrypto;
+}
+async function sha256Sync(data) {
+  if (!isNode()) {
+    return sha256(data);
+  }
+  if (!data) {
+    throw new Error("sha256Sync: data is undefined");
+  }
+  const crypto2 = await getNodeCrypto();
+  if (!crypto2) {
+    throw new Error("Node.js crypto is not available");
+  }
+  return crypto2.createHash("sha256").update(data).digest();
+}
+var ripemd160Sync = async (data) => {
+  if (!isNode()) {
+    return ripemd1602(data);
+  }
+  if (!data) {
+    throw new Error("ripemd160Sync: data is undefined");
+  }
+  const crypto2 = await getNodeCrypto();
+  if (!crypto2) {
+    throw new Error("Node.js crypto is not available");
+  }
+  return crypto2.createHash("ripemd160").update(data).digest();
+};
+
+// src/utils/fingerprint.ts
+async function calculateMasterFingerprint(node) {
+  const pubkey = node.publicKey;
+  if (!pubkey) {
+    throw new CryptoError("Public key is undefined");
+  }
+  const pubkeyData = pubkey instanceof Uint8Array ? pubkey : new Uint8Array(pubkey);
+  const sha = await sha256Sync(pubkeyData);
+  const ripemd160Fn = ripemd160Sync;
+  const ripe = await ripemd160Fn(sha);
+  const fingerprintBytes = Array.from(ripe.subarray(0, 4));
+  return fingerprintBytes.map((b) => {
+    const hex = b.toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  }).join("");
+}
+
+// src/utils/bip32-helpers.ts
+function getWifVersion(network) {
+  return network === "mainnet" ? 128 : 239;
+}
+function getNetworkVersionsFromConstants(network) {
+  const bip32Versions = BIP32_VERSIONS[network];
+  return {
+    bip32: bip32Versions,
+    wif: getWifVersion(network)
+  };
+}
+function normalizeSeedBuffer(seed) {
+  if (!seed) {
+    throw new CryptoError("Failed to generate seed - seed is undefined");
+  }
+  let seedBuffer;
+  if (seed instanceof Uint8Array) {
+    seedBuffer = seed;
+  } else if (seed instanceof ArrayBuffer) {
+    seedBuffer = new Uint8Array(seed);
+  } else if (seed && typeof seed === "object") {
+    if ("buffer" in seed && seed.buffer) {
+      const bufferValue = seed.buffer;
+      if (bufferValue instanceof ArrayBuffer) {
+        if (isNode() && seed instanceof Buffer) {
+          seedBuffer = seed;
+        } else {
+          const byteOffset = seed.byteOffset || 0;
+          const byteLength = seed.byteLength || seed.length || bufferValue.byteLength;
+          seedBuffer = new Uint8Array(bufferValue, byteOffset, byteLength);
+        }
+      } else {
+        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)}`);
+        }
+      }
+    } else {
+      try {
+        seedBuffer = new Uint8Array(seed);
+      } catch (error) {
+        throw new CryptoError(`Failed to convert seed to Uint8Array: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  } else {
+    throw new CryptoError(`Invalid seed type: ${typeof seed}`);
+  }
+  return seedBuffer;
+}
+function toNetworkName(bitcoinNetwork) {
+  const n = String(bitcoinNetwork).toLowerCase();
+  if (n.includes("main")) return "mainnet";
+  if (n.includes("reg")) return "regtest";
+  if (n.includes("sig")) return "signet";
+  if (n.includes("testnet4")) return "testnet4";
+  return "testnet";
+}
+function getNetworkVersions(bitcoinNetwork) {
+  const net = toNetworkName(bitcoinNetwork);
+  return getNetworkVersionsFromConstants(net);
+}
+
+// src/crypto/dependencies.ts
+var baseDeps = null;
+var basePromise = null;
+async function loadBaseDependencies() {
+  if (isNode()) {
+    const nodeModule = "node:module";
+    const { createRequire } = await import(nodeModule);
+    const requireFromModule = createRequire(import.meta.url);
+    const bip392 = requireFromModule("bip39");
+    const eccModule2 = requireFromModule("@bitcoinerlab/secp256k1");
+    const ecc2 = eccModule2 && typeof eccModule2 === "object" && "default" in eccModule2 ? eccModule2.default : eccModule2;
+    const bip322 = requireFromModule("bip32");
+    return {
+      bip39: bip392,
+      ecc: ecc2,
+      factory: bip322.BIP32Factory
+    };
+  }
+  const bip39Module = await import('bip39');
+  const bip39 = bip39Module.default || bip39Module;
+  const eccModule = await import('@bitcoinerlab/secp256k1');
+  const ecc = eccModule.default || eccModule;
+  const bip32 = await import('bip32');
+  return {
+    bip39,
+    ecc,
+    factory: bip32.BIP32Factory
+  };
+}
+async function ensureBaseDependencies() {
+  if (baseDeps) {
+    return baseDeps;
+  }
+  if (!basePromise) {
+    basePromise = loadBaseDependencies().then((deps) => {
+      baseDeps = deps;
+      basePromise = null;
+      return deps;
+    }).catch((error) => {
+      basePromise = null;
+      throw error;
+    });
+  }
+  return basePromise;
+}
+var signerDeps = null;
+var signerPromise = null;
+async function loadSignerDependencies() {
+  const base = await ensureBaseDependencies();
+  if (isNode()) {
+    const bdkNode = await import('@bitcoindevkit/bdk-wallet-node');
+    const init2 = bdkNode.default || bdkNode.init || bdkNode;
+    const bdk2 = bdkNode;
+    const nodeModule = "node:module";
+    const { createRequire } = await import(nodeModule);
+    const requireFromModule = createRequire(import.meta.url);
+    const bitcoinjs = requireFromModule("bitcoinjs-lib");
+    const Psbt2 = bitcoinjs.Psbt;
+    const payments2 = bitcoinjs.payments;
+    const networks2 = bitcoinjs.networks;
+    const bip3412 = requireFromModule("bitcoinjs-lib/src/payments/bip341.js");
+    const toXOnly2 = bip3412.toXOnly || ((pubkey) => Buffer.from(pubkey.slice(1)));
+    return {
+      ...base,
+      Psbt: Psbt2,
+      payments: payments2,
+      networks: networks2,
+      toXOnly: toXOnly2,
+      bdk: bdk2,
+      init: init2
+    };
+  }
+  const bdkWeb = await import('@bitcoindevkit/bdk-wallet-web');
+  const init = bdkWeb.default || bdkWeb.init || bdkWeb;
+  const bdk = bdkWeb;
+  const bitcoinModule = await import('bitcoinjs-lib');
+  const Psbt = bitcoinModule.Psbt;
+  const payments = bitcoinModule.payments;
+  const networks = bitcoinModule.networks;
+  const bip341 = await import('bitcoinjs-lib/src/payments/bip341.js');
+  const toXOnly = bip341.toXOnly || ((pubkey) => Buffer.from(pubkey.slice(1)));
+  return {
+    ...base,
+    Psbt,
+    payments,
+    networks,
+    toXOnly,
+    bdk,
+    init
+  };
+}
+async function ensureSignerDependencies() {
+  if (signerDeps) {
+    return signerDeps;
+  }
+  if (!signerPromise) {
+    signerPromise = loadSignerDependencies().then((deps) => {
+      signerDeps = deps;
+      signerPromise = null;
+      return deps;
+    }).catch((error) => {
+      signerPromise = null;
+      throw error;
+    });
+  }
+  return signerPromise;
+}
+
+// src/crypto/keys.ts
+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);
+    }
+    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);
+    }
+    if (hex.length !== 128) {
+      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);
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+      const byte = hex.slice(i * 2, i * 2 + 2);
+      bytes[i] = parseInt(byte, 16);
+    }
+    return bytes;
+  }
+  if (seed instanceof Uint8Array) {
+    if (seed.length === 0) {
+      throw new ValidationError(`${field} must not be empty`, field);
+    }
+    return new Uint8Array(seed);
+  }
+  throw new ValidationError(`${field} must be a 64-byte hex string or Uint8Array`, field);
+}
+function getCoinType(bitcoinNetwork, rgb) {
+  const net = toNetworkName(bitcoinNetwork);
+  if (rgb) return net === "mainnet" ? COIN_RGB_MAINNET : COIN_RGB_TESTNET;
+  return net === "mainnet" ? 0 : 1;
+}
+function accountDerivationPath(bitcoinNetwork, rgb) {
+  const coinType = getCoinType(bitcoinNetwork, rgb);
+  return `m/${DERIVATION_PURPOSE}'/${coinType}'/${DERIVATION_ACCOUNT}'`;
+}
+async function masterFingerprintFromNode(node) {
+  return calculateMasterFingerprint(node);
+}
+async function mnemonicToRoot(mnemonic, bitcoinNetwork) {
+  const { bip39, ecc, factory } = await ensureBaseDependencies();
+  if (!bip39 || typeof bip39.mnemonicToSeedSync !== "function") {
+    throw new CryptoError("bip39 module not loaded correctly");
+  }
+  const seedBuffer = normalizeSeedBuffer(bip39.mnemonicToSeedSync(mnemonic));
+  const versions = getNetworkVersions(bitcoinNetwork);
+  const bip32 = factory(ecc);
+  try {
+    return bip32.fromSeed(seedBuffer, versions);
+  } catch (error) {
+    throw new CryptoError(
+      `Failed to create BIP32 root node from seed: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+async function getAccountXpub(mnemonic, bitcoinNetwork, rgb) {
+  const root = await mnemonicToRoot(mnemonic, bitcoinNetwork);
+  const path3 = accountDerivationPath(bitcoinNetwork, rgb);
+  const acct = root.derivePath(path3);
+  return acct.neutered().toBase58();
+}
+async function getMasterXpriv(mnemonic, bitcoinNetwork) {
+  const root = await mnemonicToRoot(mnemonic, bitcoinNetwork);
+  return root.toBase58();
+}
+function deriveAccountXpubsFromRoot(root, network) {
+  const vanillaPath = accountDerivationPath(network, false);
+  const coloredPath = accountDerivationPath(network, true);
+  return {
+    account_xpub_vanilla: root.derivePath(vanillaPath).neutered().toBase58(),
+    account_xpub_colored: root.derivePath(coloredPath).neutered().toBase58()
+  };
+}
+async function buildGeneratedKeysFromRoot(root, network, mnemonic) {
+  const xpub = root.neutered().toBase58();
+  const xpriv = root.toBase58();
+  const master_fingerprint = await masterFingerprintFromNode(root);
+  const { account_xpub_vanilla, account_xpub_colored } = deriveAccountXpubsFromRoot(root, network);
+  return {
+    mnemonic,
+    xpub,
+    accountXpubVanilla: account_xpub_vanilla,
+    accountXpubColored: account_xpub_colored,
+    masterFingerprint: master_fingerprint,
+    xpriv
+  };
+}
+async function getXpubFromXprivInternal(xpriv, bitcoinNetwork) {
+  const { ecc, factory } = await ensureBaseDependencies();
+  try {
+    const bip32 = factory(ecc);
+    let node;
+    if (bitcoinNetwork) {
+      const versions = getNetworkVersions(bitcoinNetwork);
+      node = bip32.fromBase58(xpriv, versions);
+    } else {
+      const inferredNetwork = xpriv.startsWith("xprv") ? "mainnet" : "testnet";
+      const versions = getNetworkVersions(inferredNetwork);
+      node = bip32.fromBase58(xpriv, versions);
+    }
+    return node.neutered().toBase58();
+  } catch (error) {
+    throw new CryptoError("Failed to derive xpub from xpriv", error);
+  }
+}
+async function buildKeysOutput(mnemonic, bitcoinNetwork) {
+  const normalizedNetwork = normalizeNetwork(bitcoinNetwork);
+  const root = await mnemonicToRoot(mnemonic, normalizedNetwork);
+  return buildGeneratedKeysFromRoot(root, normalizedNetwork, mnemonic);
+}
+async function buildKeysOutputFromSeed(seed, bitcoinNetwork) {
+  const { ecc, factory } = await ensureBaseDependencies();
+  const normalizedNetwork = normalizeNetwork(bitcoinNetwork);
+  const seedBuffer = normalizeSeedBuffer(seed);
+  const versions = getNetworkVersions(bitcoinNetwork);
+  const bip32 = factory(ecc);
+  let root;
+  try {
+    root = bip32.fromSeed(seedBuffer, versions);
+  } catch (error) {
+    throw new CryptoError("Failed to create BIP32 root node from seed", error);
+  }
+  return buildGeneratedKeysFromRoot(root, normalizedNetwork, "");
+}
+async function buildKeysOutputFromXpriv(xpriv, bitcoinNetwork) {
+  const { ecc, factory } = await ensureBaseDependencies();
+  try {
+    const bip32 = factory(ecc);
+    const normalizedNetwork = normalizeNetwork(bitcoinNetwork);
+    const versions = getNetworkVersions(bitcoinNetwork);
+    const root = bip32.fromBase58(xpriv, versions);
+    return buildGeneratedKeysFromRoot(root, normalizedNetwork, "");
+  } catch (error) {
+    throw new CryptoError("Failed to derive keys from xpriv", error);
+  }
+}
+async function generateKeys3(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.");
+    }
+    const mnemonic = bip39.generateMnemonic(128);
+    return await buildKeysOutput(mnemonic, bitcoinNetwork);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("bip39 not loaded")) {
+      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);
+  }
+}
+async function deriveKeysFromMnemonic(bitcoinNetwork = "regtest", mnemonic) {
+  validateMnemonic(mnemonic, "mnemonic");
+  const normalizedNetwork = normalizeNetwork(bitcoinNetwork);
+  try {
+    const { bip39 } = await ensureBaseDependencies();
+    const trimmedMnemonic = mnemonic.trim();
+    if (!bip39 || !bip39.validateMnemonic(trimmedMnemonic)) {
+      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);
+  }
+}
+async function deriveKeysFromSeed(bitcoinNetwork = "regtest", seed) {
+  const normalizedNetwork = normalizeNetwork(bitcoinNetwork);
+  try {
+    const normalizedSeed = normalizeSeedInput(seed, "seed");
+    return await buildKeysOutputFromSeed(normalizedSeed, normalizedNetwork);
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      throw error;
+    }
+    throw new CryptoError("Failed to derive keys from seed", error);
+  }
+}
+async function restoreKeys(bitcoinNetwork = "regtest", mnemonic) {
+  return deriveKeysFromMnemonic(bitcoinNetwork, mnemonic);
+}
+async function getXprivFromMnemonic(bitcoinNetwork = "regtest", mnemonic) {
+  validateMnemonic(mnemonic, "mnemonic");
+  const normalizedNetwork = normalizeNetwork(bitcoinNetwork);
+  try {
+    return await getMasterXpriv(mnemonic, normalizedNetwork);
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      throw error;
+    }
+    throw new CryptoError("Failed to derive xpriv from mnemonic", error);
+  }
+}
+async function getXpubFromXpriv(xpriv, bitcoinNetwork) {
+  if (!xpriv || typeof xpriv !== "string") {
+    throw new ValidationError("xpriv must be a non-empty string", "xpriv");
+  }
+  try {
+    return await getXpubFromXprivInternal(xpriv, bitcoinNetwork);
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      throw error;
+    }
+    throw new CryptoError("Failed to derive xpub from xpriv", error);
+  }
+}
+async function deriveKeysFromXpriv(bitcoinNetwork = "regtest", xpriv) {
+  if (!xpriv || typeof xpriv !== "string") {
+    throw new ValidationError("xpriv must be a non-empty string", "xpriv");
+  }
+  const normalizedNetwork = normalizeNetwork(bitcoinNetwork);
+  try {
+    return await buildKeysOutputFromXpriv(xpriv, normalizedNetwork);
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      throw error;
+    }
+    throw new CryptoError("Failed to derive keys from xpriv", error);
+  }
+}
+async function accountXpubsFromMnemonic(bitcoinNetwork = "regtest", mnemonic) {
+  validateMnemonic(mnemonic, "mnemonic");
+  try {
+    const { bip39 } = await ensureBaseDependencies();
+    if (!bip39 || !bip39.validateMnemonic(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)
+    };
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      throw error;
+    }
+    throw new CryptoError("Failed to derive account xpubs from mnemonic", error);
+  }
+}
+
+// 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];
+      if (typeof second === "number" && second >= 2147483648) {
+        return path3.slice(1);
+      }
+    }
+    return path3;
+  }
+  return path3;
+}
+function pathToString(path3) {
+  if (typeof path3 === "string") {
+    return path3;
+  } else if (Array.isArray(path3)) {
+    return path3.map((p) => {
+      if (typeof p === "number") {
+        return p >= 2147483648 ? `${p & 2147483647}'` : `${p}`;
+      }
+      return String(p);
+    }).join("/");
+  }
+  return "";
+}
+function preprocessPsbtForBDK(psbtBase64, rootNode, fp, network, deps) {
+  const { Psbt, networks, payments, toXOnly } = deps;
+  if (!Psbt || !networks || !payments || !toXOnly) {
+    throw new CryptoError("BitcoinJS modules not loaded");
+  }
+  const psbt = Psbt.fromBase64(psbtBase64.trim());
+  const bjsNet = network === "mainnet" ? networks.bitcoin : networks.testnet;
+  for (let i = 0; i < psbt.inputCount; i++) {
+    const input = psbt.data.inputs[i];
+    if (input.tapBip32Derivation && input.tapBip32Derivation.length > 0) {
+      input.tapBip32Derivation.forEach((deriv) => {
+        const normalizedPath = normalizePath(deriv.path);
+        deriv.path = pathToString(normalizedPath);
+        let pathStr = pathToString(normalizedPath);
+        if (!pathStr.startsWith("m/")) {
+          pathStr = "m/" + pathStr;
+        }
+        try {
+          const derivedNode = rootNode.derivePath(pathStr);
+          const pubkey = derivedNode.publicKey;
+          if (!pubkey) {
+            return;
+          }
+          const pubkeyBuffer = pubkey instanceof Buffer ? pubkey : Buffer.from(pubkey);
+          const xOnly = toXOnly(pubkeyBuffer);
+          const p2tr = payments.p2tr({ internalPubkey: xOnly, network: bjsNet });
+          const expectedScript = p2tr.output;
+          if (!expectedScript) {
+            return;
+          }
+          if (input.witnessUtxo && expectedScript) {
+            const currentScript = input.witnessUtxo.script;
+            if (!currentScript.equals(expectedScript)) {
+              input.witnessUtxo.script = expectedScript;
+            }
+          }
+          if (xOnly) {
+            if (!input.tapInternalKey || !input.tapInternalKey.equals(xOnly)) {
+              input.tapInternalKey = xOnly;
+            }
+          }
+          const fingerprintBuf = Buffer.from(fp, "hex");
+          if (!deriv.masterFingerprint) {
+            deriv.masterFingerprint = fingerprintBuf;
+          } else {
+            const currentFp = Buffer.from(deriv.masterFingerprint);
+            if (!currentFp.equals(fingerprintBuf)) {
+              deriv.masterFingerprint = fingerprintBuf;
+            }
+          }
+          if (!deriv.pubkey || !deriv.pubkey.equals(xOnly)) {
+            deriv.pubkey = xOnly;
+          }
+        } catch (e) {
+        }
+      });
+    }
+    if (input.bip32Derivation && input.bip32Derivation.length > 0) {
+      input.bip32Derivation.forEach((deriv) => {
+        const normalizedPath = normalizePath(deriv.path);
+        deriv.path = pathToString(normalizedPath);
+      });
+    }
+  }
+  return psbt.toBase64();
+}
+function detectPsbtType(psbtBase64, deps) {
+  const { Psbt } = deps;
+  if (!Psbt) {
+    throw new CryptoError("BitcoinJS Psbt module not loaded");
+  }
+  try {
+    const psbt = Psbt.fromBase64(psbtBase64.trim());
+    for (let i = 0; i < psbt.inputCount; i++) {
+      const input = psbt.data.inputs[i];
+      if (input.tapBip32Derivation && input.tapBip32Derivation.length > 0) {
+        for (const deriv of input.tapBip32Derivation) {
+          const pathStr = pathToString(deriv.path);
+          if (pathStr.includes("827167'") || pathStr.includes("827166'")) {
+            return "send";
+          }
+        }
+      }
+    }
+    return "create_utxo";
+  } catch (e) {
+    return "create_utxo";
+  }
+}
+function deriveDescriptors(rootNode, fp, network, psbtType) {
+  const isMainnet = network === "mainnet";
+  const coinTypeBtc = isMainnet ? COIN_BITCOIN_MAINNET : COIN_BITCOIN_TESTNET;
+  const coinTypeRgb = isMainnet ? COIN_RGB_MAINNET : COIN_RGB_TESTNET;
+  if (psbtType === "create_utxo") {
+    const accountPath = `m/${DERIVATION_PURPOSE}'/${coinTypeBtc}'/${DERIVATION_ACCOUNT}'`;
+    const accountNode = rootNode.derivePath(accountPath);
+    const accountXprv = accountNode.toBase58();
+    const origin = `[${fp}/${DERIVATION_PURPOSE}'/${coinTypeBtc}'/${DERIVATION_ACCOUNT}']`;
+    return {
+      external: `tr(${origin}${accountXprv}/0/*)`,
+      internal: `tr(${origin}${accountXprv}/1/*)`
+    };
+  } else {
+    const rgbAccountPath = `m/${DERIVATION_PURPOSE}'/${coinTypeRgb}'/${DERIVATION_ACCOUNT}'`;
+    const rgbAccountNode = rootNode.derivePath(rgbAccountPath);
+    const rgbKeychainNode = rgbAccountNode.derive(KEYCHAIN_RGB);
+    const rgbKeychainXprv = rgbKeychainNode.toBase58();
+    const rgbOrigin = `[${fp}/${DERIVATION_PURPOSE}'/${coinTypeRgb}'/${DERIVATION_ACCOUNT}'/${KEYCHAIN_RGB}]`;
+    const btcAccountPath = `m/${DERIVATION_PURPOSE}'/${coinTypeBtc}'/${DERIVATION_ACCOUNT}'`;
+    const btcAccountNode = rootNode.derivePath(btcAccountPath);
+    const btcKeychainNode = btcAccountNode.derive(KEYCHAIN_BTC);
+    const btcKeychainXprv = btcKeychainNode.toBase58();
+    const btcOrigin = `[${fp}/${DERIVATION_PURPOSE}'/${coinTypeBtc}'/${DERIVATION_ACCOUNT}'/${KEYCHAIN_BTC}]`;
+    return {
+      external: `tr(${rgbOrigin}${rgbKeychainXprv}/*)`,
+      internal: `tr(${btcOrigin}${btcKeychainXprv}/*)`
+    };
+  }
+}
+function getNetworkVersions2(network) {
+  return getNetworkVersions(network);
+}
+async function getMasterFingerprint(rootNode) {
+  return calculateMasterFingerprint(rootNode);
+}
+async function signPsbtFromSeedInternal(seed, psbtBase64, network, options = {}, deps) {
+  validatePsbt(psbtBase64, "psbtBase64");
+  const { ecc, factory, bdk } = deps;
+  const bip32 = factory(ecc);
+  const seedBuffer = normalizeSeedBuffer(seed);
+  const versions = getNetworkVersions2(network);
+  let rootNode;
+  try {
+    rootNode = bip32.fromSeed(seedBuffer, versions);
+  } catch (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);
+  let wallet2;
+  try {
+    wallet2 = bdk.Wallet.create(network, external, internal);
+  } catch (error) {
+    throw new CryptoError("Failed to create BDK wallet", error);
+  }
+  let processedPsbt = psbtBase64.trim();
+  if (needsPreprocessing || options.preprocess) {
+    try {
+      processedPsbt = preprocessPsbtForBDK(psbtBase64, rootNode, fp, network, deps);
+    } catch (error) {
+      throw new CryptoError("Failed to preprocess PSBT", error);
+    }
+  }
+  let pstb;
+  try {
+    pstb = bdk.Psbt.from_string(processedPsbt);
+  } catch (error) {
+    throw new CryptoError("Failed to parse PSBT", error);
+  }
+  const signOptions = options.signOptions || new bdk.SignOptions();
+  try {
+    wallet2.sign(pstb, signOptions);
+  } catch (error) {
+    throw new CryptoError("Failed to sign PSBT", error);
+  }
+  return pstb.toString().trim();
+}
+async function signPsbt(mnemonic, psbtBase64, network = "testnet", options = {}) {
+  try {
+    validateMnemonic(mnemonic, "mnemonic");
+    const { bip39 } = await ensureBaseDependencies();
+    if (!bip39 || typeof bip39.mnemonicToSeedSync !== "function") {
+      throw new CryptoError("bip39 module not loaded correctly");
+    }
+    let seed;
+    try {
+      seed = bip39.mnemonicToSeedSync(mnemonic);
+    } 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);
+  } catch (error) {
+    if (error instanceof ValidationError || error instanceof CryptoError) {
+      throw error;
+    }
+    throw new CryptoError("Unexpected error during PSBT signing", error);
+  }
+}
+async function signPsbtSync(mnemonic, psbtBase64, network = "testnet", options = {}) {
+  return signPsbt(mnemonic, psbtBase64, network, options);
+}
+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);
+}
+function ensureMessageInput(message) {
+  if (typeof message === "string") {
+    if (!message.length) {
+      throw new ValidationError("message must not be empty", "message");
+    }
+    return Buffer.from(message, "utf8");
+  }
+  if (message instanceof Uint8Array) {
+    if (!message.length) {
+      throw new ValidationError("message must not be empty", "message");
+    }
+    return Buffer.from(message);
+  }
+  throw new ValidationError("message must be a string or Uint8Array", "message");
+}
+async function deriveRootFromSeedInput(seed, network) {
+  const { ecc, factory } = await ensureBaseDependencies();
+  const normalizedSeed = normalizeSeedInput(seed, "seed");
+  const versions = getNetworkVersions2(network);
+  const bip32 = factory(ecc);
+  try {
+    return bip32.fromSeed(normalizedSeed, versions);
+  } catch (error) {
+    throw new CryptoError("Failed to create BIP32 root node from seed", error);
+  }
+}
+var DEFAULT_RELATIVE_PATH = "0/0";
+async function signMessage(params) {
+  const { message, seed } = params;
+  if (!seed) {
+    throw new ValidationError("seed is required", "seed");
+  }
+  const normalizedNetwork = normalizeNetwork(params.network ?? "regtest");
+  const relativePath = DEFAULT_RELATIVE_PATH;
+  const accountPath = accountDerivationPath(normalizedNetwork, false);
+  const messageBytes = ensureMessageInput(message);
+  const { ecc } = await ensureBaseDependencies();
+  const root = await deriveRootFromSeedInput(seed, normalizedNetwork);
+  const accountNode = root.derivePath(accountPath);
+  const child = accountNode.derivePath(relativePath);
+  const privateKey = child.privateKey;
+  if (!privateKey) {
+    throw new CryptoError("Derived node does not contain a private key");
+  }
+  if (!ecc || typeof ecc.signSchnorr !== "function") {
+    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");
+  return signature;
+}
+async function verifyMessage(params) {
+  const { message, signature, accountXpub } = params;
+  const messageBytes = ensureMessageInput(message);
+  const relativePath = DEFAULT_RELATIVE_PATH;
+  const signatureBytes = Buffer.from(signature, "base64");
+  const normalizedNetwork = normalizeNetwork(params.network ?? "regtest");
+  const versions = getNetworkVersions2(normalizedNetwork);
+  const { ecc, factory } = await ensureBaseDependencies();
+  if (!ecc || typeof ecc.verifySchnorr !== "function" || typeof ecc.xOnlyPointFromPoint !== "function") {
+    throw new CryptoError("Schnorr verification not supported by ECC module");
+  }
+  let accountNode;
+  try {
+    accountNode = factory(ecc).fromBase58(accountXpub, versions);
+  } catch (error) {
+    throw new ValidationError("Invalid account xpub provided", "accountXpub");
+  }
+  const child = accountNode.derivePath(relativePath);
+  const pubkeyBuffer = child.publicKey instanceof Buffer ? child.publicKey : Buffer.from(child.publicKey);
+  const xOnlyPubkey = ecc.xOnlyPointFromPoint(pubkeyBuffer);
+  const messageHash = await sha256(messageBytes);
+  try {
+    return ecc.verifySchnorr(messageHash, xOnlyPubkey, signatureBytes);
+  } catch {
+    return false;
+  }
+}
+async function estimatePsbt(psbtBase64) {
+  if (!psbtBase64) {
+    throw new ValidationError("psbt is required", "psbt");
+  }
+  const { Psbt } = await ensureSignerDependencies();
+  if (!Psbt) {
+    throw new CryptoError("BitcoinJS Psbt module not loaded");
+  }
+  let psbt;
+  try {
+    psbt = Psbt.fromBase64(psbtBase64.trim());
+    return {
+      fee: psbt.getFee(),
+      feeRate: psbt.getFeeRate(),
+      vbytes: psbt.extractTransaction().virtualSize()
+    };
+  } catch (error) {
+    console.log("error", error);
+    throw new ValidationError("Invalid PSBT provided", "psbt");
+  }
+}
+var restoreFromBackup = (params) => {
+  const {
+    backupFilePath,
+    password,
+    dataDir
+  } = params;
+  if (!backupFilePath) {
+    throw new ValidationError("backup file is required", "backup");
+  }
+  if (!password) {
+    throw new ValidationError("password is required", "password");
+  }
+  if (!dataDir) {
+    throw new ValidationError("restore directory is required", "restoreDir");
+  }
+  return restoreWallet({
+    backupFilePath,
+    password,
+    dataDir
+  });
+};
+var createWallet = async (network = "regtest") => {
+  return await generateKeys3(network);
+};
+var WalletManager = class {
+  constructor(params) {
+    this.disposed = false;
+    if (!params.xpubVan) {
+      throw new ValidationError("xpubVan is required", "xpubVan");
+    }
+    if (!params.xpubCol) {
+      throw new ValidationError("xpubCol is required", "xpubCol");
+    }
+    if (!params.masterFingerprint) {
+      throw new ValidationError("masterFingerprint is required", "masterFingerprint");
+    }
+    this.network = normalizeNetwork(params.network ?? "regtest");
+    this.xpubVan = params.xpubVan;
+    this.xpubCol = params.xpubCol;
+    this.seed = params.seed ?? null;
+    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.client = new RGBLibClient({
+      xpubVan: params.xpubVan,
+      xpubCol: params.xpubCol,
+      masterFingerprint: params.masterFingerprint,
+      network: this.network,
+      transportEndpoint: params.transportEndpoint,
+      indexerUrl: params.indexerUrl,
+      dataDir: params.dataDir ?? this.dataDir
+    });
+  }
+  /**
+   * Get wallet's extended public keys
+   */
+  getXpub() {
+    return {
+      xpubVan: this.xpubVan,
+      xpubCol: this.xpubCol
+    };
+  }
+  /**
+   * Get wallet's network
+   */
+  getNetwork() {
+    return this.network;
+  }
+  /**
+   * Dispose of sensitive wallet data
+   * Clears mnemonic and seed from memory
+   * Idempotent - safe to call multiple times
+   */
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    if (this.mnemonic !== null) {
+      this.mnemonic = null;
+    }
+    if (this.seed !== null && this.seed.length > 0) {
+      this.seed.fill(0);
+      this.seed = null;
+    }
+    this.client.dropWallet();
+    this.disposed = true;
+  }
+  /**
+   * Check if wallet has been disposed
+   */
+  isDisposed() {
+    return this.disposed;
+  }
+  /**
+   * Guard method to ensure wallet has not been disposed
+   * @throws {WalletError} if wallet has been disposed
+   */
+  ensureNotDisposed() {
+    if (this.disposed) {
+      throw new WalletError("Wallet has been disposed");
+    }
+  }
+  registerWallet() {
+    return this.client.registerWallet();
+  }
+  getBtcBalance() {
+    return this.client.getBtcBalance();
+  }
+  getAddress() {
+    return this.client.getAddress();
+  }
+  listUnspents() {
+    return this.client.listUnspents();
+  }
+  listAssets() {
+    return this.client.listAssets();
+  }
+  getAssetBalance(asset_id) {
+    return this.client.getAssetBalance(asset_id);
+  }
+  createUtxosBegin(params) {
+    return this.client.createUtxosBegin(params);
+  }
+  createUtxosEnd(params) {
+    return this.client.createUtxosEnd(params);
+  }
+  sendBegin(params) {
+    return this.client.sendBegin(params);
+  }
+  sendEnd(params) {
+    return this.client.sendEnd(params);
+  }
+  sendBtcBegin(params) {
+    return this.client.sendBtcBegin(params);
+  }
+  sendBtcEnd(params) {
+    return this.client.sendBtcEnd(params);
+  }
+  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 });
+  }
+  async estimateFee(psbtBase64) {
+    return await estimatePsbt(psbtBase64);
+  }
+  async sendBtc(params) {
+    this.ensureNotDisposed();
+    const psbt = this.sendBtcBegin(params);
+    const signed = await this.signPsbt(psbt);
+    return this.sendBtcEnd({ signedPsbt: signed });
+  }
+  blindReceive(params) {
+    return this.client.blindReceive(params);
+  }
+  witnessReceive(params) {
+    return this.client.witnessReceive(params);
+  }
+  issueAssetNia(params) {
+    return this.client.issueAssetNia(params);
+  }
+  issueAssetIfa(params) {
+    return this.client.issueAssetIfa(params);
+  }
+  inflateBegin(params) {
+    return this.client.inflateBegin(params);
+  }
+  inflateEnd(params) {
+    return this.client.inflateEnd(params);
+  }
+  /**
+   * Complete inflate operation: begin → sign → end
+   * @param params - Inflate parameters
+   * @param mnemonic - Optional mnemonic for signing
+   */
+  async inflate(params, mnemonic) {
+    this.ensureNotDisposed();
+    const psbt = await this.inflateBegin(params);
+    const signedPsbt = await this.signPsbt(psbt, mnemonic);
+    return await this.inflateEnd({
+      signedPsbt
+    });
+  }
+  refreshWallet() {
+    this.client.refreshWallet();
+  }
+  listTransactions() {
+    return this.client.listTransactions();
+  }
+  listTransfers(asset_id) {
+    return this.client.listTransfers(asset_id);
+  }
+  failTransfers(params) {
+    return this.client.failTransfers(params);
+  }
+  decodeRGBInvoice(params) {
+    return this.client.decodeRGBInvoice(params);
+  }
+  createBackup(params) {
+    return this.client.createBackup(params);
+  }
+  /**
+   * Sign a PSBT using the wallet's mnemonic or a provided mnemonic
+   * @param psbt - Base64 encoded PSBT
+   * @param mnemonic - Optional mnemonic (uses wallet's mnemonic if not provided)
+   */
+  async signPsbt(psbt, mnemonic) {
+    this.ensureNotDisposed();
+    const mnemonicToUse = mnemonic ?? this.mnemonic;
+    if (mnemonicToUse) {
+      return await signPsbt(mnemonicToUse, psbt, this.network);
+    }
+    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.");
+  }
+  /**
+   * Complete send operation: begin → sign → end
+   * @param invoiceTransfer - Transfer invoice parameters
+   * @param mnemonic - Optional mnemonic for signing
+   */
+  async send(invoiceTransfer, mnemonic) {
+    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 signedPsbt = await this.signPsbt(psbt);
+    return this.createUtxosEnd({ signedPsbt });
+  }
+  syncWallet() {
+    this.client.syncWallet();
+  }
+  async signMessage(message) {
+    this.ensureNotDisposed();
+    if (!message) {
+      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.");
+    }
+    return signMessage({
+      message,
+      seed: this.seed,
+      network: this.network
+    });
+  }
+  async verifyMessage(message, signature, accountXpub) {
+    if (!message) {
+      throw new ValidationError("message is required", "message");
+    }
+    if (!signature) {
+      throw new ValidationError("signature is required", "signature");
+    }
+    return verifyMessage({
+      message,
+      signature,
+      accountXpub: this.xpubVan,
+      network: this.network
+    });
+  }
+};
+function createWalletManager(params) {
+  return new WalletManager(params);
+}
+var wallet = new Proxy({}, {
+  get(target, prop) {
+    {
+      throw new WalletError(
+        "The legacy singleton wallet instance is deprecated. Please use `new WalletManager(params)` or `createWalletManager(params)` instead. Example: const wallet = new WalletManager({ xpubVan, xpubCol, masterFingerprint, network, transportEndpoint, indexerUrl })"
+      );
+    }
+  }
+});
+
+// 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 AssetSchema2 = /* @__PURE__ */ ((AssetSchema3) => {
+  AssetSchema3["Nia"] = "Nia";
+  AssetSchema3["Uda"] = "Uda";
+  AssetSchema3["Cfa"] = "Cfa";
+  return AssetSchema3;
+})(AssetSchema2 || {});
+
+// src/utils/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
+  return LogLevel2;
+})(LogLevel || {});
+var Logger = class {
+  constructor() {
+    this.level = 3 /* ERROR */;
+  }
+  /**
+   * Set the log level
+   */
+  setLevel(level) {
+    this.level = level;
+  }
+  /**
+   * Get the current log level
+   */
+  getLevel() {
+    return this.level;
+  }
+  /**
+   * Log debug messages
+   */
+  debug(...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.debug("[SDK DEBUG]", ...args);
+    }
+  }
+  /**
+   * Log info messages
+   */
+  info(...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.info("[SDK INFO]", ...args);
+    }
+  }
+  /**
+   * Log warning messages
+   */
+  warn(...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn("[SDK WARN]", ...args);
+    }
+  }
+  /**
+   * Log error messages
+   */
+  error(...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error("[SDK ERROR]", ...args);
+    }
+  }
+};
+var logger = new Logger();
+function configureLogging(level) {
+  logger.setLevel(level);
+}
+
+export { AssetIface, AssetSchema2 as 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, generateKeys3 as generateKeys, getEnvironment, getXprivFromMnemonic, getXpubFromXpriv, isBrowser, isNode, logger, normalizeNetwork, restoreFromBackup, restoreKeys, signMessage, signPsbt, signPsbtFromSeed, signPsbtSync, validateBase64, validateHex, validateMnemonic, validateNetwork, validatePsbt, validateRequired, validateString, verifyMessage, wallet };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map