@ledgerhq/coin-solana 0.37.0 → 0.38.0-nightly.20251126160702

package/src/bridge/bridge.ts

@@ -13,7 +13,7 @@ import type { AccountBridge, AccountLike, CurrencyBridge } from "@ledgerhq/types
 import type { SolanaAccount, SolanaPreloadDataV1, Transaction, TransactionStatus } from "../types";
 import { prepareTransaction as prepareTransactionWithAPI } from "../prepareTransaction";
 import { estimateMaxSpendableWithAPI } from "../estimateMaxSpendable";
-import { PRELOAD_MAX_AGE, hydrate, preloadWithAPI } from "../preload";
+import { PRELOAD_MAX_AGE, preloadWithAPI } from "../preload";
 import { getTransactionStatus } from "../getTransactionStatus";
 import { getAccountShapeWithAPI } from "../synchronization";
 import { createTransaction } from "../createTransaction";
@@ -32,33 +32,31 @@ import {
   assignToTokenAccountRaw,
 } from "../serialization";
 import nftResolvers from "../nftResolvers";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-function makePrepare(getChainAPI: (config: Config) => Promise<ChainAPI>) {
-  const prepareTransaction: AccountBridge<
-    Transaction,
-    SolanaAccount
-  >["prepareTransaction"] = async (mainAccount, transaction) => {
+function makePrepare(getChainAPI: (config: Config) => ChainAPI) {
+  const prepareTransaction: AccountBridge<Transaction, SolanaAccount>["prepareTransaction"] = (
+    mainAccount,
+    transaction,
+  ) => {
     const config: Config = {
       endpoint: endpointByCurrencyId(mainAccount.currency.id),
     };
 
-    const chainAPI = await getChainAPI(config);
+    const chainAPI = getChainAPI(config);
     return prepareTransactionWithAPI(mainAccount, transaction, chainAPI);
   };
 
   return prepareTransaction;
 }
 
-function makeSyncAndScan(
-  getChainAPI: (config: Config) => Promise<ChainAPI>,
-  getAddress: GetAddressFn,
-) {
-  const getAccountShape: GetAccountShape<SolanaAccount> = async info => {
+function makeSyncAndScan(getChainAPI: (config: Config) => ChainAPI, getAddress: GetAddressFn) {
+  const getAccountShape: GetAccountShape<SolanaAccount> = info => {
     const config: Config = {
       endpoint: endpointByCurrencyId(info.currency.id),
     };
 
-    const chainAPI = await getChainAPI(config);
+    const chainAPI = getChainAPI(config);
     return getAccountShapeWithAPI(info, chainAPI);
   };
   return {
@@ -67,11 +65,11 @@ function makeSyncAndScan(
   };
 }
 
-function makeEstimateMaxSpendable(getChainAPI: (config: Config) => Promise<ChainAPI>) {
+function makeEstimateMaxSpendable(getChainAPI: (config: Config) => ChainAPI) {
   const estimateMaxSpendable: AccountBridge<
     Transaction,
     SolanaAccount
-  >["estimateMaxSpendable"] = async arg => {
+  >["estimateMaxSpendable"] = arg => {
     const { account, parentAccount } = arg;
 
     const currencyId =
@@ -85,7 +83,7 @@ function makeEstimateMaxSpendable(getChainAPI: (config: Config) => Promise<Chain
       endpoint: endpointByCurrencyId(currencyId),
     };
 
-    const api = await getChainAPI(config);
+    const api = getChainAPI(config);
 
     return estimateMaxSpendableWithAPI(arg, api);
   };
@@ -106,38 +104,36 @@ function makeEstimateMaxSpendable(getChainAPI: (config: Config) => Promise<Chain
 }
 
 function makeBroadcast(
-  getChainAPI: (config: Config) => Promise<ChainAPI>,
+  getChainAPI: (config: Config) => ChainAPI,
 ): AccountBridge<Transaction, SolanaAccount>["broadcast"] {
-  return async info => {
+  return info => {
     const config: Config = {
       endpoint: endpointByCurrencyId(info.account.currency.id),
     };
-    const api = await getChainAPI(config);
+    const api = getChainAPI(config);
     return broadcastWithAPI(info, api);
   };
 }
 
 function makeSign(
-  getChainAPI: (config: Config) => Promise<ChainAPI>,
+  getChainAPI: (config: Config) => ChainAPI,
   signerContext: SignerContext<SolanaSigner>,
 ): AccountBridge<Transaction, SolanaAccount>["signOperation"] {
   return info => {
     const config: Config = {
       endpoint: endpointByCurrencyId(info.account.currency.id),
     };
-    const api = () => getChainAPI(config);
+    const api = getChainAPI(config);
     return buildSignOperation(signerContext, api)(info);
   };
 }
 
-function makePreload(
-  getChainAPI: (config: Config) => Promise<ChainAPI>,
-): CurrencyBridge["preload"] {
+function makePreload(getChainAPI: (config: Config) => ChainAPI): CurrencyBridge["preload"] {
   const preload: CurrencyBridge["preload"] = (currency): Promise<SolanaPreloadDataV1> => {
     const config: Config = {
       endpoint: endpointByCurrencyId(currency.id),
     };
-    const api = () => getChainAPI(config);
+    const api = getChainAPI(config);
     return preloadWithAPI(currency, api);
   };
   return preload;
@@ -151,29 +147,25 @@ function getPreloadStrategy() {
 
 export function makeBridges({
   getAPI,
-  getQueuedAPI,
-  getQueuedAndCachedAPI,
   signerContext,
 }: {
-  getAPI: (config: Config) => Promise<ChainAPI>;
-  getQueuedAPI: (config: Config) => Promise<ChainAPI>;
-  getQueuedAndCachedAPI: (config: Config) => Promise<ChainAPI>;
+  getAPI: (config: Config) => ChainAPI;
   signerContext: SignerContext<SolanaSigner>;
 }): {
   currencyBridge: CurrencyBridge;
   accountBridge: AccountBridge<Transaction, SolanaAccount, TransactionStatus>;
 } {
   const getAddress = resolver(signerContext);
-  const { sync, scan } = makeSyncAndScan(getQueuedAPI, getAddress);
+  const { sync, scan } = makeSyncAndScan(getAPI, getAddress);
 
   const accountBridge: AccountBridge<Transaction, SolanaAccount, TransactionStatus> = {
     createTransaction,
     updateTransaction,
-    estimateMaxSpendable: makeEstimateMaxSpendable(getQueuedAndCachedAPI),
+    estimateMaxSpendable: makeEstimateMaxSpendable(getAPI),
     getTransactionStatus,
     sync,
     receive: makeAccountBridgeReceive(getAddress),
-    prepareTransaction: makePrepare(getQueuedAndCachedAPI),
+    prepareTransaction: makePrepare(getAPI),
     broadcast: makeBroadcast(getAPI),
     signOperation: makeSign(getAPI, signerContext),
     signRawOperation: () => {
@@ -189,8 +181,8 @@ export function makeBridges({
   };
 
   const currencyBridge: CurrencyBridge = {
-    preload: makePreload(getQueuedAndCachedAPI),
-    hydrate,
+    preload: makePreload(getAPI),
+    hydrate: (_data: unknown, _currency: CryptoCurrency) => {},
     scanAccounts: scan,
     getPreloadStrategy,
     nftResolvers,

package/src/bridge/js.ts

@@ -1,14 +1,10 @@
-import { makeLRUCache, minutes } from "@ledgerhq/live-network/cache";
 import { log } from "@ledgerhq/logs";
-import { cached, Config, getChainAPI, queued } from "../network";
-import { traced } from "../network/traced";
+import { Config, getChainAPI } from "../network";
 import { makeBridges } from "./bridge";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { SolanaSigner } from "../signer";
 import { CoinConfig } from "@ledgerhq/coin-framework/config";
 import solanaCoinConfig, { SolanaCoinConfig } from "../config";
-import { setCryptoAssetsStoreGetter } from "../cryptoAssetsStore";
-import { CryptoAssetsStoreGetter } from "@ledgerhq/types-live";
 
 const httpRequestLogger = (url: string, options: any) => {
   log("network", url, {
@@ -18,36 +14,20 @@ const httpRequestLogger = (url: string, options: any) => {
   });
 };
 
-const getAPI = makeLRUCache(
-  (config: Config) => Promise.resolve(traced(getChainAPI(config, httpRequestLogger))),
-  config => config.endpoint,
-  minutes(1000),
-);
-
-const getQueuedAPI = makeLRUCache(
-  (config: Config) =>
-    getAPI(config).then(api => queued(api, solanaCoinConfig.getCoinConfig().queuedInterval)),
-  config => config.endpoint,
-  minutes(1000),
-);
-
-const getQueuedAndCachedAPI = makeLRUCache(
-  (config: Config) => getQueuedAPI(config).then(cached),
-  config => config.endpoint,
-  minutes(1000),
-);
-
 export function createBridges(
   signerContext: SignerContext<SolanaSigner>,
   coinConfig: CoinConfig<SolanaCoinConfig>,
-  cryptoAssetsStoreGetter: CryptoAssetsStoreGetter,
 ) {
   solanaCoinConfig.setCoinConfig(coinConfig);
-  setCryptoAssetsStoreGetter(cryptoAssetsStoreGetter);
+  const chainAPICache = new Map<string, ReturnType<typeof getChainAPI>>();
   return makeBridges({
-    getAPI,
-    getQueuedAPI,
-    getQueuedAndCachedAPI,
+    getAPI: (config: Config) => {
+      const endpoint = config.endpoint;
+      if (!chainAPICache.has(endpoint)) {
+        chainAPICache.set(endpoint, getChainAPI(config, httpRequestLogger));
+      }
+      return chainAPICache.get(endpoint)!;
+    },
     signerContext,
   });
 }

package/src/cli-transaction.ts

@@ -3,7 +3,7 @@ import invariant from "invariant";
 import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
 import { Transaction } from "./types";
 import { assertUnreachable } from "./utils";
-import { getCryptoAssetsStore } from "./cryptoAssetsStore";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 
 const modes = [
   "send",

package/src/config.ts

@@ -2,7 +2,6 @@ import buildCoinConfig, { type CurrencyConfig } from "@ledgerhq/coin-framework/c
 
 export type SolanaConfig = {
   token2022Enabled: boolean;
-  queuedInterval: number;
   legacyOCMSMaxVersion: string;
 };
 

package/src/helpers/token.ts

@@ -10,7 +10,7 @@ import {
 } from "../types";
 import { TransferFeeConfigExt } from "../network/chain/account/tokenExtensions";
 import { PARSED_PROGRAMS } from "../network/chain/program/constants";
-import { getCryptoAssetsStore } from "../cryptoAssetsStore";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 
 export async function tokenIsListedOnLedger(currencyId: string, mint: string): Promise<boolean> {
   const token = await getCryptoAssetsStore().findTokenByAddressInCurrency(mint, currencyId);

package/src/network/chain/index.ts

@@ -154,44 +154,38 @@ export function getChainAPI(
           fetch(url, options);
         };
 
-  let _connection: Connection;
-  const connection = () => {
-    if (!_connection) {
-      _connection = new Connection(config.endpoint, {
-        ...(fetchMiddleware ? { fetchMiddleware } : {}),
-        fetch: kyNoTimeout as typeof fetch, // Type cast for jest test having an issue with the type
-        commitment: "confirmed",
-        confirmTransactionInitialTimeout: getEnv("SOLANA_TX_CONFIRMATION_TIMEOUT") || 0,
-      });
-    }
-    return _connection;
-  };
+  const connection = new Connection(config.endpoint, {
+    ...(fetchMiddleware ? { fetchMiddleware } : {}),
+    fetch: kyNoTimeout as typeof fetch, // Type cast for jest test having an issue with the type
+    commitment: "confirmed",
+    confirmTransactionInitialTimeout: getEnv("SOLANA_TX_CONFIRMATION_TIMEOUT") || 0,
+  });
 
   return {
     getBalance: (address: string) =>
-      connection().getBalance(new PublicKey(address)).catch(remapErrors),
+      connection.getBalance(new PublicKey(address)).catch(remapErrors),
 
     getLatestBlockhash: (commitmentOrConfig?: Commitment | GetLatestBlockhashConfig) =>
-      connection().getLatestBlockhash(commitmentOrConfig).catch(remapErrors),
+      connection.getLatestBlockhash(commitmentOrConfig).catch(remapErrors),
 
     getFeeForMessage: (msg: VersionedMessage) =>
-      connection()
+      connection
         .getFeeForMessage(msg)
         .then(r => r.value)
         .catch(remapErrors),
 
     getBalanceAndContext: (address: string) =>
-      connection().getBalanceAndContext(new PublicKey(address)).catch(remapErrors),
+      connection.getBalanceAndContext(new PublicKey(address)).catch(remapErrors),
 
     getParsedTokenAccountsByOwner: (address: string) =>
-      connection()
+      connection
         .getParsedTokenAccountsByOwner(new PublicKey(address), {
           programId: TOKEN_PROGRAM_ID,
         })
         .catch(remapErrors),
 
     getParsedToken2022AccountsByOwner: (address: string) =>
-      connection()
+      connection
         .getParsedTokenAccountsByOwner(new PublicKey(address), {
           programId: TOKEN_2022_PROGRAM_ID,
         })
@@ -199,7 +193,7 @@ export function getChainAPI(
 
     getStakeAccountsByStakeAuth: makeLRUCache(
       (authAddr: string) =>
-        connection()
+        connection
           .getParsedProgramAccounts(StakeProgram.programId, {
             filters: [
               {
@@ -217,7 +211,7 @@ export function getChainAPI(
 
     getStakeAccountsByWithdrawAuth: makeLRUCache(
       (authAddr: string) =>
-        connection()
+        connection
           .getParsedProgramAccounts(StakeProgram.programId, {
             filters: [
               {
@@ -234,51 +228,48 @@ export function getChainAPI(
     ),
 
     getInflationReward: (addresses: string[]) =>
-      connection()
-        .getInflationReward(addresses.map(addr => new PublicKey(addr)))
-        .catch(remapErrors),
+      connection.getInflationReward(addresses.map(addr => new PublicKey(addr))).catch(remapErrors),
 
-    getVoteAccounts: () => connection().getVoteAccounts().catch(remapErrors),
+    getVoteAccounts: () => connection.getVoteAccounts().catch(remapErrors),
 
     getSignaturesForAddress: (address: string, opts?: SignaturesForAddressOptions) => {
       const callback = () => {
-        return connection().getSignaturesForAddress(new PublicKey(address), opts);
+        return connection.getSignaturesForAddress(new PublicKey(address), opts);
       };
       return callback().catch(remapErrorsWithRetry(callback));
     },
 
     getParsedTransactions: (signatures: string[]) =>
-      connection()
+      connection
         .getParsedTransactions(signatures, {
           maxSupportedTransactionVersion: 0,
         })
         .catch(remapErrors),
 
     getAccountInfo: (address: string) =>
-      connection()
+      connection
         .getParsedAccountInfo(new PublicKey(address))
         .then(r => r.value)
         .catch(remapErrors),
 
     getMultipleAccounts: (addresses: string[]) =>
-      connection()
+      connection
         .getMultipleParsedAccounts(addresses.map(address => new PublicKey(address)))
         .then(r => r.value)
         .catch(remapErrors),
 
     sendRawTransaction: (buffer: Buffer, recentBlockhash?: BlockhashWithExpiryBlockHeight) => {
       return (async () => {
-        const conn = connection();
         const commitment = "confirmed";
 
-        const signature = await conn.sendRawTransaction(buffer, {
+        const signature = await connection.sendRawTransaction(buffer, {
           preflightCommitment: commitment,
         });
 
         if (!recentBlockhash) {
-          recentBlockhash = await conn.getLatestBlockhash(commitment);
+          recentBlockhash = await connection.getLatestBlockhash(commitment);
         }
-        const { value: status } = await conn.confirmTransaction(
+        const { value: status } = await connection.confirmTransaction(
           {
             blockhash: recentBlockhash.blockhash,
             lastValidBlockHeight: recentBlockhash.lastValidBlockHeight,
@@ -312,15 +303,15 @@ export function getChainAPI(
     },
 
     getAssocTokenAccMinNativeBalance: () =>
-      getMinimumBalanceForRentExemptAccount(connection()).catch(remapErrors),
+      getMinimumBalanceForRentExemptAccount(connection).catch(remapErrors),
 
     getMinimumBalanceForRentExemption: (dataLength: number) =>
-      connection().getMinimumBalanceForRentExemption(dataLength).catch(remapErrors),
+      connection.getMinimumBalanceForRentExemption(dataLength).catch(remapErrors),
 
-    getEpochInfo: () => connection().getEpochInfo().catch(remapErrors),
+    getEpochInfo: () => connection.getEpochInfo().catch(remapErrors),
 
     getRecentPrioritizationFees: (accounts: string[]) => {
-      return connection()
+      return connection
         .getRecentPrioritizationFees({
           lockedWritableAccounts: accounts.map(acc => new PublicKey(acc)),
         })
@@ -345,7 +336,7 @@ export function getChainAPI(
           recentBlockhash: PublicKey.default.toString(),
         }).compileToLegacyMessage(),
       );
-      const rpcResponse = await connection().simulateTransaction(testTransaction, {
+      const rpcResponse = await connection.simulateTransaction(testTransaction, {
         replaceRecentBlockhash: true,
         sigVerify: false,
       });
@@ -353,6 +344,6 @@ export function getChainAPI(
     },
 
     config,
-    connection: connection(),
+    connection,
   };
 }

package/src/network/chain/web3.integration.test.ts

@@ -2,7 +2,7 @@ import { create } from "superstruct";
 import { getChainAPI } from ".";
 import { PARSED_PROGRAMS } from "./program/constants";
 import { PublicKeyFromString } from "./validators/pubkey";
-import { getMaybeTokenAccount } from "./web3";
+import { getMaybeTokenAccount, getTransactions } from "./web3";
 
 const api = getChainAPI({
   endpoint: "https://solana.coin.ledger.com",
@@ -74,3 +74,23 @@ describe("findTokenAccAddress", () => {
     expect(ata).toEqual(address);
   });
 });
+
+describe("getTransactions", () => {
+  it.each([
+    {
+      address: "Cv9b7PuxVdKXTKTBXvZSQfSqbMNmPHP8brv77ZL2D95m",
+      untilTxSignature: undefined,
+    },
+    {
+      address: "Hj69wRzkrFuf1Nby4yzPEFHdsmQdMoVYjvDKZSLjZFEp",
+      untilTxSignature: undefined,
+    },
+  ])(
+    "returns the expected transactions without any fail transactions",
+    async ({ address, untilTxSignature }) => {
+      const txs = await getTransactions(address, untilTxSignature, api);
+      const hasError = txs.some(tx => tx.info.err);
+      expect(hasError).toBe(false);
+    },
+  );
+});

package/src/network/chain/web3.ts

@@ -122,12 +122,18 @@ async function* getTransactionsBatched(
     const transactions = await api.getParsedTransactions(
       signaturesInfoBatch.map(tx => tx.signature),
     );
-    const txsDetails = transactions.reduce((acc, tx, index) => {
+    const sortedTransactions = transactions.sort((a, b) => (b?.slot ?? 0) - (a?.slot ?? 0));
+    const txsDetails = sortedTransactions.reduce((acc, tx) => {
       if (tx && !tx.meta?.err && tx.blockTime) {
-        acc.push({
-          info: signaturesInfoBatch[index],
-          parsed: tx,
-        });
+        const info = signaturesInfoBatch.find(s =>
+          tx.transaction.signatures.includes(s.signature),
+        )!;
+        if (info) {
+          acc.push({
+            info,
+            parsed: tx,
+          });
+        }
       }
       return acc;
     }, [] as TransactionDescriptor[]);

package/src/network/index.ts

@@ -1,4 +1,2 @@
 export * from "./chain/index";
-export { cached } from "./cached";
-export { queued } from "./queued";
 export { logged } from "./logged";

package/src/network/nft/index.ts

@@ -1,5 +1,5 @@
 import { getEnv } from "@ledgerhq/live-env";
-import network from "@ledgerhq/live-network/network";
+import network from "@ledgerhq/live-network";
 import { NFTCollectionMetadataResponse, NFTMetadataResponse } from "@ledgerhq/types-live";
 import { CollectionMetadataInput, NftMetadataInput } from "@ledgerhq/coin-framework/nft/types";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";

package/src/preload-data.ts

@@ -6,7 +6,6 @@ const initialData: SolanaPreloadDataV1 = {
   version: "1",
   validatorsWithMeta: [],
   validators: [],
-  splTokens: null,
 };
 
 const dataByCurrency = new Map<string, SolanaPreloadDataV1>([

package/src/preload.test.ts

@@ -1,14 +1,123 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { hydrate } from "./preload";
-import { SolanaPreloadData } from "./types";
-
-describe("hydrate", () => {
-  it.each([undefined, null, {}, { version: null }, { version: undefined }, {}])(
-    "should return undefined if data is corrupted (%p value)",
-    value => {
-      expect(hydrate(value as unknown as SolanaPreloadData, {} as CryptoCurrency)).toEqual(
-        undefined,
-      );
-    },
-  );
+import { preloadWithAPI } from "./preload";
+import { ChainAPI } from "./network";
+import { getValidators, ValidatorsAppValidator } from "./network/validator-app";
+import { Cluster } from "@solana/web3.js";
+import { LEDGER_VALIDATOR_BY_CHORUS_ONE, LEDGER_VALIDATOR_BY_FIGMENT } from "./utils";
+import { getSolanaPreloadData } from "./preload-data";
+import { firstValueFrom } from "rxjs";
+
+jest.mock("./network/validator-app");
+
+const mockedGetValidators = jest.mocked(getValidators);
+
+describe("preloadWithAPI", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return correctly the preloaded data for solana", async () => {
+    const validators: ValidatorsAppValidator[] = [
+      {
+        activeStake: 0,
+        commission: 1,
+        totalScore: 2,
+        voteAccount: "some random account",
+      },
+      {
+        activeStake: 3,
+        commission: 4,
+        totalScore: 5,
+        voteAccount: "some random account 2",
+      },
+    ];
+    mockedGetValidators.mockImplementationOnce((_cluster: Cluster) => Promise.resolve(validators));
+
+    const currency = {
+      id: "solana",
+    } as unknown as CryptoCurrency;
+
+    const result = await preloadWithAPI(currency, {} as unknown as ChainAPI);
+    expect(result).toEqual({
+      validators: expect.arrayContaining([
+        ...validators,
+        LEDGER_VALIDATOR_BY_FIGMENT,
+        LEDGER_VALIDATOR_BY_CHORUS_ONE,
+      ]),
+      validatorsWithMeta: [],
+      version: "1",
+    });
+
+    const solanaPreloadedData = await firstValueFrom(getSolanaPreloadData(currency));
+    expect(solanaPreloadedData).toEqual(result);
+  });
+
+  it("should return correctly the preloaded data for solana_devnet", async () => {
+    const voteAccount = {
+      activatedStake: 6,
+      commission: 7,
+      votePubkey: "some random account from account",
+    };
+
+    const api = {
+      getVoteAccounts: () =>
+        Promise.resolve({
+          current: [voteAccount],
+        }),
+    } as unknown as ChainAPI;
+
+    const currency = {
+      id: "solana_devnet",
+    } as unknown as CryptoCurrency;
+    const result = await preloadWithAPI(currency, api);
+    expect(result).toEqual({
+      validators: expect.arrayContaining([
+        {
+          activeStake: voteAccount.activatedStake,
+          commission: voteAccount.commission,
+          voteAccount: voteAccount.votePubkey,
+          totalScore: 0,
+        },
+      ]),
+      validatorsWithMeta: [],
+      version: "1",
+    });
+
+    const solanaPreloadedData = await firstValueFrom(getSolanaPreloadData(currency));
+    expect(solanaPreloadedData).toEqual(result);
+  });
+
+  it("should return correctly the preloaded data for solana_testnet", async () => {
+    const validators: ValidatorsAppValidator[] = [
+      {
+        activeStake: 0,
+        commission: 1,
+        totalScore: 2,
+        voteAccount: "some random account",
+      },
+      {
+        activeStake: 3,
+        commission: 4,
+        totalScore: 5,
+        voteAccount: "some random account 2",
+      },
+    ];
+    mockedGetValidators.mockImplementationOnce((_cluster: Cluster) => Promise.resolve(validators));
+
+    const currency = {
+      id: "solana_testnet",
+    } as unknown as CryptoCurrency;
+
+    const result = await preloadWithAPI(currency, {} as unknown as ChainAPI);
+    expect(result).toEqual({
+      validators: expect.arrayContaining(validators),
+      validatorsWithMeta: [],
+      version: "1",
+    });
+
+    const solanaPreloadedData = await firstValueFrom(getSolanaPreloadData(currency));
+    expect(solanaPreloadedData).toEqual(result);
+  });
 });