@otoplo/wallet-common 0.1.0

package/dist/index.js

@@ -0,0 +1,2005 @@
+import { AddressType as E, Networks as k, Address as b, CommonUtils as W, BufferUtils as y, HDPrivateKey as Z, GroupToken as O, GroupIdType as I, TransactionBuilder as Q, Transaction as B, UnitUtils as ee, Script as A, Opcode as v, Hash as U, ScriptOpcode as J, BNExtended as z, Output as xe, TxSigner as te, SighashType as se, ScriptFactory as Ne, OutputSighashType as ae, BufferWriter as Ee } from "libnexa-ts";
+import { ElectrumClient as Me, TransportScheme as L, ConnectionStatus as Be } from "@otoplo/electrum-client";
+import { mnemonicToSeedSync as _e, generateMnemonic as Ce, validateMnemonic as Pe } from "@scure/bip39";
+import Oe from "jszip";
+import { DAppProvider as Ue } from "wallet-comms-sdk";
+import { gcm as de } from "@noble/ciphers/aes.js";
+import { pbkdf2Async as De } from "@noble/hashes/pbkdf2.js";
+import { sha256 as Ve } from "@noble/hashes/sha2.js";
+import { wordlist as ue } from "@scure/bip39/wordlists/english.js";
+import { createSlice as M, createAsyncThunk as Re, createSelector as j } from "@reduxjs/toolkit";
+import { useSelector as He } from "react-redux";
+const g = -1, ne = 9223372036854775807n, Ke = 274710, Nt = "0014461ad25081cb0119d034385ff154c8d3ad6bdd76";
+function T() {
+  return k.defaultNetwork == k.testnet;
+}
+function Et(a) {
+  return T() ? a == "508c843a4b98fb25f57cf9ebafb245a5c16468f06519cdd467059a91e7b79d52" : a == "edc7144fe1ba4edd0edf35d7eea90f6cb1dba42314aa85da8207e97c5339c801";
+}
+function F(a, e = E.PayToScriptTemplate) {
+  return b.isValid(a, k.defaultNetwork, e);
+}
+function Mt() {
+  return `https://${T() ? "testnet-" : ""}explorer.nexa.org`;
+}
+function $() {
+  return Math.floor(Date.now() / 1e3);
+}
+function Bt(a, e) {
+  const t = (e - a) * 2, s = /* @__PURE__ */ new Date();
+  return s.setMinutes(s.getMinutes() + t), s.toLocaleDateString();
+}
+function C(a) {
+  return !a || a.length === 0;
+}
+function _t(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 Ct(a) {
+  return a.length === 0 ? "" : a.charAt(0).toUpperCase() + a.substring(1);
+}
+function R(a) {
+  return W.isHexa(a) ? y.hexToBuffer(a) : b.fromString(a).data;
+}
+function S(a) {
+  return W.isHexa(a) ? a : y.bufferToHex(R(a));
+}
+function ie(a) {
+  return W.isHexa(a) ? new b(R(a), k.defaultNetwork, E.GroupIdAddress).toString() : a;
+}
+function D(a) {
+  return a == null || a === "" ? "" : BigInt(a) <= 0n ? "0" : a.toString();
+}
+function re(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 G(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;
+}
+const le = {
+  // 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" }
+};
+function Pt(a) {
+  const e = a.lastIndexOf(".");
+  if (e === -1) return "unknown";
+  const t = a.slice(e).toLowerCase();
+  return le[t]?.media ?? "unknown";
+}
+function Ot(a) {
+  const e = a.lastIndexOf(".");
+  if (e === -1) return "application/octet-stream";
+  const t = a.slice(e).toLowerCase();
+  return le[t]?.mime ?? "application/octet-stream";
+}
+class Ut {
+  getPrefix() {
+    return T() ? "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 C(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) {
+    C(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 f = /* @__PURE__ */ ((a) => (a[a.MAIN = 0] = "MAIN", a[a.VAULT = 1] = "VAULT", a[a.DAPP = 2] = "DAPP", a))(f || {}), m = /* @__PURE__ */ ((a) => (a[a.RECEIVE = 0] = "RECEIVE", a[a.CHANGE = 1] = "CHANGE", a))(m || {}), _ = /* @__PURE__ */ ((a) => (a.SignMessage = "signMessage", a.AddToken = "addToken", a.SignTransaction = "signTransaction", a.SendTransaction = "sendTransaction", a))(_ || {}), V = /* @__PURE__ */ ((a) => (a.TOKEN = "token", a.NFT = "nft", a))(V || {});
+class Dt {
+  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: V.TOKEN,
+      addedTime: $()
+    };
+    await this.store.upsertAsset(s), await this.store.upsertToken(t), this.notify({ type: "token_added", accountId: e, token: s });
+  }
+  async getLocalTokens(e) {
+    return this.store.getTokens(e);
+  }
+  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_removed", accountId: e, tokenId: t });
+  }
+  async saveNft(e, t) {
+    await this.store.upsertNft(t), await this.saveAsset(e, !0);
+  }
+  async getLocalNfts(e, t, s) {
+    return this.store.getNfts(e, t, s);
+  }
+  async getLocalNft(e) {
+    return this.store.getNft(e);
+  }
+  async deleteNft(e, t, s = !1) {
+    await this.removeAsset(e, t), await this.store.countAssetsById(t) == 0 && (await this.store.deleteNft(t), this.notify({ type: "nft_deleted", id: t })), s && this.notify({ type: "nft_refresh" });
+  }
+  async countLocalNfts(e) {
+    return this.store.countNfts(e);
+  }
+  async isNftExist(e) {
+    return this.store.isNftExist(e);
+  }
+  async saveAsset(e, t = !1) {
+    await this.store.upsertAsset(e), t && this.notify({ type: "nft_refresh" });
+  }
+  async removeAsset(e, t) {
+    return this.store.deleteAsset(e, t);
+  }
+  async isAssetExistForAccount(e, t) {
+    return this.store.isAssetExistForAccount(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: f.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: f.MAIN,
+      balance: JSON.parse(t.balance),
+      tokensBalance: JSON.parse(t.tokensBalance)
+    }));
+  }
+  async getChangeAddresses() {
+    return (await this.store.getChangeAddresses()).map((t) => ({
+      ...t,
+      type: f.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: f.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 Vt {
+  walletDb;
+  tokens = /* @__PURE__ */ new Map();
+  nfts = /* @__PURE__ */ new Map();
+  constructor(e) {
+    this.walletDb = e;
+  }
+  clear() {
+    this.tokens.clear(), this.nfts.clear();
+  }
+  async getTokenById(e) {
+    if (e = S(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 getNftById(e) {
+    if (e = S(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(S(e));
+  }
+  removeNft(e) {
+    this.nfts.delete(S(e));
+  }
+}
+class he {
+  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 Me("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 == Be.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 || he.getPredefinedInstances()[0];
+  }
+  static getPredefinedInstances() {
+    return T() ? [
+      {
+        scheme: L.WSS,
+        host: "testnet-electrum.nexa.org",
+        port: 30004,
+        label: "NexaOrg"
+      }
+    ] : [
+      {
+        scheme: L.WSS,
+        host: "rostrum.otoplo.com",
+        port: 443,
+        label: "Otoplo"
+      },
+      {
+        scheme: L.WSS,
+        host: "electrum.nexa.org",
+        port: 20004,
+        label: "NexaOrg"
+      }
+    ];
+  }
+}
+function x(a, e, t) {
+  return `${a}'/${e}/${t}`;
+}
+function Le(a) {
+  const e = a.split("/");
+  return {
+    account: parseInt(e[0].replace("'", "")),
+    type: parseInt(e[1]),
+    index: parseInt(e[2])
+  };
+}
+class Rt {
+  seed;
+  masterKey;
+  accountKeys = /* @__PURE__ */ new Map();
+  walletKeys = /* @__PURE__ */ new Map();
+  init(e) {
+    this.seed = typeof e == "string" ? _e(e) : e, this.masterKey = Z.fromSeed(this.seed).deriveChild(44, !0).deriveChild(29223, !0);
+  }
+  reset() {
+    if (!this.seed)
+      throw new Error("KeysManager not initialized");
+    this.masterKey = Z.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 : x(e.account, e.type, e.index);
+    let s = this.walletKeys.get(t);
+    if (!s) {
+      const { account: n, type: i, index: o } = typeof e == "string" ? Le(e) : e;
+      s = this.getAccountKey(n).deriveChild(i, !1).deriveChild(o, !1), this.walletKeys.set(t, s);
+    }
+    return s;
+  }
+}
+function fe() {
+  return {
+    name: "NiftyArt",
+    ticker: "NIFTY",
+    iconUrl: "https://niftyart.cash/td/niftyicon.svg",
+    parentGroup: "",
+    token: T() ? "nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx" : "nexa:tr9v70v4s9s6jfwz32ts60zqmmkp50lqv7t0ux620d50xa7dhyqqqcg6kdm6f",
+    tokenIdHex: T() ? "0e38fbf897c1d10bcce33883d40acb28fa7a37cc0733598526aecbdff4b50000" : "cacf3d958161a925c28a970d3c40deec1a3fe06796fe1b4a7b68f377cdb90000",
+    decimals: 0
+  };
+}
+function Ht(a) {
+  return Y(qe() + a, "raw");
+}
+function q(a) {
+  try {
+    const e = R(a);
+    return O.isSubgroup(e) ? y.bufferToHex(e.subarray(0, 32)) === fe().tokenIdHex : !1;
+  } catch {
+    return !1;
+  }
+}
+function Fe(a) {
+  return a = X(a), Y(a, "json");
+}
+function Ge(a) {
+  return a = X(a), Y(a, "raw");
+}
+function oe(a, e) {
+  return a && typeof a == "string" ? a.startsWith("http") ? a.replace("http://", "https://") : a.startsWith("ipfs://") ? a : `${new URL(e).origin}${a}` : "";
+}
+function Kt(a) {
+  return a ? X(a) : null;
+}
+function X(a, e = "https://ipfs.nebula.markets/") {
+  return a?.startsWith("ipfs://") ? e + a.substring(7) : a;
+}
+function qe() {
+  return `https://${T() ? "testnet." : ""}niftyart.cash/_public/`;
+}
+async function Y(a, e) {
+  try {
+    const t = await fetch(a);
+    if (!t.ok)
+      throw new Error(`Failed to perform GET. status: ${t.status}`);
+    if (e === "raw") {
+      const s = await t.arrayBuffer();
+      return new Uint8Array(s);
+    } else
+      return await t.json();
+  } catch (t) {
+    throw new Error(`Unexpected Error: ${t}`);
+  }
+}
+class Lt {
+  walletDb;
+  rostrumService;
+  walletCache;
+  constructor(e, t, s) {
+    this.walletDb = e, this.rostrumService = t, this.walletCache = s;
+  }
+  async getTokenInfo(e, t = !0) {
+    try {
+      if (t) {
+        const c = await this.walletCache.getTokenById(e);
+        if (c)
+          return c;
+      }
+      const s = await this.rostrumService.getTokenGenesis(e), n = y.hexToBuffer(s.token_id_hex);
+      let i = "", o = "";
+      if (s.op_return_id == I.NRC2 || s.op_return_id == I.NRC3 || q(e))
+        return;
+      if (O.isSubgroup(n) && (i = new b(O.getParentGroupId(n), k.defaultNetwork, E.GroupIdAddress).toString()), s.document_url)
+        try {
+          if (s.op_return_id == I.NRC1) {
+            const c = await Ge(s.document_url), u = (await Oe.loadAsync(c)).file("info.json");
+            if (u) {
+              const l = await u.async("string"), h = JSON.parse(l);
+              o = oe(h[0]?.icon, s.document_url);
+            }
+          } else {
+            const c = await Fe(s.document_url);
+            o = oe(c[0]?.icon, s.document_url);
+          }
+        } catch (c) {
+          console.error("Failed to load metadata", c);
+        }
+      return {
+        token: s.group,
+        tokenIdHex: s.token_id_hex,
+        decimals: s.decimal_places ?? 0,
+        parentGroup: i,
+        name: s.name ?? "",
+        ticker: s.ticker ?? "",
+        iconUrl: o
+      };
+    } catch (s) {
+      console.error(s);
+      return;
+    }
+  }
+  async isNftToken(e) {
+    try {
+      if (q(e) || await this.walletCache.getNftById(e) || (await this.rostrumService.getTokenGenesis(e)).op_return_id == I.NRC3)
+        return !0;
+    } catch (t) {
+      console.error(t);
+    }
+    return !1;
+  }
+  async getAssetInfo(e) {
+    let t = await this.getTokenInfo(e);
+    return t || await this.isNftToken(e) && (t = {
+      token: ie(e),
+      tokenIdHex: S(e),
+      decimals: 0
+    }), t;
+  }
+  async handleNftReceive(e, t, s) {
+    if (await this.walletDb.isNftExist(t)) {
+      const o = {
+        accountId: e,
+        tokenIdHex: t,
+        type: V.NFT,
+        addedTime: s
+      };
+      await this.walletDb.saveAsset(o, !0);
+      return;
+    }
+    const i = await this.rostrumService.getTokenGenesis(t);
+    if (i.op_return_id == I.NRC3) {
+      const o = R(t);
+      if (O.isSubgroup(o)) {
+        const r = new b(o.subarray(0, 32), k.defaultNetwork, E.GroupIdAddress).toString(), c = await this.rostrumService.getTokenGenesis(r);
+        c?.op_return_id == I.NRC2 && await this.saveNft(e, t, i.document_url ?? "", r, s, c?.name ?? "");
+      }
+    } else q(t) && await this.saveNft(e, t, "nifty", fe().token, s, "");
+  }
+  async saveNft(e, t, s, n, i, o) {
+    if (s)
+      try {
+        const r = {
+          accountId: e,
+          tokenIdHex: t,
+          type: V.NFT,
+          addedTime: i
+        }, c = {
+          parentGroup: n,
+          token: ie(t),
+          tokenIdHex: t,
+          source: s,
+          collection: o
+        };
+        await this.walletDb.saveNft(r, c);
+      } catch (r) {
+        console.error("failed to save NFT", r);
+      }
+  }
+  async fetchAndSaveTokens(e, t) {
+    for (const s in t) {
+      const n = await this.getTokenInfo(s);
+      n && await this.walletDb.saveToken(e, n);
+    }
+  }
+  async syncNfts(e, t) {
+    const s = Object.keys(t), n = await this.walletDb.getLocalNfts(e, 1, 1e3), i = async (r) => {
+      await this.walletDb.deleteNft(e, r, !0), this.walletCache.removeNft(r);
+    }, o = n?.filter((r) => !s.includes(r.tokenIdHex)) ?? [];
+    for (const r of o)
+      await i(r.tokenIdHex);
+    for (const [r, c] of Object.entries(t)) {
+      const d = S(r), u = c && BigInt(c.confirmed) + BigInt(c.unconfirmed) > 0n, l = n?.some((p) => p.tokenIdHex == d);
+      !u && !l || u && l || !await this.isNftToken(d) || (!u && l ? await i(d) : await this.handleNftReceive(e, d, $()));
+    }
+  }
+}
+class Ft {
+  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, Ke), 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 h = {
+        address: l.addresses[0],
+        nexaAmount: l.value_satoshi.toString(),
+        assetId: l.token_id_hex ?? "",
+        assetAmount: D(l.groupQuantity)
+      };
+      t.includes(h.address) ? n.push(h) : i.push(h);
+    }
+    for (const l of s.vout) {
+      if (C(l.scriptPubKey.addresses)) continue;
+      const h = {
+        address: l.scriptPubKey.addresses[0],
+        nexaAmount: l.value_satoshi.toString(),
+        assetId: l.scriptPubKey.token_id_hex ?? "",
+        assetAmount: D(l.scriptPubKey.groupQuantity)
+      };
+      t.includes(h.address) ? o.push(h) : r.push(h);
+    }
+    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 : $(),
+      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 h = await this.populateNexaInputsAndChange(u, e, s, d);
+    return l.forEach((p, P) => h.set(P, p)), await this.finalizeTransaction(u, Array.from(h.values()));
+  }
+  async buildAndSignConsolidateTransaction(e, t, s) {
+    const n = {
+      isConsolidate: !0,
+      templateData: s
+    }, i = new Q(), o = await this.populateNexaInputsAndChange(i, e, t, n);
+    return this.finalizeTransaction(i, Array.from(o.values()));
+  }
+  prepareTransaction(e, t, s, n) {
+    if (!F(e) && !F(e, E.PayToPublicKeyHash))
+      throw new Error("Invalid Address.");
+    if (s && BigInt(t) < 1n || !s && parseInt(t) < B.DUST_AMOUNT)
+      throw new Error("The amount is too low.");
+    if (s && BigInt(t) > ne || !s && parseInt(t) > B.MAX_MONEY)
+      throw new Error("The amount is too high.");
+    const i = new Q();
+    if (n && i.addData(n), s) {
+      if (!F(s, E.GroupIdAddress))
+        throw new Error("Invalid Token ID");
+      if (b.getOutputType(e) === 0)
+        throw new Error("Token must be sent to script template address");
+      i.to(e, B.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 (C(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 h = {
+          outpoint: l.outpoint_hash,
+          address: d.address,
+          satoshis: l.value,
+          templateData: n.templateData
+        };
+        if (e.from(h), !o.has(d.address)) {
+          const p = this.keyManager.getKey(d.keyPath);
+          o.set(d.address, p.privateKey);
+        }
+        if (n.isConsolidate) {
+          if (e.change(s), e.transaction.inputs.length > this.MAX_INPUTS_OUTPUTS)
+            return o;
+        } else {
+          const p = e.transaction;
+          if (p.inputs.length > this.MAX_INPUTS_OUTPUTS)
+            throw new Error("Too many inputs. Consider consolidate transactions or reduce the send amount.");
+          const P = p.getUnspentValue();
+          if (P < 0n)
+            continue;
+          if (P == 0n && n.feeFromAmount) {
+            const H = p.estimateRequiredFee();
+            return p.updateOutputAmount(0, r - H), o;
+          }
+          if (e.change(s), n.feeFromAmount) {
+            const H = p.getChangeOutput();
+            let K = p.estimateRequiredFee();
+            p.updateOutputAmount(0, r - K), !H && p.getChangeOutput() && (K = p.estimateRequiredFee(), p.updateOutputAmount(0, r - K));
+          }
+          if (p.getUnspentValue() < p.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: ee.formatNEXA(e.transaction.outputs[0].value),
+      fee: ee.formatNEXA(e.transaction.estimateRequiredFee())
+    };
+    throw new Error(JSON.stringify(c));
+  }
+  async populateTokenInputsAndChange(e, t, s, n, i) {
+    const o = S(n), r = t.filter((u) => Object.keys(u.tokensBalance).includes(o));
+    if (C(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 h of l)
+        if (!(BigInt(h.token_amount) < 0n)) {
+          if (e.from({
+            outpoint: h.outpoint_hash,
+            address: u.address,
+            satoshis: h.value,
+            groupId: h.group,
+            groupAmount: BigInt(h.token_amount)
+          }), d = d + BigInt(h.token_amount), !c.has(u.address)) {
+            const p = this.keyManager.getKey(u.keyPath);
+            c.set(u.address, p.privateKey);
+          }
+          if (d > ne)
+            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, B.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 Gt(a = 12) {
+  return Ce(ue, a === 24 ? 256 : 128);
+}
+function Je(a) {
+  return Pe(a, ue);
+}
+async function pe(a, e) {
+  return De(Ve, a, e, { c: 6e5, dkLen: 32 });
+}
+async function qt(a, e) {
+  const t = y.getRandomBuffer(16), s = y.getRandomBuffer(12), n = y.utf8ToBuffer(a), i = await pe(e, t), o = de(i, s).encrypt(n), r = y.concat([t, s, o]);
+  return y.bufferToBase64(r);
+}
+async function ze(a, e) {
+  const t = y.base64ToBuffer(a), s = t.subarray(0, 16), n = t.subarray(16, 28), i = t.subarray(28), o = await pe(e, s), r = de(o, n).decrypt(i);
+  return y.bufferToUtf8(r);
+}
+async function Jt(a, e) {
+  try {
+    if (a) {
+      const t = await ze(a, e);
+      if (t && Je(t))
+        return t;
+    }
+    return !1;
+  } catch {
+    return !1;
+  }
+}
+const ge = {
+  usd: "$",
+  eur: "€",
+  gbp: "£",
+  cny: "¥",
+  jpy: "¥",
+  aud: "A$",
+  cad: "C$",
+  chf: "Fr"
+}, ye = Object.keys(ge);
+async function We() {
+  const a = ye.join(","), e = await fetch(`https://api.coingecko.com/api/v3/simple/price?ids=nexacoin&include_24hr_change=true&vs_currencies=${a}`);
+  if (!e.ok)
+    throw new Error("Failed to fetch price");
+  return (await e.json()).nexacoin || {};
+}
+function zt(a) {
+  return ge[a] || a;
+}
+function me() {
+  const a = {};
+  return ye.forEach((e) => {
+    a[e] = { value: 0, change: 0 };
+  }), a;
+}
+function je() {
+  return A.empty().add(v.OP_FROMALTSTACK).add(v.OP_DROP).add(v.OP_FROMALTSTACK).add(v.OP_CHECKLOCKTIMEVERIFY).add(v.OP_DROP).add(v.OP_FROMALTSTACK).add(v.OP_CHECKSIGVERIFY);
+}
+function $e() {
+  const a = je();
+  return U.sha256ripemd160(a.toBuffer());
+}
+function Xe(a) {
+  return A.empty().add(a.toBuffer());
+}
+function Ye(a) {
+  const e = Xe(a);
+  return U.sha256ripemd160(e.toBuffer());
+}
+function Ze(a) {
+  return a.map((e) => e <= 16 ? J.smallInt(e) : z.fromNumber(e).toScriptNumBuffer());
+}
+function Qe(a, e) {
+  if (e.length !== 2)
+    return;
+  const t = $e(), s = Ye(a), n = Ze(e);
+  return b.fromScriptTemplate(t, s, n).toString();
+}
+class Wt {
+  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 == g)
+        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 Ue(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 h of l)
+            this.notify({
+              type: "new_notification",
+              notification: {
+                id: crypto.randomUUID(),
+                createdAt: h.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: h.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(_.SignMessage, i)), t.onAddToken((i) => n(_.AddToken, i)), t.onSendTransaction((i) => n(_.SendTransaction, i)), t.onSignTransaction((i) => n(_.SignTransaction, i)), t.onGetAccount(() => {
+      const i = { account: f.DAPP, type: m.RECEIVE, index: e.id };
+      return {
+        name: e.name,
+        address: e.address,
+        pubkey: this.keyManager.getKey(i).publicKey.toString(),
+        blockchain: "nexa",
+        network: k.defaultNetwork.name,
+        capabilities: {
+          addToken: !0,
+          sendTransaction: !0,
+          signMessage: !0,
+          signTransaction: !0
+        }
+      };
+    });
+  }
+}
+class jt {
+  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 B(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(y.bufferToHex(s.outpoint));
+    if (n.status == "spent")
+      throw new Error("Input UTXO is already spent.");
+    if (s.output = new xe(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: D(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 ? S(s.groupId) : "NEXA", i = {
+        address: s.address,
+        nexaAmount: s.value.toString(),
+        assetId: n,
+        assetAmount: D(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 = te.sign(e.txDetails.tx, t, se.ALL, n, e.privateKey).toTxFormat(), o = A.empty().add(e.privateKey.publicKey.toBuffer());
+        s.scriptSig = Ne.buildScriptTemplateIn(void 0, o, A.empty().add(i));
+      } else {
+        const i = s.scriptSig.findPlaceholder(), r = s.scriptSig.chunks[i].buf.subarray(64), c = se.fromBuffer(r);
+        this.processSignatureCoverage(e, c);
+        const d = te.sign(e.txDetails.tx, t, c, n, e.privateKey).toTxFormat(r);
+        s.scriptSig.replaceChunk(i, A.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 A.empty().add(v.OP_FROMALTSTACK).add(v.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 (y.equals(t, U.sha256ripemd160(s)) || y.equals(t, U.sha256sha256(s)))
+        return A.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 == ae.TWO)
+        e.coveredOutputs.add(t.outData[0]), e.coveredOutputs.add(t.outData[1]), this.checkSignatureCoverage(e);
+      else if (t.outType == ae.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);
+    }
+  }
+}
+const et = 274710, tt = "0014461ad25081cb0119d034385ff154c8d3ad6bdd76";
+class st {
+  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, et);
+    for (const n of s) {
+      const o = (await this.rostrumService.getTransaction(n.tx_hash)).vout.filter((r) => r.scriptPubKey.hex.startsWith(tt));
+      for (const r of o)
+        t.add(r.scriptPubKey.hex);
+    }
+    return t;
+  }
+  parseVaultDetails(e) {
+    const t = A.fromHex(e), s = new Ee().writeVarLengthBuf(t.toBuffer()).toBuffer(), n = new b(s).toString(), i = t.getVisibleArgs(), o = z.fromScriptNumBuffer(i.chunks[0].buf).toNumber(), r = J.isSmallIntOp(i.chunks[1].opcodenum) ? J.decodeOP_N(i.chunks[1].opcodenum) : z.fromScriptNumBuffer(i.chunks[1].buf).toNumber(), c = [o, r], d = this.keyManager.getKey({ account: f.VAULT, type: m.RECEIVE, index: r }), u = Qe(d.publicKey, c);
+    return n != u ? void 0 : {
+      address: n,
+      block: o,
+      idx: r,
+      statusHash: "",
+      balance: { confirmed: "0", unconfirmed: "0" },
+      tokensBalance: {},
+      height: 0,
+      type: f.VAULT
+    };
+  }
+}
+class N {
+  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 st(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 = g) {
+    return e != g ? this.accounts.get(e).address : this.changeAddresses.find((t) => !t.used).address;
+  }
+  getUsedAddressKeys(e = g) {
+    if (e != g) {
+      const t = this.accounts.get(e);
+      return [{
+        address: t.address,
+        keyPath: x(f.DAPP, 0, t.id),
+        balance: t.balance,
+        tokensBalance: t.tokensBalance
+      }];
+    }
+    return this.getMainAddresses().filter((t) => t.used).map((t) => ({
+      address: t.address,
+      keyPath: x(f.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(f.MAIN, m.RECEIVE), t = this.discoveryService.discoverWalletIndex(f.MAIN, m.CHANGE), s = this.discoveryService.discoverWalletIndex(f.DAPP, m.RECEIVE), [n, i, o] = await Promise.all([e, t, s]);
+    this.receiveAddresses = this.deriveAddresses(m.RECEIVE, 0, n + N.GAP_LIMIT), this.changeAddresses = this.deriveAddresses(m.CHANGE, 0, i + N.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.fetchAndSaveTokens(g, G(this.getMainAddresses().map((t) => t.tokensBalance))));
+    for (const t of this.accounts.values())
+      e.push(this.assetService.fetchAndSaveTokens(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: g,
+        name: "Main Wallet",
+        address: this.getReceiveAddress(),
+        balance: re(e.map((t) => t.balance)),
+        tokensBalance: G(e.map((t) => t.tokensBalance)),
+        tokens: [],
+        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,
+          tokens: [],
+          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 = x(f.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: f.MAIN
+      };
+      n.push(c);
+    }
+    return n;
+  }
+  deriveAccounts(e, t) {
+    const s = /* @__PURE__ */ new Map();
+    for (let n = e; n < e + t; n++) {
+      const i = x(f.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: f.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();
+    }, N.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.postProcessAccountUpdate(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: r } of e)
+      for (const c of r)
+        t.set(c.tx_hash, c);
+    await this.checkGapLimit(m.RECEIVE), await this.checkGapLimit(m.CHANGE);
+    const s = this.getMainAddresses(), n = re(s.map((r) => r.balance)), i = G(s.map((r) => r.tokensBalance));
+    this.notify({ type: "account_balance_updated", accountId: g, balance: n, tokensBalance: i }), this.notify({ type: "main_address_updated", address: this.getReceiveAddress() });
+    const o = this.assetService.syncNfts(g, i);
+    for (const r of t.values())
+      await this.transactionService.classifyAndSaveTransaction(g, r.tx_hash, s.map((c) => c.address));
+    await o;
+  }
+  async postProcessAccountUpdate(e) {
+    if (e.length !== 0)
+      for (const { address: t, txs: s } of e) {
+        const n = t;
+        this.notify({ type: "account_balance_updated", accountId: n.id, balance: n.balance, tokensBalance: n.tokensBalance });
+        const i = this.assetService.syncNfts(n.id, n.tokensBalance);
+        for (const o of s)
+          await this.transactionService.classifyAndSaveTransaction(n.id, o.tx_hash, [n.address]);
+        await 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 === m.RECEIVE ? this.receiveAddresses : this.changeAddresses, s = e === m.RECEIVE ? "Receive" : "Change", n = t.filter((i) => !i.used).length;
+    if (n < N.GAP_LIMIT) {
+      const i = N.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 === m.RECEIVE ? this.receiveAddresses.push(...r) : this.changeAddresses.push(...r), await this.saveAddresses(r), await this.subscribeAddresses(r);
+    }
+  }
+  async addNewAccount(e, t) {
+    const s = x(f.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: f.DAPP
+    };
+    this.accounts.set(e, i), this.accountsAddressToId.set(n, e), await this.walletDb.saveAccount(i), await this.subscribeAddresses([i]), this.notify({
+      type: "new_account",
+      account: {
+        id: i.id,
+        name: i.name,
+        address: i.address,
+        balance: i.balance,
+        tokensBalance: i.tokensBalance,
+        tokens: [],
+        sessions: {}
+      }
+    });
+  }
+  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 == g) {
+      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: f.VAULT
+    };
+    await this.addVault(n);
+  }
+  async addVault(e) {
+    this.vaults.set(e.address, e), await this.walletDb.saveVault(e), await this.subscribeAddresses([e]), this.notify({
+      type: "new_vault",
+      vault: {
+        address: e.address,
+        balance: e.balance,
+        block: e.block,
+        index: e.idx
+      }
+    });
+  }
+  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 == f.VAULT;
+  }
+  isAccountAddress(e) {
+    return e.type == f.DAPP;
+  }
+  isMainAddress(e) {
+    return e.type == f.MAIN;
+  }
+}
+const at = {
+  isWalletExist: !1,
+  isAuthorized: !1
+}, we = M({
+  name: "auth",
+  initialState: at,
+  reducers: {
+    setWalletExist: (a, e) => {
+      a.isWalletExist = e.payload;
+    },
+    setAuthorized: (a, e) => {
+      a.isAuthorized = e.payload;
+    }
+  }
+}), $t = we.actions, nt = we.reducer, it = {
+  modalType: null,
+  currentRequest: null
+}, ve = M({
+  name: "dappModal",
+  initialState: it,
+  reducers: {
+    showRequest(a, e) {
+      a.modalType = e.payload.type, a.currentRequest = e.payload;
+    },
+    clear(a) {
+      a.modalType = null, a.currentRequest = null;
+    }
+  }
+}), Xt = ve.actions, rt = ve.reducer, ot = {
+  counter: 0,
+  loading: !1
+}, Ae = M({
+  name: "loader",
+  initialState: ot,
+  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;
+    }
+  }
+}), Yt = Ae.actions, ct = Ae.reducer, dt = {
+  wallet: {},
+  web3: {}
+}, Se = M({
+  name: "notifications",
+  initialState: dt,
+  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 = {});
+    }
+  }
+}), Zt = Se.actions, ut = Se.reducer, lt = {
+  status: "Offline",
+  height: 0,
+  price: me(),
+  hasNetwork: !0,
+  isSuspended: !1
+}, ce = Re("status/fetchPrice", async () => {
+  const a = me();
+  try {
+    const e = await We();
+    Object.keys(e).forEach((t) => {
+      a[t] = {
+        value: e[t],
+        change: e[`${t}_24h_change`]
+      };
+    });
+  } catch {
+  }
+  return a;
+}), be = M({
+  name: "status",
+  initialState: lt,
+  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;
+    }
+  },
+  extraReducers: (a) => {
+    a.addCase(ce.fulfilled, (e, t) => {
+      e.price = t.payload;
+    }).addCase(ce.rejected, (e, t) => {
+      console.error(t.error.message);
+    });
+  }
+}), Qt = be.actions, ht = be.reducer, ft = {
+  isAuthorized: !1,
+  selectedAccount: g,
+  accounts: {
+    "-1": {
+      id: g,
+      name: "Main Wallet",
+      address: "",
+      balance: { confirmed: "0", unconfirmed: "0" },
+      tokensBalance: {},
+      tokens: [],
+      sessions: {}
+    }
+  },
+  vaults: {},
+  sync: !1,
+  initLoad: !0,
+  txUpdateTrigger: 0,
+  nftsUpdateTrigger: 0
+}, ke = M({
+  name: "wallet",
+  initialState: ft,
+  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[g].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;
+    },
+    setTokens: (a, e) => {
+      a.accounts[e.payload.id].tokens = e.payload.assets;
+    },
+    addToken: (a, e) => {
+      a.accounts[e.payload.id].tokens.unshift(e.payload.asset);
+    },
+    removeToken: (a, e) => {
+      a.accounts[e.payload.id].tokens = a.accounts[e.payload.id].tokens.filter((t) => t.tokenIdHex !== e.payload.tokenId);
+    },
+    refreshTxs: (a) => {
+      a.txUpdateTrigger++;
+    },
+    refreshNfts: (a) => {
+      a.nftsUpdateTrigger++;
+    },
+    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 = {};
+    }
+  }
+}), es = ke.actions, pt = ke.reducer, ts = {
+  loader: ct,
+  dapp: rt,
+  status: ht,
+  wallet: pt,
+  auth: nt,
+  notifications: ut
+}, w = He.withTypes(), ss = () => w((a) => a.auth), as = () => w((a) => a.status.height), ns = (a) => w((e) => e.wallet.accounts[a]), is = () => w((a) => a.wallet.selectedAccount), rs = () => w((a) => Math.max(...Object.keys(a.wallet.accounts).map(Number))), os = (a) => w((e) => e.wallet.accounts[a].address), cs = (a) => w((e) => e.wallet.accounts[a].balance), ds = (a, e) => w((t) => t.wallet.accounts[a].tokensBalance[e]), us = (a, e) => w((t) => t.wallet.accounts[a].sessions[e]), ls = () => w((a) => a.wallet.vaults), Te = j(
+  [(a) => a.notifications.wallet],
+  (a) => Object.values(a).sort((e, t) => t.createdAt - e.createdAt)
+), Ie = j(
+  [(a) => a.notifications.web3],
+  (a) => Object.values(a).sort((e, t) => t.createdAt - e.createdAt)
+), gt = j(
+  [Te, Ie],
+  (a, e) => [...a, ...e].sort((t, s) => s.createdAt - t.createdAt)
+), hs = () => w(Te), fs = () => w(Ie), ps = () => w(gt);
+export {
+  f as AccountType,
+  Lt as AssetService,
+  V as AssetType,
+  Ut as KVStore,
+  Rt as KeyManager,
+  m as KeySpace,
+  g as MAIN_WALLET_ID,
+  ne as MAX_INT64,
+  he as RostrumService,
+  Wt as SessionManager,
+  _ as SessionRequestType,
+  Ft as TransactionService,
+  jt as TransactionTransformer,
+  Ke as VAULT_FIRST_BLOCK,
+  Nt as VAULT_SCRIPT_PREFIX,
+  Vt as WalletCache,
+  Dt as WalletDB,
+  N as WalletManager,
+  $t as authActions,
+  nt as authReducer,
+  Ct as capitalizeFirstLetter,
+  ye as currencies,
+  $ as currentTimestamp,
+  Xt as dappModalActions,
+  rt as dappModalReducer,
+  qt as encryptMnemonic,
+  Bt as estimateDateByFutureBlock,
+  Ge as fetchAssetBlob,
+  Fe as fetchAssetDoc,
+  Ht as fetchNiftyNFT,
+  ce as fetchPrice,
+  Gt as generateNewMnemonic,
+  Qe as generateVaultAddress,
+  Xe as generateVaultConstraint,
+  Ze as generateVaultVisibleArgs,
+  R as getAddressBuffer,
+  zt as getCurrencySymbol,
+  Mt as getExplorerUrl,
+  Pt as getFileMediaType,
+  Ot as getFileMimeType,
+  We as getNexaPrices,
+  fe as getNiftyToken,
+  Ye as getVaultConstraintHash,
+  je as getVaultTemplate,
+  $e as getVaultTemplateHash,
+  me as initializePrices,
+  Et as isGenesisHashValid,
+  Je as isMnemonicValid,
+  q as isNiftySubgroup,
+  C as isNullOrEmpty,
+  T as isTestnet,
+  F as isValidNexaAddress,
+  x as keyPathToString,
+  Yt as loaderActions,
+  ct as loaderReducer,
+  Zt as notificationsActions,
+  ut as notificationsReducer,
+  Kt as parseTokenDataUrl,
+  ts as sharedReducers,
+  Qt as statusActions,
+  ht as statusReducer,
+  Le as stringToKeyPath,
+  re as sumBalance,
+  G as sumTokensBalance,
+  D as tokenAmountToAssetAmount,
+  ie as tokenHexToAddr,
+  S as tokenIdToHex,
+  oe as transformTokenIconUrl,
+  _t as truncateStringMiddle,
+  ns as useAccount,
+  ps as useAllNotifications,
+  ss as useAuth,
+  as as useBlockHeight,
+  us as useDAppSession,
+  rs as useLastAccountId,
+  os as useMainReceiveAddress,
+  is as useSelectedAccount,
+  ds as useTokenBalance,
+  ls as useVaults,
+  cs as useWalletBalance,
+  hs as useWalletNotifications,
+  fs as useWeb3Notifications,
+  Jt as validateAndDecryptMnemonic,
+  es as walletActions,
+  pt as walletReducer
+};
+//# sourceMappingURL=index.js.map