@ecency/wallets 1.1.0 → 1.1.2

package/dist/ecency-wallets.es.d.ts

@@ -38,7 +38,8 @@ export declare enum EcencyWalletCurrency {
 
 declare namespace EcencyWalletsPrivateApi {
     export {
-        useCreateAccountWithWallets
+        useCreateAccountWithWallets,
+        useCheckWalletExistence
     }
 }
 export { EcencyWalletsPrivateApi }
@@ -54,9 +55,15 @@ declare interface Payload {
 
 declare interface Payload_2 {
     address: string;
+    currency: EcencyWalletCurrency;
+}
+
+declare interface Payload_3 {
     privateKeyOrSeed: string;
 }
 
+declare function useCheckWalletExistence(): UseMutationResult<boolean, Error, Payload_2, unknown>;
+
 export declare function useCoinGeckoPriceQuery(currency?: EcencyWalletCurrency): UseQueryResult<number, Error>;
 
 declare function useCreateAccountWithWallets(username: string): UseMutationResult<Response, Error, Payload, unknown>;
@@ -77,7 +84,7 @@ export declare function useImportWallet(username: string, currency: EcencyWallet
 privateKey: string;
 address: any;
 publicKey: string;
-}, Error, Payload_2, unknown>;
+}, Error, Payload_3, unknown>;
 
 export declare function useSeedPhrase(username: string): UseQueryResult<string, Error>;
 

package/dist/ecency-wallets.es.js

@@ -1,76 +1,64 @@
-import { useCallback } from "react";
-import { useQuery, useQueryClient, useMutation } from "@tanstack/react-query";
-import { BtcWallet } from "@okxweb3/coin-bitcoin";
-import { EthWallet } from "@okxweb3/coin-ethereum";
-import { TrxWallet } from "@okxweb3/coin-tron";
-import { TonWallet } from "@okxweb3/coin-ton";
-import { SolWallet } from "@okxweb3/coin-solana";
-import { AtomWallet } from "@okxweb3/coin-cosmos";
-import { AptosWallet } from "@okxweb3/coin-aptos";
-import bip39, { mnemonicToSeedSync } from "bip39";
-import { LRUCache } from "lru-cache";
-import { PrivateKey } from "@hiveio/dhive";
-var EcencyWalletCurrency = /* @__PURE__ */ ((EcencyWalletCurrency2) => {
-  EcencyWalletCurrency2["BTC"] = "btc";
-  EcencyWalletCurrency2["ETH"] = "eth";
-  EcencyWalletCurrency2["APT"] = "aptos";
-  EcencyWalletCurrency2["ATOM"] = "cosmos";
-  EcencyWalletCurrency2["TON"] = "ton";
-  EcencyWalletCurrency2["TRON"] = "tron";
-  EcencyWalletCurrency2["SOL"] = "solana";
-  return EcencyWalletCurrency2;
-})(EcencyWalletCurrency || {});
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+import { useCallback as R } from "react";
+import { useQuery as p, useQueryClient as y, useMutation as m } from "@tanstack/react-query";
+import { BtcWallet as O } from "@okxweb3/coin-bitcoin";
+import { EthWallet as v } from "@okxweb3/coin-ethereum";
+import { TrxWallet as k } from "@okxweb3/coin-tron";
+import { TonWallet as A } from "@okxweb3/coin-ton";
+import { SolWallet as N } from "@okxweb3/coin-solana";
+import { AtomWallet as K } from "@okxweb3/coin-cosmos";
+import { AptosWallet as D } from "@okxweb3/coin-aptos";
+import j, { mnemonicToSeedSync as C } from "bip39";
+import { LRUCache as H } from "lru-cache";
+import { PrivateKey as u } from "@hiveio/dhive";
+var o = /* @__PURE__ */ ((e) => (e.BTC = "btc", e.ETH = "eth", e.APT = "aptos", e.ATOM = "cosmos", e.TON = "ton", e.TRON = "tron", e.SOL = "solana", e))(o || {});
+function x(e) {
+  return new Promise((t) => setTimeout(t, e));
 }
-function getWallet(currency) {
-  switch (currency) {
-    case EcencyWalletCurrency.BTC:
-      return new BtcWallet();
-    case EcencyWalletCurrency.ETH:
-      return new EthWallet();
-    case EcencyWalletCurrency.TRON:
-      return new TrxWallet();
-    case EcencyWalletCurrency.TON:
-      return new TonWallet();
-    case EcencyWalletCurrency.SOL:
-      return new SolWallet();
-    case EcencyWalletCurrency.ATOM:
-      return new AtomWallet();
-    case EcencyWalletCurrency.APT:
-      return new AptosWallet();
+function h(e) {
+  switch (e) {
+    case o.BTC:
+      return new O();
+    case o.ETH:
+      return new v();
+    case o.TRON:
+      return new k();
+    case o.TON:
+      return new A();
+    case o.SOL:
+      return new N();
+    case o.ATOM:
+      return new K();
+    case o.APT:
+      return new D();
     default:
-      return void 0;
+      return;
   }
 }
-function mnemonicToSeedBip39(value) {
-  return mnemonicToSeedSync(value).toString("hex");
+function ce(e) {
+  return C(e).toString("hex");
 }
-function useGetExternalWalletBalanceQuery(currency, address) {
-  return useQuery({
-    queryKey: ["ecency-wallets", "external-wallet-balance", currency, address],
+function ie(e, t) {
+  return p({
+    queryKey: ["ecency-wallets", "external-wallet-balance", e, t],
     queryFn: async () => {
-      switch (currency) {
-        case EcencyWalletCurrency.BTC:
-          const btcResponse = await fetch(
-            `https://mempool.space/api/address/${address}`
-          );
-          const btcResponseData = await btcResponse.json();
-          return (btcResponseData.chain_stats.funded_txo_sum - btcResponseData.chain_stats.spent_txo_sum) / 1e8;
-        case EcencyWalletCurrency.ETH:
-          const ethResponse = await fetch("https://eth.llamarpc.com", {
+      switch (e) {
+        case o.BTC:
+          const r = await (await fetch(
+            `https://mempool.space/api/address/${t}`
+          )).json();
+          return (r.chain_stats.funded_txo_sum - r.chain_stats.spent_txo_sum) / 1e8;
+        case o.ETH:
+          return +(await (await fetch("https://eth.llamarpc.com", {
             method: "POST",
             body: JSON.stringify({
               jsonrpc: "2.0",
               id: "1",
               method: "eth_getBalance",
-              params: [address, "latest"]
+              params: [t, "latest"]
             })
-          });
-          const ethResponseData = await ethResponse.json();
-          return +ethResponseData.result / 1e18;
-        case EcencyWalletCurrency.SOL:
-          const solResponse = await fetch(
+          })).json()).result / 1e18;
+        case o.SOL:
+          return (await (await fetch(
             "https://api.mainnet-beta.solana.com",
             {
               method: "POST",
@@ -78,222 +66,193 @@ function useGetExternalWalletBalanceQuery(currency, address) {
                 jsonrpc: "2.0",
                 id: "1",
                 method: "getBalance",
-                params: [address]
+                params: [t]
               })
             }
+          )).json()).result.value / 1e9;
+        case o.TRON:
+          return (await (await fetch(
+            `https://api.trongrid.io/v1/accounts/${t}`
+          )).json()).data[0].balance / 1e6;
+        case o.TON:
+          return (await (await fetch(
+            `https://tonapi.io/v1/blockchain/getAccount?account=${t}`
+          )).json()).balance / 1e9;
+        case o.APT:
+          const d = (await (await fetch(
+            `https://fullnode.mainnet.aptoslabs.com/v1/accounts/${t}/resources`
+          )).json()).find(
+            (S) => S.type.includes("coin::CoinStore")
           );
-          const solResponseData = await solResponse.json();
-          return solResponseData.result.value / 1e9;
-        case EcencyWalletCurrency.TRON:
-          const tronResponse = await fetch(
-            `https://api.trongrid.io/v1/accounts/${address}`
-          );
-          const tronResponseData = await tronResponse.json();
-          return tronResponseData.data[0].balance / 1e6;
-        case EcencyWalletCurrency.TON:
-          const tonResponse = await fetch(
-            `https://tonapi.io/v1/blockchain/getAccount?account=${address}`
-          );
-          const tonResponseData = await tonResponse.json();
-          return tonResponseData.balance / 1e9;
-        case EcencyWalletCurrency.APT:
-          const aptResponse = await fetch(
-            `https://fullnode.mainnet.aptoslabs.com/v1/accounts/${address}/resources`
-          );
-          const aptResponseData = await aptResponse.json();
-          const coinStore = aptResponseData.find(
-            (resource) => resource.type.includes("coin::CoinStore")
-          );
-          if (!coinStore) return 0;
-          return parseInt(coinStore.data.coin.value) / 1e8;
-        case EcencyWalletCurrency.ATOM:
-          const atomResponse = await fetch(
-            `https://rest.cosmos.directory/cosmoshub/auth/accounts/${address}`
-          );
-          const atomResponseData = await atomResponse.json();
-          return +atomResponseData.result.value.coins[0].amount / 1e6;
+          return d ? parseInt(d.data.coin.value) / 1e8 : 0;
+        case o.ATOM:
+          return +(await (await fetch(
+            `https://rest.cosmos.directory/cosmoshub/auth/accounts/${t}`
+          )).json()).result.value.coins[0].amount / 1e6;
       }
     }
   });
 }
-function useSeedPhrase(username) {
-  return useQuery({
-    queryKey: ["ecency-wallets", "seed", username],
-    queryFn: async () => bip39.generateMnemonic(128)
+function f(e) {
+  return p({
+    queryKey: ["ecency-wallets", "seed", e],
+    queryFn: async () => j.generateMnemonic(128)
   });
 }
-const options = {
+const W = {
   max: 500,
   // how long to live in ms
   ttl: 1e3 * 60 * 5,
   // return stale items before removing from cache?
-  allowStale: false,
-  updateAgeOnGet: false,
-  updateAgeOnHas: false
+  allowStale: !1,
+  updateAgeOnGet: !1,
+  updateAgeOnHas: !1
+}, b = new H(W), w = Symbol("undefined"), _ = (e, t) => b.set(e, t === void 0 ? w : t), E = (e) => {
+  const t = b.get(e);
+  return t === w ? void 0 : t;
 };
-const cache = new LRUCache(options);
-const undefinedValue = Symbol("undefined");
-const cacheSet = (key, value) => cache.set(key, value === void 0 ? undefinedValue : value);
-const cacheGet = (key) => {
-  const v = cache.get(key);
-  return v === undefinedValue ? void 0 : v;
-};
-function useCoinGeckoPriceQuery(currency) {
-  return useQuery({
-    queryKey: ["ecency-wallets", "coingecko-price", currency],
+function le(e) {
+  return p({
+    queryKey: ["ecency-wallets", "coingecko-price", e],
     queryFn: async () => {
-      let curr = currency;
-      switch (currency) {
-        case EcencyWalletCurrency.BTC:
-          curr = "binance-wrapped-btc";
+      let t = e;
+      switch (e) {
+        case o.BTC:
+          t = "binance-wrapped-btc";
           break;
-        case EcencyWalletCurrency.ETH:
-          curr = "ethereum";
+        case o.ETH:
+          t = "ethereum";
           break;
-        case EcencyWalletCurrency.SOL:
-          curr = "solana";
+        case o.SOL:
+          t = "solana";
           break;
-        case EcencyWalletCurrency.TON:
-          curr = "trx";
+        case o.TON:
+          t = "trx";
           break;
         default:
-          curr = currency;
+          t = e;
       }
-      let rate = cacheGet("gecko");
-      let response;
-      if (rate) {
-        response = rate;
-      } else {
-        const httpResponse = await fetch(
+      let n = E("gecko"), r;
+      if (n)
+        r = n;
+      else {
+        const a = await (await fetch(
           "https://api.coingecko.com/api/v3/simple/price",
           {
             method: "POST",
             body: JSON.stringify({
               params: {
-                ids: [curr],
+                ids: [t],
                 vs_currencies: "usd"
               }
             })
           }
-        );
-        const data = await httpResponse.json();
-        cacheSet("gecko", data === void 0 ? undefinedValue : data);
-        response = data;
+        )).json();
+        _("gecko", a === void 0 ? w : a), r = a;
       }
-      const rateValue = +response[Object.keys(response)[0]].usd;
-      return 1 / rateValue;
+      return 1 / +r[Object.keys(r)[0]].usd;
     },
-    enabled: !!currency
+    enabled: !!e
   });
 }
-function useHiveKeysQuery(username) {
-  const { data: seed } = useSeedPhrase(username);
-  return useQuery({
-    queryKey: ["ecencу-wallets", "hive-keys", username, seed],
+function q(e) {
+  const { data: t } = f(e);
+  return p({
+    queryKey: ["ecencу-wallets", "hive-keys", e, t],
     queryFn: async () => {
-      if (!seed) {
+      if (!t)
         throw new Error("[Ecency][Wallets] - no seed to create Hive account");
-      }
-      const ownerKey = PrivateKey.fromLogin(username, seed, "owner");
-      const activeKey = PrivateKey.fromLogin(username, seed, "active");
-      const postingKey = PrivateKey.fromLogin(username, seed, "posting");
-      const memoKey = PrivateKey.fromLogin(username, seed, "memo");
+      const n = u.fromLogin(e, t, "owner"), r = u.fromLogin(e, t, "active"), s = u.fromLogin(e, t, "posting"), i = u.fromLogin(e, t, "memo");
       return {
-        username,
-        owner: ownerKey.toString(),
-        active: activeKey.toString(),
-        posting: postingKey.toString(),
-        memo: memoKey.toString(),
-        ownerPubkey: ownerKey.createPublic().toString(),
-        activePubkey: activeKey.createPublic().toString(),
-        postingPubkey: postingKey.createPublic().toString(),
-        memoPubkey: memoKey.createPublic().toString()
+        username: e,
+        owner: n.toString(),
+        active: r.toString(),
+        posting: s.toString(),
+        memo: i.toString(),
+        ownerPubkey: n.createPublic().toString(),
+        activePubkey: r.createPublic().toString(),
+        postingPubkey: s.createPublic().toString(),
+        memoPubkey: i.createPublic().toString()
       };
     }
   });
 }
-const PATHS = {
-  [EcencyWalletCurrency.BTC]: "m/44'/0'/0'/0/0",
+const B = {
+  [o.BTC]: "m/44'/0'/0'/0/0",
   // Bitcoin (BIP44)
-  [EcencyWalletCurrency.ETH]: "m/44'/60'/0'/0/0",
+  [o.ETH]: "m/44'/60'/0'/0/0",
   // Ethereum (BIP44)
-  [EcencyWalletCurrency.SOL]: "m/44'/501'/0'/0'",
+  [o.SOL]: "m/44'/501'/0'/0'",
   // Solana (BIP44)
-  [EcencyWalletCurrency.TON]: "m/44'/607'/0'",
+  [o.TON]: "m/44'/607'/0'",
   // TON (BIP44)
-  [EcencyWalletCurrency.TRON]: "m/44'/195'/0'/0/0",
+  [o.TRON]: "m/44'/195'/0'/0/0",
   // Tron (BIP44)
-  [EcencyWalletCurrency.APT]: "m/44'/637'/0'/0'/0'",
+  [o.APT]: "m/44'/637'/0'/0'/0'",
   // Aptos (BIP44)
-  [EcencyWalletCurrency.ATOM]: "m/44'/118'/0'/0/0"
+  [o.ATOM]: "m/44'/118'/0'/0/0"
   // Cosmos (BIP44)
 };
-function useWalletCreate(username, currency) {
-  const { data: mnemonic } = useSeedPhrase(username);
-  const queryClient = useQueryClient();
-  const createWallet = useMutation({
-    mutationKey: ["ecency-wallets", "create-wallet", username, currency],
+function pe(e, t) {
+  const { data: n } = f(e), r = y(), s = m({
+    mutationKey: ["ecency-wallets", "create-wallet", e, t],
     mutationFn: async () => {
-      if (!mnemonic) {
+      if (!n)
         throw new Error("[Ecency][Wallets] - No seed to create a wallet");
-      }
-      const wallet = getWallet(currency);
-      const privateKey = await (wallet == null ? void 0 : wallet.getDerivedPrivateKey({
-        mnemonic,
-        hdPath: PATHS[currency]
+      const a = h(t), c = await (a == null ? void 0 : a.getDerivedPrivateKey({
+        mnemonic: n,
+        hdPath: B[t]
       }));
-      await delay(1e3);
-      const address = await (wallet == null ? void 0 : wallet.getNewAddress({
-        privateKey
+      await x(1e3);
+      const l = await (a == null ? void 0 : a.getNewAddress({
+        privateKey: c
       }));
       return {
-        privateKey,
-        address: address.address,
-        publicKey: address.publicKey,
-        username,
-        currency
+        privateKey: c,
+        address: l.address,
+        publicKey: l.publicKey,
+        username: e,
+        currency: t
       };
     },
-    onSuccess: (info) => {
-      queryClient.setQueryData(
-        ["ecency-wallets", "wallets", info.username],
-        (data) => new Map(data ? Array.from(data.entries()) : []).set(info.currency, info)
+    onSuccess: (a) => {
+      r.setQueryData(
+        ["ecency-wallets", "wallets", a.username],
+        (c) => new Map(c ? Array.from(c.entries()) : []).set(a.currency, a)
       );
     }
-  });
-  const importWallet = useCallback(() => {
+  }), i = R(() => {
   }, []);
   return {
-    createWallet,
-    importWallet
+    createWallet: s,
+    importWallet: i
   };
 }
-const CONFIG = { privateApiHost: "https://ecency.com" };
-function useCreateAccountWithWallets(username) {
-  const { data } = useQuery({
-    queryKey: ["ecency-wallets", "wallets", username]
-  });
-  const { data: hiveKeys } = useHiveKeysQuery(username);
-  return useMutation({
-    mutationKey: ["ecency-wallets", "create-account-with-wallets", username],
-    mutationFn: ({ currency, address }) => fetch(CONFIG.privateApiHost + "/private-api/wallets-add", {
+const g = { privateApiHost: "https://ecency.com" };
+function L(e) {
+  const { data: t } = p({
+    queryKey: ["ecency-wallets", "wallets", e]
+  }), { data: n } = q(e);
+  return m({
+    mutationKey: ["ecency-wallets", "create-account-with-wallets", e],
+    mutationFn: ({ currency: r, address: s }) => fetch(g.privateApiHost + "/private-api/wallets-add", {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
       },
       body: JSON.stringify({
-        username,
-        token: currency,
-        address,
+        username: e,
+        token: r,
+        address: s,
         meta: {
-          ownerPublicKey: hiveKeys == null ? void 0 : hiveKeys.ownerPubkey,
-          activePublicKey: hiveKeys == null ? void 0 : hiveKeys.activePubkey,
-          postingPublicKey: hiveKeys == null ? void 0 : hiveKeys.postingPubkey,
-          memoPublicKey: hiveKeys == null ? void 0 : hiveKeys.memoPubkey,
-          ...Array.from((data == null ? void 0 : data.entries()) ?? []).reduce(
-            (acc, [curr, info]) => ({
-              ...acc,
-              [curr]: info.address
+          ownerPublicKey: n == null ? void 0 : n.ownerPubkey,
+          activePublicKey: n == null ? void 0 : n.activePubkey,
+          postingPublicKey: n == null ? void 0 : n.postingPubkey,
+          memoPublicKey: n == null ? void 0 : n.memoPubkey,
+          ...Array.from((t == null ? void 0 : t.entries()) ?? []).reduce(
+            (i, [a, c]) => ({
+              ...i,
+              [a]: c.address
             }),
             {}
           )
@@ -302,98 +261,113 @@ function useCreateAccountWithWallets(username) {
     })
   });
 }
-const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+function T() {
+  return m({
+    mutationKey: ["ecency-wallets", "check-wallet-existence"],
+    mutationFn: async ({ address: e, currency: t }) => (await (await fetch(
+      g.privateApiHost + "/private-api/wallets-exist",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          address: e,
+          token: t
+        })
+      }
+    )).json()).length === 0
+  });
+}
+const ue = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  useCreateAccountWithWallets
-}, Symbol.toStringTag, { value: "Module" }));
-const HD_PATHS = {
-  [EcencyWalletCurrency.BTC]: ["m/84'/0'/0'/0/0"],
-  [EcencyWalletCurrency.ETH]: ["m/84'/60'/0'/0/0"],
+  useCheckWalletExistence: T,
+  useCreateAccountWithWallets: L
+}, Symbol.toStringTag, { value: "Module" })), F = {
+  [o.BTC]: ["m/84'/0'/0'/0/0"],
+  [o.ETH]: ["m/84'/60'/0'/0/0"],
   // its not working for Trust, Exodus, todo: check others below
-  [EcencyWalletCurrency.SOL]: ["m/84'/501'/0'/0/0"],
-  [EcencyWalletCurrency.TRON]: ["m/84'/195'/0'/0/0"],
-  [EcencyWalletCurrency.APT]: ["m/84'/637'/0'/0/0"],
-  [EcencyWalletCurrency.TON]: [],
+  [o.SOL]: ["m/84'/501'/0'/0/0"],
+  [o.TRON]: ["m/84'/195'/0'/0/0"],
+  [o.APT]: ["m/84'/637'/0'/0/0"],
+  [o.TON]: [],
   // Disabled
-  [EcencyWalletCurrency.ATOM]: ["m/84'/118'/0'/0'/0"]
+  [o.ATOM]: ["m/84'/118'/0'/0'/0"]
 };
-async function getKeysFromSeed(mnemonic, wallet, currency) {
-  for (const hdPath of HD_PATHS[currency] || []) {
+async function M(e, t, n) {
+  for (const r of F[n] || [])
     try {
-      const derivedPrivateKey = await wallet.getDerivedPrivateKey({
-        mnemonic,
-        hdPath
-      });
-      const derivedPublicKey = await wallet.getNewAddress({
-        privateKey: derivedPrivateKey,
+      const s = await t.getDerivedPrivateKey({
+        mnemonic: e,
+        hdPath: r
+      }), i = await t.getNewAddress({
+        privateKey: s,
         addressType: "segwit_native"
       });
-      return [derivedPrivateKey.toString(), derivedPublicKey.address];
-    } catch (error) {
+      return [s.toString(), i.address];
+    } catch {
       return [];
     }
-  }
   return [];
 }
-function useImportWallet(username, currency) {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationKey: ["ecency-wallets", "import-wallet", username, currency],
-    mutationFn: async ({ privateKeyOrSeed }) => {
-      const wallet = getWallet(currency);
-      if (!wallet) {
+function me(e, t) {
+  const n = y(), { mutateAsync: r } = T();
+  return m({
+    mutationKey: ["ecency-wallets", "import-wallet", e, t],
+    mutationFn: async ({ privateKeyOrSeed: s }) => {
+      const i = h(t);
+      if (!i)
         throw new Error("Cannot find token for this currency");
-      }
-      const isSeed = privateKeyOrSeed.split(" ").length === 12;
-      let address;
-      let privateKey = privateKeyOrSeed;
-      if (isSeed) {
-        [privateKey, address] = await getKeysFromSeed(
-          privateKeyOrSeed,
-          wallet,
-          currency
-        );
-      } else {
-        address = (await wallet.getNewAddress({
-          privateKey: privateKeyOrSeed
-        })).address;
-      }
-      if (!address || !privateKeyOrSeed) {
+      const a = s.split(" ").length === 12;
+      let c, l = s;
+      if (a ? [l, c] = await M(
+        s,
+        i,
+        t
+      ) : c = (await i.getNewAddress({
+        privateKey: s
+      })).address, !c || !s)
         throw new Error(
           "Private key/seed phrase isn't matching with public key or token"
         );
-      }
+      if (!await r({
+        address: c,
+        currency: t
+      }))
+        throw new Error(
+          "This wallet has already in use by Hive account. Please, try another one"
+        );
       return {
-        privateKey,
-        address,
+        privateKey: l,
+        address: c,
         publicKey: ""
       };
     },
-    onSuccess: ({ privateKey, publicKey, address }) => {
-      queryClient.setQueryData(
-        ["ecency-wallets", "wallets", username],
-        (data) => new Map(data ? Array.from(data.entries()) : []).set(currency, {
-          privateKey,
-          publicKey,
-          address,
-          username,
-          currency,
-          custom: true
+    onSuccess: ({ privateKey: s, publicKey: i, address: a }) => {
+      n.setQueryData(
+        ["ecency-wallets", "wallets", e],
+        (c) => new Map(c ? Array.from(c.entries()) : []).set(t, {
+          privateKey: s,
+          publicKey: i,
+          address: a,
+          username: e,
+          currency: t,
+          custom: !0
         })
       );
     }
   });
 }
 export {
-  EcencyWalletCurrency,
-  index as EcencyWalletsPrivateApi,
-  delay,
-  getWallet,
-  mnemonicToSeedBip39,
-  useCoinGeckoPriceQuery,
-  useGetExternalWalletBalanceQuery,
-  useHiveKeysQuery,
-  useImportWallet,
-  useSeedPhrase,
-  useWalletCreate
+  o as EcencyWalletCurrency,
+  ue as EcencyWalletsPrivateApi,
+  x as delay,
+  h as getWallet,
+  ce as mnemonicToSeedBip39,
+  le as useCoinGeckoPriceQuery,
+  ie as useGetExternalWalletBalanceQuery,
+  q as useHiveKeysQuery,
+  me as useImportWallet,
+  f as useSeedPhrase,
+  pe as useWalletCreate
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ecency/wallets",
   "private": false,
-  "version": "1.1.0",
+  "version": "1.1.2",
   "type": "module",
   "main": "./dist/ecency-wallets.umd.js",
   "module": "./dist/ecency-wallets.es.js",