@ledgerhq/live-common 31.6.0 → 31.7.0

package/src/families/cosmos/specs.ts

@@ -24,22 +24,37 @@ import type {
   Transaction,
   CosmosOperationRaw,
 } from "../../families/cosmos/types";
-import cryptoFactory from "./chain/chain";
 import { canDelegate, canRedelegate, canUndelegate, getMaxDelegationAvailable } from "./logic";
 import { acceptTransaction } from "./speculos-deviceActions";
 import { Operation } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { log } from "@ledgerhq/logs";
 
 const maxAccounts = 16;
 
 // amounts of delegation are not exact so we are applying an approximation
-function approximateValue(value): string {
-  return "~" + value.div(100).integerValue().times(100).toString();
+function checkAmountsCloseEnough(amount1: BigNumber | string, amount2: BigNumber | string) {
+  amount1 = new BigNumber(amount1);
+  amount2 = new BigNumber(amount2);
+  expect(amount1.isNegative()).toBe(false);
+  expect(amount2.isNegative()).toBe(false);
+  const difference = amount1.minus(amount2).absoluteValue();
+  const onePercentOfLargerNumber = BigNumber.max(amount1, amount2).multipliedBy(0.01);
+  const isCloseEnough = difference.isLessThan(onePercentOfLargerNumber);
+  if (!isCloseEnough) {
+    log(
+      "bot",
+      "delegation amounts do not match",
+      `Amount1: ${amount1.toString()} , Amount2: ${amount2.toString()}`,
+    );
+  }
+  expect(isCloseEnough).toBe(true);
 }
 
-function approximateExtra(extra: CosmosOperationExtraRaw) {
+function extraWithoutAmount(extra: CosmosOperationExtraRaw) {
   if (extra.validators && Array.isArray(extra.validators)) {
     extra.validators = extra.validators.map((validator: CosmosDelegationInfoRaw) => {
-      return { ...validator, amount: approximateValue(validator.amount) };
+      return { ...validator, amount: "" };
     });
   }
   return extra;
@@ -74,18 +89,30 @@ const cosmosLikeTest: ({
   delete opExpected.blockHeight;
   delete opExpected.extra;
   delete opExpected.transactionSequenceNumber;
+  delete opExpected.nftOperations;
 
   const op: Partial<CosmosOperationRaw> = toOperationRaw(operation) as CosmosOperationRaw;
   const opExtra: CosmosOperationExtraRaw = op.extra || {};
   delete op.extra;
 
   botTest("optimistic operation matches op", () => expect(op).toMatchObject(opExpected));
-  botTest("operation extra matches", () =>
-    expect(approximateExtra(opExtra)).toMatchObject(approximateExtra(expectedExtra)),
-  );
+  botTest("operation extra matches", () => {
+    // compare the validators amount firstly
+    if (
+      expectedExtra.validators &&
+      Array.isArray(expectedExtra.validators) &&
+      expectedExtra.validators.length > 0
+    ) {
+      for (let i = 0; i < expectedExtra.validators.length; i++) {
+        checkAmountsCloseEnough(opExtra.validators![i].amount, expectedExtra.validators[i].amount);
+      }
+    }
+    // compare the rest of the extra, except the amount
+    expect(extraWithoutAmount(opExtra)).toMatchObject(extraWithoutAmount(expectedExtra));
+  });
 };
 
-function cosmosLikeMutations(currency: string): MutationSpec<Transaction>[] {
+function cosmosLikeMutations(minimalTransactionAmount: BigNumber): MutationSpec<Transaction>[] {
   return [
     {
       name: "send some",
@@ -97,6 +124,7 @@ function cosmosLikeMutations(currency: string): MutationSpec<Transaction>[] {
         );
       },
       transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minimalTransactionAmount), "balance is too low for send");
         const amount = maxSpendable.times(0.3 + 0.4 * Math.random()).integerValue();
         invariant(amount.gt(0), "random amount to be positive");
         return {
@@ -121,7 +149,8 @@ function cosmosLikeMutations(currency: string): MutationSpec<Transaction>[] {
       name: "send max",
       maxRun: 1,
       testDestination: genericTestDestination,
-      transaction: ({ account, siblings, bridge }) => {
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minimalTransactionAmount), "balance is too low for send max");
         return {
           transaction: bridge.createTransaction(account),
           updates: [
@@ -156,7 +185,7 @@ function cosmosLikeMutations(currency: string): MutationSpec<Transaction>[] {
         const data = getCurrentCosmosPreloadData()[account.currency.id];
         const count = 1; // we'r always going to have only one validator because of the new delegation flow.
         let remaining = getMaxDelegationAvailable(account as CosmosAccount, count)
-          .minus(cryptoFactory(currency).minimalTransactionAmount.times(2))
+          .minus(minimalTransactionAmount.times(2))
           .times(0.1 * Math.random());
         invariant(remaining.gt(0), "not enough funds in account for delegate");
         const all = data.validators.filter(
@@ -201,25 +230,21 @@ function cosmosLikeMutations(currency: string): MutationSpec<Transaction>[] {
             d => d.validatorAddress === v.address,
           );
           invariant(d, "delegated %s must be found in account", v.address);
-          botTest("delegator have planned address and amount", () =>
-            expect({
-              address: v.address,
-              amount: approximateValue(v.amount),
-            }).toMatchObject({
-              address: (d as CosmosDelegation).validatorAddress,
-              amount: approximateValue((d as CosmosDelegation).amount),
-            }),
-          );
+          botTest("delegator have planned address and amount", () => {
+            expect(v.address).toBe((d as CosmosDelegation).validatorAddress);
+            checkAmountsCloseEnough(v.amount, (d as CosmosDelegation).amount);
+          });
         });
       },
     },
     {
       name: "undelegate",
       maxRun: 5,
-      transaction: ({ account, bridge }) => {
+      transaction: ({ account, bridge, maxSpendable }) => {
         invariant(canUndelegate(account as CosmosAccount), "can undelegate");
         const { cosmosResources } = account as CosmosAccount;
         invariant(cosmosResources, "cosmos");
+        invariant(maxSpendable.gt(minimalTransactionAmount.times(2)), "balance is too low");
         invariant(
           (cosmosResources as CosmosResources).delegations.length > 0,
           "already enough delegations",
@@ -270,24 +295,23 @@ function cosmosLikeMutations(currency: string): MutationSpec<Transaction>[] {
             d => d.validatorAddress === v.address,
           );
           invariant(d, "undelegated %s must be found in account", v.address);
-          botTest("validator have planned address and amount", () =>
-            expect({
-              address: v.address,
-              amount: approximateValue(v.amount),
-            }).toMatchObject({
-              address: (d as CosmosUnbonding).validatorAddress,
-              amount: approximateValue((d as CosmosUnbonding).amount),
-            }),
-          );
+          botTest("validator have planned address and amount", () => {
+            expect(v.address).toBe((d as CosmosUnbonding).validatorAddress);
+            checkAmountsCloseEnough(v.amount, (d as CosmosUnbonding).amount);
+          });
         });
       },
     },
     {
       name: "redelegate",
       maxRun: 1,
-      transaction: ({ account, bridge }) => {
+      transaction: ({ account, bridge, maxSpendable }) => {
         const { cosmosResources } = account as CosmosAccount;
         invariant(cosmosResources, "cosmos");
+        invariant(
+          maxSpendable.gt(minimalTransactionAmount.times(3)),
+          "balance is too low for redelegate",
+        );
         const sourceDelegation = sample(
           (cosmosResources as CosmosResources).delegations.filter(d =>
             canRedelegate(account as CosmosAccount, d),
@@ -346,15 +370,10 @@ function cosmosLikeMutations(currency: string): MutationSpec<Transaction>[] {
                   d.validatorSrcAddress === transaction.sourceValidator,
               );
             invariant(d, "redelegated %s must be found in account", v.address);
-            botTest("validator have planned address and amount", () =>
-              expect({
-                address: v.address,
-                amount: approximateValue(v.amount),
-              }).toMatchObject({
-                address: (d as CosmosRedelegation).validatorDstAddress,
-                amount: approximateValue((d as CosmosRedelegation).amount),
-              }),
-            );
+            botTest("validator have planned address and amount", () => {
+              expect(v.address).toBe((d as CosmosRedelegation).validatorDstAddress);
+              checkAmountsCloseEnough(v.amount, (d as CosmosRedelegation).amount);
+            });
           }
         });
       },
@@ -362,9 +381,13 @@ function cosmosLikeMutations(currency: string): MutationSpec<Transaction>[] {
     {
       name: "claim rewards",
       maxRun: 1,
-      transaction: ({ account, bridge }) => {
+      transaction: ({ account, bridge, maxSpendable }) => {
         const { cosmosResources } = account as CosmosAccount;
         invariant(cosmosResources, "cosmos");
+        invariant(
+          maxSpendable.gt(minimalTransactionAmount.times(2)),
+          "balance is too low for claim rewards",
+        );
         const delegation = sample(
           (cosmosResources as CosmosResources).delegations.filter(d => d.pendingRewards.gt(1000)),
         ) as CosmosDelegation;
@@ -417,73 +440,109 @@ const generateGenericCosmosTest = (currencyId: string, config?: Partial<AppSpec<
     },
     genericDeviceAction: acceptTransaction,
     testTimeout: 2 * 60 * 1000,
-    minViableAmount: cryptoFactory(currencyId).minimalTransactionAmount,
-    transactionCheck: ({ maxSpendable }) => {
-      invariant(
-        maxSpendable.gt(cryptoFactory(currencyId).minimalTransactionAmount),
-        "balance is too low",
-      );
-    },
     test: cosmosLikeTest,
-    mutations: cosmosLikeMutations(currencyId),
     ...config,
   };
 };
 
+// In the bot tests, when we make a transaction ,we should make sure that the spendable balance is greater than minimalTransactionAmount.
+// We usually use the upper limit of send transaction fee as the minimalTransactionAmount. e.g. 5000 uatom for cosmos.
+const cosmosMinimalTransactionAmount = new BigNumber(5000);
 const cosmos = {
-  ...generateGenericCosmosTest("cosmos"),
+  ...generateGenericCosmosTest("cosmos", {
+    minViableAmount: cosmosMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(cosmosMinimalTransactionAmount),
+  }),
 };
 
+const osmosisMinimalTransactionAmount = new BigNumber(5000);
 const osmosis = {
   ...generateGenericCosmosTest("osmosis", {
+    minViableAmount: osmosisMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(osmosisMinimalTransactionAmount),
     testTimeout: 8 * 60 * 1000,
   }),
 };
 
+const desmosMinimalTransactionAmount = new BigNumber(500);
 const desmos = {
   ...generateGenericCosmosTest("desmos", {
+    minViableAmount: desmosMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(desmosMinimalTransactionAmount),
     testTimeout: 8 * 60 * 1000,
+    skipOperationHistory: true,
   }),
 };
 
+const umeeMinimalTransactionAmount = new BigNumber(15000);
 const umee = {
   ...generateGenericCosmosTest("umee", {
+    minViableAmount: umeeMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(umeeMinimalTransactionAmount),
     testTimeout: 8 * 60 * 1000,
+    skipOperationHistory: true,
   }),
 };
 
+const persistenceMinimalTransactionAmount = new BigNumber(5000);
 const persistence = {
   ...generateGenericCosmosTest("persistence", {
+    minViableAmount: persistenceMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(persistenceMinimalTransactionAmount),
     testTimeout: 8 * 60 * 1000,
   }),
 };
 
+const quicksilverMinimalTransactionAmount = new BigNumber(600);
 const quicksilver = {
   ...generateGenericCosmosTest("quicksilver", {
+    minViableAmount: quicksilverMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(quicksilverMinimalTransactionAmount),
     testTimeout: 8 * 60 * 1000,
+    skipOperationHistory: true,
   }),
 };
 
+const onomyMinimalTransactionAmount = new BigNumber(5000);
 const onomy = {
   ...generateGenericCosmosTest("onomy", {
+    minViableAmount: onomyMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(onomyMinimalTransactionAmount),
     testTimeout: 8 * 60 * 1000,
   }),
 };
 
+const axelarMinimalTransactionAmount = new BigNumber(10000);
 const axelar = {
-  ...generateGenericCosmosTest("axelar"),
+  ...generateGenericCosmosTest("axelar", {
+    minViableAmount: axelarMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(axelarMinimalTransactionAmount),
+    skipOperationHistory: true,
+  }),
 };
 
+const secretNetworkMinimalTransactionAmount = new BigNumber(60000);
 const secretNetwork = {
-  ...generateGenericCosmosTest("secret_network"),
+  ...generateGenericCosmosTest("secret_network", {
+    minViableAmount: secretNetworkMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(secretNetworkMinimalTransactionAmount),
+  }),
 };
 
+const stargazeMinimalTransactionAmount = new BigNumber(160000);
 const stargaze = {
-  ...generateGenericCosmosTest("stargaze"),
+  ...generateGenericCosmosTest("stargaze", {
+    minViableAmount: stargazeMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(stargazeMinimalTransactionAmount),
+  }),
 };
 
+const coreumMinimalTransactionAmount = new BigNumber(20000);
 const coreum = {
-  ...generateGenericCosmosTest("coreum"),
+  ...generateGenericCosmosTest("coreum", {
+    minViableAmount: coreumMinimalTransactionAmount,
+    mutations: cosmosLikeMutations(coreumMinimalTransactionAmount),
+  }),
 };
 
 export default {

package/src/families/cosmos/types.ts

@@ -62,6 +62,7 @@ export type CosmosResources = {
   pendingRewardsBalance: BigNumber;
   unbondingBalance: BigNumber;
   withdrawAddress: string;
+  sequence: number;
 };
 export type CosmosDelegationRaw = {
   validatorAddress: string;
@@ -88,6 +89,7 @@ export type CosmosResourcesRaw = {
   pendingRewardsBalance: string;
   unbondingBalance: string;
   withdrawAddress: string;
+  sequence: number;
 };
 // NB this must be serializable (no Date, no BigNumber)
 export type CosmosValidatorItem = {

package/src/families/elrond/specs.ts

@@ -121,7 +121,6 @@ function expectCorrectOptimisticOperation(input: TransactionTestInput<Transactio
       optimisticOperation.transactionSequenceNumber,
     ),
   );
-
   botTest("raw optimistic operation matches", () =>
     expect(toOperationRaw(operation)).toMatchObject(opExpected),
   );

package/src/families/polkadot/bridge/mock.ts

@@ -64,7 +64,9 @@ const getTransactionStatus = (account: PolkadotAccount, t: Transaction) => {
   if (!t.recipient) {
     errors.recipient = new RecipientRequired("");
   } else if (isInvalidRecipient(t.recipient)) {
-    errors.recipient = new InvalidAddress("");
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
   }
 
   return Promise.resolve({
@@ -97,111 +99,115 @@ const accountBridge: AccountBridge<Transaction> = {
   signOperation,
   broadcast,
 };
+
+const preload = () => {
+  return Promise.resolve({
+    validators: [
+      {
+        address: "111B8CxcmnWbuDLyGvgUmRezDCK1brRZmvUuQ6SrFdMyc3S",
+        identity: "",
+        nominatorsCount: 84,
+        rewardPoints: "28220",
+        commission: "1",
+        totalBonded: "19189935927996803",
+        selfBonded: "0",
+        isElected: true,
+        isOversubscribed: false,
+      },
+      {
+        address: "114SUbKCXjmb9czpWTtS3JANSmNRwVa4mmsMrWYpRG1kDH5",
+        identity: "BINANCE_STAKE_9",
+        nominatorsCount: 58,
+        rewardPoints: "45700",
+        commission: "1",
+        totalBonded: "19978546965782204",
+        selfBonded: "0",
+        isElected: true,
+        isOversubscribed: false,
+      },
+      {
+        address: "11VR4pF6c7kfBhfmuwwjWY3FodeYBKWx7ix2rsRCU2q6hqJ",
+        identity: "🐑 HODL.FARM 🐑 - C",
+        nominatorsCount: 498,
+        rewardPoints: "35440",
+        commission: "0.008",
+        totalBonded: "19983183606433211",
+        selfBonded: "8214924206368",
+        isElected: true,
+        isOversubscribed: false,
+      },
+      {
+        address: "11uMPbeaEDJhUxzU4ZfWW9VQEsryP9XqFcNRfPdYda6aFWJ",
+        identity: "P2P.ORG - 4",
+        nominatorsCount: 406,
+        rewardPoints: "83240",
+        commission: "0.025",
+        totalBonded: "19983278498651499",
+        selfBonded: "0",
+        isElected: true,
+        isOversubscribed: false,
+      },
+      {
+        address: "13mK8AssyPekT5cFuYQ7ijKNXcjHPq8Gnx6TxF5eFCAwoLQ",
+        identity: "HYPERSPHERE - 5",
+        nominatorsCount: 457,
+        rewardPoints: "83100",
+        commission: "0.03",
+        totalBonded: "19983182481092181",
+        selfBonded: "11099882066510",
+        isElected: true,
+        isOversubscribed: false,
+      },
+      {
+        address: "14QRY2UTErfZCqVMFVRmgbeUt7XQdeCVgNUV1XqDcza4g9E",
+        identity: "",
+        nominatorsCount: 1,
+        rewardPoints: "64600",
+        commission: "1",
+        totalBonded: "20294901840238041",
+        selfBonded: "0",
+        isElected: true,
+        isOversubscribed: false,
+      },
+      {
+        address: "17bR6rzVsVrzVJS1hM4dSJU43z2MUmz7ZDpPLh8y2fqVg7m",
+        identity: "",
+        nominatorsCount: 3,
+        rewardPoints: "60160",
+        commission: "1",
+        totalBonded: "25412727149722391",
+        selfBonded: "15697837257290",
+        isElected: true,
+        isOversubscribed: false,
+      },
+      {
+        address: "19K3AKAkcrVWcXrXCXJ1fbaySuo58kUXhpsh7gBpa6emdgz",
+        identity: "",
+        nominatorsCount: 21,
+        rewardPoints: "36960",
+        commission: "1",
+        totalBonded: "17669588437879800",
+        selfBonded: "0",
+        isElected: true,
+        isOversubscribed: false,
+      },
+    ],
+    staking: {
+      activeEra: 1123,
+      electionClosed: true,
+      maxNominatorRewardedPerValidator: 512,
+      bondingDuration: 28,
+    },
+    minimumBondBalance: "2500000000000",
+  });
+};
+
 const currencyBridge: CurrencyBridge = {
   scanAccounts,
-  preload: () => {
-    return Promise.resolve({
-      validators: [
-        {
-          address: "111B8CxcmnWbuDLyGvgUmRezDCK1brRZmvUuQ6SrFdMyc3S",
-          identity: "",
-          nominatorsCount: 84,
-          rewardPoints: "28220",
-          commission: "1",
-          totalBonded: "19189935927996803",
-          selfBonded: "0",
-          isElected: true,
-          isOversubscribed: false,
-        },
-        {
-          address: "114SUbKCXjmb9czpWTtS3JANSmNRwVa4mmsMrWYpRG1kDH5",
-          identity: "BINANCE_STAKE_9",
-          nominatorsCount: 58,
-          rewardPoints: "45700",
-          commission: "1",
-          totalBonded: "19978546965782204",
-          selfBonded: "0",
-          isElected: true,
-          isOversubscribed: false,
-        },
-        {
-          address: "11VR4pF6c7kfBhfmuwwjWY3FodeYBKWx7ix2rsRCU2q6hqJ",
-          identity: "🐑 HODL.FARM 🐑 - C",
-          nominatorsCount: 498,
-          rewardPoints: "35440",
-          commission: "0.008",
-          totalBonded: "19983183606433211",
-          selfBonded: "8214924206368",
-          isElected: true,
-          isOversubscribed: false,
-        },
-        {
-          address: "11uMPbeaEDJhUxzU4ZfWW9VQEsryP9XqFcNRfPdYda6aFWJ",
-          identity: "P2P.ORG - 4",
-          nominatorsCount: 406,
-          rewardPoints: "83240",
-          commission: "0.025",
-          totalBonded: "19983278498651499",
-          selfBonded: "0",
-          isElected: true,
-          isOversubscribed: false,
-        },
-        {
-          address: "13mK8AssyPekT5cFuYQ7ijKNXcjHPq8Gnx6TxF5eFCAwoLQ",
-          identity: "HYPERSPHERE - 5",
-          nominatorsCount: 457,
-          rewardPoints: "83100",
-          commission: "0.03",
-          totalBonded: "19983182481092181",
-          selfBonded: "11099882066510",
-          isElected: true,
-          isOversubscribed: false,
-        },
-        {
-          address: "14QRY2UTErfZCqVMFVRmgbeUt7XQdeCVgNUV1XqDcza4g9E",
-          identity: "",
-          nominatorsCount: 1,
-          rewardPoints: "64600",
-          commission: "1",
-          totalBonded: "20294901840238041",
-          selfBonded: "0",
-          isElected: true,
-          isOversubscribed: false,
-        },
-        {
-          address: "17bR6rzVsVrzVJS1hM4dSJU43z2MUmz7ZDpPLh8y2fqVg7m",
-          identity: "",
-          nominatorsCount: 3,
-          rewardPoints: "60160",
-          commission: "1",
-          totalBonded: "25412727149722391",
-          selfBonded: "15697837257290",
-          isElected: true,
-          isOversubscribed: false,
-        },
-        {
-          address: "19K3AKAkcrVWcXrXCXJ1fbaySuo58kUXhpsh7gBpa6emdgz",
-          identity: "",
-          nominatorsCount: 21,
-          rewardPoints: "36960",
-          commission: "1",
-          totalBonded: "17669588437879800",
-          selfBonded: "0",
-          isElected: true,
-          isOversubscribed: false,
-        },
-      ],
-      staking: {
-        activeEra: 1123,
-        electionClosed: true,
-        maxNominatorRewardedPerValidator: 512,
-        bondingDuration: 28,
-      },
-      minimumBondBalance: "2500000000000",
-    });
-  },
-  hydrate: hydrate,
+  preload,
+  hydrate,
 };
+
 export default {
   currencyBridge,
   accountBridge,

package/src/hooks/useAPI.ts

@@ -0,0 +1,81 @@
+import { useState, useEffect, useCallback } from "react";
+
+type AsyncFn<T, P = undefined> = P extends undefined ? () => Promise<T> : (props: P) => Promise<T>;
+
+type UseAsyncReturn<T> = {
+  data: T | undefined;
+  isLoading: boolean;
+  error: Error | undefined;
+  refetch: () => void;
+};
+
+export type ApiOptions<T> = {
+  enabled?: boolean;
+  staleTimeout?: number;
+  onSuccess?(data: T): void;
+  onError?(error: unknown): void;
+};
+
+type Props<T, P> = ApiOptions<T> & {
+  queryFn: AsyncFn<T, P>;
+  queryProps?: P;
+};
+
+const apiCache = {};
+
+export function useAPI<T, P extends Record<PropertyKey, unknown> | undefined>({
+  queryFn,
+  queryProps = {},
+  enabled = true,
+  staleTimeout = 5000,
+  onSuccess,
+  onError,
+}: Props<T, P>): UseAsyncReturn<T> {
+  const [isLoading, setIsLoading] = useState(false);
+  const [data, setData] = useState<T | undefined>(undefined);
+  const [error, setError] = useState<Error | undefined>(undefined);
+
+  const cacheKey = queryFn.name + JSON.stringify(queryProps);
+
+  const fetch = useCallback(async () => {
+    setIsLoading(true);
+    setData(undefined);
+    setError(undefined);
+
+    try {
+      const res = await queryFn({ ...queryProps });
+      setData(res);
+      setIsLoading(false);
+      apiCache[cacheKey] = { data: res, timestamp: new Date().getTime() };
+      onSuccess?.(res);
+    } catch (e: unknown) {
+      if (e instanceof Error) {
+        setError(e);
+        onError?.(e);
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  }, [cacheKey, onError, onSuccess, queryFn, queryProps]);
+
+  const execute = useCallback(() => {
+    if (enabled) {
+      const cachedItem = apiCache[cacheKey];
+      if (cachedItem && new Date().getTime() - cachedItem.timestamp < staleTimeout) {
+        // The cached item is still fresh, so we use it
+        setData(cachedItem.data);
+        onSuccess?.(cachedItem.data);
+        setIsLoading(false);
+      } else {
+        // The cached item is stale or doesn't exist, so we fetch fresh data
+        fetch();
+      }
+    }
+  }, [cacheKey, staleTimeout, enabled, fetch, onSuccess]);
+
+  useEffect(() => {
+    execute();
+  }, [execute]);
+
+  return { data, isLoading, error, refetch: execute };
+}

package/src/mock/account.ts

@@ -57,6 +57,7 @@ export function genAccount(id: number | string, opts: GenAccountOptions = {}): A
             pendingRewardsBalance: new BigNumber(0),
             unbondingBalance: new BigNumber(0),
             withdrawAddress: address,
+            sequence: 0,
           };
           break;
         case "bitcoin":