@ledgerhq/coin-stellar 6.26.0 → 6.26.1

package/src/network/fetchLedgerOperations.unit.test.ts

@@ -0,0 +1,155 @@
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import type { CoinConfig } from '@ledgerhq/coin-module-framework/config'
+import { Horizon, NotFoundError } from '@stellar/stellar-sdk'
+import coinConfig, { type StellarCoinConfig } from '../config'
+import { fetchAllLedgerOperations, fetchLedgerRecord } from './horizon'
+
+const HORIZON = 'https://horizon-testnet.stellar.org'
+
+let originalGetCoinConfig: CoinConfig<StellarCoinConfig>
+
+/** Minimal Horizon payment op shape (embedded.records). */
+const MINIMAL_HORIZON_PAYMENT_OP = {
+  _links: {
+    self: { href: '' },
+    transaction: { href: '' },
+    effects: { href: '' },
+    succeeds: { href: '' },
+    precedes: { href: '' },
+  },
+  id: '1',
+  paging_token: '1',
+  transaction_successful: true,
+  source_account: 'GB7FW6GRFEH63Q3BVRT65VMB26OKHQRG74QRFUMTL6D553UKDZCDM7U',
+  type: 'payment',
+  type_i: 1,
+  created_at: '2015-07-20T20:27:50Z',
+  transaction_hash: 'txh',
+  asset_type: 'native',
+  from: 'GB7FW6GRFEH63Q3BVRT65VMB26OKHQRG74QRFUMTL6D553UKDZCDM7U',
+  to: 'GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN',
+  amount: '1.0000000',
+}
+
+/**
+ * Minimal chainable stub of a Horizon call builder: every builder method returns
+ * the builder itself, and `call()` resolves (or rejects) with the configured value.
+ * Lets us drive `getServer().ledgers()...call()` / `.operations()...call()` without HTTP.
+ */
+function callBuilder(call: () => Promise<unknown>): unknown {
+  const builder: unknown = new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (prop === 'call') return call
+        return () => builder
+      },
+    }
+  )
+  return builder
+}
+
+function setExplorer(fetchLimit = 100): void {
+  coinConfig.setCoinConfig(
+    (): StellarCoinConfig =>
+      ({
+        status: { type: 'active' },
+        explorer: { url: `${HORIZON}/`, fetchLimit },
+      }) as StellarCoinConfig
+  )
+}
+
+function mockLedgers(call: () => Promise<unknown>): void {
+  jest.spyOn(Horizon.Server.prototype, 'ledgers').mockReturnValue(callBuilder(call) as never)
+}
+
+function mockOperations(call: () => Promise<unknown>): void {
+  jest.spyOn(Horizon.Server.prototype, 'operations').mockReturnValue(callBuilder(call) as never)
+}
+
+describe('fetchLedgerRecord / fetchAllLedgerOperations', () => {
+  beforeAll(() => {
+    originalGetCoinConfig = coinConfig.getCoinConfig
+  })
+
+  afterAll(() => {
+    if (originalGetCoinConfig) {
+      coinConfig.setCoinConfig(originalGetCoinConfig)
+    }
+  })
+
+  beforeEach(() => {
+    setExplorer(100)
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  it('fetchLedgerRecord maps 404 to not found error', async () => {
+    mockLedgers(() => Promise.reject(new NotFoundError('Not Found', {} as never)))
+
+    await expect(fetchLedgerRecord(424242)).rejects.toThrow('Stellar ledger 424242 not found')
+  })
+
+  it('fetchAllLedgerOperations maps 404 to not found error', async () => {
+    mockOperations(() => Promise.reject(new NotFoundError('Not Found', {} as never)))
+
+    await expect(fetchAllLedgerOperations(424243)).rejects.toThrow(
+      'Stellar ledger 424243 not found'
+    )
+  })
+
+  it('fetchLedgerRecord returns ledger on 200', async () => {
+    const ledgerBody = {
+      _links: { self: { href: '' }, transactions: { href: '' }, operations: { href: '' } },
+      id: 'abc',
+      paging_token: 'abc',
+      hash: '0000000000000000000000000000000000000000000000000000000000000000',
+      prev_hash: '',
+      sequence: 3,
+      successful_transaction_count: 0,
+      failed_transaction_count: 0,
+      operation_count: 0,
+      tx_set_operation_count: 0,
+      closed_at: '2015-07-20T20:27:50Z',
+      total_coins: '100000000000.0000000',
+      fee_pool: '0.0000000',
+      base_fee_in_stroops: 100,
+      base_reserve_in_stroops: 100000000,
+      max_tx_set_size: 50,
+      protocol_version: 1,
+      header_xdr: '',
+    }
+    mockLedgers(() => Promise.resolve(ledgerBody))
+
+    const rec = await fetchLedgerRecord(3)
+    expect(rec.sequence).toBe(3)
+    expect(rec.hash).toBe(ledgerBody.hash)
+  })
+
+  it('fetchAllLedgerOperations returns embedded records on 200', async () => {
+    const page = {
+      records: [MINIMAL_HORIZON_PAYMENT_OP],
+      next: () => Promise.resolve({ records: [] }),
+    }
+    mockOperations(() => Promise.resolve(page))
+
+    const records = await fetchAllLedgerOperations(10)
+    expect(records).toHaveLength(1)
+    expect(records[0].type).toBe('payment')
+  })
+
+  it('fetchAllLedgerOperations paginates when page is full then stops on empty page', async () => {
+    setExplorer(1)
+
+    const page2 = { records: [], next: () => Promise.resolve({ records: [] }) }
+    const page1 = { records: [MINIMAL_HORIZON_PAYMENT_OP], next: () => Promise.resolve(page2) }
+    mockOperations(() => Promise.resolve(page1))
+
+    const records = await fetchAllLedgerOperations(11)
+    expect(records.length).toBe(1)
+  })
+})

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

@@ -1,67 +1,70 @@
-import coinConfig, { StellarCoinConfig } from "../config";
-import { fetchAllOperations, registerHorizonInterceptors } from "./horizon";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-describe("fetchAllOperations", () => {
+import coinConfig, { StellarCoinConfig } from '../config'
+import { fetchAllOperations, registerHorizonInterceptors } from './horizon'
+
+describe('fetchAllOperations', () => {
   beforeAll(() => {
     coinConfig.setCoinConfig(
       (): StellarCoinConfig => ({
-        status: { type: "active" },
+        status: { type: 'active' },
         explorer: {
-          url: "https://stellar.coin.ledger.com",
+          url: 'https://stellar.coin.ledger.com',
           fetchLimit: 10,
         },
-      }),
-    );
-    registerHorizonInterceptors();
-  });
+      })
+    )
+    registerHorizonInterceptors()
+  })
 
   it(
-    "fetch operations with limitations, set order to desc",
+    'fetch operations with limitations, set order to desc',
     async () => {
-      const addr = "GCOCZ3ODGW3YH6PPGMLGT3MORS5YBTVJCSL46TC2NMU2KCXGL52XLEZB";
-      const limit = 30;
-      const ops = await fetchAllOperations(addr, addr, "desc", "241343231793946722", limit);
-      expect(ops.length).toEqual(limit);
+      const addr = 'GCOCZ3ODGW3YH6PPGMLGT3MORS5YBTVJCSL46TC2NMU2KCXGL52XLEZB'
+      const limit = 30
+      const ops = await fetchAllOperations(addr, addr, 'desc', '241343231793946722', limit)
+      expect(ops.length).toEqual(limit)
       expect(ops[0].id).toEqual(
-        `${addr}-00b0081a2c5c5e62cf5f5813691d33ab71a8b46b115d645bcd9df4e9c7941778-IN`,
-      );
+        `${addr}-00b0081a2c5c5e62cf5f5813691d33ab71a8b46b115d645bcd9df4e9c7941778-IN`
+      )
       expect(ops[29].id).toEqual(
-        `${addr}-00b0081a2c5c5e62cf5f5813691d33ab71a8b46b115d645bcd9df4e9c7941778-IN`,
-      );
+        `${addr}-00b0081a2c5c5e62cf5f5813691d33ab71a8b46b115d645bcd9df4e9c7941778-IN`
+      )
     },
