@ecency/sdk 1.0.14 → 1.0.16

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

@@ -1,8 +1,11 @@
 import { BaseWallet } from '@okxweb3/coin-base';
 import { Operation } from '@hiveio/dhive';
+import { TransactionConfirmation } from '@hiveio/dhive';
 import { UseMutationResult } from '@tanstack/react-query';
 import { UseQueryResult } from '@tanstack/react-query';
 
+declare const broadcast: (account: string, operations: Operation[], key: KeychainAuthorityTypes, rpc?: string | null) => Promise<TxResponse>;
+
 export declare function delay(ms: number): Promise<unknown>;
 
 export declare interface EcencyCreateWalletInformation {
@@ -47,6 +50,18 @@ export { EcencyWalletsPrivateApi }
 
 export declare function getWallet(currency: EcencyWalletCurrency): BaseWallet | undefined;
 
+declare function handshake(): Promise<void>;
+
+declare namespace Keychain {
+    export {
+        handshake,
+        KeychainAuthorityTypes,
+        broadcast
+    }
+}
+
+declare type KeychainAuthorityTypes = "Owner" | "Active" | "Posting" | "Memo";
+
 export declare function mnemonicToSeedBip39(value: string): string;
 
 declare interface Payload {
@@ -63,6 +78,11 @@ declare interface Payload_3 {
     privateKeyOrSeed: string;
 }
 
+declare interface TxResponse {
+    success: boolean;
+    result: string;
+}
+
 export declare function useAccountUpdate(username: string): UseMutationResult<any, Error, any, unknown>;
 
 declare function useCheckWalletExistence(): UseMutationResult<boolean, Error, Payload_2, unknown>;
@@ -95,7 +115,14 @@ wallets: Map<EcencyWalletCurrency, EcencyCreateWalletInformation>;
 
 export declare function useSeedPhrase(username: string): UseQueryResult<string, Error>;
 
-export declare function useSignOperation(username: string | undefined): UseMutationResult<any, Error, Operation, unknown>;
+export declare function useSignOperationByHivesigner(callbackUri?: string): void;
+
+export declare function useSignOperationByKey(username: string | undefined): UseMutationResult<TransactionConfirmation, Error, {
+operation: Operation;
+keyOrSeed: string;
+}, unknown>;
+
+export declare function useSignOperationByKeychain(username: string | undefined, keyType?: Keychain.KeychainAuthorityTypes): void;
 
 export declare function useWalletCreate(username: string, currency: EcencyWalletCurrency): {
     createWallet: UseMutationResult<EcencyCreateWalletInformation, Error, void, unknown>;

package/dist/ecency-sdk.es.js

@@ -1,28 +1,28 @@
-import { useCallback as O } from "react";
-import { useQuery as m, useQueryClient as f, useMutation as u } from "@tanstack/react-query";
+import { useCallback as k } from "react";
+import { useQuery as h, useQueryClient as f, useMutation as l } from "@tanstack/react-query";
 import { BtcWallet as A } from "@okxweb3/coin-bitcoin";
-import { EthWallet as R } from "@okxweb3/coin-ethereum";
-import { TrxWallet as K } from "@okxweb3/coin-tron";
+import { EthWallet as K } from "@okxweb3/coin-ethereum";
+import { TrxWallet as R } from "@okxweb3/coin-tron";
 import { TonWallet as C } from "@okxweb3/coin-ton";
 import { SolWallet as N } from "@okxweb3/coin-solana";
 import { AtomWallet as x } from "@okxweb3/coin-cosmos";
-import { AptosWallet as j } from "@okxweb3/coin-aptos";
-import D, { mnemonicToSeedSync as _ } from "bip39";
-import { Client as H, PrivateKey as d } from "@hiveio/dhive";
+import { AptosWallet as D } from "@okxweb3/coin-aptos";
+import _, { mnemonicToSeedSync as j } from "bip39";
+import { Client as B, PrivateKey as p, cryptoUtils as H } from "@hiveio/dhive";
 import { LRUCache as E } from "lru-cache";
-import B from "hivesigner";
-var o = /* @__PURE__ */ ((e) => (e.BTC = "BTC", e.ETH = "ETH", e.APT = "APT", e.ATOM = "ATOM", e.TON = "TON", e.TRON = "TRX", e.SOL = "SOL", e))(o || {});
-function W(e) {
-  return new Promise((t) => setTimeout(t, e));
+import g from "hivesigner";
+var o = /* @__PURE__ */ ((t) => (t.BTC = "BTC", t.ETH = "ETH", t.APT = "APT", t.ATOM = "ATOM", t.TON = "TON", t.TRON = "TRX", t.SOL = "SOL", t))(o || {});
+function F(t) {
+  return new Promise((e) => setTimeout(e, t));
 }
-function g(e) {
-  switch (e) {
+function T(t) {
+  switch (t) {
     case o.BTC:
       return new A();
     case o.ETH:
-      return new R();
-    case o.TRON:
       return new K();
+    case o.TRON:
+      return new R();
     case o.TON:
       return new C();
     case o.SOL:
@@ -30,19 +30,19 @@ function g(e) {
     case o.ATOM:
       return new x();
     case o.APT:
-      return new j();
+      return new D();
     default:
       return;
   }
 }
-function ye(e) {
-  return _(e).toString("hex");
+function gt(t) {
+  return j(t).toString("hex");
 }
-const p = {
+const u = {
   privateApiHost: "https://ecency.com",
   storage: localStorage,
   storagePrefix: "ecency",
-  hiveClient: new H(
+  hiveClient: new B(
     [
       "https://api.hive.blog",
       "https://api.deathwing.me",
@@ -64,30 +64,30 @@ const p = {
   ),
   heliusApiKey: "fb1e2935-f911-4b1d-8e1c-3863f6879d42"
 };
-function fe(e, t) {
-  return m({
-    queryKey: ["ecency-wallets", "external-wallet-balance", e, t],
+function Tt(t, e) {
+  return h({
+    queryKey: ["ecency-wallets", "external-wallet-balance", t, e],
     queryFn: async () => {
-      switch (e) {
+      switch (t) {
         case o.BTC:
-          const s = await (await fetch(
-            `https://mempool.space/api/address/${t}`
+          const a = await (await fetch(
+            `https://mempool.space/api/address/${e}`
           )).json();
-          return (s.chain_stats.funded_txo_sum - s.chain_stats.spent_txo_sum) / 1e8;
+          return (a.chain_stats.funded_txo_sum - a.chain_stats.spent_txo_sum) / 1e8;
         case o.ETH:
           return +(await (await fetch(
-            `https://api.ethplorer.io/getAddressInfo/${t}?apiKey=freekey`
+            `https://api.ethplorer.io/getAddressInfo/${e}?apiKey=freekey`
           )).json()).ETH.balance;
         case o.SOL:
           return (await (await fetch(
-            `https://rpc.helius.xyz/?api-key=${p.heliusApiKey}`,
+            `https://rpc.helius.xyz/?api-key=${u.heliusApiKey}`,
             {
               method: "POST",
               body: JSON.stringify({
                 jsonrpc: "2.0",
                 id: "1",
                 method: "getBalance",
-                params: [t]
+                params: [e]
               }),
               headers: {
                 "Content-Type": "application/json"
@@ -96,34 +96,34 @@ function fe(e, t) {
           )).json()).result.value / 1e9;
         case o.TRON:
           return (await (await fetch(
-            `https://api.trongrid.io/v1/accounts/${t}`
+            `https://api.trongrid.io/v1/accounts/${e}`
           )).json()).data[0].balance / 1e6;
         case o.TON:
           return (await (await fetch(
-            `https://tonapi.io/v1/blockchain/getAccount?account=${t}`
+            `https://tonapi.io/v1/blockchain/getAccount?account=${e}`
           )).json()).balance / 1e9;
         case o.APT:
           const y = (await (await fetch(
-            `https://fullnode.mainnet.aptoslabs.com/v1/accounts/${t}/resources`
+            `https://fullnode.mainnet.aptoslabs.com/v1/accounts/${e}/resources`
           )).json()).find(
-            (k) => k.type.includes("coin::CoinStore")
+            (O) => O.type.includes("coin::CoinStore")
           );
           return y ? parseInt(y.data.coin.value) / 1e8 : 0;
         case o.ATOM:
           return +(await (await fetch(
-            `https://rest.cosmos.directory/cosmoshub/auth/accounts/${t}`
+            `https://rest.cosmos.directory/cosmoshub/auth/accounts/${e}`
           )).json()).result.value.coins[0].amount / 1e6;
       }
     }
   });
 }
-function T(e) {
-  return m({
-    queryKey: ["ecency-wallets", "seed", e],
-    queryFn: async () => D.generateMnemonic(128)
+function b(t) {
+  return h({
+    queryKey: ["ecency-wallets", "seed", t],
+    queryFn: async () => _.generateMnemonic(128)
   });
 }
-const F = {
+const W = {
   max: 500,
   // how long to live in ms
   ttl: 1e3 * 60 * 5,
@@ -131,72 +131,72 @@ const F = {
   allowStale: !1,
   updateAgeOnGet: !1,
   updateAgeOnHas: !1
-}, b = new E(F), w = Symbol("undefined"), M = (e, t) => b.set(e, t === void 0 ? w : t), L = (e) => {
-  const t = b.get(e);
-  return t === w ? void 0 : t;
+}, v = new E(W), w = Symbol("undefined"), L = (t, e) => v.set(t, e === void 0 ? w : e), M = (t) => {
+  const e = v.get(t);
+  return e === w ? void 0 : e;
 };
-function ge(e) {
-  return m({
-    queryKey: ["ecency-wallets", "coingecko-price", e],
+function bt(t) {
+  return h({
+    queryKey: ["ecency-wallets", "coingecko-price", t],
     queryFn: async () => {
-      let t = e;
-      switch (e) {
+      let e = t;
+      switch (t) {
         case o.BTC:
-          t = "binance-wrapped-btc";
+          e = "binance-wrapped-btc";
           break;
         case o.ETH:
-          t = "ethereum";
+          e = "ethereum";
           break;
         case o.SOL:
-          t = "solana";
+          e = "solana";
           break;
         case o.TON:
-          t = "trx";
+          e = "trx";
           break;
         default:
-          t = e;
+          e = t;
       }
-      let n = L("gecko"), s;
+      let n = M("gecko"), a;
       if (n)
-        s = n;
+        a = n;
       else {
-        const r = await (await fetch(
+        const i = await (await fetch(
           "https://api.coingecko.com/api/v3/simple/price",
           {
             method: "POST",
             body: JSON.stringify({
               params: {
-                ids: [t],
+                ids: [e],
                 vs_currencies: "usd"
               }
             })
           }
         )).json();
-        M("gecko", r === void 0 ? w : r), s = r;
+        L("gecko", i === void 0 ? w : i), a = i;
       }
-      return 1 / +s[Object.keys(s)[0]].usd;
+      return 1 / +a[Object.keys(a)[0]].usd;
     },
-    enabled: !!e
+    enabled: !!t
   });
 }
-function q(e) {
-  const { data: t } = T(e);
-  return m({
-    queryKey: ["ecencу-wallets", "hive-keys", e, t],
+function q(t) {
+  const { data: e } = b(t);
+  return h({
+    queryKey: ["ecencу-wallets", "hive-keys", t, e],
     queryFn: async () => {
-      if (!t)
+      if (!e)
         throw new Error("[Ecency][Wallets] - no seed to create Hive account");
-      const n = d.fromLogin(e, t, "owner"), s = d.fromLogin(e, t, "active"), a = d.fromLogin(e, t, "posting"), i = d.fromLogin(e, t, "memo");
+      const n = p.fromLogin(t, e, "owner"), a = p.fromLogin(t, e, "active"), s = p.fromLogin(t, e, "posting"), r = p.fromLogin(t, e, "memo");
       return {
-        username: e,
+        username: t,
         owner: n.toString(),
-        active: s.toString(),
-        posting: a.toString(),
-        memo: i.toString(),
+        active: a.toString(),
+        posting: s.toString(),
+        memo: r.toString(),
         ownerPubkey: n.createPublic().toString(),
-        activePubkey: s.createPublic().toString(),
-        postingPubkey: a.createPublic().toString(),
-        memoPubkey: i.createPublic().toString()
+        activePubkey: a.createPublic().toString(),
+        postingPubkey: s.createPublic().toString(),
+        memoPubkey: r.createPublic().toString()
       };
     }
   });
@@ -217,65 +217,65 @@ const I = {
   [o.ATOM]: "m/44'/118'/0'/0/0"
   // Cosmos (BIP44)
 };
-function Te(e, t) {
-  const { data: n } = T(e), s = f(), a = u({
-    mutationKey: ["ecency-wallets", "create-wallet", e, t],
+function vt(t, e) {
+  const { data: n } = b(t), a = f(), s = l({
+    mutationKey: ["ecency-wallets", "create-wallet", t, e],
     mutationFn: async () => {
       if (!n)
         throw new Error("[Ecency][Wallets] - No seed to create a wallet");
-      const r = g(t), c = await (r == null ? void 0 : r.getDerivedPrivateKey({
+      const i = T(e), c = await (i == null ? void 0 : i.getDerivedPrivateKey({
         mnemonic: n,
-        hdPath: I[t]
+        hdPath: I[e]
       }));
-      await W(1e3);
-      const l = await (r == null ? void 0 : r.getNewAddress({
+      await F(1e3);
+      const m = await (i == null ? void 0 : i.getNewAddress({
         privateKey: c
       }));
       return {
         privateKey: c,
-        address: l.address,
-        publicKey: l.publicKey,
-        username: e,
-        currency: t
+        address: m.address,
+        publicKey: m.publicKey,
+        username: t,
+        currency: e
       };
     },
-    onSuccess: (r) => {
-      s.setQueryData(
-        ["ecency-wallets", "wallets", r.username],
-        (c) => new Map(c ? Array.from(c.entries()) : []).set(r.currency, r)
+    onSuccess: (i) => {
+      a.setQueryData(
+        ["ecency-wallets", "wallets", i.username],
+        (c) => new Map(c ? Array.from(c.entries()) : []).set(i.currency, i)
       );
     }
-  }), i = O(() => {
+  }), r = k(() => {
   }, []);
   return {
-    createWallet: a,
-    importWallet: i
+    createWallet: s,
+    importWallet: r
   };
 }
-function J(e) {
-  const { data: t } = m({
-    queryKey: ["ecency-wallets", "wallets", e]
-  }), { data: n } = q(e);
-  return u({
-    mutationKey: ["ecency-wallets", "create-account-with-wallets", e],
-    mutationFn: ({ currency: s, address: a }) => fetch(p.privateApiHost + "/private-api/wallets-add", {
+function J(t) {
+  const { data: e } = h({
+    queryKey: ["ecency-wallets", "wallets", t]
+  }), { data: n } = q(t);
+  return l({
+    mutationKey: ["ecency-wallets", "create-account-with-wallets", t],
+    mutationFn: ({ currency: a, address: s }) => fetch(u.privateApiHost + "/private-api/wallets-add", {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
       },
       body: JSON.stringify({
-        username: e,
-        token: s,
-        address: a,
+        username: t,
+        token: a,
+        address: s,
         meta: {
           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, [r, c]) => ({
-              ...i,
-              [r]: c.address
+          ...Array.from((e == null ? void 0 : e.entries()) ?? []).reduce(
+            (r, [i, c]) => ({
+              ...r,
+              [i]: c.address
             }),
             {}
           )
@@ -284,27 +284,27 @@ function J(e) {
     })
   });
 }
-function v() {
-  return u({
+function P() {
+  return l({
     mutationKey: ["ecency-wallets", "check-wallet-existence"],
-    mutationFn: async ({ address: e, currency: t }) => (await (await fetch(
-      p.privateApiHost + "/private-api/wallets-exist",
+    mutationFn: async ({ address: t, currency: e }) => (await (await fetch(
+      u.privateApiHost + "/private-api/wallets-exist",
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          address: e,
-          token: t
+          address: t,
+          token: e
         })
       }
     )).json()).length === 0
   });
 }
-const be = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const Pt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  useCheckWalletExistence: v,
+  useCheckWalletExistence: P,
   useCreateAccountWithWallets: J
 }, Symbol.toStringTag, { value: "Module" })), Q = {
   [o.BTC]: ["m/84'/0'/0'/0/0"],
@@ -317,125 +317,125 @@ const be = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   // Disabled
   [o.ATOM]: ["m/84'/118'/0'/0'/0"]
 };
-async function $(e, t, n) {
-  for (const s of Q[n] || [])
+async function $(t, e, n) {
+  for (const a of Q[n] || [])
     try {
-      const a = await t.getDerivedPrivateKey({
-        mnemonic: e,
-        hdPath: s
-      }), i = await t.getNewAddress({
-        privateKey: a,
+      const s = await e.getDerivedPrivateKey({
+        mnemonic: t,
+        hdPath: a
+      }), r = await e.getNewAddress({
+        privateKey: s,
         addressType: n === o.BTC ? "segwit_native" : void 0
       });
-      return [a.toString(), i.address];
+      return [s.toString(), r.address];
     } catch {
       return [];
     }
   return [];
 }
-function ve(e, t) {
-  const n = f(), { mutateAsync: s } = v();
-  return u({
-    mutationKey: ["ecency-wallets", "import-wallet", e, t],
-    mutationFn: async ({ privateKeyOrSeed: a }) => {
-      const i = g(t);
-      if (!i)
+function St(t, e) {
+  const n = f(), { mutateAsync: a } = P();
+  return l({
+    mutationKey: ["ecency-wallets", "import-wallet", t, e],
+    mutationFn: async ({ privateKeyOrSeed: s }) => {
+      const r = T(e);
+      if (!r)
         throw new Error("Cannot find token for this currency");
-      const r = a.split(" ").length === 12;
-      let c, l = a;
-      if (r ? [l, c] = await $(
-        a,
-        i,
-        t
-      ) : c = (await i.getNewAddress({
-        privateKey: a
-      })).address, !c || !a)
+      const i = s.split(" ").length === 12;
+      let c, m = s;
+      if (i ? [m, c] = await $(
+        s,
+        r,
+        e
+      ) : c = (await r.getNewAddress({
+        privateKey: s
+      })).address, !c || !s)
         throw new Error(
           "Private key/seed phrase isn't matching with public key or token"
         );
-      if (!await s({
+      if (!await a({
         address: c,
-        currency: t
+        currency: e
       }))
         throw new Error(
           "This wallet has already in use by Hive account. Please, try another one"
         );
       return {
-        privateKey: l,
+        privateKey: m,
         address: c,
         publicKey: ""
       };
     },
-    onSuccess: ({ privateKey: a, publicKey: i, address: r }) => {
+    onSuccess: ({ privateKey: s, publicKey: r, address: i }) => {
       n.setQueryData(
-        ["ecency-wallets", "wallets", e],
-        (c) => new Map(c ? Array.from(c.entries()) : []).set(t, {
-          privateKey: a,
-          publicKey: i,
-          address: r,
-          username: e,
-          currency: t,
+        ["ecency-wallets", "wallets", t],
+        (c) => new Map(c ? Array.from(c.entries()) : []).set(e, {
+          privateKey: s,
+          publicKey: r,
+          address: i,
+          username: t,
+          currency: e,
           custom: !0
         })
       );
     }
   });
 }
-function G(e) {
-  let t = atob(e);
-  if (t[0] === "{")
-    return JSON.parse(t);
+function G(t) {
+  let e = atob(t);
+  if (e[0] === "{")
+    return JSON.parse(e);
 }
-const h = (e) => {
+const d = (t) => {
   try {
-    const t = p.storage.getItem(
-      p.storagePrefix + "_user_" + e
+    const e = u.storage.getItem(
+      u.storagePrefix + "_user_" + t
     );
-    return G(JSON.parse(t));
-  } catch (t) {
-    console.error(t);
+    return G(JSON.parse(e));
+  } catch (e) {
+    console.error(e);
     return;
   }
-}, U = (e) => h(e) && h(e).accessToken, V = (e) => h(e) && h(e).postingKey;
-function P(e = [], t, n) {
-  return u({
-    mutationKey: [...e, t],
-    mutationFn: async (s) => {
-      if (!t)
+}, U = (t) => d(t) && d(t).accessToken, V = (t) => d(t) && d(t).postingKey;
+function z(t = [], e, n) {
+  return l({
+    mutationKey: [...t, e],
+    mutationFn: async (a) => {
+      if (!e)
         throw new Error(
           "[Core][Broadcast] Attempted to call broadcast API with anon user"
         );
-      const a = V(t);
-      if (a) {
-        const r = d.fromString(a);
-        return p.hiveClient.broadcast.sendOperations(
-          n(s),
-          r
+      const s = V(e);
+      if (s) {
+        const i = p.fromString(s);
+        return u.hiveClient.broadcast.sendOperations(
+          n(a),
+          i
         );
       }
-      let i = U(t);
-      if (i)
-        return (await new B.Client({
-          accessToken: i
-        }).broadcast(n(s))).result;
+      let r = U(e);
+      if (r)
+        return (await new g.Client({
+          accessToken: r
+        }).broadcast(n(a))).result;
       throw new Error(
         "[SDK][Broadcast] – cannot broadcast w/o posting key or token"
       );
     }
   });
 }
-function z(e) {
-  return P(
+function X(t) {
+  return z(
     ["accounts", "update"],
-    e,
-    (t) => [
+    t,
+    (e) => [
       [
         "account_update2",
         {
-          account: e,
+          account: t,
           json_metadata: "",
           posting_json_metadata: JSON.stringify({
-            profile: { ...t, version: 2 }
+            profile: { ...e, version: 2 }
           }),
           extensions: []
         }
@@ -443,43 +443,86 @@ function z(e) {
     ]
   );
 }
-function Pe(e) {
-  const { mutateAsync: t } = z(e);
-  return u({
-    mutationKey: ["ecency-wallets", "save-wallet-to-metadata", e],
+function Ot(t) {
+  const { mutateAsync: e } = X(t);
+  return l({
+    mutationKey: ["ecency-wallets", "save-wallet-to-metadata", t],
     mutationFn: ({
       wallets: n
-    }) => t(
+    }) => e(
       Array.from(n.entries() ?? []).reduce(
-        (s, [a, i]) => ({
-          ...s,
-          [a]: i.address
+        (a, [s, r]) => ({
+          ...a,
+          [s]: r.address
         }),
         {}
       )
     )
   });
 }
-function Se(e) {
-  return P(
-    ["operations", "sign"],
+function kt(t) {
+  return l({
+    mutationKey: ["operations", "sign", t],
+    mutationFn: ({
+      operation: e,
+      keyOrSeed: n
+    }) => {
+      if (!t)
+        throw new Error("[Operations][Sign] – cannot sign op with anon user");
+      let a;
+      return n.split(" ").length === 12 ? a = p.fromLogin(t, n, "active") : H.isWif(n) ? a = p.fromString(n) : a = p.from(n), u.hiveClient.broadcast.sendOperations(
+        [e],
+        a
+      );
+    }
+  });
+}
+const Y = (t, e, n, a = null) => new Promise((s, r) => {
+  var i;
+  (i = window.hive_keychain) == null || i.requestBroadcast(
+    t,
     e,
-    (t) => [t]
+    n,
+    (c) => {
+      c.success || r({ message: "Operation cancelled" }), s(c);
+    },
+    a
   );
+});
+function At(t, e = "Active") {
+  l({
+    mutationKey: ["operations", "sign-keychain", t],
+    mutationFn: ({ operation: n }) => {
+      if (!t)
+        throw new Error(
+          "[SDK][Keychain] – cannot sign operation with anon user"
+        );
+      return Y(t, [n], e);
+    }
+  });
+}
+function Kt(t = "/") {
+  l({
+    mutationKey: ["operations", "sign-hivesigner", t],
+    mutationFn: async ({ operation: e }) => g.sendOperation(e, { callback: t }, () => {
+    })
+  });
 }
 export {
   o as EcencyWalletCurrency,
-  be as EcencyWalletsPrivateApi,
-  W as delay,
-  g as getWallet,
-  ye as mnemonicToSeedBip39,
-  z as useAccountUpdate,
-  ge as useCoinGeckoPriceQuery,
-  fe as useGetExternalWalletBalanceQuery,
+  Pt as EcencyWalletsPrivateApi,
+  F as delay,
+  T as getWallet,
+  gt as mnemonicToSeedBip39,
+  X as useAccountUpdate,
+  bt as useCoinGeckoPriceQuery,
+  Tt as useGetExternalWalletBalanceQuery,
   q as useHiveKeysQuery,
-  ve as useImportWallet,
-  Pe as useSaveWalletInformationToMetadata,
-  T as useSeedPhrase,
-  Se as useSignOperation,
-  Te as useWalletCreate
+  St as useImportWallet,
+  Ot as useSaveWalletInformationToMetadata,
+  b as useSeedPhrase,
+  Kt as useSignOperationByHivesigner,
+  kt as useSignOperationByKey,
+  At as useSignOperationByKeychain,
+  vt as useWalletCreate
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ecency/sdk",
   "private": false,
-  "version": "1.0.14",
+  "version": "1.0.16",
   "type": "module",
   "license": "MIT",
   "main": "./dist/ecency-sdk.umd.js",