@ledgerhq/coin-polkadot 6.13.1-nightly.20251202023925 → 6.14.0-nightly.20251203101856

package/src/bridge/synchronization.test.ts

@@ -183,6 +183,173 @@ describe("getAccountShape", () => {
     expect(shape.operationsCount).toEqual(0);
     expect(shape.operations).toEqual([]);
   });
+
+  it("does not migrate when assethub has not been migrated", async () => {
+    mockGetCoinConfig.mockImplementation((currency?: CryptoCurrency): any => {
+      if (currency?.id === "assethub_polkadot") {
+        return {
+          hasBeenMigrated: false,
+        };
+      }
+    });
+
+    const initialAccount = undefined;
+    const accountInfo = createAccountInfo();
+    mockGetAccount.mockResolvedValue(accountInfo);
+    mockGetOperations.mockResolvedValue([]);
+
+    await getAccountShape(
+      {
+        index: -1,
+        derivationPath: "not used",
+        currency: CURRENCY,
+        address: "5D4yQHKfqCQYThhHmTfN1JEDi47uyDJc1xg9eZfAG1R7FC7J",
+        initialAccount,
+        derivationMode: "polkadotbip44",
+      },
+      { paginationConfig: {} },
+    );
+
+    expect(mockGetAccount).toHaveBeenCalledTimes(1);
+    expect(mockGetAccount.mock.lastCall[1]).toEqual(CURRENCY);
+    expect(mockGetOperations).toHaveBeenCalledTimes(1);
+    expect(mockGetOperations.mock.lastCall[2]).toEqual(CURRENCY);
+  });
+
+  it("does not migrate when currency is not polkadot", async () => {
+    const nonPolkadotCurrency = getCryptoCurrencyById("westend");
+    mockGetCoinConfig.mockImplementation((currency?: CryptoCurrency): any => {
+      if (currency?.id === "assethub_polkadot") {
+        return {
+          hasBeenMigrated: true,
+        };
+      }
+    });
+
+    const initialAccount = undefined;
+    const accountInfo = createAccountInfo();
+    mockGetAccount.mockResolvedValue(accountInfo);
+    mockGetOperations.mockResolvedValue([]);
+
+    await getAccountShape(
+      {
+        index: -1,
+        derivationPath: "not used",
+        currency: nonPolkadotCurrency,
+        address: "5D4yQHKfqCQYThhHmTfN1JEDi47uyDJc1xg9eZfAG1R7FC7J",
+        initialAccount,
+        derivationMode: "polkadotbip44",
+      },
+      { paginationConfig: {} },
+    );
+
+    expect(mockGetAccount).toHaveBeenCalledTimes(1);
+    expect(mockGetAccount.mock.lastCall[1]).toEqual(nonPolkadotCurrency);
+    expect(mockGetOperations).toHaveBeenCalledTimes(1);
+    expect(mockGetOperations.mock.lastCall[2]).toEqual(nonPolkadotCurrency);
+  });
+
+  it("generates correct account ID with migration", async () => {
+    const initialAccount = undefined;
+    const accountInfo = createAccountInfo();
+    mockGetAccount.mockResolvedValue(accountInfo);
+    mockGetOperations.mockResolvedValue([]);
+
+    const shape = await getAccountShape(
+      {
+        index: -1,
+        derivationPath: "not used",
+        currency: CURRENCY,
+        address: "5D4yQHKfqCQYThhHmTfN1JEDi47uyDJc1xg9eZfAG1R7FC7J",
+        initialAccount,
+        derivationMode: "polkadotbip44",
+      },
+      { paginationConfig: {} },
+    );
+
+    expect(shape.id).toEqual(
+      "js:2:assethub_polkadot:5D4yQHKfqCQYThhHmTfN1JEDi47uyDJc1xg9eZfAG1R7FC7J:polkadotbip44",
+    );
+  });
+
+  it("generates correct account ID without migration", async () => {
+    mockGetCoinConfig.mockImplementation((currency?: CryptoCurrency): any => {
+      if (currency?.id === "assethub_polkadot") {
+        return {
+          hasBeenMigrated: false,
+        };
+      }
+    });
+
+    const initialAccount = undefined;
+    const accountInfo = createAccountInfo();
+    mockGetAccount.mockResolvedValue(accountInfo);
+    mockGetOperations.mockResolvedValue([]);
+
+    const shape = await getAccountShape(
+      {
+        index: -1,
+        derivationPath: "not used",
+        currency: CURRENCY,
+        address: "5D4yQHKfqCQYThhHmTfN1JEDi47uyDJc1xg9eZfAG1R7FC7J",
+        initialAccount,
+        derivationMode: "polkadotbip44",
+      },
+      { paginationConfig: {} },
+    );
+
+    expect(shape.id).toEqual(
+      "js:2:polkadot:5D4yQHKfqCQYThhHmTfN1JEDi47uyDJc1xg9eZfAG1R7FC7J:polkadotbip44",
+    );
+  });
+
+  it("returns correct currency in account shape", async () => {
+    const accountInfo = createAccountInfo();
+    mockGetAccount.mockResolvedValue(accountInfo);
+    mockGetOperations.mockResolvedValue([]);
+
+    const shape = await getAccountShape(
+      {
+        index: -1,
+        derivationPath: "not used",
+        currency: CURRENCY,
+        address: "5D4yQHKfqCQYThhHmTfN1JEDi47uyDJc1xg9eZfAG1R7FC7J",
+        initialAccount: undefined,
+        derivationMode: "polkadotbip44",
+      },
+      { paginationConfig: {} },
+    );
+
+    expect(shape.currency).toEqual(EXPECTED_CURRENCY);
+  });
+
+  it("returns correct currency in account shape without migration", async () => {
+    mockGetCoinConfig.mockImplementation((currency?: CryptoCurrency): any => {
+      if (currency?.id === "assethub_polkadot") {
+        return {
+          hasBeenMigrated: false,
+        };
+      }
+    });
+
+    const accountInfo = createAccountInfo();
+    mockGetAccount.mockResolvedValue(accountInfo);
+    mockGetOperations.mockResolvedValue([]);
+
+    const shape = await getAccountShape(
+      {
+        index: -1,
+        derivationPath: "not used",
+        currency: CURRENCY,
+        address: "5D4yQHKfqCQYThhHmTfN1JEDi47uyDJc1xg9eZfAG1R7FC7J",
+        initialAccount: undefined,
+        derivationMode: "polkadotbip44",
+      },
+      { paginationConfig: {} },
+    );
+
+    expect(shape.currency).toEqual(CURRENCY);
+  });
 });
 
 function createAccountInfo() {

package/src/logic/broadcast.test.ts

@@ -15,16 +15,19 @@ describe("broadcast", () => {
     submitExtrinsicMock.mockClear();
   });
 
-  it("should broadcast using currency when provided", async () => {
-    const signature = "some random signature";
-    await broadcast(signature, "polkadot");
+  it.each(["polkadot", "assethub_polkadot", "westend", "assethub_westend"])(
+    "should broadcast using %s when provided",
+    async currencyId => {
+      const signature = "some random signature";
+      await broadcast(signature, currencyId);
 
-    expect(submitExtrinsicMock).toHaveBeenCalledTimes(1);
-    expect(submitExtrinsicMock.mock.lastCall[0]).toEqual(signature);
+      expect(submitExtrinsicMock).toHaveBeenCalledTimes(1);
+      expect(submitExtrinsicMock.mock.lastCall[0]).toEqual(signature);
 
-    const currency = getCryptoCurrencyById("polkadot");
-    expect(submitExtrinsicMock.mock.lastCall[1]).toEqual(currency);
-  });
+      const currency = getCryptoCurrencyById(currencyId);
+      expect(submitExtrinsicMock.mock.lastCall[1]).toEqual(currency);
+    },
+  );
 
   it("should broadcast using only signature when no currency provided", async () => {
     const signature = "some random signature";

package/src/network/index.ts

@@ -99,7 +99,7 @@ const isControllerAddress = makeLRUCache(
   minutes(5),
 );
 const isElectionClosed = makeLRUCache(
-  (currency: CryptoCurrency | undefined) => sidecarIsElectionClosed(currency),
+  (currency: CryptoCurrency) => sidecarIsElectionClosed(currency),
   () => "",
   minutes(1),
 );
@@ -139,7 +139,7 @@ const shortenMetadata = async (transaction: string, currency?: CryptoCurrency):
 };
 
 export default {
-  getAccount: async (address: string, currency?: CryptoCurrency): Promise<PolkadotAPIAccount> =>
+  getAccount: async (address: string, currency: CryptoCurrency): Promise<PolkadotAPIAccount> =>
     sidecardGetAccount(address, currency),
   getBalances: async (
     address: string,

package/src/network/node/validators.ts

@@ -29,11 +29,16 @@ export const fetchValidators = async (
   const api = await getApiPromise(currency);
 
   const [activeOpt, allStashes, elected] = await Promise.all([
-    api.query.staking.activeEra(),
-    api.derive.staking.stashes(),
-    api.query.session.validators(),
+    // staking can be undefined if the currency is not supported
+    api.query.staking?.activeEra?.(),
+    api.derive.staking?.stashes?.(),
+    api.query.session?.validators?.(),
   ]);
 
+  if (!activeOpt) {
+    return [];
+  }
+
   const { index: activeEra } = activeOpt.unwrapOrDefault();
 
   let selected: string[] = [];

package/src/network/sidecar.integ.test.ts

@@ -1,107 +1,266 @@
 import BigNumber from "bignumber.js";
-import { getAccount, getStakingInfo, getStakingProgress, getValidators } from "./sidecar";
+import {
+  getAccount,
+  getStakingInfo,
+  getStakingProgress,
+  getValidators,
+  getBalances,
+  getMinimumBondBalance,
+  isElectionClosed,
+  isNewAccount,
+  isControllerAddress,
+  getTransactionParams,
+  getRegistry,
+  getLastBlock,
+  fetchChainSpec,
+} from "./sidecar";
 import coinConfig from "../config";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 
-const currency = getCryptoCurrencyById("polkadot");
-
-describe("sidecar integration test", () => {
-  beforeAll(() => {
-    coinConfig.setCoinConfig(() => ({
-      status: {
-        type: "active",
+const CURRENCY_CONFIGS = {
+  polkadot: {
+    currency: getCryptoCurrencyById("polkadot"),
+    config: {
+      status: { type: "active" as const },
+      node: { url: "https://polkadot-rpc.publicnode.com" },
+      sidecar: { url: "https://polkadot-sidecar.coin.ledger.com" },
+      indexer: { url: "https://polkadot.coin.ledger.com" },
+      staking: { electionStatusThreshold: 25 },
+      metadataShortener: {
+        id: "dot",
+        url: "https://polkadot-metadata-shortener.api.live.ledger.com/transaction/metadata",
+      },
+      metadataHash: {
+        url: "https://polkadot-metadata-shortener.api.live.ledger.com/node/metadata/hash",
       },
-      node: {
-        url: "https://polkadot-rpc.publicnode.com",
+    },
+    testAddress: "163WJAxWrQzsAVEZdn2w6mq4gmT4FmEgvCfex3uEEUHTE9GL",
+  },
+  assethub_polkadot: {
+    currency: getCryptoCurrencyById("assethub_polkadot"),
+    config: {
+      status: { type: "active" as const },
+      sidecar: { url: "https://polkadot-asset-hub-sidecar.coin.ledger.com" },
+      node: { url: "https://polkadot-asset-hub-fullnodes.api.live.ledger.com" },
+      indexer: { url: "https://explorers.api.live.ledger.com/blockchain/dot_asset_hub" },
+      staking: { electionStatusThreshold: 25 },
+      metadataShortener: {
+        url: "https://polkadot-metadata-shortener.api.live.ledger.com/transaction/metadata",
+        id: "dot-hub",
       },
-      sidecar: {
-        url: "https://polkadot-sidecar.coin.ledger.com",
+      metadataHash: {
+        url: "https://polkadot-metadata-shortener.api.live.ledger.com/node/metadata/hash",
+        id: "dot-hub",
       },
-      indexer: {
-        url: "https://polkadot.coin.ledger.com",
+      hasBeenMigrated: true,
+    },
+    testAddress: "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
+  },
+  westend: {
+    currency: getCryptoCurrencyById("westend"),
+    config: {
+      status: { type: "active" as const },
+      sidecar: { url: "https://polkadot-westend-sidecar.coin.ledger.com/rc" },
+      node: { url: "https://polkadot-westend-fullnodes.api.live.ledger.com" },
+      indexer: { url: "https://explorers.api.live.ledger.com/blockchain/dot_westend" },
+      metadataShortener: {
+        url: "https://polkadot-westend-metadata-shortener.api.live.ledger.com/transaction/metadata",
+        id: "dot-hub",
       },
-      staking: {
-        electionStatusThreshold: 25,
+      metadataHash: {
+        url: "https://polkadot-westend-metadata-shortener.api.live.ledger.com/node/metadata/hash",
+        id: "dot-hub",
       },
+    },
+    testAddress: "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
+  },
+  assethub_westend: {
+    currency: getCryptoCurrencyById("assethub_westend"),
+    config: {
+      status: { type: "active" as const },
+      sidecar: { url: "https://polkadot-westend-sidecar.coin.ledger.com" },
+      node: { url: "https://polkadot-westend-asset-hub-fullnodes.api.live.ledger.com" },
+      indexer: { url: "https://explorers.api.live.ledger.com/blockchain/dot_asset_hub_westend" },
       metadataShortener: {
-        id: "dot",
-        url: "https://polkadot-metadata-shortener.api.live.ledger.com/transaction/metadata",
+        url: "https://polkadot-westend-metadata-shortener.api.live.ledger.com/transaction/metadata",
+        id: "dot-hub",
       },
       metadataHash: {
-        url: "https://polkadot-metadata-shortener.api.live.ledger.com/node/metadata/hash",
+        url: "https://polkadot-westend-metadata-shortener.api.live.ledger.com/node/metadata/hash",
+        id: "dot-hub",
       },
-    }));
-  });
-
-  describe("getStakingProgress", () => {
-    it("returns expected result", async () => {
-      const result = await getStakingProgress(currency);
-
-      expect(result).toEqual({
-        activeEra: expect.any(Number),
-        bondingDuration: 28,
-        electionClosed: true,
-        maxNominatorRewardedPerValidator: 128,
+    },
+    testAddress: "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
+  },
+};
+
+describe("sidecar integration test", () => {
+  describe.each(Object.entries(CURRENCY_CONFIGS))(
+    "%s tests",
+    (currencyId, { currency, config, testAddress }) => {
+      beforeAll(() => {
+        coinConfig.setCoinConfig(() => config);
+      });
+
+      describe("getValidators", () => {
+        it(`returns expected result with ${currencyId}`, async () => {
+          const result = await getValidators(undefined, currency);
+
+          expect(result).toEqual(
+            expect.arrayContaining([
+              expect.objectContaining({
+                address: expect.any(String),
+                commission: expect.any(BigNumber),
+                identity: expect.any(String),
+                isElected: expect.any(Boolean),
+                isOversubscribed: expect.any(Boolean),
+                nominatorsCount: expect.any(Number),
+                selfBonded: expect.any(BigNumber),
+                totalBonded: expect.any(BigNumber),
+              }),
+            ]),
+          );
+        }, 10000); // 10 seconds, because more than 5s may be required
+      });
+
+      describe("getAccount", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await getAccount(testAddress, currency);
+
+          expect(result).toMatchObject({
+            balance: expect.any(BigNumber),
+            blockHeight: expect.any(Number),
+            lockedBalance: expect.any(BigNumber),
+            nominations: expect.any(Array),
+            nonce: expect.any(Number),
+            spendableBalance: expect.any(BigNumber),
+            unlockedBalance: expect.any(BigNumber),
+            unlockingBalance: expect.any(BigNumber),
+            unlockings: expect.any(Array),
+          });
+        });
+      });
+
+      describe("getStakingInfo", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await getStakingInfo(testAddress, currency);
+
+          expect(result).toMatchObject({
+            unlockedBalance: expect.any(BigNumber),
+            unlockingBalance: expect.any(BigNumber),
+            unlockings: expect.any(Array),
+          });
+        });
       });
-    });
-  });
-
-  describe("getStakingInfo", () => {
-    it("returns expected result", async () => {
-      const address = "163WJAxWrQzsAVEZdn2w6mq4gmT4FmEgvCfex3uEEUHTE9GL";
-      const result = await getStakingInfo(address, currency);
-
-      expect(result).toEqual({
-        controller: "163WJAxWrQzsAVEZdn2w6mq4gmT4FmEgvCfex3uEEUHTE9GL",
-        numSlashingSpans: 0,
-        stash: "163WJAxWrQzsAVEZdn2w6mq4gmT4FmEgvCfex3uEEUHTE9GL",
-        unlockedBalance: BigNumber("0"),
-        unlockingBalance: BigNumber("0"),
-        unlockings: [],
+
+      describe("getStakingProgress", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await getStakingProgress(currency);
+
+          expect(result).toMatchObject({
+            activeEra: expect.any(Number),
+            bondingDuration: expect.any(Number),
+            electionClosed: expect.any(Boolean),
+            maxNominatorRewardedPerValidator: expect.any(Number),
+          });
+        });
+      });
+
+      describe("getBalances", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await getBalances(testAddress, currency);
+
+          expect(result).toMatchObject({
+            balance: expect.any(BigNumber),
+            blockHeight: expect.any(Number),
+            lockedBalance: expect.any(BigNumber),
+            nonce: expect.any(Number),
+            spendableBalance: expect.any(BigNumber),
+          });
+        });
+      });
+
+      describe("getMinimumBondBalance", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await getMinimumBondBalance(currency);
+
+          expect(result).toBeInstanceOf(BigNumber);
+          expect(result.isGreaterThanOrEqualTo(0)).toBe(true);
+        });
+      });
+
+      describe("isElectionClosed", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await isElectionClosed(currency);
+
+          expect(typeof result).toBe("boolean");
+        });
+      });
+
+      describe("isNewAccount", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await isNewAccount(testAddress, currency);
+
+          expect(typeof result).toBe("boolean");
+        });
       });
-    });
-  });
-
-  describe("getAccount", () => {
-    it("returns expected result", async () => {
-      const address = "163WJAxWrQzsAVEZdn2w6mq4gmT4FmEgvCfex3uEEUHTE9GL";
-      const result = await getAccount(address, currency);
-
-      expect(result).toMatchObject({
-        balance: expect.any(BigNumber),
-        // blockHeight: expect.any(Number),
-        controller: "163WJAxWrQzsAVEZdn2w6mq4gmT4FmEgvCfex3uEEUHTE9GL",
-        lockedBalance: expect.any(BigNumber),
-        nominations: [],
-        nonce: expect.any(Number),
-        numSlashingSpans: 0,
-        spendableBalance: expect.any(BigNumber),
-        stash: "163WJAxWrQzsAVEZdn2w6mq4gmT4FmEgvCfex3uEEUHTE9GL",
-        unlockedBalance: BigNumber("0"),
-        unlockingBalance: BigNumber("0"),
-        unlockings: [],
+
+      describe("isControllerAddress", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await isControllerAddress(testAddress, currency);
+
+          expect(typeof result).toBe("boolean");
+        });
+      });
+
+      describe("getTransactionParams", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await getTransactionParams(currency);
+
+          expect(result).toMatchObject({
+            blockHash: expect.any(String),
+            blockNumber: expect.any(String),
+            chainName: expect.any(String),
+            genesisHash: expect.any(String),
+            specName: expect.any(String),
+            transactionVersion: expect.any(String),
+            specVersion: expect.any(String),
+          });
+        });
+      });
+
+      describe("getRegistry", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await getRegistry(currency);
+
+          expect(result).toMatchObject({
+            registry: expect.any(Object),
+            extrinsics: expect.any(Object),
+          });
+        });
+      });
+
+      describe("getLastBlock", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await getLastBlock(currency);
+
+          expect(result).toMatchObject({
+            hash: expect.any(String),
+            height: expect.any(Number),
+            time: expect.any(Date),
+          });
+        });
+      });
+
+      describe("fetchChainSpec", () => {
+        it(`works with ${currencyId}`, async () => {
+          const result = await fetchChainSpec(currency);
+
+          expect(result).toMatchObject({
+            properties: expect.any(Object),
+          });
+        });
       });