-    10 * 1_000,
-  );
+    10 * 1_000
+  )
 
   it(
-    "fetch operations without limitations, set order to desc",
+    'fetch operations without limitations, set order to desc',
     async () => {
-      const addr = "GCOCZ3ODGW3YH6PPGMLGT3MORS5YBTVJCSL46TC2NMU2KCXGL52XLEZB";
-      const ops = await fetchAllOperations(addr, addr, "desc", "241330913827401737");
-      expect(ops.length).toEqual(19);
+      const addr = 'GCOCZ3ODGW3YH6PPGMLGT3MORS5YBTVJCSL46TC2NMU2KCXGL52XLEZB'
+      const ops = await fetchAllOperations(addr, addr, 'desc', '241330913827401737')
+      expect(ops.length).toEqual(19)
       expect(ops[0].id).toEqual(
-        `${addr}-7352d7e754c93b39213288a268efec78843ce8db6fa15f88308c7c852f6806c9-IN`,
-      );
+        `${addr}-7352d7e754c93b39213288a268efec78843ce8db6fa15f88308c7c852f6806c9-IN`
+      )
       expect(ops[18].id).toEqual(
-        `${addr}-af8982997f1765ebbd41b36ab6927825f7083dc3ced07d1d086c1a3ca9c7e3e9-IN`,
-      );
+        `${addr}-af8982997f1765ebbd41b36ab6927825f7083dc3ced07d1d086c1a3ca9c7e3e9-IN`
+      )
     },
