@otoplo/wallet-common 0.2.2 → 0.4.0

package/dist/index.js

@@ -1,2030 +1,1842 @@
-import { AddressType as O, Networks as E, Address as I, CommonUtils as W, BufferUtils as m, HDPrivateKey as j, TransactionBuilder as z, Transaction as x, UnitUtils as q, Script as b, Opcode as A, Hash as _, ScriptOpcode as L, BNExtended as F, Output as we, TxSigner as X, SighashType as Y, ScriptFactory as Ae, OutputSighashType as Z, BufferWriter as ve } from "libnexa-ts";
-import B from "js-big-decimal";
-import { ElectrumClient as be, TransportScheme as H, ConnectionStatus as Se } from "@otoplo/electrum-client";
-import { mnemonicToSeedSync as ke, generateMnemonic as Te, validateMnemonic as Ie } from "@scure/bip39";
-import { DAppProvider as xe } from "wallet-comms-sdk";
-import { wordlist as se } from "@scure/bip39/wordlists/english.js";
-import { createSlice as S, createAsyncThunk as Ne, createSelector as G } from "@reduxjs/toolkit";
-import { useSelector as Me } from "react-redux";
-const w = -1, Q = 9223372036854775807n, Ee = 274710, yt = "0014461ad25081cb0119d034385ff154c8d3ad6bdd76";
-function C() {
-  return E.defaultNetwork == E.testnet;
+import { Address as e, AddressType as t, BNExtended as n, BufferUtils as r, BufferWriter as i, CommonUtils as a, HDPrivateKey as o, Hash as s, Networks as c, Opcode as l, Output as u, OutputSighashType as d, Script as f, ScriptFactory as ee, ScriptOpcode as p, SighashType as m, Transaction as h, TransactionBuilder as g, TxSigner as _, UnitUtils as v } from "libnexa-ts";
+import y from "js-big-decimal";
+import { ConnectionStatus as te, ElectrumClient as ne, TransportScheme as b } from "@otoplo/electrum-client";
+import { generateMnemonic as re, mnemonicToSeedSync as ie, validateMnemonic as ae } from "@scure/bip39";
+import { DAppProvider as oe } from "wallet-comms-sdk";
+import { wordlist as x } from "@scure/bip39/wordlists/english.js";
+// src/utils/enums.ts
+var S = /* @__PURE__ */ function(e) {
+	return e[e.MAIN = 0] = "MAIN", e[e.VAULT = 1] = "VAULT", e[e.DAPP = 2] = "DAPP", e;
+}({}), C = /* @__PURE__ */ function(e) {
+	return e[e.RECEIVE = 0] = "RECEIVE", e[e.CHANGE = 1] = "CHANGE", e;
+}({}), w = /* @__PURE__ */ function(e) {
+	return e.SignMessage = "signMessage", e.AddToken = "addToken", e.SignTransaction = "signTransaction", e.SendTransaction = "sendTransaction", e;
+}({}), se = -1, ce = 9223372036854775807n, T = 274710, le = "0014461ad25081cb0119d034385ff154c8d3ad6bdd76";
+function E() {
+	return c.defaultNetwork == c.testnet;
 }
-function wt(a) {
-  return C() ? a == "508c843a4b98fb25f57cf9ebafb245a5c16468f06519cdd467059a91e7b79d52" : a == "edc7144fe1ba4edd0edf35d7eea90f6cb1dba42314aa85da8207e97c5339c801";
+function ue(e) {
+	return E() ? e == "508c843a4b98fb25f57cf9ebafb245a5c16468f06519cdd467059a91e7b79d52" : e == "edc7144fe1ba4edd0edf35d7eea90f6cb1dba42314aa85da8207e97c5339c801";
 }
-function R(a, e = O.PayToScriptTemplate) {
-  return I.isValid(a, E.defaultNetwork, e);
+function D(n, r = t.PayToScriptTemplate) {
+	return e.isValid(n, c.defaultNetwork, r);
 }
-function At() {
-  return `https://${C() ? "testnet-" : ""}explorer.nexa.org`;
+function de() {
+	return `https://${E() ? "testnet-" : ""}explorer.nexa.org`;
 }
-function J() {
-  return Math.floor(Date.now() / 1e3);
+function O() {
+	return Math.floor(Date.now() / 1e3);
 }
-function vt(a, e) {
-  const t = (e - a) * 2, s = /* @__PURE__ */ new Date();
-  return s.setMinutes(s.getMinutes() + t), s.toLocaleDateString();
+function fe(e, t) {
+	let n = (t - e) * 2, r = /* @__PURE__ */ new Date();
+	return r.setMinutes(r.getMinutes() + n), r.toLocaleDateString();
 }
-function M(a) {
-  return !a || a.length === 0;
+function k(e) {
+	return !e || e.length === 0;
 }
-function bt(a, e = 0) {
-  if (!a || a.length <= e)
-    return a || "";
-  const t = "...", s = Math.floor((e - t.length) / 2), n = a.slice(0, s), i = a.slice(a.length - s);
-  return n + t + i;
+function pe(e, t = 0) {
+	if (!e || e.length <= t) return e || "";
+	let n = Math.floor((t - 3) / 2), r = e.slice(0, n), i = e.slice(e.length - n);
+	return r + "..." + i;
 }
-function St(a) {
-  return a.length === 0 ? "" : a.charAt(0).toUpperCase() + a.substring(1);
+function me(e) {
+	return e.length === 0 ? "" : e.charAt(0).toUpperCase() + e.substring(1);
 }
-function ae(a) {
-  return W.isHexa(a) ? m.hexToBuffer(a) : I.fromString(a).data;
+function A(t) {
+	return a.isHexa(t) ? r.hexToBuffer(t) : e.fromString(t).data;
 }
-function v(a) {
-  return W.isHexa(a) ? a : m.bufferToHex(ae(a));
+function j(e) {
+	return a.isHexa(e) ? e : r.bufferToHex(A(e));
 }
-function kt(a) {
-  return W.isHexa(a) ? new I(ae(a), E.defaultNetwork, O.GroupIdAddress).toString() : a;
+function he(n) {
+	return a.isHexa(n) ? new e(A(n), c.defaultNetwork, t.GroupIdAddress).toString() : n;
 }
-function U(a) {
-  return a == null || a === "" ? "" : BigInt(a) <= 0n ? "0" : a.toString();
+function M(e) {
+	return e == null || e === "" ? "" : BigInt(e) <= 0n ? "0" : e.toString();
 }
-function ee(a) {
-  let e = BigInt(0), t = BigInt(0);
-  return a.forEach((s) => {
-    e += BigInt(s.confirmed), t += BigInt(s.unconfirmed);
-  }), { confirmed: e.toString(), unconfirmed: t.toString() };
+function N(e) {
+	let t = BigInt(0), n = BigInt(0);
+	return e.forEach((e) => {
+		t += BigInt(e.confirmed), n += BigInt(e.unconfirmed);
+	}), {
+		confirmed: t.toString(),
+		unconfirmed: n.toString()
+	};
 }
-function K(a) {
-  const e = {};
-  return a.forEach((t) => {
-    for (const s in t)
-      e[s] ? (e[s].confirmed = (BigInt(e[s].confirmed) + BigInt(t[s].confirmed)).toString(), e[s].unconfirmed = (BigInt(e[s].unconfirmed) + BigInt(t[s].unconfirmed)).toString()) : e[s] = { confirmed: BigInt(t[s].confirmed).toString(), unconfirmed: BigInt(t[s].unconfirmed).toString() };
-  }), e;
+function P(e) {
+	let t = {};
+	return e.forEach((e) => {
+		for (let n in e) t[n] ? (t[n].confirmed = (BigInt(t[n].confirmed) + BigInt(e[n].confirmed)).toString(), t[n].unconfirmed = (BigInt(t[n].unconfirmed) + BigInt(e[n].unconfirmed)).toString()) : t[n] = {
+			confirmed: BigInt(e[n].confirmed).toString(),
+			unconfirmed: BigInt(e[n].unconfirmed).toString()
+		};
+	}), t;
 }
-const ne = {
-  // Images
-  //'.svg': { media: 'image', mime: 'image/svg+xml' },
-  ".gif": { media: "image", mime: "image/gif" },
-  ".png": { media: "image", mime: "image/png" },
-  ".apng": { media: "image", mime: "image/apng" },
-  ".jpg": { media: "image", mime: "image/jpeg" },
-  ".jpeg": { media: "image", mime: "image/jpeg" },
-  ".avif": { media: "image", mime: "image/avif" },
-  ".webp": { media: "image", mime: "image/webp" },
-  ".bmp": { media: "image", mime: "image/bmp" },
-  // Videos
-  ".mp4": { media: "video", mime: "video/mp4" },
-  ".mpeg": { media: "video", mime: "video/mpeg" },
-  ".mpg": { media: "video", mime: "video/mpeg" },
-  ".webm": { media: "video", mime: "video/webm" },
-  ".mov": { media: "video", mime: "video/quicktime" },
-  // Audio
-  ".mp3": { media: "audio", mime: "audio/mpeg" },
-  ".ogg": { media: "audio", mime: "audio/ogg" },
-  ".wav": { media: "audio", mime: "audio/wav" },
-  ".m4a": { media: "audio", mime: "audio/mp4" }
+var F = {
+	".gif": {
+		media: "image",
+		mime: "image/gif"
+	},
+	".png": {
+		media: "image",
+		mime: "image/png"
+	},
+	".apng": {
+		media: "image",
+		mime: "image/apng"
+	},
+	".jpg": {
+		media: "image",
+		mime: "image/jpeg"
+	},
+	".jpeg": {
+		media: "image",
+		mime: "image/jpeg"
+	},
+	".avif": {
+		media: "image",
+		mime: "image/avif"
+	},
+	".webp": {
+		media: "image",
+		mime: "image/webp"
+	},
+	".bmp": {
+		media: "image",
+		mime: "image/bmp"
+	},
+	".mp4": {
+		media: "video",
+		mime: "video/mp4"
+	},
+	".mpeg": {
+		media: "video",
+		mime: "video/mpeg"
+	},
+	".mpg": {
+		media: "video",
+		mime: "video/mpeg"
+	},
+	".webm": {
+		media: "video",
+		mime: "video/webm"
+	},
+	".mov": {
+		media: "video",
+		mime: "video/quicktime"
+	},
+	".mp3": {
+		media: "audio",
+		mime: "audio/mpeg"
+	},
+	".ogg": {
+		media: "audio",
+		mime: "audio/ogg"
+	},
+	".wav": {
+		media: "audio",
+		mime: "audio/wav"
+	},
+	".m4a": {
+		media: "audio",
+		mime: "audio/mp4"
+	}
 };
-function Tt(a) {
-  const e = a.lastIndexOf(".");
-  if (e === -1) return "unknown";
-  const t = a.slice(e).toLowerCase();
-  return ne[t]?.media ?? "unknown";
-}
-function It(a) {
-  const e = a.lastIndexOf(".");
-  if (e === -1) return "application/octet-stream";
-  const t = a.slice(e).toLowerCase();
-  return ne[t]?.mime ?? "application/octet-stream";
-}
-function xt(a) {
-  return new Promise((e) => setTimeout(e, a));
-}
-function Nt(a) {
-  let e = B.getPrettyValue(a);
-  return e.match(/\./) && (e = e.replace(/\.?0+$/, "")), e;
-}
-class Mt {
-  getPrefix() {
-    return C() ? "testnet-" : "";
-  }
-  async getEncryptedSeed() {
-    return this.getValue("seed");
-  }
-  async saveEncryptedSeed(e) {
-    return this.setValue("seed", e);
-  }
-  async getVersionCode() {
-    return this.getValue("version-code");
-  }
-  async setVersionCode(e) {
-    return this.setValue("version-code", e);
-  }
-  async getReleaseNumber() {
-    return this.getValue("release-number");
-  }
-  async setReleaseNumber(e) {
-    return this.setValue("release-number", e);
-  }
-  async getRostrumParams() {
-    const e = await this.getValue(this.getPrefix() + "rostrum-params");
-    if (e)
-      return JSON.parse(e);
-  }
-  async saveRostrumParams(e) {
-    return this.setValue(this.getPrefix() + "rostrum-params", JSON.stringify(e));
-  }
-  async removeRostrumParams() {
-    return this.removeValue(this.getPrefix() + "rostrum-params");
-  }
-  async setHideZeroTokenConfig(e) {
-    return this.setValue("zero-tokens", JSON.stringify(e));
-  }
-  async getHideZeroTokenConfig() {
-    return await this.getValue("zero-tokens") === "true";
-  }
-  async setHideZeroVaultsConfig(e) {
-    return this.setValue("zero-vaults", JSON.stringify(e));
-  }
-  async getHideZeroVaultsConfig() {
-    return await this.getValue("zero-vaults") === "true";
-  }
-  async getSelectedCurrency() {
-    return await this.getValue("selectedCurrency") || "usd";
-  }
-  async setSelectedCurrency(e) {
-    return this.setValue("selectedCurrency", e);
-  }
-  async getUseBiometric() {
-    return await this.getValue("biometrics") === "true";
-  }
-  async setUseBiometric(e) {
-    return this.setValue("biometrics", JSON.stringify(e));
-  }
-  async getRequireAuth() {
-    const e = await this.getValue("auth");
-    return M(e) || e === "true";
-  }
-  async setRequireAuth(e) {
-    await this.setValue("auth", JSON.stringify(e));
-  }
-  async getReleaseNotesTime() {
-    const e = await this.getValue("show-notes");
-    return e ? Number(e) : void 0;
-  }
-  async setReleaseNotesTime(e) {
-    M(e) ? await this.removeValue("show-notes") : await this.setValue("show-notes", e);
-  }
-  async getIsTestnet() {
-    return await this.getValue("testnet") === "1";
-  }
-  async setIsTestnet(e) {
-    await this.setValue("testnet", e ? "1" : "0");
-  }
-  async getAutoLockSeconds() {
-    const e = await this.getValue("auto-lock");
-    return e ? parseInt(e) : 60;
-  }
-  async setAutoLockSeconds(e) {
-    await this.setValue("auto-lock", `${e}`);
-  }
-}
-var h = /* @__PURE__ */ ((a) => (a[a.MAIN = 0] = "MAIN", a[a.VAULT = 1] = "VAULT", a[a.DAPP = 2] = "DAPP", a))(h || {}), y = /* @__PURE__ */ ((a) => (a[a.RECEIVE = 0] = "RECEIVE", a[a.CHANGE = 1] = "CHANGE", a))(y || {}), N = /* @__PURE__ */ ((a) => (a.SignMessage = "signMessage", a.AddToken = "addToken", a.SignTransaction = "signTransaction", a.SendTransaction = "sendTransaction", a))(N || {});
-class Et {
-  store;
-  updateCallback;
-  constructor(e) {
-    this.store = e;
-  }
-  onUpdate(e) {
-    this.updateCallback = e;
-  }
-  notify(e) {
-    this.updateCallback?.(e);
-  }
-  async initSchema() {
-    return this.store.initSchema();
-  }
-  async clearData() {
-    return this.store.clearData();
-  }
-  async addLocalTransaction(e) {
-    try {
-      await this.store.upsertTransaction(e), this.notify({ type: "tx_refresh" });
-    } catch (t) {
-      console.error(t);
-    }
-  }
-  async addAssetTransaction(e) {
-    return this.store.upsertAssetTransaction(e);
-  }
-  async getLocalTransactions(e, t) {
-    return this.store.getTransactions(e, t);
-  }
-  async getPageLocalTransactions(e, t, s, n) {
-    return this.store.getPageTransactions(e, t, s, n);
-  }
-  async countLocalTransactions(e, t) {
-    return this.store.countTransactions(e, t);
-  }
-  async clearLocalTransactions(e) {
-    await this.store.clearTransactions(e), this.notify({ type: "tx_refresh" });
-  }
-  async saveToken(e, t) {
-    const s = {
-      accountId: e,
-      tokenIdHex: t.tokenIdHex,
-      type: "token",
-      addedTime: J()
-    };
-    await this.store.upsertToken(t), await this.saveAsset(s), this.notify({ type: "token_refresh" });
-  }
-  async getLocalTokens(e, t, s) {
-    return this.store.getTokens(e, t, s);
-  }
-  async getToken(e) {
-    return this.store.getToken(e);
-  }
-  async deleteToken(e, t) {
-    await this.removeAsset(e, t), await this.store.countAssetsById(t) == 0 && await this.store.deleteToken(t), this.notify({ type: "token_refresh" });
-  }
-  async saveNft(e, t, s) {
-    const n = {
-      accountId: e,
-      tokenIdHex: t.tokenIdHex,
-      type: "nft",
-      addedTime: s
-    };
-    await this.store.upsertNft(t), await this.saveAsset(n), this.notify({ type: "nft_refresh" });
-  }
-  async getLocalNfts(e, t, s) {
-    return this.store.getNfts(e, t, s);
-  }
-  async getLocalNft(e) {
-    return this.store.getNft(e);
-  }
-  async deleteNft(e, t) {
-    await this.removeAsset(e, t), await this.store.countAssetsById(t) == 0 && await this.store.deleteNft(t), this.notify({ type: "nft_refresh" });
-  }
-  async countLocalNfts(e) {
-    return this.store.countNfts(e);
-  }
-  async getAssets(e, t) {
-    return this.store.getAssets(e, t);
-  }
-  async saveAsset(e) {
-    await this.store.upsertAsset(e);
-  }
-  async removeAsset(e, t) {
-    return this.store.deleteAsset(e, t);
-  }
-  async saveAccount(e) {
-    const t = {
-      id: e.id,
-      address: e.address,
-      name: e.name,
-      height: e.height,
-      hidden: e.hidden,
-      statusHash: e.statusHash,
-      balance: JSON.stringify(e.balance),
-      tokensBalance: JSON.stringify(e.tokensBalance)
-    };
-    return this.store.upsertAccount(t);
-  }
-  async getAccounts() {
-    return (await this.store.getAccounts()).map((t) => ({
-      ...t,
-      type: h.DAPP,
-      balance: JSON.parse(t.balance),
-      tokensBalance: JSON.parse(t.tokensBalance)
-    }));
-  }
-  async countAccounts() {
-    return this.store.countAccounts();
-  }
-  async updateAccountName(e, t) {
-    return this.store.updateAccountName(e, t);
-  }
-  async saveSession(e) {
-    return this.store.upsertSession(e);
-  }
-  async getAccountSessions(e) {
-    return this.store.getSessionsByAccount(e);
-  }
-  async removeSession(e) {
-    return this.store.deleteSession(e);
-  }
-  async saveAddress(e) {
-    const t = {
-      address: e.address,
-      idx: e.idx,
-      space: e.space,
-      height: e.height,
-      statusHash: e.statusHash,
-      used: e.used,
-      balance: JSON.stringify(e.balance),
-      tokensBalance: JSON.stringify(e.tokensBalance)
-    };
-    return this.store.upsertAddress(t);
-  }
-  async getReceiveAddresses() {
-    return (await this.store.getReceiveAddresses()).map((t) => ({
-      ...t,
-      type: h.MAIN,
-      balance: JSON.parse(t.balance),
-      tokensBalance: JSON.parse(t.tokensBalance)
-    }));
-  }
-  async getChangeAddresses() {
-    return (await this.store.getChangeAddresses()).map((t) => ({
-      ...t,
-      type: h.MAIN,
-      balance: JSON.parse(t.balance),
-      tokensBalance: JSON.parse(t.tokensBalance)
-    }));
-  }
-  async countAddresses() {
-    return this.store.countAddresses();
-  }
-  async getVaults() {
-    return (await this.store.getVaults()).map((t) => ({
-      ...t,
-      type: h.VAULT,
-      balance: JSON.parse(t.balance),
-      tokensBalance: JSON.parse(t.tokensBalance)
-    }));
-  }
-  async saveVault(e) {
-    const t = {
-      address: e.address,
-      idx: e.idx,
-      block: e.block,
-      height: e.height,
-      statusHash: e.statusHash,
-      balance: JSON.stringify(e.balance),
-      tokensBalance: JSON.stringify(e.tokensBalance)
-    };
-    return this.store.upsertVault(t);
-  }
-}
-class Ct {
-  walletDb;
-  tokens = /* @__PURE__ */ new Map();
-  nfts = /* @__PURE__ */ new Map();
-  constructor(e) {
-    this.walletDb = e;
-  }
-  clear() {
-    this.tokens.clear(), this.nfts.clear();
-  }
-  hasToken(e) {
-    return e = v(e), this.tokens.has(e);
-  }
-  hasNft(e) {
-    return e = v(e), this.nfts.has(e);
-  }
-  async getToken(e) {
-    if (e = v(e), this.tokens.has(e))
-      return this.tokens.get(e);
-    const t = await this.walletDb.getToken(e);
-    return t && this.tokens.set(e, t), t;
-  }
-  async getNft(e) {
-    if (e = v(e), this.nfts.has(e))
-      return this.nfts.get(e);
-    const t = await this.walletDb.getLocalNft(e);
-    return t && this.nfts.set(e, t), t;
-  }
-  removeToken(e) {
-    this.tokens.delete(v(e));
-  }
-  removeNft(e) {
-    this.nfts.delete(v(e));
-  }
-}
-class ie {
-  kvStore;
-  client;
-  constructor(e) {
-    this.kvStore = e;
-  }
-  getFeatures() {
-    return this.execute("server.features");
-  }
-  getBlockTip() {
-    return this.execute("blockchain.headers.tip");
-  }
-  getBalance(e) {
-    return this.execute("blockchain.address.get_balance", e, "exclude_tokens");
-  }
-  getTransactionsHistory(e, t = 0) {
-    return this.execute("blockchain.address.get_history", e, { from_height: t });
-  }
-  getFirstUse(e) {
-    return this.execute("blockchain.address.get_first_use", e);
-  }
-  async isAddressUsed(e) {
-    try {
-      const t = await this.getFirstUse(e);
-      return !!(t.tx_hash && t.tx_hash !== "");
-    } catch (t) {
-      if (t instanceof Error && t.message.includes("not found"))
-        return !1;
-      throw t;
-    }
-  }
-  getTransaction(e, t = !0) {
-    return this.execute("blockchain.transaction.get", e, t);
-  }
-  getUtxo(e) {
-    return this.execute("blockchain.utxo.get", e);
-  }
-  getNexaUtxos(e) {
-    return this.execute("blockchain.address.listunspent", e, "exclude_tokens");
-  }
-  async getTokenUtxos(e, t) {
-    return (await this.execute("token.address.listunspent", e, null, t)).unspent;
-  }
-  async getTokensBalance(e) {
-    const t = await this.execute("token.address.get_balance", e), s = {};
-    for (const n in t.confirmed)
-      t.confirmed[n] != 0 && (s[n] = { confirmed: BigInt(t.confirmed[n]).toString(), unconfirmed: "0" });
-    for (const n in t.unconfirmed)
-      t.unconfirmed[n] != 0 && (s[n] ? s[n].unconfirmed = BigInt(t.unconfirmed[n]).toString() : s[n] = { confirmed: "0", unconfirmed: BigInt(t.unconfirmed[n]).toString() });
-    return s;
-  }
-  getTokenGenesis(e) {
-    return this.execute("token.genesis.info", e);
-  }
-  broadcast(e) {
-    return this.execute("blockchain.transaction.broadcast", e);
-  }
-  subscribeHeaders(e) {
-    return this.client.subscribe((t) => {
-      const s = Array.isArray(t) ? t[0] : t, n = typeof s?.height == "number" ? s.height : 0;
-      e(n);
-    }, "blockchain.headers.subscribe");
-  }
-  subscribeAddress(e, t) {
-    return this.client.subscribe(t, "blockchain.address.subscribe", e);
-  }
-  async getLatency() {
-    try {
-      const e = Date.now();
-      return await this.getBlockTip() ? Date.now() - e : 0;
-    } catch {
-      return 0;
-    }
-  }
-  async connect(e) {
-    try {
-      e || (e = await this.getCurrentInstance()), this.client = new be("com.otoplo.wallet", "1.4.3", e.host, e.port, e.scheme, 45 * 1e3, 10 * 1e3), await this.client.connect();
-    } catch (t) {
-      throw t instanceof Error ? console.info(t.message) : console.error(t), t;
-    }
-  }
-  async disconnect(e) {
-    try {
-      return await this.client?.disconnect(e) ?? !1;
-    } catch (t) {
-      return console.error(t), !1;
-    }
-  }
-  async execute(e, ...t) {
-    await this.waitForConnection();
-    const s = await this.client.request(e, ...t);
-    if (s instanceof Error)
-      throw s;
-    return s;
-  }
-  waitForConnection(e = 5e3) {
-    const t = Date.now();
-    return new Promise((s, n) => {
-      const i = () => {
-        if (this.client?.connectionStatus == Se.CONNECTED)
-          return s();
-        if (Date.now() - t > e)
-          return n(new Error("Rostrum Connection timeout"));
-        setTimeout(i, 250);
-      };
-      i();
-    });
-  }
-  async getCurrentInstance() {
-    const e = await this.kvStore.getRostrumParams();
-    return e || ie.getPredefinedInstances()[0];
-  }
-  static getPredefinedInstances() {
-    return C() ? [
-      {
-        scheme: H.WSS,
-        host: "testnet-electrum.nexa.org",
-        port: 30004,
-        label: "NexaOrg"
-      }
-    ] : [
-      {
-        scheme: H.WSS,
-        host: "rostrum.otoplo.com",
-        port: 443,
-        label: "Otoplo"
-      },
-      {
-        scheme: H.WSS,
-        host: "electrum.nexa.org",
-        port: 20004,
-        label: "NexaOrg"
-      }
-    ];
-  }
-}
-function k(a, e, t) {
-  return `${a}'/${e}/${t}`;
-}
-function Ce(a) {
-  const e = a.split("/");
-  return {
-    account: parseInt(e[0].replace("'", "")),
-    type: parseInt(e[1]),
-    index: parseInt(e[2])
-  };
+function ge(e) {
+	let t = e.lastIndexOf(".");
+	return t === -1 ? "unknown" : F[e.slice(t).toLowerCase()]?.media ?? "unknown";
 }
-class Pt {
-  seed;
-  masterKey;
-  accountKeys = /* @__PURE__ */ new Map();
-  walletKeys = /* @__PURE__ */ new Map();
-  init(e) {
-    this.seed = typeof e == "string" ? ke(e) : e, this.masterKey = j.fromSeed(this.seed).deriveChild(44, !0).deriveChild(29223, !0);
-  }
-  reset() {
-    if (!this.seed)
-      throw new Error("KeysManager not initialized");
-    this.masterKey = j.fromSeed(this.seed).deriveChild(44, !0).deriveChild(29223, !0), this.accountKeys.clear(), this.walletKeys.clear();
-  }
-  getAccountKey(e) {
-    let t = this.accountKeys.get(e);
-    return t || (t = this.masterKey.deriveChild(e, !0), this.accountKeys.set(e, t)), t;
-  }
-  getKey(e) {
-    const t = typeof e == "string" ? e : k(e.account, e.type, e.index);
-    let s = this.walletKeys.get(t);
-    if (!s) {
-      const { account: n, type: i, index: o } = typeof e == "string" ? Ce(e) : e;
-      s = this.getAccountKey(n).deriveChild(i, !1).deriveChild(o, !1), this.walletKeys.set(t, s);
-    }
-    return s;
-  }
+function _e(e) {
+	let t = e.lastIndexOf(".");
+	return t === -1 ? "application/octet-stream" : F[e.slice(t).toLowerCase()]?.mime ?? "application/octet-stream";
 }
-function Bt(a, e) {
-  return a && typeof a == "string" ? a.startsWith("http") ? a.replace("http://", "https://") : a.startsWith("ipfs://") ? a : `${new URL(e).origin}${a}` : "";
+function ve(e) {
+	return new Promise((t) => setTimeout(t, e));
 }
-function Ot(a) {
-  return a ? Pe(a) : null;
+function ye(e) {
+	let t = y.getPrettyValue(e);
+	return t.match(/\./) && (t = t.replace(/\.?0+$/, "")), t;
 }
-function Pe(a, e = "https://ipfs.nebula.markets/") {
-  return a?.startsWith("ipfs://") ? e + a.substring(7) : a;
-}
-function Be(a) {
-  return Oe(`${re()}/metadata/${a}`, "json");
-}
-function _t(a, e) {
-  return `${re()}/assets/${a}/${e}`;
-}
-function re() {
-  return `https://${C() ? "testapi" : "api"}.otoplo.com`;
-}
-async function Oe(a, e) {
-  try {
-    const t = await fetch(a);
-    if (!t.ok)
-      throw new Error(`Failed to perform GET. status: ${t.status}`);
-    if (e !== "raw") return await t.json();
-  } catch (t) {
-    throw new Error(`Unexpected Error: ${t}`);
-  }
-}
-class Ut {
-  walletDb;
-  walletCache;
-  constructor(e, t) {
-    this.walletDb = e, this.walletCache = t;
-  }
-  async getAssetInfo(e) {
-    try {
-      if (this.walletCache.hasToken(e)) {
-        const t = await this.walletCache.getToken(e);
-        return {
-          type: "token",
-          parent: t.parent,
-          token: t.token,
-          tokenIdHex: t.tokenIdHex,
-          data: {
-            name: t.name,
-            ticker: t.ticker,
-            decimals: t.decimals,
-            iconUrl: t.iconUrl
-          }
-        };
-      }
-      if (this.walletCache.hasNft(e)) {
-        const t = await this.walletCache.getNft(e);
-        return {
-          type: "nft",
-          parent: t.parent,
-          token: t.token,
-          tokenIdHex: t.tokenIdHex,
-          data: {
-            name: t.name,
-            series: t.series,
-            collection: t.collection,
-            author: t.author,
-            public: t.public,
-            front: t.front,
-            back: t.back
-          }
-        };
-      }
-      return await Be(e);
-    } catch (t) {
-      console.error(t);
-      return;
-    }
-  }
-  async handleNftReceive(e, t, s) {
-    const n = await this.getAssetInfo(t);
-    if (n && n.type == "nft") {
-      const i = {
-        token: n.token,
-        tokenIdHex: n.tokenIdHex,
-        parent: n.parent,
-        ...n.data
-      };
-      await this.walletDb.saveNft(e, i, s);
-    }
-  }
-  async syncTokens(e, t) {
-    for (const s in t) {
-      const n = t[s];
-      if (n && BigInt(n.confirmed) + BigInt(n.unconfirmed) > 0n) {
-        const i = await this.getAssetInfo(s);
-        if (i && i.type == "token") {
-          const o = {
-            token: i.token,
-            tokenIdHex: i.tokenIdHex,
-            parent: i.parent,
-            ...i.data
-          };
-          await this.walletDb.saveToken(e, o);
-        }
-      }
-    }
-  }
-  async syncNfts(e, t) {
-    const s = Object.keys(t), n = await this.walletDb.getAssets(e, "nft"), i = n?.filter((o) => !s.includes(o.tokenIdHex)) ?? [];
-    for (const o of i)
-      await this.deleteNft(e, o.tokenIdHex);
-    for (const [o, r] of Object.entries(t)) {
-      const c = v(o), d = r && BigInt(r.confirmed) + BigInt(r.unconfirmed) > 0n, u = n?.some((l) => l.tokenIdHex == c);
-      !d && !u || d && u || (!d && u ? await this.deleteNft(e, c) : await this.handleNftReceive(e, c, J()));
-    }
-  }
-  async deleteToken(e, t) {
-    await this.walletDb.deleteToken(e, t), this.walletCache.removeToken(t);
-  }
-  async deleteNft(e, t) {
-    await this.walletDb.deleteNft(e, t), this.walletCache.removeNft(t);
-  }
+// src/persistence/wallet-db.ts
+var be = class {
+	constructor(e) {
+		this.repository = e;
+	}
+	initSchema() {
+		return this.repository.initSchema();
+	}
+	clearData() {
+		return this.repository.clearData();
+	}
+	upsertTransaction(e) {
+		let t = {
+			...e,
+			othersOutputs: JSON.stringify(e.othersOutputs),
+			myOutputs: JSON.stringify(e.myOutputs),
+			myInputs: JSON.stringify(e.myInputs)
+		};
+		return this.repository.upsertTransaction(t);
+	}
+	upsertAssetTransaction(e) {
+		return this.repository.upsertAssetTransaction(e);
+	}
+	async getTransactions(e, t) {
+		return (await this.repository.getTransactions(e, t)).map((e) => ({
+			...e,
+			othersOutputs: JSON.parse(e.othersOutputs),
+			myOutputs: JSON.parse(e.myOutputs),
+			myInputs: JSON.parse(e.myInputs)
+		}));
+	}
+	async getPageTransactions(e, t, n, r) {
+		return (await this.repository.getPageTransactions(e, t, n, r)).map((e) => ({
+			...e,
+			othersOutputs: JSON.parse(e.othersOutputs),
+			myOutputs: JSON.parse(e.myOutputs),
+			myInputs: JSON.parse(e.myInputs)
+		}));
+	}
+	countTransactions(e, t) {
+		return this.repository.countTransactions(e, t);
+	}
+	clearTransactions(e) {
+		return this.repository.clearTransactions(e);
+	}
+	async saveToken(e, t) {
+		let n = {
+			accountId: e,
+			tokenIdHex: t.tokenIdHex,
+			type: "token",
+			addedTime: O()
+		};
+		await this.repository.upsertToken(t), await this.saveAsset(n);
+	}
+	getTokens(e, t, n) {
+		return this.repository.getTokens(e, t, n);
+	}
+	getToken(e) {
+		return this.repository.getToken(e);
+	}
+	async deleteToken(e, t) {
+		await this.removeAsset(e, t), await this.repository.countAssetsById(t) == 0 && await this.repository.deleteToken(t);
+	}
+	async saveNft(e, t, n) {
+		let r = {
+			accountId: e,
+			tokenIdHex: t.tokenIdHex,
+			type: "nft",
+			addedTime: n
+		};
+		await this.repository.upsertNft(t), await this.saveAsset(r);
+	}
+	getNfts(e, t, n) {
+		return this.repository.getNfts(e, t, n);
+	}
+	getNft(e) {
+		return this.repository.getNft(e);
+	}
+	async deleteNft(e, t) {
+		await this.removeAsset(e, t), await this.repository.countAssetsById(t) == 0 && await this.repository.deleteNft(t);
+	}
+	countNfts(e) {
+		return this.repository.countNfts(e);
+	}
+	getAssets(e, t) {
+		return this.repository.getAssets(e, t);
+	}
+	saveAsset(e) {
+		return this.repository.upsertAsset(e);
+	}
+	removeAsset(e, t) {
+		return this.repository.deleteAsset(e, t);
+	}
+	saveAccount(e) {
+		let t = {
+			id: e.id,
+			address: e.address,
+			name: e.name,
+			height: e.height,
+			hidden: e.hidden,
+			statusHash: e.statusHash,
+			balance: JSON.stringify(e.balance),
+			tokensBalance: JSON.stringify(e.tokensBalance)
+		};
+		return this.repository.upsertAccount(t);
+	}
+	async getAccounts() {
+		return (await this.repository.getAccounts()).map((e) => ({
+			...e,
+			type: S.DAPP,
+			balance: JSON.parse(e.balance),
+			tokensBalance: JSON.parse(e.tokensBalance)
+		}));
+	}
+	countAccounts() {
+		return this.repository.countAccounts();
+	}
+	updateAccountName(e, t) {
+		return this.repository.updateAccountName(e, t);
+	}
+	saveSession(e) {
+		return this.repository.upsertSession(e);
+	}
+	getAccountSessions(e) {
+		return this.repository.getSessionsByAccount(e);
+	}
+	removeSession(e) {
+		return this.repository.deleteSession(e);
+	}
+	saveAddress(e) {
+		let t = {
+			address: e.address,
+			idx: e.idx,
+			space: e.space,
+			height: e.height,
+			statusHash: e.statusHash,
+			used: e.used,
+			balance: JSON.stringify(e.balance),
+			tokensBalance: JSON.stringify(e.tokensBalance)
+		};
+		return this.repository.upsertAddress(t);
+	}
+	async getReceiveAddresses() {
+		return (await this.repository.getReceiveAddresses()).map((e) => ({
+			...e,
+			type: S.MAIN,
+			balance: JSON.parse(e.balance),
+			tokensBalance: JSON.parse(e.tokensBalance)
+		}));
+	}
+	async getChangeAddresses() {
+		return (await this.repository.getChangeAddresses()).map((e) => ({
+			...e,
+			type: S.MAIN,
+			balance: JSON.parse(e.balance),
+			tokensBalance: JSON.parse(e.tokensBalance)
+		}));
+	}
+	countAddresses() {
+		return this.repository.countAddresses();
+	}
+	async getVaults() {
+		return (await this.repository.getVaults()).map((e) => ({
+			...e,
+			type: S.VAULT,
+			balance: JSON.parse(e.balance),
+			tokensBalance: JSON.parse(e.tokensBalance)
+		}));
+	}
+	saveVault(e) {
+		let t = {
+			address: e.address,
+			idx: e.idx,
+			block: e.block,
+			height: e.height,
+			statusHash: e.statusHash,
+			balance: JSON.stringify(e.balance),
+			tokensBalance: JSON.stringify(e.tokensBalance)
+		};
+		return this.repository.upsertVault(t);
+	}
+	getSetting(e) {
+		return this.repository.getSetting(e);
+	}
+	saveSetting(e, t) {
+		return this.repository.saveSetting(e, t);
+	}
+	removeSetting(e) {
+		return this.repository.deleteSetting(e);
+	}
+}, xe = class {
+	constructor(e) {
+		this.tokens = /* @__PURE__ */ new Map(), this.nfts = /* @__PURE__ */ new Map(), this.walletDb = e;
+	}
+	clear() {
+		this.tokens.clear(), this.nfts.clear();
+	}
+	async getToken(e) {
+		if (e = j(e), this.tokens.has(e)) return this.tokens.get(e);
+		let t = await this.walletDb.getToken(e);
+		return t && this.tokens.set(e, t), t;
+	}
+	async getNft(e) {
+		if (e = j(e), this.nfts.has(e)) return this.nfts.get(e);
+		let t = await this.walletDb.getNft(e);
+		return t && this.nfts.set(e, t), t;
+	}
+	removeToken(e) {
+		this.tokens.delete(j(e));
+	}
+	removeNft(e) {
+		this.nfts.delete(j(e));
+	}
+}, Se = class e {
+	constructor(e) {
+		this.walletDb = e;
+	}
+	getFeatures() {
+		return this.execute("server.features");
+	}
+	getBlockTip() {
+		return this.execute("blockchain.headers.tip");
+	}
+	getBalance(e) {
+		return this.execute("blockchain.address.get_balance", e, "exclude_tokens");
+	}
+	getTransactionsHistory(e, t = 0) {
+		return this.execute("blockchain.address.get_history", e, { from_height: t });
+	}
+	getFirstUse(e) {
+		return this.execute("blockchain.address.get_first_use", e);
+	}
+	async isAddressUsed(e) {
+		try {
+			let t = await this.getFirstUse(e);
+			return !!(t.tx_hash && t.tx_hash !== "");
+		} catch (e) {
+			if (e instanceof Error && e.message.includes("not found")) return !1;
+			throw e;
+		}
+	}
+	getTransaction(e, t = !0) {
+		return this.execute("blockchain.transaction.get", e, t);
+	}
+	getUtxo(e) {
+		return this.execute("blockchain.utxo.get", e);
+	}
+	getNexaUtxos(e) {
+		return this.execute("blockchain.address.listunspent", e, "exclude_tokens");
+	}
+	async getTokenUtxos(e, t) {
+		return (await this.execute("token.address.listunspent", e, null, t)).unspent;
+	}
+	async getTokensBalance(e) {
+		let t = await this.execute("token.address.get_balance", e), n = {};
+		for (let e in t.confirmed) t.confirmed[e] != 0 && (n[e] = {
+			confirmed: BigInt(t.confirmed[e]).toString(),
+			unconfirmed: "0"
+		});
+		for (let e in t.unconfirmed) t.unconfirmed[e] != 0 && (n[e] ? n[e].unconfirmed = BigInt(t.unconfirmed[e]).toString() : n[e] = {
+			confirmed: "0",
+			unconfirmed: BigInt(t.unconfirmed[e]).toString()
+		});
+		return n;
+	}
+	getTokenGenesis(e) {
+		return this.execute("token.genesis.info", e);
+	}
+	broadcast(e) {
+		return this.execute("blockchain.transaction.broadcast", e);
+	}
+	subscribeHeaders(e) {
+		return this.client.subscribe((t) => {
+			let n = Array.isArray(t) ? t[0] : t;
+			e(typeof n?.height == "number" ? n.height : 0);
+		}, "blockchain.headers.subscribe");
+	}
+	subscribeAddress(e, t) {
+		return this.client.subscribe(t, "blockchain.address.subscribe", e);
+	}
+	async getLatency() {
+		try {
+			let e = Date.now();
+			return await this.getBlockTip() ? Date.now() - e : 0;
+		} catch {
+			return 0;
+		}
+	}
+	async connect(e) {
+		try {
+			e ||= await this.getCurrentInstance(), this.client = new ne("com.otoplo.wallet", "1.4.3", e.host, e.port, e.scheme, 45e3, 1e4), await this.client.connect();
+		} catch (e) {
+			throw e instanceof Error ? console.info(e.message) : console.error(e), e;
+		}
+	}
+	async disconnect(e) {
+		try {
+			return await this.client?.disconnect(e) ?? !1;
+		} catch (e) {
+			return console.error(e), !1;
+		}
+	}
+	async execute(e, ...t) {
+		await this.waitForConnection();
+		let n = await this.client.request(e, ...t);
+		if (n instanceof Error) throw n;
+		return n;
+	}
+	waitForConnection(e = 5e3) {
+		let t = Date.now();
+		return new Promise((n, r) => {
+			let i = () => {
+				if (this.client?.connectionStatus == te.CONNECTED) return n();
+				if (Date.now() - t > e) return r(/* @__PURE__ */ Error("Rostrum Connection timeout"));
+				setTimeout(i, 250);
+			};
+			i();
+		});
+	}
+	setCurrentInstance(e) {
+		return this.walletDb.saveSetting("rostrum-params", JSON.stringify(e));
+	}
+	resetCurrentInstance() {
+		return this.walletDb.removeSetting("rostrum-params");
+	}
+	async getCurrentInstance() {
+		let t = await this.walletDb.getSetting("rostrum-params");
+		return t ? JSON.parse(t) : e.getPredefinedInstances()[0];
+	}
+	static getPredefinedInstances() {
+		return E() ? [{
+			scheme: b.WSS,
+			host: "testnet-electrum.nexa.org",
+			port: 30004,
+			label: "NexaOrg"
+		}] : [{
+			scheme: b.WSS,
+			host: "rostrum.otoplo.com",
+			port: 443,
+			label: "Otoplo"
+		}, {
+			scheme: b.WSS,
+			host: "electrum.nexa.org",
+			port: 20004,
+			label: "NexaOrg"
+		}];
+	}
+};
+// src/utils/keypath.ts
+function I(e, t, n) {
+	return `${e}'/${t}/${n}`;
 }
-class Dt {
-  rostrumService;
-  keyManager;
-  walletDb;
-  MAX_INPUTS_OUTPUTS = 250;
-  constructor(e, t, s) {
-    this.rostrumService = e, this.keyManager = t, this.walletDb = s;
-  }
-  async broadcastTransaction(e) {
-    return this.rostrumService.broadcast(e);
-  }
-  async fetchTransactionsHistory(e, t) {
-    let s = t;
-    const n = t > 0 ? t + 1 : 0, i = await this.rostrumService.getTransactionsHistory(e, n);
-    for (const o of i)
-      s = Math.max(s, o.height);
-    return { txs: i, lastHeight: s };
-  }
-  async fetchVaultTransactions(e) {
-    const t = await this.rostrumService.getTransactionsHistory(e, Ee), s = [];
-    for (const n of t) {
-      const i = this.classifyTransaction(n.tx_hash, [e]);
-      s.push(i);
-    }
-    return Promise.all(s);
-  }
-  async classifyAndSaveTransaction(e, t, s) {
-    const n = await this.classifyTransaction(t, s);
-    n.accountId = e;
-    const i = {
-      ...n,
-      othersOutputs: JSON.stringify(n.othersOutputs),
-      myOutputs: JSON.stringify(n.myOutputs),
-      myInputs: JSON.stringify(n.myInputs)
-    }, o = /* @__PURE__ */ new Set();
-    n.myInputs.forEach((r) => r.assetId && o.add(r.assetId)), n.myOutputs.forEach((r) => r.assetId && o.add(r.assetId));
-    for (const r of o)
-      await this.walletDb.addAssetTransaction({
-        accountId: e,
-        assetId: r,
-        txIdem: n.txIdem,
-        time: n.time
-      });
-    await this.walletDb.addLocalTransaction(i);
-  }
-  async classifyTransaction(e, t) {
-    const s = await this.rostrumService.getTransaction(e), n = [], i = [], o = [], r = [];
-    for (const l of s.vin) {
-      const p = {
-        address: l.addresses[0],
-        nexaAmount: l.value_satoshi.toString(),
-        assetId: l.token_id_hex ?? "",
-        assetAmount: U(l.groupQuantity)
-      };
-      t.includes(p.address) ? n.push(p) : i.push(p);
-    }
-    for (const l of s.vout) {
-      if (M(l.scriptPubKey.addresses)) continue;
-      const p = {
-        address: l.scriptPubKey.addresses[0],
-        nexaAmount: l.value_satoshi.toString(),
-        assetId: l.scriptPubKey.token_id_hex ?? "",
-        assetAmount: U(l.scriptPubKey.groupQuantity)
-      };
-      t.includes(p.address) ? o.push(p) : r.push(p);
-    }
-    let c;
-    n.length === 0 ? c = "receive" : o.length === 0 ? c = "send" : i.length === 0 && r.length === 0 ? c = "self" : i.length === 0 && r.length > 0 ? c = "send" : i.length > 0 && r.length === 0 ? c = "receive" : c = "swap";
-    const d = s.height > 0;
-    return {
-      accountId: 0,
-      // Will be set in classifyAndSaveTransaction
-      txId: s.txid,
-      txIdem: s.txidem,
-      time: d ? s.time : J(),
-      height: d ? s.height : 0,
-      type: c,
-      fee: s.fee_satoshi.toString(),
-      othersOutputs: c == "send" || c == "swap" ? r : [],
-      myOutputs: o,
-      myInputs: n
-    };
-  }
-  async buildAndSignTransferTransaction(e, t, s, n, i, o, r, c) {
-    const d = {
-      feeFromAmount: i
-    }, u = this.prepareTransaction(t, n, o, c);
-    r && u.feePerByte(r);
-    let l = /* @__PURE__ */ new Map();
-    o && (l = await this.populateTokenInputsAndChange(u, e, s, o, BigInt(n)));
-    const p = await this.populateNexaInputsAndChange(u, e, s, d);
-    return l.forEach((f, P) => p.set(P, f)), await this.finalizeTransaction(u, Array.from(p.values()));
-  }
-  async buildAndSignConsolidateTransaction(e, t, s) {
-    const n = {
-      isConsolidate: !0,
-      templateData: s
-    }, i = new z(), o = await this.populateNexaInputsAndChange(i, e, t, n);
-    return this.finalizeTransaction(i, Array.from(o.values()));
-  }
-  prepareTransaction(e, t, s, n) {
-    if (!R(e) && !R(e, O.PayToPublicKeyHash))
-      throw new Error("Invalid Address.");
-    if (s && BigInt(t) < 1n || !s && parseInt(t) < x.DUST_AMOUNT)
-      throw new Error("The amount is too low.");
-    if (s && BigInt(t) > Q || !s && parseInt(t) > x.MAX_MONEY)
-      throw new Error("The amount is too high.");
-    const i = new z();
-    if (n && i.addData(n), s) {
-      if (!R(s, O.GroupIdAddress))
-        throw new Error("Invalid Token ID");
-      if (I.getOutputType(e) === 0)
-        throw new Error("Token must be sent to script template address");
-      i.to(e, x.DUST_AMOUNT, s, BigInt(t));
-    } else
-      i.to(e, t);
-    return i;
-  }
-  async populateNexaInputsAndChange(e, t, s, n) {
-    const i = t.filter((d) => BigInt(d.balance.confirmed) + BigInt(d.balance.unconfirmed) > 0n);
-    if (M(i))
-      throw new Error("Not enough Nexa balance.");
-    const o = /* @__PURE__ */ new Map(), r = n.isConsolidate ? 0 : Number(e.transaction.outputs.find((d) => d.value > 0n).value);
-    for (const d of i) {
-      const u = await this.rostrumService.getNexaUtxos(d.address);
-      for (const l of u) {
-        const p = {
-          outpoint: l.outpoint_hash,
-          address: d.address,
-          satoshis: l.value,
-          templateData: n.templateData
-        };
-        if (e.from(p), !o.has(d.address)) {
-          const f = this.keyManager.getKey(d.keyPath);
-          o.set(d.address, f.privateKey);
-        }
-        if (n.isConsolidate) {
-          if (e.change(s), e.transaction.inputs.length > this.MAX_INPUTS_OUTPUTS)
-            return o;
-        } else {
-          const f = e.transaction;
-          if (f.inputs.length > this.MAX_INPUTS_OUTPUTS)
-            throw new Error("Too many inputs. Consider consolidate transactions or reduce the send amount.");
-          const P = f.getUnspentValue();
-          if (P < 0n)
-            continue;
-          if (P == 0n && n.feeFromAmount) {
-            const D = f.estimateRequiredFee();
-            return f.updateOutputAmount(0, r - D), o;
-          }
-          if (e.change(s), n.feeFromAmount) {
-            const D = f.getChangeOutput();
-            let V = f.estimateRequiredFee();
-            f.updateOutputAmount(0, r - V), !D && f.getChangeOutput() && (V = f.estimateRequiredFee(), f.updateOutputAmount(0, r - V));
-          }
-          if (f.getUnspentValue() < f.estimateRequiredFee())
-            continue;
-          return o;
-        }
-      }
-    }
-    if (n.isConsolidate) {
-      if (o.size > 0)
-        return o;
-      throw new Error("Not enough Nexa balance.");
-    }
-    const c = {
-      errorMsg: "Not enough Nexa balance.",
-      amount: q.formatNEXA(e.transaction.outputs[0].value),
-      fee: q.formatNEXA(e.transaction.estimateRequiredFee())
-    };
-    throw new Error(JSON.stringify(c));
-  }
-  async populateTokenInputsAndChange(e, t, s, n, i) {
-    const o = v(n), r = t.filter((u) => Object.keys(u.tokensBalance).includes(o));
-    if (M(r))
-      throw new Error("Not enough token balance.");
-    const c = /* @__PURE__ */ new Map();
-    let d = 0n;
-    for (const u of r) {
-      const l = await this.rostrumService.getTokenUtxos(u.address, n);
-      for (const p of l)
-        if (!(BigInt(p.token_amount) < 0n)) {
-          if (e.from({
-            outpoint: p.outpoint_hash,
-            address: u.address,
-            satoshis: p.value,
-            groupId: p.group,
-            groupAmount: BigInt(p.token_amount)
-          }), d = d + BigInt(p.token_amount), !c.has(u.address)) {
-            const f = this.keyManager.getKey(u.keyPath);
-            c.set(u.address, f.privateKey);
-          }
-          if (d > Q)
-            throw new Error("Token inputs exceeded max amount. Consider sending in small chunks");
-          if (e.transaction.inputs.length > this.MAX_INPUTS_OUTPUTS)
-            throw new Error("Too many inputs. Consider consolidating transactions or reduce the send amount.");
-          if (d == i)
-            return c;
-          if (d > i)
-            return e.to(s, x.DUST_AMOUNT, n, d - i), c;
-        }
-    }
-    throw new Error("Not enough token balance");
-  }
-  async finalizeTransaction(e, t) {
-    const s = await this.rostrumService.getBlockTip();
-    return e.lockUntilBlockHeight(s.height).sign(t).build();
-  }
-  printTransactionJson(e) {
-    if (!e)
-      return "";
-    const t = {
-      ...e.toObject(),
-      hex: e.toString()
-    };
-    return JSON.stringify(t, null, 2);
-  }
+function L(e) {
+	let t = e.split("/");
+	return {
+		account: parseInt(t[0].replace("'", "")),
+		type: parseInt(t[1]),
+		index: parseInt(t[2])
+	};
 }
-function Vt(a = 12) {
-  return Te(se, a === 24 ? 256 : 128);
+// src/services/key.ts
+var R = class {
+	constructor() {
+		this.accountKeys = /* @__PURE__ */ new Map(), this.walletKeys = /* @__PURE__ */ new Map();
+	}
+	static {
+		this.GAP_LIMIT = 20;
+	}
+	init(e) {
+		this.seed = typeof e == "string" ? ie(e) : e, this.masterKey = o.fromSeed(this.seed).deriveChild(44, !0).deriveChild(29223, !0);
+	}
+	reset() {
+		if (!this.seed) throw Error("KeysManager not initialized");
+		this.masterKey = o.fromSeed(this.seed).deriveChild(44, !0).deriveChild(29223, !0), this.accountKeys.clear(), this.walletKeys.clear();
+	}
+	getAccountKey(e) {
+		let t = this.accountKeys.get(e);
+		return t || (t = this.masterKey.deriveChild(e, !0), this.accountKeys.set(e, t)), t;
+	}
+	deriveAddress(e, t, n) {
+		return this.getKey({
+			account: e,
+			type: t,
+			index: n
+		}).privateKey.toAddress().toString();
+	}
+	getKey(e) {
+		let t = typeof e == "string" ? e : I(e.account, e.type, e.index), n = this.walletKeys.get(t);
+		if (!n) {
+			let { account: r, type: i, index: a } = typeof e == "string" ? L(e) : e;
+			n = this.getAccountKey(r).deriveChild(i, !1).deriveChild(a, !1), this.walletKeys.set(t, n);
+		}
+		return n;
+	}
+};
+// src/utils/asset.ts
+function Ce(e, t) {
+	return e && typeof e == "string" ? e.startsWith("http") ? e.replace("http://", "https://") : e.startsWith("ipfs://") ? e : `${new URL(t).origin}${e}` : "";
 }
-function _e(a) {
-  return Ie(a, se);
+function we(e) {
+	return e ? Te(e) : null;
 }
-async function oe(a, e) {
-  const t = await crypto.subtle.importKey(
-    "raw",
-    new Uint8Array(a),
-    "PBKDF2",
-    !1,
-    ["deriveKey"]
-  );
-  return crypto.subtle.deriveKey(
-    {
-      name: "PBKDF2",
-      salt: new Uint8Array(e),
-      iterations: 21e4,
-      hash: "SHA-256"
-    },
-    t,
-    {
-      name: "AES-GCM",
-      length: 256
-    },
-    !1,
-    ["encrypt", "decrypt"]
-  );
+function Te(e, t = "https://ipfs.nebula.markets/") {
+	return e?.startsWith("ipfs://") ? t + e.substring(7) : e;
 }
-async function Ht(a, e) {
-  const t = m.utf8ToBuffer(e), s = m.getRandomBuffer(16), n = m.getRandomBuffer(12), i = m.utf8ToBuffer(a), o = await oe(t, s), r = await crypto.subtle.encrypt(
-    {
-      name: "AES-GCM",
-      iv: new Uint8Array(n)
-    },
-    o,
-    new Uint8Array(i)
-  ), c = m.concat([s, n, new Uint8Array(r)]);
-  return m.bufferToBase64(c);
+function z(e) {
+	return `${V()}/metadata/${e}`;
 }
-async function Ue(a, e) {
-  const t = m.utf8ToBuffer(e), s = m.base64ToBuffer(a), n = s.slice(0, 16), i = s.slice(16, 28), o = s.slice(28), r = await oe(t, n), c = await crypto.subtle.decrypt(
-    {
-      name: "AES-GCM",
-      iv: i
-    },
-    r,
-    o
-  );
-  return m.bufferToUtf8(new Uint8Array(c));
+function B(e, t) {
+	return `${V()}/assets/${e}/${t}`;
 }
-async function Rt(a, e) {
-  try {
-    if (a) {
-      const t = await Ue(a, e);
-      if (t && _e(t))
-        return t;
-    }
-    return !1;
-  } catch {
-    return !1;
-  }
+function V() {
+	return `https://${E() ? "testapi" : "api"}.otoplo.com`;
 }
-const ce = [
-  { code: "usd", symbol: "$", name: "US Dollar" },
-  { code: "eur", symbol: "€", name: "Euro" },
-  { code: "gbp", symbol: "£", name: "British Pound" },
-  { code: "aud", symbol: "A$", name: "Australian Dollar" },
-  { code: "cad", symbol: "C$", name: "Canadian Dollar" },
-  { code: "chf", symbol: "Fr", name: "Swiss Franc" },
-  { code: "inr", symbol: "₹", name: "Indian Rupee" },
-  { code: "cny", symbol: "¥", name: "Chinese Yuan" },
-  { code: "jpy", symbol: "¥", name: "Japanese Yen" }
-], De = Object.fromEntries(
-  ce.map((a) => [a.code, a.symbol])
-), Kt = ce.map((a) => a.code), te = {
-  nexacoin: "nexa"
+// src/services/asset.ts
+var Ee = class {
+	constructor(e, t) {
+		this.walletDb = e, this.walletCache = t;
+	}
+	async getAssetInfo(e) {
+		try {
+			let t = await this.walletCache.getToken(e);
+			if (t) return {
+				type: "token",
+				parent: t.parent,
+				token: t.token,
+				tokenIdHex: t.tokenIdHex,
+				data: {
+					name: t.name,
+					ticker: t.ticker,
+					decimals: t.decimals,
+					iconUrl: t.iconUrl
+				}
+			};
+			let n = await this.walletCache.getNft(e);
+			return n ? {
+				type: "nft",
+				parent: n.parent,
+				token: n.token,
+				tokenIdHex: n.tokenIdHex,
+				data: {
+					name: n.name,
+					series: n.series,
+					collection: n.collection,
+					author: n.author,
+					public: n.public,
+					front: n.front,
+					back: n.back
+				}
+			} : await this.getAssetMetadata(e);
+		} catch (e) {
+			console.error(e);
+			return;
+		}
+	}
+	async handleNftReceive(e, t, n) {
+		let r = await this.getAssetInfo(t);
+		if (r && r.type == "nft") {
+			let t = {
+				token: r.token,
+				tokenIdHex: r.tokenIdHex,
+				parent: r.parent,
+				...r.data
+			};
+			await this.saveNft(e, t, n);
+		}
+	}
+	async syncTokens(e, t) {
+		for (let n in t) {
+			let r = t[n];
+			if (r && BigInt(r.confirmed) + BigInt(r.unconfirmed) > 0n) {
+				let t = await this.getAssetInfo(n);
+				if (t && t.type == "token") {
+					let n = {
+						token: t.token,
+						tokenIdHex: t.tokenIdHex,
+						parent: t.parent,
+						...t.data
+					};
+					await this.saveToken(e, n);
+				}
+			}
+		}
+	}
+	async syncNfts(e, t) {
+		let n = Object.keys(t), r = await this.walletDb.getAssets(e, "nft"), i = r?.filter((e) => !n.includes(e.tokenIdHex)) ?? [];
+		for (let t of i) await this.deleteNft(e, t.tokenIdHex);
+		for (let [n, i] of Object.entries(t)) {
+			let t = j(n), a = i && BigInt(i.confirmed) + BigInt(i.unconfirmed) > 0n, o = r?.some((e) => e.tokenIdHex == t);
+			!a && !o || a && o || (!a && o ? await this.deleteNft(e, t) : await this.handleNftReceive(e, t, O()));
+		}
+	}
+	async saveToken(e, t) {
+		await this.walletDb.saveToken(e, t);
+	}
+	async deleteToken(e, t) {
+		await this.walletDb.deleteToken(e, t), this.walletCache.removeToken(t);
+	}
+	async saveNft(e, t, n) {
+		await this.walletDb.saveNft(e, t, n);
+	}
+	async deleteNft(e, t) {
+		await this.walletDb.deleteNft(e, t), this.walletCache.removeNft(t);
+	}
+	getAssetFile(e, t) {
+		return this.performGet(B(e, t), "raw");
+	}
+	getAssetMetadata(e) {
+		return this.performGet(z(e), "json");
+	}
+	async performGet(e, t) {
+		try {
+			let n = await fetch(e);
+			if (!n.ok) throw Error(`Failed to perform GET. status: ${n.status}`);
+			if (t === "raw") {
+				let e = await n.arrayBuffer();
+				return new Uint8Array(e);
+			}
+			return await n.json();
+		} catch (e) {
+			throw Error(`Unexpected Error: ${e}`);
+		}
+	}
+}, De = class {
+	constructor(e, t, n) {
+		this.MAX_INPUTS_OUTPUTS = 250, this.rostrumService = e, this.keyManager = t, this.walletDb = n;
+	}
+	async broadcastTransaction(e) {
+		return this.rostrumService.broadcast(e);
+	}
+	async fetchTransactionsHistory(e, t) {
+		let n = t, r = t > 0 ? t + 1 : 0, i = await this.rostrumService.getTransactionsHistory(e, r);
+		for (let e of i) n = Math.max(n, e.height);
+		return {
+			txs: i,
+			lastHeight: n
+		};
+	}
+	async fetchVaultTransactions(e) {
+		let t = await this.rostrumService.getTransactionsHistory(e, T), n = [];
+		for (let r of t) {
+			let t = this.classifyTransaction(r.tx_hash, [e]);
+			n.push(t);
+		}
+		return Promise.all(n);
+	}
+	async classifyAndSaveTransaction(e, t, n) {
+		let r = await this.classifyTransaction(t, n);
+		r.accountId = e;
+		let i = /* @__PURE__ */ new Set();
+		r.myInputs.forEach((e) => e.assetId && i.add(e.assetId)), r.myOutputs.forEach((e) => e.assetId && i.add(e.assetId));
+		for (let t of i) await this.walletDb.upsertAssetTransaction({
+			accountId: e,
+			assetId: t,
+			txIdem: r.txIdem,
+			time: r.time
+		});
+		await this.walletDb.upsertTransaction(r);
+	}
+	async classifyTransaction(e, t) {
+		let n = await this.rostrumService.getTransaction(e), r = [], i = [], a = [], o = [];
+		for (let e of n.vin) {
+			let n = {
+				address: e.addresses[0],
+				nexaAmount: e.value_satoshi.toString(),
+				assetId: e.token_id_hex ?? "",
+				assetAmount: M(e.groupQuantity)
+			};
+			t.includes(n.address) ? r.push(n) : i.push(n);
+		}
+		for (let e of n.vout) {
+			if (k(e.scriptPubKey.addresses)) continue;
+			let n = {
+				address: e.scriptPubKey.addresses[0],
+				nexaAmount: e.value_satoshi.toString(),
+				assetId: e.scriptPubKey.token_id_hex ?? "",
+				assetAmount: M(e.scriptPubKey.groupQuantity)
+			};
+			t.includes(n.address) ? a.push(n) : o.push(n);
+		}
+		let s;
+		s = r.length === 0 ? "receive" : a.length === 0 ? "send" : i.length === 0 && o.length === 0 ? "self" : i.length === 0 && o.length > 0 ? "send" : i.length > 0 && o.length === 0 ? "receive" : "swap";
+		let c = n.height > 0;
+		return {
+			accountId: 0,
+			txId: n.txid,
+			txIdem: n.txidem,
+			time: c ? n.time : O(),
+			height: c ? n.height : 0,
+			type: s,
+			fee: n.fee_satoshi.toString(),
+			othersOutputs: s == "send" || s == "swap" ? o : [],
+			myOutputs: a,
+			myInputs: r
+		};
+	}
+	async buildAndSignTransferTransaction(e, t, n, r, i, a, o, s) {
+		let c = { feeFromAmount: i }, l = this.prepareTransaction(t, r, a, s);
+		o && l.feePerByte(o);
+		let u = /* @__PURE__ */ new Map();
+		a && (u = await this.populateTokenInputsAndChange(l, e, n, a, BigInt(r)));
+		let d = await this.populateNexaInputsAndChange(l, e, n, c);
+		return u.forEach((e, t) => d.set(t, e)), await this.finalizeTransaction(l, Array.from(d.values()));
+	}
+	async buildAndSignConsolidateTransaction(e, t, n) {
+		let r = {
+			isConsolidate: !0,
+			templateData: n
+		}, i = new g(), a = await this.populateNexaInputsAndChange(i, e, t, r);
+		return this.finalizeTransaction(i, Array.from(a.values()));
+	}
+	prepareTransaction(n, r, i, a) {
+		if (!D(n) && !D(n, t.PayToPublicKeyHash)) throw Error("Invalid Address.");
+		if (i && BigInt(r) < 1n || !i && parseInt(r) < h.DUST_AMOUNT) throw Error("The amount is too low.");
+		if (i && BigInt(r) > 9223372036854775807n || !i && parseInt(r) > h.MAX_MONEY) throw Error("The amount is too high.");
+		let o = new g();
+		if (a && o.addData(a), i) {
+			if (!D(i, t.GroupIdAddress)) throw Error("Invalid Token ID");
+			if (e.getOutputType(n) === 0) throw Error("Token must be sent to script template address");
+			o.to(n, h.DUST_AMOUNT, i, BigInt(r));
+		} else o.to(n, r);
+		return o;
+	}
+	async populateNexaInputsAndChange(e, t, n, r) {
+		let i = t.filter((e) => BigInt(e.balance.confirmed) + BigInt(e.balance.unconfirmed) > 0n);
+		if (k(i)) throw Error("Not enough Nexa balance.");
+		let a = /* @__PURE__ */ new Map(), o = r.isConsolidate ? 0 : Number(e.transaction.outputs.find((e) => e.value > 0n).value);
+		for (let t of i) {
+			let i = await this.rostrumService.getNexaUtxos(t.address);
+			for (let s of i) {
+				let i = {
+					outpoint: s.outpoint_hash,
+					address: t.address,
+					satoshis: s.value,
+					templateData: r.templateData
+				};
+				if (e.from(i), !a.has(t.address)) {
+					let e = this.keyManager.getKey(t.keyPath);
+					a.set(t.address, e.privateKey);
+				}
+				if (r.isConsolidate) {
+					if (e.change(n), e.transaction.inputs.length > this.MAX_INPUTS_OUTPUTS) return a;
+				} else {
+					let t = e.transaction;
+					if (t.inputs.length > this.MAX_INPUTS_OUTPUTS) throw Error("Too many inputs. Consider consolidate transactions or reduce the send amount.");
+					let i = t.getUnspentValue();
+					if (i < 0n) continue;
+					if (i == 0n && r.feeFromAmount) {
+						let e = t.estimateRequiredFee();
+						return t.updateOutputAmount(0, o - e), a;
+					}
+					if (e.change(n), r.feeFromAmount) {
+						let e = t.getChangeOutput(), n = t.estimateRequiredFee();
+						t.updateOutputAmount(0, o - n), !e && t.getChangeOutput() && (n = t.estimateRequiredFee(), t.updateOutputAmount(0, o - n));
+					}
+					if (t.getUnspentValue() < t.estimateRequiredFee()) continue;
+					return a;
+				}
+			}
+		}
+		if (r.isConsolidate) {
+			if (a.size > 0) return a;
+			throw Error("Not enough Nexa balance.");
+		}
+		let s = {
+			errorMsg: "Not enough Nexa balance.",
+			amount: v.formatNEXA(e.transaction.outputs[0].value),
+			fee: v.formatNEXA(e.transaction.estimateRequiredFee())
+		};
+		throw Error(JSON.stringify(s));
+	}
+	async populateTokenInputsAndChange(e, t, n, r, i) {
+		let a = j(r), o = t.filter((e) => Object.keys(e.tokensBalance).includes(a));
+		if (k(o)) throw Error("Not enough token balance.");
+		let s = /* @__PURE__ */ new Map(), c = 0n;
+		for (let t of o) {
+			let a = await this.rostrumService.getTokenUtxos(t.address, r);
+			for (let o of a) if (!(BigInt(o.token_amount) < 0n)) {
+				if (e.from({
+					outpoint: o.outpoint_hash,
+					address: t.address,
+					satoshis: o.value,
+					groupId: o.group,
+					groupAmount: BigInt(o.token_amount)
+				}), c += BigInt(o.token_amount), !s.has(t.address)) {
+					let e = this.keyManager.getKey(t.keyPath);
+					s.set(t.address, e.privateKey);
+				}
+				if (c > 9223372036854775807n) throw Error("Token inputs exceeded max amount. Consider sending in small chunks");
+				if (e.transaction.inputs.length > this.MAX_INPUTS_OUTPUTS) throw Error("Too many inputs. Consider consolidating transactions or reduce the send amount.");
+				if (c == i) return s;
+				if (c > i) return e.to(n, h.DUST_AMOUNT, r, c - i), s;
+			}
+		}
+		throw Error("Not enough token balance");
+	}
+	async finalizeTransaction(e, t) {
+		let n = await this.rostrumService.getBlockTip();
+		return e.lockUntilBlockHeight(n.height).sign(t).build();
+	}
+	printTransactionJson(e) {
+		if (!e) return "";
+		let t = {
+			...e.toObject(),
+			hex: e.toString()
+		};
+		return JSON.stringify(t, null, 2);
+	}
 };
-async function Ve(a) {
-  const e = Object.keys(te).join(","), t = await fetch(`https://api.coingecko.com/api/v3/coins/markets?ids=${e}&vs_currency=${a}`);
-  if (!t.ok)
-    throw new Error("Failed to fetch market data");
-  const s = await t.json(), n = {};
-  return s.forEach((i) => {
-    n[te[i.id]] = {
-      id: i.id,
-      name: i.name ?? "",
-      symbol: i.symbol ?? "",
-      image: i.image ?? "",
-      price: i.current_price ?? 0,
-      priceChange: i.price_change_24h,
-      priceChangePercentage: i.price_change_percentage_24h,
-      marketCap: i.market_cap,
-      fdv: i.fully_diluted_valuation,
-      circSupply: i.circulating_supply,
-      totalSupply: i.total_supply,
-      maxSupply: i.max_supply,
-      totalVolume: i.total_volume
-    };
-  }), n;
+// src/utils/seed.ts
+function Oe(e = 12) {
+	return re(x, e === 24 ? 256 : 128);
 }
-function Lt(a) {
-  return De[a] || a;
+function H(e) {
+	return ae(e, x);
 }
-function Ft(a, e, t) {
-  const s = B.multiply(a, e), n = B.round(s, 2, B.RoundingModes.HALF_DOWN);
-  return t ? He(n, t) : n;
+async function U(e, t) {
+	let n = await crypto.subtle.importKey("raw", new Uint8Array(e), "PBKDF2", !1, ["deriveKey"]);
+	return crypto.subtle.deriveKey({
+		name: "PBKDF2",
+		salt: new Uint8Array(t),
+		iterations: 21e4,
+		hash: "SHA-256"
+	}, n, {
+		name: "AES-GCM",
+		length: 256
+	}, !1, ["encrypt", "decrypt"]);
 }
-function He(a, e, t = "en-US") {
-  return new Intl.NumberFormat(t, {
-    style: "currency",
-    currency: e,
-    maximumFractionDigits: 2,
-    minimumFractionDigits: 2
-  }).format(Number(a));
+async function ke(e, t) {
+	let n = r.utf8ToBuffer(t), i = r.getRandomBuffer(16), a = r.getRandomBuffer(12), o = r.utf8ToBuffer(e), s = await U(n, i), c = await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv: new Uint8Array(a)
+	}, s, new Uint8Array(o)), l = r.concat([
+		i,
+		a,
+		new Uint8Array(c)
+	]);
+	return r.bufferToBase64(l);
 }
-function Re() {
-  return b.empty().add(A.OP_FROMALTSTACK).add(A.OP_DROP).add(A.OP_FROMALTSTACK).add(A.OP_CHECKLOCKTIMEVERIFY).add(A.OP_DROP).add(A.OP_FROMALTSTACK).add(A.OP_CHECKSIGVERIFY);
+async function Ae(e, t) {
+	let n = r.utf8ToBuffer(t), i = r.base64ToBuffer(e), a = i.slice(0, 16), o = i.slice(16, 28), s = i.slice(28), c = await U(n, a), l = await crypto.subtle.decrypt({
+		name: "AES-GCM",
+		iv: o
+	}, c, s);
+	return r.bufferToUtf8(new Uint8Array(l));
 }
-function Ke() {
-  const a = Re();
-  return _.sha256ripemd160(a.toBuffer());
+async function je(e, t) {
+	try {
+		if (e) {
+			let n = await Ae(e, t);
+			if (n && H(n)) return n;
+		}
+		return !1;
+	} catch {
+		return !1;
+	}
 }
-function Le(a) {
-  return b.empty().add(a.toBuffer());
+// src/utils/market.ts
+var W = [
+	{
+		code: "usd",
+		symbol: "$",
+		name: "US Dollar"
+	},
+	{
+		code: "eur",
+		symbol: "€",
+		name: "Euro"
+	},
+	{
+		code: "gbp",
+		symbol: "£",
+		name: "British Pound"
+	},
+	{
+		code: "aud",
+		symbol: "A$",
+		name: "Australian Dollar"
+	},
+	{
+		code: "cad",
+		symbol: "C$",
+		name: "Canadian Dollar"
+	},
+	{
+		code: "chf",
+		symbol: "Fr",
+		name: "Swiss Franc"
+	},
+	{
+		code: "inr",
+		symbol: "₹",
+		name: "Indian Rupee"
+	},
+	{
+		code: "cny",
+		symbol: "¥",
+		name: "Chinese Yuan"
+	},
+	{
+		code: "jpy",
+		symbol: "¥",
+		name: "Japanese Yen"
+	}
+], G = Object.fromEntries(W.map((e) => [e.code, e.symbol])), K = W.map((e) => e.code);
+function Me(e) {
+	return G[e] || e;
 }
-function Fe(a) {
-  const e = Le(a);
-  return _.sha256ripemd160(e.toBuffer());
+function Ne(e, t, n) {
+	let r = y.multiply(e, t), i = y.round(r, 2, y.RoundingModes.HALF_DOWN);
+	return n ? q(i, n) : i;
 }
-function $e(a) {
-  return a.map((e) => e <= 16 ? L.smallInt(e) : F.fromNumber(e).toScriptNumBuffer());
+function q(e, t, n = "en-US") {
+	return new Intl.NumberFormat(n, {
+		style: "currency",
+		currency: t,
+		maximumFractionDigits: 2,
+		minimumFractionDigits: 2
+	}).format(Number(e));
+}
+// src/utils/vault.ts
+function J() {
+	return f.empty().add(l.OP_FROMALTSTACK).add(l.OP_DROP).add(l.OP_FROMALTSTACK).add(l.OP_CHECKLOCKTIMEVERIFY).add(l.OP_DROP).add(l.OP_FROMALTSTACK).add(l.OP_CHECKSIGVERIFY);
 }
-function We(a, e) {
-  if (e.length !== 2)
-    return;
-  const t = Ke(), s = Fe(a), n = $e(e);
-  return I.fromScriptTemplate(t, s, n).toString();
+function Y() {
+	let e = J();
+	return s.sha256ripemd160(e.toBuffer());
 }
-class $t {
-  walletDb;
-  keyManager;
-  providers;
-  handlers;
-  removeOnClose;
-  updateCallback;
-  constructor(e, t) {
-    this.walletDb = e, this.keyManager = t, this.providers = /* @__PURE__ */ new Map(), this.handlers = /* @__PURE__ */ new Map(), this.removeOnClose = !0;
-  }
-  onUpdate(e) {
-    this.updateCallback = e;
-  }
-  notify(e) {
-    this.updateCallback?.(e);
-  }
-  getHandler(e) {
-    return this.handlers.get(e);
-  }
-  add(e, t, s) {
-    this.providers.has(e.id) || this.providers.set(e.id, /* @__PURE__ */ new Map());
-    const n = s.details.sessionId, i = this.providers.get(e.id);
-    this.registerHandlers(e, t, n), i.set(n, t), this.notify({ type: "session_added", accountId: e.id, sessionInfo: s });
-  }
-  remove(e, t) {
-    const s = this.providers.get(e);
-    if (s) {
-      const n = s.get(t);
-      n && (n.disconnect(), s.delete(t)), s.size === 0 && this.providers.delete(e);
-    }
-    this.notify({ type: "session_removed", accountId: e, sessionId: t });
-  }
-  async reload(e) {
-    for (const t of e.values()) {
-      if (t.id == w)
-        continue;
-      const s = await this.walletDb.getAccountSessions(t.id), n = this.providers.get(t.id), i = s.map(async (r) => {
-        if (n?.has(r.sessionId))
-          return;
-        let c;
-        try {
-          c = new xe(r.uri);
-          const d = c.getSessionInfo();
-          await c.connect(3e3);
-          const u = await c.getAppInfo(2e3);
-          await c.joinSession(t.address, 2e3);
-          const l = await c.fetchPendingMessages();
-          for (const p of l)
-            this.notify({
-              type: "new_notification",
-              notification: {
-                id: crypto.randomUUID(),
-                createdAt: p.createdAt,
-                type: "web3",
-                title: "Request pending approval",
-                message: `A connected dApp (${u.name}) has requested an action from your Account: ${t.name}. Review the request details before approving or rejecting.`,
-                action: {
-                  type: "DAPP_REQUEST",
-                  account: t.id,
-                  sessionId: d.sessionId,
-                  payload: p.message
-                }
-              }
-            });
-          return { account: t, provider: c, metadata: { details: d, appInfo: u } };
-        } catch (d) {
-          console.error(`Failed to reload session ${r.sessionId}`, d), c?.disconnect(), await this.walletDb.removeSession(r.sessionId);
-        }
-      }), o = await Promise.allSettled(i);
-      for (const r of o)
-        r.status === "fulfilled" && r.value && this.add(r.value.account, r.value.provider, r.value.metadata);
-    }
-  }
-  clear() {
-    try {
-      this.removeOnClose = !1;
-      for (const [e, t] of this.providers) {
-        for (const [, s] of t)
-          s.disconnect();
-        t.clear(), this.notify({ type: "sessions_cleared", accountId: e });
-      }
-      this.providers.clear();
-    } finally {
-      this.removeOnClose = !0;
-    }
-  }
-  async revoke(e, t) {
-    const s = this.providers.get(e);
-    if (s) {
-      const n = s.get(t);
-      n && await n.revokeSession();
-    }
-  }
-  async replayMessage(e, t, s) {
-    const n = this.providers.get(e);
-    if (n) {
-      const i = n.get(t);
-      i && await i.replayMessage(s);
-    }
-  }
-  registerHandlers(e, t, s) {
-    t.onSessionDelete(() => this.walletDb.removeSession(s)), t.onClose(() => {
-      this.removeOnClose && this.remove(e.id, s);
-    });
-    const n = (i, o) => new Promise((r, c) => {
-      this.handlers.set(i, { resolve: r, reject: c }), this.notify({ type: "new_request", request: { type: i, accountId: e.id, sessionId: s, request: o } });
-    });
-    t.onSignMessage((i) => n(N.SignMessage, i)), t.onAddToken((i) => n(N.AddToken, i)), t.onSendTransaction((i) => n(N.SendTransaction, i)), t.onSignTransaction((i) => n(N.SignTransaction, i)), t.onGetAccount(() => {
-      const i = { account: h.DAPP, type: y.RECEIVE, index: e.id };
-      return {
-        name: e.name,
-        address: e.address,
-        pubkey: this.keyManager.getKey(i).publicKey.toString(),
-        blockchain: "nexa",
-        network: E.defaultNetwork.name,
-        capabilities: {
-          addToken: !0,
-          sendTransaction: !0,
-          signMessage: !0,
-          signTransaction: !0
-        }
-      };
-    });
-  }
+function X(e) {
+	return f.empty().add(e.toBuffer());
 }
-class Wt {
-  rostrumService;
-  keyManager;
-  assetService;
-  constructor(e, t, s) {
-    this.rostrumService = e, this.keyManager = t, this.assetService = s;
-  }
-  async transformRawTransaction(e, t) {
-    const s = this.createContext(e, t);
-    return await this.processInputs(s), this.processOutputs(s), this.signInputs(s), await this.processAssetMovements(s), s.txDetails;
-  }
-  createContext(e, t) {
-    try {
-      return {
-        address: t.address,
-        privateKey: this.keyManager.getKey(t.keyPath).privateKey,
-        txDetails: {
-          tx: new x(e),
-          send: [],
-          receive: []
-        },
-        myInputs: /* @__PURE__ */ new Map(),
-        myOutputs: /* @__PURE__ */ new Map(),
-        involvedAssets: /* @__PURE__ */ new Set(),
-        inputsToSign: /* @__PURE__ */ new Set(),
-        coveredOutputs: /* @__PURE__ */ new Set(),
-        allMyOutputsCovered: !1
-      };
-    } catch {
-      throw new Error("Invalid transaction format.");
-    }
-  }
-  async processInputs(e) {
-    const t = [];
-    for (let s = 0; s < e.txDetails.tx.inputs.length; s++) {
-      const n = this.processInput(e, s);
-      t.push(n);
-    }
-    await Promise.all(t);
-  }
-  async processInput(e, t) {
-    const s = e.txDetails.tx.inputs[t], n = await this.rostrumService.getUtxo(m.bufferToHex(s.outpoint));
-    if (n.status == "spent")
-      throw new Error("Input UTXO is already spent.");
-    if (s.output = new we(n.amount, n.scriptpubkey), s.output.address == e.address) {
-      const i = n.token_id_hex || "NEXA";
-      e.myInputs.set(t, {
-        address: e.address,
-        nexaAmount: n.amount.toString(),
-        assetId: i,
-        assetAmount: U(n.group_quantity) || n.amount.toString()
-      }), e.involvedAssets.add(i), s.scriptSig.isEmpty() && e.inputsToSign.add(t);
-    }
-    s.scriptSig.findPlaceholder() > 0 && e.inputsToSign.add(t);
-  }
-  processOutputs(e) {
-    for (let t = 0; t < e.txDetails.tx.outputs.length; t++) {
-      const s = e.txDetails.tx.outputs[t].toObject();
-      if (s.address !== e.address)
-        continue;
-      const n = s.groupId ? v(s.groupId) : "NEXA", i = {
-        address: s.address,
-        nexaAmount: s.value.toString(),
-        assetId: n,
-        assetAmount: U(s.groupAmount) || s.value.toString()
-      };
-      e.involvedAssets.add(n), e.myOutputs.set(t, i);
-    }
-  }
-  signInputs(e) {
-    if (e.inputsToSign.size == 0)
-      throw new Error("No inputs to sign.");
-    for (const t of e.inputsToSign) {
-      const s = e.txDetails.tx.inputs[t], n = this.validateAndGetSubscript(s);
-      if (s.scriptSig.isEmpty()) {
-        e.allMyOutputsCovered = !0;
-        const i = X.sign(e.txDetails.tx, t, Y.ALL, n, e.privateKey).toTxFormat(), o = b.empty().add(e.privateKey.publicKey.toBuffer());
-        s.scriptSig = Ae.buildScriptTemplateIn(void 0, o, b.empty().add(i));
-      } else {
-        const i = s.scriptSig.findPlaceholder(), r = s.scriptSig.chunks[i].buf.subarray(64), c = Y.fromBuffer(r);
-        this.processSignatureCoverage(e, c);
-        const d = X.sign(e.txDetails.tx, t, c, n, e.privateKey).toTxFormat(r);
-        s.scriptSig.replaceChunk(i, b.empty().add(d));
-      }
-    }
-    if (!e.allMyOutputsCovered)
-      throw new Error("Some of interested outputs are not covered by signatures.");
-  }
-  validateAndGetSubscript(e) {
-    if (e.output.scriptPubKey.isPublicKeyTemplateOut()) {
-      if (e.scriptSig.isEmpty() || e.scriptSig.isPublicKeyTemplateIn())
-        return b.empty().add(A.OP_FROMALTSTACK).add(A.OP_CHECKSIGVERIFY);
-      throw new Error("Invalid input script type.");
-    }
-    if (e.output.scriptPubKey.isScriptTemplateOut()) {
-      if (!e.scriptSig.isScriptTemplateIn())
-        throw new Error("Unsupported input script type.");
-      const t = e.output.scriptPubKey.getTemplateHash(), s = e.scriptSig.chunks[0].buf;
-      if (m.equals(t, _.sha256ripemd160(s)) || m.equals(t, _.sha256sha256(s)))
-        return b.fromBuffer(s);
-      throw new Error("Invalid input script template.");
-    }
-    throw new Error("Unsupported prevout script type.");
-  }
-  processSignatureCoverage(e, t) {
-    if (!e.allMyOutputsCovered)
-      if (t.outType == Z.TWO)
-        e.coveredOutputs.add(t.outData[0]), e.coveredOutputs.add(t.outData[1]), this.checkSignatureCoverage(e);
-      else if (t.outType == Z.FIRSTN) {
-        const s = t.outData[0];
-        for (let n = 0; n < s; n++)
-          e.coveredOutputs.add(n);
-        this.checkSignatureCoverage(e);
-      } else
-        e.allMyOutputsCovered = !0;
-  }
-  checkSignatureCoverage(e) {
-    if (!e.allMyOutputsCovered) {
-      for (const t of e.myOutputs.keys())
-        if (!e.coveredOutputs.has(t))
-          return;
-      e.allMyOutputsCovered = !0;
-    }
-  }
-  async processAssetMovements(e) {
-    const t = Array.from(e.myInputs.values()), s = Array.from(e.myOutputs.values()), n = [];
-    for (const i of e.involvedAssets) {
-      const o = this.processAssetMovement(e, i, t, s);
-      n.push(o);
-    }
-    await Promise.all(n);
-  }
-  async processAssetMovement(e, t, s, n) {
-    const i = s.reduce((r, c) => c.assetId === t ? r + BigInt(c.assetAmount) : r, 0n), o = n.reduce((r, c) => c.assetId === t ? r + BigInt(c.assetAmount) : r, 0n);
-    if (i > 0n || o > 0n) {
-      const r = { amount: o - i };
-      t !== "NEXA" && (r.asset = await this.assetService.getAssetInfo(t)), r.amount > 0n ? e.txDetails.receive.push(r) : r.amount < 0n && e.txDetails.send.push(r);
-    }
-  }
+function Z(e) {
+	let t = X(e);
+	return s.sha256ripemd160(t.toBuffer());
 }
-const Ge = 274710, Je = "0014461ad25081cb0119d034385ff154c8d3ad6bdd76";
-class je {
-  rostrumService;
-  keyManager;
-  constructor(e, t) {
-    this.rostrumService = e, this.keyManager = t;
-  }
-  async discoverWalletIndex(e, t) {
-    let s = 0, n = !1, i = 0;
-    do {
-      n = !0;
-      for (let o = i; o < i + 20; o++) {
-        const r = { account: e, type: t, index: o }, c = this.keyManager.getKey(r).privateKey.toAddress().toString();
-        await this.rostrumService.isAddressUsed(c) && (s = o, n = !1);
-      }
-      i += 20;
-    } while (!n);
-    return s;
-  }
-  async discoverVaults(e) {
-    const t = [];
-    for (const i of e) {
-      const o = this.checkVaultsForAddress(i);
-      t.push(o);
-    }
-    const s = await Promise.all(t), n = /* @__PURE__ */ new Map();
-    return s.forEach((i) => {
-      i.forEach((o) => {
-        const r = this.parseVaultDetails(o);
-        r && n.set(r.address, r);
-      });
-    }), n;
-  }
-  async checkVaultsForAddress(e) {
-    const t = /* @__PURE__ */ new Set(), s = await this.rostrumService.getTransactionsHistory(e, Ge);
-    for (const n of s) {
-      const o = (await this.rostrumService.getTransaction(n.tx_hash)).vout.filter((r) => r.scriptPubKey.hex.startsWith(Je));
-      for (const r of o)
-        t.add(r.scriptPubKey.hex);
-    }
-    return t;
-  }
-  parseVaultDetails(e) {
-    const t = b.fromHex(e), s = new ve().writeVarLengthBuf(t.toBuffer()).toBuffer(), n = new I(s).toString(), i = t.getVisibleArgs(), o = F.fromScriptNumBuffer(i.chunks[0].buf).toNumber(), r = L.isSmallIntOp(i.chunks[1].opcodenum) ? L.decodeOP_N(i.chunks[1].opcodenum) : F.fromScriptNumBuffer(i.chunks[1].buf).toNumber(), c = [o, r], d = this.keyManager.getKey({ account: h.VAULT, type: y.RECEIVE, index: r }), u = We(d.publicKey, c);
-    return n != u ? void 0 : {
-      address: n,
-      block: o,
-      idx: r,
-      statusHash: "",
-      balance: { confirmed: "0", unconfirmed: "0" },
-      tokensBalance: {},
-      height: 0,
-      type: h.VAULT
-    };
-  }
+function Q(e) {
+	return e.map((e) => e <= 16 ? p.smallInt(e) : n.fromNumber(e).toScriptNumBuffer());
 }
-class T {
-  constructor(e, t, s, n, i, o, r) {
-    this.keyManager = e, this.kvStore = t, this.walletDb = s, this.rostrumService = n, this.assetService = i, this.transactionService = o, this.sessionManager = r, this.discoveryService = new je(this.rostrumService, this.keyManager), this.accounts = /* @__PURE__ */ new Map(), this.accountsAddressToId = /* @__PURE__ */ new Map(), this.receiveAddresses = [], this.changeAddresses = [], this.vaults = /* @__PURE__ */ new Map(), this.pendingUpdates = /* @__PURE__ */ new Map(), this.addressResolvers = /* @__PURE__ */ new Map();
-  }
-  static GAP_LIMIT = 20;
-  static DEBOUNCE_MS = 1e3;
-  addressResolvers;
-  accounts;
-  accountsAddressToId;
-  receiveAddresses;
-  changeAddresses;
-  vaults;
-  pendingUpdates;
-  updateTimer;
-  updateCallback;
-  discoveryService;
-  onUpdate(e) {
-    this.updateCallback = e;
-  }
-  notify(e) {
-    this.updateCallback?.(e);
-  }
-  getAllAddresses() {
-    return [...this.receiveAddresses, ...this.changeAddresses, ...this.accounts.values(), ...this.vaults.values()];
-  }
-  getMainAddresses() {
-    return [...this.receiveAddresses, ...this.changeAddresses];
-  }
-  getReceiveAddress() {
-    return this.receiveAddresses.find((e) => !e.used).address;
-  }
-  getChangeAddress(e = w) {
-    return e != w ? this.accounts.get(e).address : this.changeAddresses.find((t) => !t.used).address;
-  }
-  getUsedAddressKeys(e = w) {
-    if (e != w) {
-      const t = this.accounts.get(e);
-      return [{
-        address: t.address,
-        keyPath: k(h.DAPP, 0, t.id),
-        balance: t.balance,
-        tokensBalance: t.tokensBalance
-      }];
-    }
-    return this.getMainAddresses().filter((t) => t.used).map((t) => ({
-      address: t.address,
-      keyPath: k(h.MAIN, t.space, t.idx),
-      balance: t.balance,
-      tokensBalance: t.tokensBalance
-    }));
-  }
-  async reloadRostrum(e) {
-    await this.kvStore.saveRostrumParams(e), await this.rostrumService.disconnect(!0), await this.initRostrum(), await this.subscribeAddresses(this.getAllAddresses());
-  }
-  async initRostrum() {
-    await this.rostrumService.connect(), await this.rostrumService.subscribeHeaders((e) => this.notify({ type: "new_tip", tip: e }));
-  }
-  async initialize() {
-    await this.initRostrum(), await this.walletDb.countAddresses() ? await this.loadWallet() : await this.discoverWallet();
-  }
-  async discoverWallet() {
-    this.notify({ type: "discover_wallet", loading: !0 });
-    const e = this.discoveryService.discoverWalletIndex(h.MAIN, y.RECEIVE), t = this.discoveryService.discoverWalletIndex(h.MAIN, y.CHANGE), s = this.discoveryService.discoverWalletIndex(h.DAPP, y.RECEIVE), [n, i, o] = await Promise.all([e, t, s]);
-    this.receiveAddresses = this.deriveAddresses(y.RECEIVE, 0, n + T.GAP_LIMIT), this.changeAddresses = this.deriveAddresses(y.CHANGE, 0, i + T.GAP_LIMIT), this.accounts = this.deriveAccounts(0, o + 1), this.accounts.forEach((r) => this.accountsAddressToId.set(r.address, r.id)), await this.saveAddresses(this.receiveAddresses), await this.saveAddresses(this.changeAddresses), await this.saveAccounts(this.accounts), this.initState(), await this.initialSync(), this.notify({ type: "discover_wallet", loading: !1 }), this.notify({ type: "load_wallet", loading: !1 }), await this.rescanVaults();
-  }
-  async loadWallet() {
-    this.receiveAddresses = await this.walletDb.getReceiveAddresses(), this.changeAddresses = await this.walletDb.getChangeAddresses();
-    const e = await this.walletDb.getAccounts();
-    this.accounts = new Map(e.map((s) => [s.id, s])), this.accountsAddressToId = new Map(e.map((s) => [s.address, s.id]));
-    const t = await this.walletDb.getVaults();
-    this.vaults = new Map(t.map((s) => [s.address, s])), this.initState(), this.notify({ type: "load_wallet", loading: !1 }), await this.reconnectSync();
-  }
-  async initialSync() {
-    await this.subscribeAddresses(this.getAllAddresses(), !0);
-    const e = [];
-    e.push(this.assetService.syncTokens(w, K(this.getMainAddresses().map((t) => t.tokensBalance))));
-    for (const t of this.accounts.values())
-      e.push(this.assetService.syncTokens(t.id, t.tokensBalance));
-    await Promise.all(e);
-  }
-  async reconnectSync() {
-    await Promise.all([
-      this.sessionManager.reload(this.accounts),
-      this.subscribeAddresses(this.getAllAddresses())
-    ]);
-  }
-  initState() {
-    const e = this.getMainAddresses();
-    this.notify({
-      type: "new_account",
-      account: {
-        id: w,
-        name: "Main Wallet",
-        address: this.getReceiveAddress(),
-        balance: ee(e.map((t) => t.balance)),
-        tokensBalance: K(e.map((t) => t.tokensBalance)),
-        sessions: {}
-      }
-    });
-    for (const t of this.accounts.values())
-      this.notify({
-        type: "new_account",
-        account: {
-          id: t.id,
-          name: t.name,
-          address: t.address,
-          balance: t.balance,
-          tokensBalance: t.tokensBalance,
-          sessions: {}
-        }
-      });
-    for (const t of this.vaults.values())
-      this.notify({
-        type: "new_vault",
-        vault: {
-          address: t.address,
-          balance: t.balance,
-          block: t.block,
-          index: t.idx
-        }
-      });
-  }
-  deriveAddresses(e, t, s) {
-    const n = [];
-    for (let i = t; i < t + s; i++) {
-      const o = k(h.MAIN, e, i), c = {
-        address: this.keyManager.getKey(o).privateKey.toAddress().toString(),
-        space: e,
-        idx: i,
-        used: !1,
-        height: 0,
-        statusHash: "",
-        balance: { confirmed: "0", unconfirmed: "0" },
-        tokensBalance: {},
-        type: h.MAIN
-      };
-      n.push(c);
-    }
-    return n;
-  }
-  deriveAccounts(e, t) {
-    const s = /* @__PURE__ */ new Map();
-    for (let n = e; n < e + t; n++) {
-      const i = k(h.DAPP, 0, n), o = this.keyManager.getKey(i).privateKey.toAddress().toString(), r = {
-        id: n,
-        name: `Account ${n + 1}`,
-        address: o,
-        height: 0,
-        hidden: 0,
-        statusHash: "",
-        balance: { confirmed: "0", unconfirmed: "0" },
-        tokensBalance: {},
-        type: h.DAPP
-      };
-      s.set(r.id, r);
-    }
-    return s;
-  }
-  async saveAddresses(e) {
-    for (const t of e)
-      await this.walletDb.saveAddress(t);
-  }
-  async saveAccounts(e) {
-    for (const t of e.values())
-      await this.walletDb.saveAccount(t);
-  }
-  async subscribeAddresses(e, t = !1) {
-    const s = e.map(async (o) => {
-      const r = await this.rostrumService.subscribeAddress(o.address, this.onSubscribeEvent);
-      return { addr: o, result: r };
-    }), n = [], i = await Promise.all(s);
-    for (const { addr: o, result: r } of i)
-      if (r && typeof r == "string" && o.statusHash != r) {
-        if (t) {
-          const c = new Promise((d) => {
-            this.addressResolvers.set(o.address, d);
-          });
-          n.push(c);
-        }
-        this.registerUpdate({ address: o, result: r });
-      }
-    await Promise.all(n);
-  }
-  onSubscribeEvent = (e) => {
-    if (!Array.isArray(e) || e.length < 2)
-      return;
-    const [t, s] = e, i = this.getAllAddresses().find((o) => o.address === t);
-    i && i.statusHash !== s && this.registerUpdate({ address: i, result: s });
-  };
-  registerUpdate(e) {
-    this.pendingUpdates.set(e.address.address, e), clearTimeout(this.updateTimer), this.updateTimer = setTimeout(() => {
-      this.processPendingUpdates();
-    }, T.DEBOUNCE_MS);
-  }
-  async processPendingUpdates() {
-    if (this.pendingUpdates.size !== 0)
-      try {
-        this.notify({ type: "sync_wallet", loading: !0 }), console.log(`Processing ${this.pendingUpdates.size} pending updates...`);
-        const e = Array.from(this.pendingUpdates);
-        this.pendingUpdates.clear();
-        const t = [], s = [], n = [];
-        for (const [, r] of e)
-          if (this.isAccountAddress(r.address)) {
-            const c = this.fetchAndUpdateAccount(r.address, r.result);
-            t.push(c);
-          } else if (this.isVaultAddress(r.address)) {
-            const c = this.fetchAndUpdateVault(r.address, r.result);
-            s.push(c);
-          } else {
-            const c = this.fetchAndUpdateAddress(r.address, r.result);
-            n.push(c);
-          }
-        const i = await Promise.all(t);
-        await Promise.all(s);
-        const o = await Promise.all(n);
-        if (this.addressResolvers.size > 0)
-          for (const [r] of e) {
-            const c = this.addressResolvers.get(r);
-            c && (c(), this.addressResolvers.delete(r));
-          }
-        await Promise.all([this.postProcessWalletUpdate(o), this.postProcessAccountsUpdate(i)]);
-      } catch (e) {
-        console.error("Error processing pending updates:", e);
-      } finally {
-        this.notify({ type: "sync_wallet", loading: !1 });
-      }
-  }
-  async postProcessWalletUpdate(e) {
-    if (e.length === 0)
-      return;
-    const t = /* @__PURE__ */ new Map();
-    for (const { txs: o } of e)
-      for (const r of o)
-        t.set(r.tx_hash, r);
-    await this.checkGapLimit(y.RECEIVE), await this.checkGapLimit(y.CHANGE);
-    const s = this.getMainAddresses(), n = ee(s.map((o) => o.balance)), i = K(s.map((o) => o.tokensBalance));
-    this.notify({ type: "account_balance_updated", accountId: w, balance: n, tokensBalance: i }), this.notify({ type: "main_address_updated", address: this.getReceiveAddress() }), await this.postProcessActivity(w, Array.from(t.values()), s.map((o) => o.address), i);
-  }
-  async postProcessAccountsUpdate(e) {
-    if (e.length === 0)
-      return;
-    const t = [];
-    for (const { address: s, txs: n } of e) {
-      const i = s;
-      this.notify({ type: "account_balance_updated", accountId: i.id, balance: i.balance, tokensBalance: i.tokensBalance });
-      const o = this.postProcessActivity(i.id, n, [i.address], i.tokensBalance);
-      t.push(o);
-    }
-    await Promise.all(t);
-  }
-  async postProcessActivity(e, t, s, n) {
-    const i = [], o = this.assetService.syncNfts(e, n);
-    for (const r of t) {
-      const c = this.transactionService.classifyAndSaveTransaction(e, r.tx_hash, s);
-      i.push(c);
-    }
-    i.push(o), await Promise.all(i);
-  }
-  async fetchAndUpdateAddress(e, t) {
-    e.statusHash = t, e.balance = await this.rostrumService.getBalance(e.address), e.tokensBalance = await this.rostrumService.getTokensBalance(e.address);
-    const s = await this.transactionService.fetchTransactionsHistory(e.address, e.height);
-    return e.height = s.lastHeight, e.used || (e.used = s.txs.length > 0), await this.walletDb.saveAddress(e), { address: e, txs: s.txs };
-  }
-  async fetchAndUpdateAccount(e, t) {
-    e.statusHash = t, e.balance = await this.rostrumService.getBalance(e.address), e.tokensBalance = await this.rostrumService.getTokensBalance(e.address);
-    const s = await this.transactionService.fetchTransactionsHistory(e.address, e.height);
-    return e.height = s.lastHeight, await this.walletDb.saveAccount(e), { address: e, txs: s.txs };
-  }
-  async fetchAndUpdateVault(e, t) {
-    e.statusHash = t, e.balance = await this.rostrumService.getBalance(e.address);
-    const s = await this.transactionService.fetchTransactionsHistory(e.address, e.height);
-    return e.height = s.lastHeight, await this.walletDb.saveVault(e), this.notify({ type: "vault_balance_updated", address: e.address, balance: e.balance }), { address: e, txs: s.txs };
-  }
-  async checkGapLimit(e) {
-    const t = e === y.RECEIVE ? this.receiveAddresses : this.changeAddresses, s = e === y.RECEIVE ? "Receive" : "Change", n = t.filter((i) => !i.used).length;
-    if (n < T.GAP_LIMIT) {
-      const i = T.GAP_LIMIT - n, o = t[t.length - 1].idx;
-      console.log(`Deriving ${i} more ${s} addresses...`);
-      const r = this.deriveAddresses(e, o + 1, i);
-      e === y.RECEIVE ? this.receiveAddresses.push(...r) : this.changeAddresses.push(...r), await this.saveAddresses(r), await this.subscribeAddresses(r);
-    }
-  }
-  async addNewAccount(e, t) {
-    const s = k(h.DAPP, 0, e), n = this.keyManager.getKey(s).privateKey.toAddress().toString(), i = {
-      id: e,
-      name: t,
-      address: n,
-      height: 0,
-      hidden: 0,
-      statusHash: "",
-      balance: { confirmed: "0", unconfirmed: "0" },
-      tokensBalance: {},
-      type: h.DAPP
-    };
-    this.accounts.set(e, i), this.accountsAddressToId.set(n, e), await this.walletDb.saveAccount(i), this.notify({
-      type: "new_account",
-      account: {
-        id: i.id,
-        name: i.name,
-        address: i.address,
-        balance: i.balance,
-        tokensBalance: i.tokensBalance,
-        sessions: {}
-      }
-    }), await this.subscribeAddresses([i]);
-  }
-  async updateAccountName(e, t) {
-    if (!t)
-      return;
-    const s = this.accounts.get(e);
-    s.name = t, await this.walletDb.updateAccountName(e, t);
-  }
-  rescanAccount(e) {
-    if (e == w) {
-      const t = this.getMainAddresses();
-      for (const s of t)
-        s.height = 0, this.registerUpdate({ address: s, result: s.statusHash });
-    } else {
-      const t = this.accounts.get(e);
-      t.height = 0, this.registerUpdate({ address: t, result: t.statusHash });
-    }
-  }
-  getVaultNextIndex() {
-    return this.vaults.size == 0 ? 0 : Math.max(...Array.from(this.vaults.values(), (e) => e.idx)) + 1;
-  }
-  async addNewVault(e, t, s) {
-    const n = {
-      address: e,
-      block: t,
-      idx: s,
-      height: 0,
-      statusHash: "",
-      balance: { confirmed: "0", unconfirmed: "0" },
-      tokensBalance: {},
-      type: h.VAULT
-    };
-    await this.addVault(n);
-  }
-  async addVault(e) {
-    this.vaults.set(e.address, e), await this.walletDb.saveVault(e), this.notify({
-      type: "new_vault",
-      vault: {
-        address: e.address,
-        balance: e.balance,
-        block: e.block,
-        index: e.idx
-      }
-    }), await this.subscribeAddresses([e]);
-  }
-  async rescanVaults() {
-    let e = !1;
-    const t = await this.discoveryService.discoverVaults(this.getMainAddresses().map((n) => n.address)), s = [];
-    for (const [n, i] of t)
-      this.vaults.has(n) || (e = !0, s.push(this.addVault(i)));
-    return await Promise.all(s), e;
-  }
-  isVaultAddress(e) {
-    return e.type == h.VAULT;
-  }
-  isAccountAddress(e) {
-    return e.type == h.DAPP;
-  }
-  isMainAddress(e) {
-    return e.type == h.MAIN;
-  }
+function $(t, n) {
+	if (n.length !== 2) return;
+	let r = Y(), i = Z(t), a = Q(n);
+	return e.fromScriptTemplate(r, i, a).toString();
 }
-const ze = {
-  isWalletExist: !1,
-  isAuthorized: !1
-}, de = S({
-  name: "auth",
-  initialState: ze,
-  reducers: {
-    setWalletExist: (a, e) => {
-      a.isWalletExist = e.payload;
-    },
-    setAuthorized: (a, e) => {
-      a.isAuthorized = e.payload;
-    }
-  }
-}), Gt = de.actions, qe = de.reducer, Xe = {
-  modalType: null,
-  currentRequest: null
-}, ue = S({
-  name: "dappModal",
-  initialState: Xe,
-  reducers: {
-    showRequest(a, e) {
-      a.modalType = e.payload.type, a.currentRequest = e.payload;
-    },
-    clear(a) {
-      a.modalType = null, a.currentRequest = null;
-    }
-  }
-}), Jt = ue.actions, Ye = ue.reducer, Ze = {
-  counter: 0,
-  loading: !1
-}, le = S({
-  name: "loader",
-  initialState: Ze,
-  reducers: {
-    setLoader: (a, e) => {
-      const t = e.payload.loading ? a.counter + 1 : Math.max(0, a.counter - 1);
-      a.counter = t, a.loading = t > 0, a.text = e.payload.text;
-    }
-  }
-}), jt = le.actions, Qe = le.reducer, et = {
-  currency: "usd",
-  data: {}
-}, $ = Ne("market/updateMarketData", async (a, e) => {
-  const t = e.getState();
-  return await Ve(t.market.currency);
-}), he = S({
-  name: "market",
-  initialState: et,
-  reducers: {
-    setCurrency: (a, e) => {
-      a.currency = e.payload;
-    },
-    setMarketData: (a, e) => {
-      a.data = e.payload;
-    }
-  },
-  extraReducers: (a) => {
-    a.addCase($.fulfilled, (e, t) => {
-      e.data = t.payload;
-    }).addCase($.rejected, (e, t) => {
-      console.error(t.error.message);
-    });
-  }
-}), zt = { updateMarketData: $ }, qt = he.actions, tt = he.reducer, st = {
-  wallet: {},
-  web3: {}
-}, pe = S({
-  name: "notifications",
-  initialState: st,
-  reducers: {
-    addNotification: (a, e) => {
-      e.payload.type == "wallet" ? a.wallet[e.payload.id] = e.payload : e.payload.type == "web3" && (a.web3[e.payload.id] = e.payload);
-    },
-    removeNotification: (a, e) => {
-      delete a.wallet[e.payload], delete a.web3[e.payload];
-    },
-    clearAll: (a, e) => {
-      e.payload === "wallet" ? a.wallet = {} : e.payload === "web3" ? a.web3 = {} : e.payload === "all" && (a.wallet = {}, a.web3 = {});
-    }
-  }
-}), Xt = pe.actions, at = pe.reducer, nt = {
-  status: "Offline",
-  height: 0,
-  hasNetwork: !0,
-  isSuspended: !1
-}, fe = S({
-  name: "status",
-  initialState: nt,
-  reducers: {
-    setHeight: (a, e) => {
-      e.payload > 0 && (a.status = "Online"), a.height = e.payload;
-    },
-    setOffline: (a) => {
-      a.status = "Offline";
-    },
-    setHasNetwork: (a, e) => {
-      a.hasNetwork = e.payload;
-    },
-    setIsSuspended: (a, e) => {
-      a.isSuspended = e.payload;
-    }
-  }
-}), Yt = fe.actions, it = fe.reducer, rt = {
-  isAuthorized: !1,
-  selectedAccount: w,
-  accounts: {
-    "-1": {
-      id: w,
-      name: "Main Wallet",
-      address: "",
-      balance: { confirmed: "0", unconfirmed: "0" },
-      tokensBalance: {},
-      sessions: {}
-    }
-  },
-  vaults: {},
-  sync: !1,
-  initLoad: !0,
-  txUpdateTrigger: 0,
-  nftsUpdateTrigger: 0,
-  tokensUpdateTrigger: 0
-}, me = S({
-  name: "wallet",
-  initialState: rt,
-  reducers: {
-    setInitLoad: (a, e) => {
-      a.initLoad = e.payload;
-    },
-    setSelectedAccount: (a, e) => {
-      a.selectedAccount = e.payload;
-    },
-    setSync: (a, e) => {
-      a.sync = e.payload;
-    },
-    setVault: (a, e) => {
-      a.vaults[e.payload.address] = e.payload;
-    },
-    setVaultBalance: (a, e) => {
-      a.vaults[e.payload.address].balance = e.payload.balance;
-    },
-    setAccount: (a, e) => {
-      a.accounts[e.payload.id] = e.payload;
-    },
-    setMainAddress: (a, e) => {
-      a.accounts[w].address = e.payload;
-    },
-    setAccountBalance: (a, e) => {
-      a.accounts[e.payload.id].balance = e.payload.balance, a.accounts[e.payload.id].tokensBalance = e.payload.tokensBalance;
-    },
-    setAccountName: (a, e) => {
-      a.accounts[e.payload.id].name = e.payload.name;
-    },
-    refreshTxs: (a) => {
-      a.txUpdateTrigger++;
-    },
-    refreshNfts: (a) => {
-      a.nftsUpdateTrigger++;
-    },
-    refreshTokens: (a) => {
-      a.tokensUpdateTrigger++;
-    },
-    addSession(a, e) {
-      const { accountId: t, sessionInfo: s } = e.payload;
-      a.accounts[t].sessions[s.details.sessionId] = s;
-    },
-    removeSession(a, e) {
-      const { accountId: t, sessionId: s } = e.payload;
-      a.accounts[t].sessions[s] && delete a.accounts[t].sessions[s];
-    },
-    clearSessions(a, e) {
-      a.accounts[e.payload.accountId].sessions = {};
-    }
-  }
-}), Zt = me.actions, ot = me.reducer, Qt = {
-  loader: Qe,
-  dapp: Ye,
-  status: it,
-  wallet: ot,
-  auth: qe,
-  notifications: at,
-  market: tt
-}, g = Me.withTypes(), es = () => g((a) => a.auth), ts = (a) => g((e) => e.market.data[a]), ss = () => g((a) => a.status.height), as = (a) => g((e) => e.wallet.accounts[a]), ns = () => g((a) => a.wallet.selectedAccount), is = () => g((a) => Math.max(...Object.keys(a.wallet.accounts).map(Number))), rs = (a) => g((e) => e.wallet.accounts[a].address), os = (a) => g((e) => e.wallet.accounts[a].balance), cs = (a, e) => g((t) => t.wallet.accounts[a].tokensBalance[e]), ds = (a, e) => g((t) => t.wallet.accounts[a].sessions[e]), us = () => g((a) => a.wallet.vaults), ge = G(
-  [(a) => a.notifications.wallet],
-  (a) => Object.values(a).sort((e, t) => t.createdAt - e.createdAt)
-), ye = G(
-  [(a) => a.notifications.web3],
-  (a) => Object.values(a).sort((e, t) => t.createdAt - e.createdAt)
-), ct = G(
-  [ge, ye],
-  (a, e) => [...a, ...e].sort((t, s) => s.createdAt - t.createdAt)
-), ls = () => g(ge), hs = () => g(ye), ps = () => g(ct);
-export {
-  h as AccountType,
-  Ut as AssetService,
-  ce as CURRENCIES,
-  Mt as KVStore,
-  Pt as KeyManager,
-  y as KeySpace,
-  w as MAIN_WALLET_ID,
-  Q as MAX_INT64,
-  ie as RostrumService,
-  te as SUPPORTED_TOKENS,
-  $t as SessionManager,
-  N as SessionRequestType,
-  Dt as TransactionService,
-  Wt as TransactionTransformer,
-  Ee as VAULT_FIRST_BLOCK,
-  yt as VAULT_SCRIPT_PREFIX,
-  Ct as WalletCache,
-  Et as WalletDB,
-  T as WalletManager,
-  Gt as authActions,
-  qe as authReducer,
-  Ft as calculateFiatValue,
-  St as capitalizeFirstLetter,
-  Kt as currencyCodes,
-  De as currencySymbols,
-  J as currentTimestamp,
-  Jt as dappModalActions,
-  Ye as dappModalReducer,
-  Ht as encryptMnemonic,
-  vt as estimateDateByFutureBlock,
-  He as formatMoney,
-  Vt as generateNewMnemonic,
-  We as generateVaultAddress,
-  Le as generateVaultConstraint,
-  $e as generateVaultVisibleArgs,
-  ae as getAddressBuffer,
-  _t as getAssetFileUrl,
-  Be as getAssetMetadata,
-  Lt as getCurrencySymbol,
-  At as getExplorerUrl,
-  Tt as getFileMediaType,
-  It as getFileMimeType,
-  Ve as getMarketData,
-  Fe as getVaultConstraintHash,
-  Re as getVaultTemplate,
-  Ke as getVaultTemplateHash,
-  wt as isGenesisHashValid,
-  _e as isMnemonicValid,
-  M as isNullOrEmpty,
-  C as isTestnet,
-  R as isValidNexaAddress,
-  k as keyPathToString,
-  jt as loaderActions,
-  Qe as loaderReducer,
-  qt as marketActions,
-  tt as marketReducer,
-  zt as marketThunks,
-  Xt as notificationsActions,
-  at as notificationsReducer,
-  Ot as parseTokenDataUrl,
-  Nt as prettifyAmount,
-  Qt as sharedReducers,
-  xt as sleep,
-  Yt as statusActions,
-  it as statusReducer,
-  Ce as stringToKeyPath,
-  ee as sumBalance,
-  K as sumTokensBalance,
-  U as tokenAmountToAssetAmount,
-  kt as tokenHexToAddr,
-  v as tokenIdToHex,
-  Bt as transformTokenIconUrl,
-  bt as truncateStringMiddle,
-  as as useAccount,
-  ps as useAllNotifications,
-  es as useAuth,
-  ss as useBlockHeight,
-  ds as useDAppSession,
-  is as useLastAccountId,
-  rs as useMainReceiveAddress,
-  ts as useMarketData,
-  ns as useSelectedAccount,
-  cs as useTokenBalance,
-  us as useVaults,
-  os as useWalletBalance,
-  ls as useWalletNotifications,
-  hs as useWeb3Notifications,
-  Rt as validateAndDecryptMnemonic,
-  Zt as walletActions,
-  ot as walletReducer
+// src/services/session.ts
+var Pe = class {
+	constructor(e, t) {
+		this.walletDb = e, this.keyManager = t, this.providers = /* @__PURE__ */ new Map(), this.handlers = /* @__PURE__ */ new Map(), this.removeOnClose = !0;
+	}
+	onUpdate(e) {
+		this.updateCallback = e;
+	}
+	notify(e) {
+		this.updateCallback?.(e);
+	}
+	getHandler(e) {
+		return this.handlers.get(e);
+	}
+	add(e, t, n) {
+		this.providers.has(e.id) || this.providers.set(e.id, /* @__PURE__ */ new Map());
+		let r = n.details.sessionId, i = this.providers.get(e.id);
+		this.registerHandlers(e, t, r), i.set(r, t), this.notify({
+			type: "session_added",
+			accountId: e.id,
+			sessionInfo: n
+		});
+	}
+	remove(e, t) {
+		let n = this.providers.get(e);
+		if (n) {
+			let r = n.get(t);
+			r && (r.disconnect(), n.delete(t)), n.size === 0 && this.providers.delete(e);
+		}
+		this.notify({
+			type: "session_removed",
+			accountId: e,
+			sessionId: t
+		});
+	}
+	async reload(e) {
+		for (let t of e.values()) {
+			if (t.id == -1) continue;
+			let e = await this.walletDb.getAccountSessions(t.id), n = this.providers.get(t.id), r = e.map(async (e) => {
+				if (n?.has(e.sessionId)) return;
+				let r;
+				try {
+					r = new oe(e.uri);
+					let n = r.getSessionInfo();
+					await r.connect(3e3);
+					let i = await r.getAppInfo(2e3);
+					await r.joinSession(t.address, 2e3);
+					let a = await r.fetchPendingMessages();
+					for (let e of a) this.notify({
+						type: "new_notification",
+						notification: {
+							id: crypto.randomUUID(),
+							createdAt: e.createdAt,
+							type: "web3",
+							title: "Request pending approval",
+							message: `A connected dApp (${i.name}) has requested an action from your Account: ${t.name}. Review the request details before approving or rejecting.`,
+							action: {
+								type: "DAPP_REQUEST",
+								account: t.id,
+								sessionId: n.sessionId,
+								payload: e.message
+							}
+						}
+					});
+					return {
+						account: t,
+						provider: r,
+						metadata: {
+							details: n,
+							appInfo: i
+						}
+					};
+				} catch (t) {
+					console.error(`Failed to reload session ${e.sessionId}`, t), r?.disconnect(), await this.walletDb.removeSession(e.sessionId);
+				}
+			}), i = await Promise.allSettled(r);
+			for (let e of i) e.status === "fulfilled" && e.value && this.add(e.value.account, e.value.provider, e.value.metadata);
+		}
+	}
+	clear() {
+		try {
+			this.removeOnClose = !1;
+			for (let [e, t] of this.providers) {
+				for (let [, e] of t) e.disconnect();
+				t.clear(), this.notify({
+					type: "sessions_cleared",
+					accountId: e
+				});
+			}
+			this.providers.clear();
+		} finally {
+			this.removeOnClose = !0;
+		}
+	}
+	async revoke(e, t) {
+		let n = this.providers.get(e);
+		if (n) {
+			let e = n.get(t);
+			e && await e.revokeSession();
+		}
+	}
+	async replayMessage(e, t, n) {
+		let r = this.providers.get(e);
+		if (r) {
+			let e = r.get(t);
+			e && await e.replayMessage(n);
+		}
+	}
+	registerHandlers(e, t, n) {
+		t.onSessionDelete(() => this.walletDb.removeSession(n)), t.onClose(() => {
+			this.removeOnClose && this.remove(e.id, n);
+		});
+		let r = (t, r) => new Promise((i, a) => {
+			this.handlers.set(t, {
+				resolve: i,
+				reject: a
+			}), this.notify({
+				type: "new_request",
+				request: {
+					type: t,
+					accountId: e.id,
+					sessionId: n,
+					request: r
+				}
+			});
+		});
+		t.onSignMessage((e) => r(w.SignMessage, e)), t.onAddToken((e) => r(w.AddToken, e)), t.onSendTransaction((e) => r(w.SendTransaction, e)), t.onSignTransaction((e) => r(w.SignTransaction, e)), t.onGetAccount(() => {
+			let t = {
+				account: S.DAPP,
+				type: C.RECEIVE,
+				index: e.id
+			};
+			return {
+				name: e.name,
+				address: e.address,
+				pubkey: this.keyManager.getKey(t).publicKey.toString(),
+				blockchain: "nexa",
+				network: c.defaultNetwork.name,
+				capabilities: {
+					addToken: !0,
+					sendTransaction: !0,
+					signMessage: !0,
+					signTransaction: !0
+				}
+			};
+		});
+	}
+}, Fe = class {
+	constructor(e, t, n) {
+		this.rostrumService = e, this.keyManager = t, this.assetService = n;
+	}
+	async transformRawTransaction(e, t) {
+		let n = this.createContext(e, t);
+		return await this.processInputs(n), this.processOutputs(n), this.signInputs(n), await this.processAssetMovements(n), n.txDetails;
+	}
+	createContext(e, t) {
+		try {
+			return {
+				address: t.address,
+				privateKey: this.keyManager.getKey(t.keyPath).privateKey,
+				txDetails: {
+					tx: new h(e),
+					send: [],
+					receive: []
+				},
+				myInputs: /* @__PURE__ */ new Map(),
+				myOutputs: /* @__PURE__ */ new Map(),
+				involvedAssets: /* @__PURE__ */ new Set(),
+				inputsToSign: /* @__PURE__ */ new Set(),
+				coveredOutputs: /* @__PURE__ */ new Set(),
+				allMyOutputsCovered: !1
+			};
+		} catch {
+			throw Error("Invalid transaction format.");
+		}
+	}
+	async processInputs(e) {
+		let t = [];
+		for (let n = 0; n < e.txDetails.tx.inputs.length; n++) {
+			let r = this.processInput(e, n);
+			t.push(r);
+		}
+		await Promise.all(t);
+	}
+	async processInput(e, t) {
+		let n = e.txDetails.tx.inputs[t], i = await this.rostrumService.getUtxo(r.bufferToHex(n.outpoint));
+		if (i.status == "spent") throw Error("Input UTXO is already spent.");
+		if (n.output = new u(i.amount, i.scriptpubkey), n.output.address == e.address) {
+			let r = i.token_id_hex || "NEXA";
+			e.myInputs.set(t, {
+				address: e.address,
+				nexaAmount: i.amount.toString(),
+				assetId: r,
+				assetAmount: M(i.group_quantity) || i.amount.toString()
+			}), e.involvedAssets.add(r), n.scriptSig.isEmpty() && e.inputsToSign.add(t);
+		}
+		n.scriptSig.findPlaceholder() > 0 && e.inputsToSign.add(t);
+	}
+	processOutputs(e) {
+		for (let t = 0; t < e.txDetails.tx.outputs.length; t++) {
+			let n = e.txDetails.tx.outputs[t].toObject();
+			if (n.address !== e.address) continue;
+			let r = n.groupId ? j(n.groupId) : "NEXA", i = {
+				address: n.address,
+				nexaAmount: n.value.toString(),
+				assetId: r,
+				assetAmount: M(n.groupAmount) || n.value.toString()
+			};
+			e.involvedAssets.add(r), e.myOutputs.set(t, i);
+		}
+	}
+	signInputs(e) {
+		if (e.inputsToSign.size == 0) throw Error("No inputs to sign.");
+		for (let t of e.inputsToSign) {
+			let n = e.txDetails.tx.inputs[t], r = this.validateAndGetSubscript(n);
+			if (n.scriptSig.isEmpty()) {
+				e.allMyOutputsCovered = !0;
+				let i = _.sign(e.txDetails.tx, t, m.ALL, r, e.privateKey).toTxFormat(), a = f.empty().add(e.privateKey.publicKey.toBuffer());
+				n.scriptSig = ee.buildScriptTemplateIn(void 0, a, f.empty().add(i));
+			} else {
+				let i = n.scriptSig.findPlaceholder(), a = n.scriptSig.chunks[i].buf.subarray(64), o = m.fromBuffer(a);
+				this.processSignatureCoverage(e, o);
+				let s = _.sign(e.txDetails.tx, t, o, r, e.privateKey).toTxFormat(a);
+				n.scriptSig.replaceChunk(i, f.empty().add(s));
+			}
+		}
+		if (!e.allMyOutputsCovered) throw Error("Some of interested outputs are not covered by signatures.");
+	}
+	validateAndGetSubscript(e) {
+		if (e.output.scriptPubKey.isPublicKeyTemplateOut()) {
+			if (e.scriptSig.isEmpty() || e.scriptSig.isPublicKeyTemplateIn()) return f.empty().add(l.OP_FROMALTSTACK).add(l.OP_CHECKSIGVERIFY);
+			throw Error("Invalid input script type.");
+		}
+		if (e.output.scriptPubKey.isScriptTemplateOut()) {
+			if (!e.scriptSig.isScriptTemplateIn()) throw Error("Unsupported input script type.");
+			let t = e.output.scriptPubKey.getTemplateHash(), n = e.scriptSig.chunks[0].buf;
+			if (r.equals(t, s.sha256ripemd160(n)) || r.equals(t, s.sha256sha256(n))) return f.fromBuffer(n);
+			throw Error("Invalid input script template.");
+		}
+		throw Error("Unsupported prevout script type.");
+	}
+	processSignatureCoverage(e, t) {
+		if (!e.allMyOutputsCovered) {
+			if (t.outType == d.TWO) e.coveredOutputs.add(t.outData[0]), e.coveredOutputs.add(t.outData[1]), this.checkSignatureCoverage(e);
+			else if (t.outType == d.FIRSTN) {
+				let n = t.outData[0];
+				for (let t = 0; t < n; t++) e.coveredOutputs.add(t);
+				this.checkSignatureCoverage(e);
+			} else e.allMyOutputsCovered = !0;
+		}
+	}
+	checkSignatureCoverage(e) {
+		if (!e.allMyOutputsCovered) {
+			for (let t of e.myOutputs.keys()) if (!e.coveredOutputs.has(t)) return;
+			e.allMyOutputsCovered = !0;
+		}
+	}
+	async processAssetMovements(e) {
+		let t = Array.from(e.myInputs.values()), n = Array.from(e.myOutputs.values()), r = [];
+		for (let i of e.involvedAssets) {
+			let a = this.processAssetMovement(e, i, t, n);
+			r.push(a);
+		}
+		await Promise.all(r);
+	}
+	async processAssetMovement(e, t, n, r) {
+		let i = n.reduce((e, n) => n.assetId === t ? e + BigInt(n.assetAmount) : e, 0n), a = r.reduce((e, n) => n.assetId === t ? e + BigInt(n.assetAmount) : e, 0n);
+		if (i > 0n || a > 0n) {
+			let n = { amount: a - i };
+			t !== "NEXA" && (n.asset = await this.assetService.getAssetInfo(t)), n.amount > 0n ? e.txDetails.receive.push(n) : n.amount < 0n && e.txDetails.send.push(n);
+		}
+	}
+}, Ie = 274710, Le = "0014461ad25081cb0119d034385ff154c8d3ad6bdd76", Re = class {
+	constructor(e, t) {
+		this.rostrumService = e, this.keyManager = t;
+	}
+	async discoverWalletIndex(e, t) {
+		let n = 0, r = -1, i = [];
+		for (;;) {
+			let a = await Promise.all(Array.from({ length: R.GAP_LIMIT }, (r, i) => this.rostrumService.isAddressUsed(this.keyManager.deriveAddress(e, t, n + i))));
+			if (a.some((e) => e)) r = n, i = a, n += R.GAP_LIMIT;
+			else break;
+		}
+		if (r === -1) return -1;
+		for (let e = R.GAP_LIMIT - 1; e >= 0; e--) if (i[e]) return r + e;
+		return r;
+	}
+	async discoverVaults(e) {
+		let t = await this.checkForVaults(e), n = /* @__PURE__ */ new Map();
+		return t.forEach((e) => {
+			let t = this.parseVaultDetails(e);
+			t && n.set(t.address, t);
+		}), n;
+	}
+	async checkForVaults(e) {
+		let t = /* @__PURE__ */ new Set();
+		return await Promise.all(e.map(async (e) => {
+			if (e.height > 0 && e.height < Ie) return;
+			let n = await this.rostrumService.getTransaction(e.tx_hash);
+			for (let e of n.vout) e.scriptPubKey.hex.startsWith(Le) && t.add(e.scriptPubKey.hex);
+		})), t;
+	}
+	parseVaultDetails(t) {
+		let r = f.fromHex(t), a = new i().writeVarLengthBuf(r.toBuffer()).toBuffer(), o = new e(a).toString(), s = r.getVisibleArgs(), c = n.fromScriptNumBuffer(s.chunks[0].buf).toNumber(), l = p.isSmallIntOp(s.chunks[1].opcodenum) ? p.decodeOP_N(s.chunks[1].opcodenum) : n.fromScriptNumBuffer(s.chunks[1].buf).toNumber(), u = [c, l];
+		if (o == $(this.keyManager.getKey({
+			account: S.VAULT,
+			type: C.RECEIVE,
+			index: l
+		}).publicKey, u)) return {
+			address: o,
+			block: c,
+			idx: l,
+			statusHash: "",
+			balance: {
+				confirmed: "0",
+				unconfirmed: "0"
+			},
+			tokensBalance: {},
+			height: 0,
+			type: S.VAULT
+		};
+	}
+}, ze = class e {
+	static {
+		this.DEBOUNCE_MS = 2e3;
+	}
+	constructor(e, t, n, r, i, a) {
+		this.keyManager = e, this.walletDb = t, this.rostrumService = n, this.assetService = r, this.transactionService = i, this.sessionManager = a, this.onSubscribeEvent = (e) => {
+			if (!Array.isArray(e) || e.length < 2) return;
+			let [t, n] = e, r = this.getAllAddresses().find((e) => e.address === t);
+			r && r.statusHash !== n && this.registerUpdate({
+				address: r,
+				result: n
+			});
+		}, this.discoveryService = new Re(this.rostrumService, this.keyManager), this.accounts = /* @__PURE__ */ new Map(), this.accountsAddressToId = /* @__PURE__ */ new Map(), this.receiveAddresses = [], this.changeAddresses = [], this.vaults = /* @__PURE__ */ new Map(), this.pendingUpdates = /* @__PURE__ */ new Map(), this.addressResolvers = /* @__PURE__ */ new Map();
+	}
+	onUpdate(e) {
+		this.updateCallback = e;
+	}
+	notify(e) {
+		this.updateCallback?.(e);
+	}
+	getAllAddresses() {
+		return [
+			...this.receiveAddresses,
+			...this.changeAddresses,
+			...this.accounts.values(),
+			...this.vaults.values()
+		];
+	}
+	getMainAddresses() {
+		return [...this.receiveAddresses, ...this.changeAddresses];
+	}
+	getReceiveAddress() {
+		return this.receiveAddresses.find((e) => !e.used).address;
+	}
+	getChangeAddress(e = -1) {
+		return e == -1 ? this.changeAddresses.find((e) => !e.used).address : this.accounts.get(e).address;
+	}
+	getUsedAddressKeys(e = -1) {
+		if (e != -1) {
+			let t = this.accounts.get(e);
+			return [{
+				address: t.address,
+				keyPath: I(S.DAPP, 0, t.id),
+				balance: t.balance,
+				tokensBalance: t.tokensBalance
+			}];
+		}
+		return this.getMainAddresses().filter((e) => e.used).map((e) => ({
+			address: e.address,
+			keyPath: I(S.MAIN, e.space, e.idx),
+			balance: e.balance,
+			tokensBalance: e.tokensBalance
+		}));
+	}
+	async reloadRostrum(e) {
+		await this.rostrumService.setCurrentInstance(e), await this.rostrumService.disconnect(!0), await this.initRostrum(), await this.subscribeAddresses(this.getAllAddresses());
+	}
+	async initRostrum() {
+		await this.rostrumService.connect(), await this.rostrumService.subscribeHeaders((e) => this.notify({
+			type: "new_tip",
+			tip: e
+		}));
+	}
+	async initialize() {
+		await this.initRostrum(), await this.walletDb.countAddresses() ? await this.loadWallet() : await this.discoverWallet();
+	}
+	async discoverWallet() {
+		this.notify({
+			type: "discover_wallet",
+			loading: !0
+		});
+		let e = this.discoveryService.discoverWalletIndex(S.MAIN, C.RECEIVE), t = this.discoveryService.discoverWalletIndex(S.MAIN, C.CHANGE), n = this.discoveryService.discoverWalletIndex(S.DAPP, C.RECEIVE), [r, i, a] = await Promise.all([
+			e,
+			t,
+			n
+		]);
+		this.receiveAddresses = this.deriveAddresses(C.RECEIVE, 0, r + R.GAP_LIMIT + 1), this.changeAddresses = this.deriveAddresses(C.CHANGE, 0, i + R.GAP_LIMIT + 1), this.accounts = this.deriveAccounts(0, a < 0 ? 1 : a + 1), this.accounts.forEach((e) => this.accountsAddressToId.set(e.address, e.id)), await this.saveAddresses(this.receiveAddresses), await this.saveAddresses(this.changeAddresses), await this.saveAccounts(this.accounts), this.initState(), await this.initialSync(), this.notify({
+			type: "discover_wallet",
+			loading: !1
+		}), this.notify({
+			type: "load_wallet",
+			loading: !1
+		});
+	}
+	async loadWallet() {
+		this.receiveAddresses = await this.walletDb.getReceiveAddresses(), this.changeAddresses = await this.walletDb.getChangeAddresses();
+		let e = await this.walletDb.getAccounts();
+		this.accounts = new Map(e.map((e) => [e.id, e])), this.accountsAddressToId = new Map(e.map((e) => [e.address, e.id]));
+		let t = await this.walletDb.getVaults();
+		this.vaults = new Map(t.map((e) => [e.address, e])), this.initState(), this.notify({
+			type: "load_wallet",
+			loading: !1
+		}), await this.reconnectSync();
+	}
+	async initialSync() {
+		await this.subscribeAddresses(this.getAllAddresses(), !0);
+	}
+	async reconnectSync() {
+		await Promise.all([this.sessionManager.reload(this.accounts), this.subscribeAddresses(this.getAllAddresses())]);
+	}
+	initState() {
+		let e = this.getMainAddresses();
+		this.notify({
+			type: "new_account",
+			account: {
+				id: -1,
+				name: "HD Wallet",
+				address: this.getReceiveAddress(),
+				balance: N(e.map((e) => e.balance)),
+				tokensBalance: P(e.map((e) => e.tokensBalance)),
+				sessions: {}
+			}
+		});
+		for (let e of this.accounts.values()) this.notify({
+			type: "new_account",
+			account: {
+				id: e.id,
+				name: e.name,
+				address: e.address,
+				balance: e.balance,
+				tokensBalance: e.tokensBalance,
+				sessions: {}
+			}
+		});
+		for (let e of this.vaults.values()) this.notify({
+			type: "new_vault",
+			vault: {
+				address: e.address,
+				balance: e.balance,
+				block: e.block,
+				index: e.idx
+			}
+		});
+	}
+	deriveAddresses(e, t, n) {
+		let r = [];
+		for (let i = t; i < t + n; i++) {
+			let t = {
+				address: this.keyManager.deriveAddress(S.MAIN, e, i),
+				space: e,
+				idx: i,
+				used: !1,
+				height: 0,
+				statusHash: "",
+				balance: {
+					confirmed: "0",
+					unconfirmed: "0"
+				},
+				tokensBalance: {},
+				type: S.MAIN
+			};
+			r.push(t);
+		}
+		return r;
+	}
+	deriveAccounts(e, t) {
+		let n = /* @__PURE__ */ new Map();
+		for (let r = e; r < e + t; r++) {
+			let e = {
+				id: r,
+				name: `Account ${r + 1}`,
+				address: this.keyManager.deriveAddress(S.DAPP, C.RECEIVE, r),
+				height: 0,
+				hidden: 0,
+				statusHash: "",
+				balance: {
+					confirmed: "0",
+					unconfirmed: "0"
+				},
+				tokensBalance: {},
+				type: S.DAPP
+			};
+			n.set(e.id, e);
+		}
+		return n;
+	}
+	async saveAddresses(e) {
+		for (let t of e) await this.walletDb.saveAddress(t);
+	}
+	async saveAccounts(e) {
+		for (let t of e.values()) await this.walletDb.saveAccount(t);
+	}
+	async subscribeAddresses(e, t = !1) {
+		let n = e.map(async (e) => ({
+			addr: e,
+			result: await this.rostrumService.subscribeAddress(e.address, this.onSubscribeEvent)
+		})), r = [], i = await Promise.all(n);
+		for (let { addr: e, result: n } of i) if (n && typeof n == "string" && e.statusHash != n) {
+			if (t) {
+				let t = new Promise((t) => {
+					this.addressResolvers.set(e.address, t);
+				});
+				if (r.push(t), !this.discoveryResolver) {
+					let e = new Promise((e) => {
+						this.discoveryResolver = e;
+					});
+					r.push(e);
+				}
+			}
+			this.registerUpdate({
+				address: e,
+				result: n
+			});
+		}
+		await Promise.all(r);
+	}
+	registerUpdate(t) {
+		this.pendingUpdates.set(t.address.address, t), clearTimeout(this.updateTimer), this.updateTimer = setTimeout(() => {
+			this.processPendingUpdates();
+		}, e.DEBOUNCE_MS);
+	}
+	async processPendingUpdates() {
+		if (this.pendingUpdates.size !== 0) try {
+			this.notify({
+				type: "sync_wallet",
+				loading: !0
+			}), console.log(`Processing ${this.pendingUpdates.size} pending updates...`);
+			let e = Array.from(this.pendingUpdates);
+			this.pendingUpdates.clear();
+			let t = [], n = [], r = [];
+			for (let [, i] of e) if (this.isAccountAddress(i.address)) {
+				let e = this.fetchAndUpdateAccount(i.address, i.result);
+				t.push(e);
+			} else if (this.isVaultAddress(i.address)) {
+				let e = this.fetchAndUpdateVault(i.address, i.result);
+				n.push(e);
+			} else {
+				let e = this.fetchAndUpdateAddress(i.address, i.result);
+				r.push(e);
+			}
+			let i = !1;
+			if (this.addressResolvers.size > 0) {
+				for (let [t] of e) {
+					let e = this.addressResolvers.get(t);
+					e && (e(), this.addressResolvers.delete(t));
+				}
+				i = this.addressResolvers.size === 0;
+			}
+			let a = await Promise.all(t);
+			await Promise.all(n);
+			let o = await Promise.all(r), s = [this.postProcessWalletUpdate(o, i), this.postProcessAccountsUpdate(a)];
+			i && s.push(this.recoverTokens()), await Promise.all(s), i && this.discoveryResolver && (this.discoveryResolver(), this.discoveryResolver = void 0);
+		} catch (e) {
+			console.error("Error processing pending updates:", e);
+		} finally {
+			this.notify({
+				type: "sync_wallet",
+				loading: !1
+			});
+		}
+	}
+	async postProcessWalletUpdate(e, t) {
+		if (e.length === 0) return;
+		let n = /* @__PURE__ */ new Map();
+		for (let { txs: t } of e) for (let e of t) n.set(e.tx_hash, e);
+		let r = Array.from(n.values());
+		t && this.recoverVaults(r), await this.checkGapLimit(C.RECEIVE), await this.checkGapLimit(C.CHANGE);
+		let i = this.getMainAddresses(), a = N(i.map((e) => e.balance)), o = P(i.map((e) => e.tokensBalance));
+		this.notify({
+			type: "account_balance_updated",
+			accountId: -1,
+			balance: a,
+			tokensBalance: o
+		}), this.notify({
+			type: "main_address_updated",
+			address: this.getReceiveAddress()
+		}), await this.postProcessActivity(-1, r, i.map((e) => e.address), o);
+	}
+	async postProcessAccountsUpdate(e) {
+		if (e.length === 0) return;
+		let t = [];
+		for (let { address: n, txs: r } of e) {
+			let e = n;
+			this.notify({
+				type: "account_balance_updated",
+				accountId: e.id,
+				balance: e.balance,
+				tokensBalance: e.tokensBalance
+			});
+			let i = this.postProcessActivity(e.id, r, [e.address], e.tokensBalance);
+			t.push(i);
+		}
+		await Promise.all(t);
+	}
+	async postProcessActivity(e, t, n, r) {
+		let i = [], a = this.assetService.syncNfts(e, r);
+		for (let r of t) {
+			let t = this.transactionService.classifyAndSaveTransaction(e, r.tx_hash, n);
+			i.push(t);
+		}
+		i.push(a), await Promise.all(i);
+	}
+	async fetchAndUpdateAddress(e, t) {
+		e.statusHash = t, e.balance = await this.rostrumService.getBalance(e.address), e.tokensBalance = await this.rostrumService.getTokensBalance(e.address);
+		let n = await this.transactionService.fetchTransactionsHistory(e.address, e.height);
+		return e.height = n.lastHeight, e.used ||= n.txs.length > 0, await this.walletDb.saveAddress(e), {
+			address: e,
+			txs: n.txs
+		};
+	}
+	async fetchAndUpdateAccount(e, t) {
+		e.statusHash = t, e.balance = await this.rostrumService.getBalance(e.address), e.tokensBalance = await this.rostrumService.getTokensBalance(e.address);
+		let n = await this.transactionService.fetchTransactionsHistory(e.address, e.height);
+		return e.height = n.lastHeight, await this.walletDb.saveAccount(e), {
+			address: e,
+			txs: n.txs
+		};
+	}
+	async fetchAndUpdateVault(e, t) {
+		e.statusHash = t, e.balance = await this.rostrumService.getBalance(e.address);
+		let n = await this.transactionService.fetchTransactionsHistory(e.address, e.height);
+		return e.height = n.lastHeight, await this.walletDb.saveVault(e), this.notify({
+			type: "vault_balance_updated",
+			address: e.address,
+			balance: e.balance
+		}), {
+			address: e,
+			txs: n.txs
+		};
+	}
+	async checkGapLimit(e) {
+		let t = e === C.RECEIVE ? this.receiveAddresses : this.changeAddresses, n = e === C.RECEIVE ? "Receive" : "Change", r = t.filter((e) => !e.used).length;
+		if (r < R.GAP_LIMIT) {
+			let i = R.GAP_LIMIT - r, a = t[t.length - 1].idx;
+			console.log(`Deriving ${i} more ${n} addresses...`);
+			let o = this.deriveAddresses(e, a + 1, i);
+			e === C.RECEIVE ? this.receiveAddresses.push(...o) : this.changeAddresses.push(...o), await this.saveAddresses(o), await this.subscribeAddresses(o);
+		}
+	}
+	async addNewAccount(e, t) {
+		let n = this.keyManager.deriveAddress(S.DAPP, C.RECEIVE, e), r = {
+			id: e,
+			name: t,
+			address: n,
+			height: 0,
+			hidden: 0,
+			statusHash: "",
+			balance: {
+				confirmed: "0",
+				unconfirmed: "0"
+			},
+			tokensBalance: {},
+			type: S.DAPP
+		};
+		this.accounts.set(e, r), this.accountsAddressToId.set(n, e), await this.walletDb.saveAccount(r), this.notify({
+			type: "new_account",
+			account: {
+				id: r.id,
+				name: r.name,
+				address: r.address,
+				balance: r.balance,
+				tokensBalance: r.tokensBalance,
+				sessions: {}
+			}
+		}), await this.subscribeAddresses([r]);
+	}
+	async updateAccountName(e, t) {
+		if (!t) return;
+		let n = this.accounts.get(e);
+		n.name = t, await this.walletDb.updateAccountName(e, t);
+	}
+	rescanAccount(e) {
+		if (e == -1) {
+			let e = this.getMainAddresses();
+			for (let t of e) t.height = 0, this.registerUpdate({
+				address: t,
+				result: t.statusHash
+			});
+		} else {
+			let t = this.accounts.get(e);
+			t.height = 0, this.registerUpdate({
+				address: t,
+				result: t.statusHash
+			});
+		}
+	}
+	rescanVaults() {
+		let e = [];
+		for (let t of this.vaults.values()) {
+			let n = this.fetchAndUpdateVault(t, t.statusHash);
+			e.push(n);
+		}
+		return Promise.all(e);
+	}
+	getVaultNextIndex() {
+		return this.vaults.size == 0 ? 0 : Math.max(...Array.from(this.vaults.values(), (e) => e.idx)) + 1;
+	}
+	async addNewVault(e, t, n) {
+		let r = {
+			address: e,
+			block: t,
+			idx: n,
+			height: 0,
+			statusHash: "",
+			balance: {
+				confirmed: "0",
+				unconfirmed: "0"
+			},
+			tokensBalance: {},
+			type: S.VAULT
+		};
+		await this.addVault(r);
+	}
+	async addVault(e) {
+		this.vaults.set(e.address, e), await this.walletDb.saveVault(e), this.notify({
+			type: "new_vault",
+			vault: {
+				address: e.address,
+				balance: e.balance,
+				block: e.block,
+				index: e.idx
+			}
+		}), await this.subscribeAddresses([e]);
+	}
+	async recoverVaults(e) {
+		let t = !1, n = await this.discoveryService.discoverVaults(e), r = [];
+		for (let [e, i] of n) this.vaults.has(e) || (t = !0, r.push(this.addVault(i)));
+		return await Promise.all(r), t;
+	}
+	async recoverTokens() {
+		let e = [];
+		e.push(this.assetService.syncTokens(-1, P(this.getMainAddresses().map((e) => e.tokensBalance))));
+		for (let t of this.accounts.values()) e.push(this.assetService.syncTokens(t.id, t.tokensBalance));
+		await Promise.all(e);
+	}
+	isVaultAddress(e) {
+		return e.type == S.VAULT;
+	}
+	isAccountAddress(e) {
+		return e.type == S.DAPP;
+	}
+	isMainAddress(e) {
+		return e.type == S.MAIN;
+	}
+}, Be = class e {
+	static {
+		this.POLL_INTERVAL_MS = 12e4;
+	}
+	static {
+		this.CURRENCY_SETTING = "market-currency";
+	}
+	static {
+		this.SUPPORTED_TOKENS = { nexacoin: "nexa" };
+	}
+	constructor(e) {
+		this.currency = "usd", this.running = !1, this.walletDb = e;
+	}
+	onUpdate(e) {
+		this.updateCallback = e;
+	}
+	notify(e) {
+		this.updateCallback?.(e);
+	}
+	async init() {
+		this.stop();
+		let t = await this.walletDb.getSetting(e.CURRENCY_SETTING);
+		this.currency = K.includes(t) ? t : "usd", this.notify({
+			type: "currency_updated",
+			currency: this.currency
+		}), this.running = !0, this.poll();
+	}
+	stop() {
+		this.running = !1, clearTimeout(this.pollTimer), this.pollTimer = void 0;
+	}
+	getCurrency() {
+		return this.currency;
+	}
+	async setCurrency(t) {
+		t !== this.currency && (await this.walletDb.saveSetting(e.CURRENCY_SETTING, t), this.currency = t, this.notify({
+			type: "currency_updated",
+			currency: t
+		}), this.poll());
+	}
+	async poll() {
+		clearTimeout(this.pollTimer);
+		let e = this.currency;
+		try {
+			let t = await this.fetchMarketData(e);
+			e === this.currency && this.notify({
+				type: "market_data_updated",
+				currency: e,
+				data: t
+			});
+		} catch (e) {
+			console.error(e);
+		} finally {
+			this.scheduleNext();
+		}
+	}
+	scheduleNext() {
+		clearTimeout(this.pollTimer), this.running && (this.pollTimer = setTimeout(() => this.poll(), e.POLL_INTERVAL_MS));
+	}
+	async fetchMarketData(t) {
+		let n = Object.keys(e.SUPPORTED_TOKENS).join(","), r = await fetch(`https://api.coingecko.com/api/v3/coins/markets?ids=${n}&vs_currency=${t}`);
+		if (!r.ok) throw Error("Failed to fetch market data");
+		let i = await r.json(), a = {};
+		return i.forEach((t) => {
+			a[e.SUPPORTED_TOKENS[t.id]] = {
+				id: t.id,
+				name: t.name ?? "",
+				symbol: t.symbol ?? "",
+				image: t.image ?? "",
+				price: t.current_price ?? 0,
+				priceChange: t.price_change_24h,
+				priceChangePercentage: t.price_change_percentage_24h,
+				marketCap: t.market_cap,
+				fdv: t.fully_diluted_valuation,
+				circSupply: t.circulating_supply,
+				totalSupply: t.total_supply,
+				maxSupply: t.max_supply,
+				totalVolume: t.total_volume
+			};
+		}), a;
+	}
 };
-//# sourceMappingURL=index.js.map
+export { S as AccountType, Ee as AssetService, W as CURRENCIES, R as KeyManager, C as KeySpace, se as MAIN_WALLET_ID, ce as MAX_INT64, Be as MarketService, Se as RostrumService, Pe as SessionManager, w as SessionRequestType, De as TransactionService, Fe as TransactionTransformer, T as VAULT_FIRST_BLOCK, le as VAULT_SCRIPT_PREFIX, xe as WalletCache, be as WalletDB, ze as WalletManager, Ne as calculateFiatValue, me as capitalizeFirstLetter, K as currencyCodes, G as currencySymbols, O as currentTimestamp, ke as encryptMnemonic, fe as estimateDateByFutureBlock, q as formatMoney, Oe as generateNewMnemonic, $ as generateVaultAddress, X as generateVaultConstraint, Q as generateVaultVisibleArgs, A as getAddressBuffer, B as getAssetFileUrl, z as getAssetMetadataUrl, Me as getCurrencySymbol, de as getExplorerUrl, ge as getFileMediaType, _e as getFileMimeType, Z as getVaultConstraintHash, J as getVaultTemplate, Y as getVaultTemplateHash, ue as isGenesisHashValid, H as isMnemonicValid, k as isNullOrEmpty, E as isTestnet, D as isValidNexaAddress, I as keyPathToString, we as parseTokenDataUrl, ye as prettifyAmount, ve as sleep, L as stringToKeyPath, N as sumBalance, P as sumTokensBalance, M as tokenAmountToAssetAmount, he as tokenHexToAddr, j as tokenIdToHex, Ce as transformTokenIconUrl, pe as truncateStringMiddle, je as validateAndDecryptMnemonic };
+
+//# sourceMappingURL=index.js.map