-    }, 10000);
-  });
-
-  describe("getValidators", () => {
-    it.skip("returns expected result", async () => {
-      const result = await getValidators(undefined, getCryptoCurrencyById("polkadot"));
-
-      expect(result).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            address: "111B8CxcmnWbuDLyGvgUmRezDCK1brRZmvUuQ6SrFdMyc3S",
-            commission: BigNumber("1"),
-            identity: "",
-            isElected: true,
-            isOversubscribed: false,
-            nominatorsCount: expect.any(Number),
-            selfBonded: BigNumber("0"),
-            totalBonded: expect.any(BigNumber),
-          }),
-        ]),
-      );
-    }, 10000); // 10 seconds, because more than 5s may be required
-  });
+    },
+  );
 });

package/src/network/sidecar.mock.ts

@@ -6,7 +6,7 @@ import {
   fixtureTxMaterialWithMetadata,
 } from "./sidecar.fixture";
 
-export const SIDECAR_BASE_URL_TEST = "https://polkadot-sidecar.coin.ledger.com";
+export const SIDECAR_BASE_URL_TEST = "https://polkadot-asset-hub-sidecar.coin.ledger.com";
 
 const handlers = [
   http.get(`${SIDECAR_BASE_URL_TEST}/accounts/:addr/balance-info`, () => {

package/src/network/sidecar.ts

@@ -48,10 +48,10 @@ const getSidecarUrl = (route: string, currency?: CryptoCurrency): string => {
     route = `/rc${route}`;
   } else if (
     currency?.id === "westend" &&
-    (route.startsWith("/pallets/staking") || route.startsWith("/transaction/material"))
+    (route.startsWith("/pallets/staking") || route.startsWith("/transaction"))
   ) {
     // Fetch Staking Info from Westend AssetHub (remove /rc)
-    sidecarUrl = `${sidecarUrl.slice(0, -3)}`;
+    sidecarUrl = sidecarUrl.replace("/rc", "");
   }
   return `${sidecarUrl}${route || ""}`;
 };
@@ -61,6 +61,7 @@ const getElectionOptimisticThreshold = (currency?: CryptoCurrency): number => {
 };
 
 const VALIDATOR_COMISSION_RATIO = 1000000000;
+const UNSUPPORTED_STAKING_NETWORKS = ["polkadot", "westend"];
 
 // blocks = 2 minutes 30
 
@@ -277,7 +278,9 @@ export const fetchChainSpec = async (currency?: CryptoCurrency) => {
  *
  * @returns {boolean}
  */
-export const isElectionClosed = async (currency?: CryptoCurrency): Promise<boolean> => {
+export const isElectionClosed = async (currency: CryptoCurrency): Promise<boolean> => {
+  if (UNSUPPORTED_STAKING_NETWORKS.includes(currency.id)) return true;
+
   const progress = await fetchStakingProgress(currency);
   return !progress.electionStatus?.status?.Open;
 };
@@ -334,7 +337,7 @@ export const verifyValidatorAddresses = async (
  * @async
  * @param {*} addr
  */
-export const getAccount = async (addr: string, currency?: CryptoCurrency) => {
+export const getAccount = async (addr: string, currency: CryptoCurrency) => {
   const balances = await getBalances(addr, currency);
   const stakingInfo = await getStakingInfo(addr, currency);
   const nominations = await getNominations(addr);
@@ -371,13 +374,13 @@ export const getBalances = async (addr: string, currency?: CryptoCurrency) => {
  * @async
  * @param {*} addr
  */
-export const getStakingInfo = async (addr: string, currency?: CryptoCurrency) => {
+export const getStakingInfo = async (addr: string, currency: CryptoCurrency) => {
   const [stash, controller] = await Promise.all([
     fetchStashAddr(addr, currency),
     fetchControllerAddr(addr, currency),
   ]);
   // If account is not a stash, no need to fetch staking-info (it would return an error)
-  if (!controller || currency?.id === "westend") {
+  if (!controller || UNSUPPORTED_STAKING_NETWORKS.includes(currency.id)) {
     return {
       controller: null,
       stash: stash || null,
@@ -566,8 +569,17 @@ export const getValidators = async (
  * @returns {PolkadotStakingProgress}
  */
 export const getStakingProgress = async (
-  currency?: CryptoCurrency,
+  currency: CryptoCurrency,
 ): Promise<PolkadotStakingProgress> => {
+  if (UNSUPPORTED_STAKING_NETWORKS.includes(currency.id)) {
+    return {
+      electionClosed: true,
+      activeEra: 0,
+      maxNominatorRewardedPerValidator: 128,
+      bondingDuration: 28,
+    };
+  }
+
   const [progress, consts] = await Promise.all([
     fetchStakingProgress(currency),
     getConstants(currency),