-    10 * 1_000,
-  );
+    10 * 1_000
+  )
 
   it(
-    "fetch operations with limitations, set order to asc",
+    'fetch operations with limitations, set order to asc',
     async () => {
-      const addr = "GCOCZ3ODGW3YH6PPGMLGT3MORS5YBTVJCSL46TC2NMU2KCXGL52XLEZB";
-      const limit = 20;
-      const ops = await fetchAllOperations(addr, addr, "asc", "241343201729257475", limit);
-      expect(ops.length).toEqual(limit);
+      const addr = 'GCOCZ3ODGW3YH6PPGMLGT3MORS5YBTVJCSL46TC2NMU2KCXGL52XLEZB'
+      const limit = 20
+      const ops = await fetchAllOperations(addr, addr, 'asc', '241343201729257475', limit)
+      expect(ops.length).toEqual(limit)
       expect(ops[0].id).toEqual(
-        `${addr}-71b49018e0ad4f9c72132a89bb58f921158aed3023f7543bab176881ff0b5b14-IN`,
-      );
+        `${addr}-71b49018e0ad4f9c72132a89bb58f921158aed3023f7543bab176881ff0b5b14-IN`
+      )
       expect(ops[19].id).toEqual(
-        `${addr}-71b49018e0ad4f9c72132a89bb58f921158aed3023f7543bab176881ff0b5b14-IN`,
-      );
+        `${addr}-71b49018e0ad4f9c72132a89bb58f921158aed3023f7543bab176881ff0b5b14-IN`
+      )
     },
-    10 * 1_000,
-  );
-});
+    10 * 1_000
+  )
+})

package/src/network/horizon.test.ts

@@ -1,19 +1,22 @@
-import coinConfig from "../config";
-import { useConfigHostAndProtocol } from "./horizon";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-describe("Horizon", () => {
+import coinConfig from '../config'
+import { useConfigHostAndProtocol } from './horizon'
+
+describe('Horizon', () => {
   beforeAll(() => {
     coinConfig.setCoinConfig(
-      () => ({ explorer: { url: "https://stellar.coin.ledger.com" } }) as any,
-    );
-  });
+      () => ({ explorer: { url: 'https://stellar.coin.ledger.com' } }) as any
+    )
+  })
 
-  describe("useConfigHostAndProtocol", () => {
+  describe('useConfigHostAndProtocol', () => {
     it.each([
-      ["host", "https://injected.com/1"],
-      ["protocol", "injected://stellar.coin.ledger.com/1"],
-    ])("overwrites the %s of the URL with the original one", (_s, url) => {
-      expect(useConfigHostAndProtocol(url)).toEqual("https://stellar.coin.ledger.com/1");
-    });
-  });
-});
+      ['host', 'https://injected.com/1'],
+      ['protocol', 'injected://stellar.coin.ledger.com/1'],
+    ])('overwrites the %s of the URL with the original one', (_s, url) => {
+      expect(useConfigHostAndProtocol(url)).toEqual('https://stellar.coin.ledger.com/1')
+    })
+  })
+})