@ledgerhq/coin-stellar 6.26.0 → 6.26.1

package/src/api/index.test.ts

@@ -1,163 +1,166 @@
-import { BalanceOptions, TransactionIntent } from "@ledgerhq/coin-module-framework/api/types";
-import { InvalidParameterError } from "@ledgerhq/errors";
-import { StellarMemo } from "../types";
-import { createApi, envelopeFromAnyXDR } from "./index";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-const mockGetOperations = jest.fn();
+import { BalanceOptions, TransactionIntent } from '@ledgerhq/coin-module-framework/api/types'
+import { InvalidParameterError } from '@ledgerhq/errors'
+import { StellarMemo } from '../types'
+import { createApi, envelopeFromAnyXDR } from './index'
 
-jest.mock("../logic/listOperations", () => ({
+const mockGetOperations = jest.fn()
+
+jest.mock('../logic/listOperations', () => ({
   listOperations: () => mockGetOperations(),
-}));
+}))
 
-const CUSTOM_FEES = 300n;
-const estimateFeesMock = jest.fn(() => CUSTOM_FEES);
-jest.mock("../logic/estimateFees", () => ({
+const CUSTOM_FEES = 300n
+const estimateFeesMock = jest.fn(() => CUSTOM_FEES)
+jest.mock('../logic/estimateFees', () => ({
   estimateFees: () => estimateFeesMock(),
-}));
+}))
 
 const logicCraftTransactionMock = jest.fn((_account: unknown, _transaction: { fee: bigint }) => {
-  return { xdr: undefined };
-});
-jest.mock("../logic/craftTransaction", () => ({
+  return { xdr: undefined }
+})
+jest.mock('../logic/craftTransaction', () => ({
   craftTransaction: (account: unknown, transaction: { fee: bigint }) =>
     logicCraftTransactionMock(account, transaction),
-}));
+}))
 
 const api = createApi({
   explorer: {
-    url: "explorer.com",
+    url: 'explorer.com',
     fetchLimit: 200,
   },
   useStaticFees: true,
   enableNetworkLogs: false,
-});
+})
 
-const fromGenesisMinHeight = 0;
-const fromGenesisOrder = "asc" as const;
+const fromGenesisMinHeight = 0
+const fromGenesisOrder = 'asc' as const
 
-describe("operations", () => {
+describe('operations', () => {
   beforeEach(() => {
-    jest.clearAllMocks();
-  });
+    jest.clearAllMocks()
+  })
 
   const mockOperation = {
-    asset: { type: "native" },
+    asset: { type: 'native' },
     tx: {
-      hash: "e035a56c32003e3b0e4c9c5499b0750d71d98233ae6ae94323ff0a458b05a30b",
+      hash: 'e035a56c32003e3b0e4c9c5499b0750d71d98233ae6ae94323ff0a458b05a30b',
       fees: 0.0291,
       block: {
-        hash: "hash",
-        time: new Date("2024-03-20T10:00:00Z"),
+        hash: 'hash',
+        time: new Date('2024-03-20T10:00:00Z'),
         height: 10,
       },
-      date: new Date("2024-03-20T10:00:00Z"),
+      date: new Date('2024-03-20T10:00:00Z'),
     },
-    type: "Operation",
+    type: 'Operation',
     value: 200,
-    senders: ["addr"],
-    recipients: ["recipient"],
-  };
+    senders: ['addr'],
+    recipients: ['recipient'],
+  }
 
-  it("should return 0 operations for a valid account", async () => {
-    mockGetOperations.mockResolvedValue({ items: [], next: "" });
+  it('should return 0 operations for a valid account', async () => {
+    mockGetOperations.mockResolvedValue({ items: [], next: '' })
 
     // When
-    const operations = await api.listOperations("addr", {
+    const operations = await api.listOperations('addr', {
       minHeight: fromGenesisMinHeight,
       order: fromGenesisOrder,
-    });
+    })
 
     // Then
-    expect(operations).toEqual({ items: [], next: undefined });
-    expect(mockGetOperations).toHaveBeenCalledTimes(1);
-  });
+    expect(operations).toEqual({ items: [], next: undefined })
+    expect(mockGetOperations).toHaveBeenCalledTimes(1)
+  })
 
-  it("should return 1 operation for a valid account", async () => {
-    mockGetOperations.mockResolvedValue({ items: [mockOperation], next: "" });
+  it('should return 1 operation for a valid account', async () => {
+    mockGetOperations.mockResolvedValue({ items: [mockOperation], next: '' })
 
     // When
-    const operations = await api.listOperations("addr", {
+    const operations = await api.listOperations('addr', {
       minHeight: fromGenesisMinHeight,
       order: fromGenesisOrder,
-    });
+    })
 
     // Then
-    expect(operations).toEqual({ items: [mockOperation], next: undefined });
-    expect(mockGetOperations).toHaveBeenCalledTimes(1);
-  });
+    expect(operations).toEqual({ items: [mockOperation], next: undefined })
+    expect(mockGetOperations).toHaveBeenCalledTimes(1)
+  })
 
-  it("should return cursor for caller-driven pagination", async () => {
-    mockGetOperations.mockResolvedValueOnce({ items: [mockOperation], next: "cursor-abc" });
+  it('should return cursor for caller-driven pagination', async () => {
+    mockGetOperations.mockResolvedValueOnce({ items: [mockOperation], next: 'cursor-abc' })
 
     // When
-    const operations = await api.listOperations("addr", {
+    const operations = await api.listOperations('addr', {
       minHeight: fromGenesisMinHeight,
       order: fromGenesisOrder,
-    });
+    })
 
-    expect(operations).toEqual({ items: [mockOperation], next: "cursor-abc" });
-    expect(mockGetOperations).toHaveBeenCalledTimes(1);
-  });
-});
+    expect(operations).toEqual({ items: [mockOperation], next: 'cursor-abc' })
+    expect(mockGetOperations).toHaveBeenCalledTimes(1)
+  })
+})
 
-describe("Testing craftTransaction function", () => {
+describe('Testing craftTransaction function', () => {
   beforeEach(() => {
-    estimateFeesMock.mockClear();
-    logicCraftTransactionMock.mockClear();
-  });
+    estimateFeesMock.mockClear()
+    logicCraftTransactionMock.mockClear()
+  })
 
-  it("should use estimated fees when user does not provide them for crafting a transaction", async () => {
-    await api.craftTransaction({ asset: {} } as TransactionIntent<StellarMemo>);
-    expect(estimateFeesMock).toHaveBeenCalledTimes(1);
+  it('should use estimated fees when user does not provide them for crafting a transaction', async () => {
+    await api.craftTransaction({ asset: {} } as TransactionIntent<StellarMemo>)
+    expect(estimateFeesMock).toHaveBeenCalledTimes(1)
     expect(logicCraftTransactionMock).toHaveBeenCalledWith(
       expect.any(Object),
-      expect.objectContaining({ fee: CUSTOM_FEES }),
-    );
-  });
+      expect.objectContaining({ fee: CUSTOM_FEES })
+    )
+  })
 
   it.each([[1n], [50n], [99n]])(
-    "should use custom user fees when user provide them for crafting a transaction",
+    'should use custom user fees when user provide them for crafting a transaction',
     async (fees: bigint) => {
-      await api.craftTransaction({ asset: {} } as TransactionIntent<StellarMemo>, { value: fees });
-      expect(estimateFeesMock).toHaveBeenCalledTimes(0);
+      await api.craftTransaction({ asset: {} } as TransactionIntent<StellarMemo>, { value: fees })
+      expect(estimateFeesMock).toHaveBeenCalledTimes(0)
       expect(logicCraftTransactionMock).toHaveBeenCalledWith(
         expect.any(Object),
-        expect.objectContaining({ fee: fees }),
-      );
-    },
-  );
-});
-
-describe("Testing transaction loading functions", () => {
-  it("should deserialize a transaction as expected", async () => {
+        expect.objectContaining({ fee: fees })
+      )
+    }
+  )
+})
+
+describe('Testing transaction loading functions', () => {
+  it('should deserialize a transaction as expected', async () => {
     const transactionPayloadXDR =
-      "esM5l1ROMXXSZr0CJDmyLNsWUIwBFj8m5csqPhBFqXkAAAACAAAAAEFMhHdla/OhHE2CYrF1VVPnLgBThGuzpNFZyYMh" +
-      "8L6XAAAAZAAAJ/cAAAkYAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAABAAAABHRlc3QAAAABAAAAAAAAAAAAAAAA/QIumXyU" +
-      "+Nq3dDZfGCXjgxYI7uvPElz8zGb0gN+vWD8AAAAAAA9CQAAAAAA=";
+      'esM5l1ROMXXSZr0CJDmyLNsWUIwBFj8m5csqPhBFqXkAAAACAAAAAEFMhHdla/OhHE2CYrF1VVPnLgBThGuzpNFZyYMh' +
+      '8L6XAAAAZAAAJ/cAAAkYAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAABAAAABHRlc3QAAAABAAAAAAAAAAAAAAAA/QIumXyU' +
+      '+Nq3dDZfGCXjgxYI7uvPElz8zGb0gN+vWD8AAAAAAA9CQAAAAAA='
     const transactionEnvelopeXDR =
-      "AAAAAgAAAABBTIR3ZWvzoRxNgmKxdVVT5y4AU4Rrs6TRWcmDIfC+lwAAAGQAACf3AAAJGAAAAAEAAAAAAAAAAAAAAAAA" +
-      "AAAAAAAAAQAAAAR0ZXN0AAAAAQAAAAAAAAAAAAAAAP0CLpl8lPjat3Q2Xxgl44MWCO7rzxJc/Mxm9IDfr1g/AAAAAAAP" +
-      "QkAAAAAAAAAAAA==";
-    const txFromSignaturePayload = envelopeFromAnyXDR(transactionPayloadXDR, "base64");
-    const txFromEnvelope = envelopeFromAnyXDR(transactionEnvelopeXDR, "base64");
-    expect(txFromEnvelope).toEqual(txFromSignaturePayload);
-    expect(txFromEnvelope.toXDR("base64")).toEqual(transactionEnvelopeXDR);
-    expect(txFromSignaturePayload.toXDR("base64")).toEqual(transactionEnvelopeXDR);
-  });
-
-  it("throw expected error when deserializing an invalid transaction", async () => {
-    expect(() => envelopeFromAnyXDR("lulz", "base64")).toThrow(
-      "Failed decoding transaction as an envelope (TypeError: XDR Read Error: attempt to read outside the boundary of" +
-        " the buffer) or as a signature base: (TypeError: XDR Read Error: attempt to read outside the boundary of the" +
-        " buffer)",
-    );
-  });
-});
-
-describe("getBalance", () => {
-  it("should throw an exception when options is provided", async () => {
-    await expect(api.getBalance("random address", {} as unknown as BalanceOptions)).rejects.toThrow(
-      InvalidParameterError,
-    );
-  });
-});
+      'AAAAAgAAAABBTIR3ZWvzoRxNgmKxdVVT5y4AU4Rrs6TRWcmDIfC+lwAAAGQAACf3AAAJGAAAAAEAAAAAAAAAAAAAAAAA' +
+      'AAAAAAAAAQAAAAR0ZXN0AAAAAQAAAAAAAAAAAAAAAP0CLpl8lPjat3Q2Xxgl44MWCO7rzxJc/Mxm9IDfr1g/AAAAAAAP' +
+      'QkAAAAAAAAAAAA=='
+    const txFromSignaturePayload = envelopeFromAnyXDR(transactionPayloadXDR, 'base64')
+    const txFromEnvelope = envelopeFromAnyXDR(transactionEnvelopeXDR, 'base64')
+    expect(txFromEnvelope).toEqual(txFromSignaturePayload)
+    expect(txFromEnvelope.toXDR('base64')).toEqual(transactionEnvelopeXDR)
+    expect(txFromSignaturePayload.toXDR('base64')).toEqual(transactionEnvelopeXDR)
+  })
+
+  it('throw expected error when deserializing an invalid transaction', async () => {
+    expect(() => envelopeFromAnyXDR('lulz', 'base64')).toThrow(
+      'Failed decoding transaction as an envelope (TypeError: XDR Read Error: attempt to read outside the boundary of' +
+        ' the buffer) or as a signature base: (TypeError: XDR Read Error: attempt to read outside the boundary of the' +
+        ' buffer)'
+    )
+  })
+})
+
+describe('getBalance', () => {
+  it('should throw an exception when options is provided', async () => {
+    await expect(api.getBalance('random address', {} as unknown as BalanceOptions)).rejects.toThrow(
+      InvalidParameterError
+    )
+  })
+})

package/src/api/index.ts

@@ -1,4 +1,7 @@
-import { rejectBalanceOptions } from "@ledgerhq/coin-module-framework/api/getBalance/rejectBalanceOptions";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { rejectBalanceOptions } from '@ledgerhq/coin-module-framework/api/getBalance/rejectBalanceOptions'
 import {
   CoinModuleApi,
   BalanceOptions,
@@ -12,10 +15,10 @@ import {
   Stake,
   TransactionIntent,
   Validator,
-} from "@ledgerhq/coin-module-framework/api/index";
-import { craftTransactionData } from "@ledgerhq/coin-module-framework/logic/craftTransactionData";
-import { xdr } from "@stellar/stellar-sdk";
-import coinConfig, { type StellarConfig } from "../config";
+} from '@ledgerhq/coin-module-framework/api/index'
+import { craftTransactionData } from '@ledgerhq/coin-module-framework/logic/craftTransactionData'
+import { xdr } from '@stellar/stellar-sdk'
+import coinConfig, { type StellarConfig } from '../config'
 import {
   broadcast,
   combine,
@@ -26,15 +29,15 @@ import {
   getBlockInfo,
   lastBlock,
   validateIntent,
-} from "../logic";
-import { listOperations } from "../logic";
-import { validateAddress } from "../logic/validateAddress";
-import { fetchSequence, registerHorizonInterceptors } from "../network";
-import { StellarMemo } from "../types";
+} from '../logic'
+import { listOperations } from '../logic'
+import { validateAddress } from '../logic/validateAddress'
+import { fetchSequence, registerHorizonInterceptors } from '../network'
+import { StellarMemo } from '../types'
 
 export function createApi(config: StellarConfig): CoinModuleApi<StellarMemo> {
-  coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
-  registerHorizonInterceptors();
+  coinConfig.setCoinConfig(() => ({ ...config, status: { type: 'active' } }))
+  registerHorizonInterceptors()
 
   return {
     broadcast,
@@ -44,9 +47,9 @@ export function createApi(config: StellarConfig): CoinModuleApi<StellarMemo> {
       _transaction: string,
       _sender: string,
       _publicKey: string,
-      _sequence: bigint,
+      _sequence: bigint
     ): Promise<CraftedTransaction> => {
-      throw new Error("craftRawTransaction is not supported");
+      throw new Error('craftRawTransaction is not supported')
     },
     estimateFees: estimate,
     getBalance: (address: string, options?: BalanceOptions) =>
@@ -56,36 +59,36 @@ export function createApi(config: StellarConfig): CoinModuleApi<StellarMemo> {
     getBlock,
     getBlockInfo,
     getStakes(_address: string, _cursor?: Cursor): Promise<Page<Stake>> {
-      throw new Error("getStakes is not supported");
+      throw new Error('getStakes is not supported')
     },
     getRewards(_address: string, _cursor?: Cursor): Promise<Page<Reward>> {
-      throw new Error("getRewards is not supported");
+      throw new Error('getRewards is not supported')
     },
     validateIntent,
     getNextSequence: async (address: string) => {
-      const sequence = await fetchSequence(address);
-      return BigInt(sequence.plus(1).toFixed());
+      const sequence = await fetchSequence(address)
+      return BigInt(sequence.plus(1).toFixed())
     },
     getValidators(_cursor?: Cursor): Promise<Page<Validator>> {
-      throw new Error("getValidators is not supported");
+      throw new Error('getValidators is not supported')
     },
     validateAddress,
     craftTransactionData,
-  };
+  }
 }
 
 async function craft(
   transactionIntent: TransactionIntent<StellarMemo>,
-  customFees?: FeeEstimation,
+  customFees?: FeeEstimation
 ): Promise<CraftedTransaction> {
-  const fees = customFees?.value || (await estimateFees());
+  const fees = customFees?.value || (await estimateFees())
 
   // NOTE: check how many memos, throw if more than one?
   // if (transactionIntent.memos && transactionIntent.memos.length > 1) {
   //   throw new Error("Stellar only supports one memo per transaction.");
   // }
-  const memo = "memo" in transactionIntent ? transactionIntent.memo : undefined;
-  const hasMemoValue = memo && memo.type !== "NO_MEMO";
+  const memo = 'memo' in transactionIntent ? transactionIntent.memo : undefined
+  const hasMemoValue = memo && memo.type !== 'NO_MEMO'
   const tx = await craftTransaction(
     { address: transactionIntent.sender },
     {
@@ -93,7 +96,7 @@ async function craft(
       recipient: transactionIntent.recipient,
       amount: transactionIntent.amount,
       fee: fees,
-      ...(transactionIntent.asset.type !== "native" && "assetReference" in transactionIntent.asset
+      ...(transactionIntent.asset.type !== 'native' && 'assetReference' in transactionIntent.asset
         ? {
             assetCode: transactionIntent.asset.assetReference,
             assetIssuer: transactionIntent.asset.assetOwner,
@@ -101,32 +104,32 @@ async function craft(
         : {}),
       memoType: memo?.type,
       ...(hasMemoValue ? { memoValue: (memo as { value: string }).value } : {}),
-    },
-  );
+    }
+  )
 
   // Note: the API returns the signature base, not the full XDR, see BACK-8727 for more context
-  return { transaction: tx.signatureBase };
+  return { transaction: tx.signatureBase }
 }
 
 function compose(tx: string, signature: string, pubkey?: string): string {
   if (!pubkey) {
-    throw new Error("Missing pubkey");
+    throw new Error('Missing pubkey')
   }
   // note: accept here `TransactionEnvelope` or `TransactionSignaturePayload`, see BACK-8727 for more context
-  return combine(envelopeFromAnyXDR(tx, "base64"), signature, pubkey);
+  return combine(envelopeFromAnyXDR(tx, 'base64'), signature, pubkey)
 }
 
 async function estimate(_transactionIntent: TransactionIntent): Promise<FeeEstimation> {
-  const value = await estimateFees();
-  return { value };
+  const value = await estimateFees()
+  return { value }
 }
 
 async function operations(
   address: string,
-  options: ListOperationsOptions,
+  options: ListOperationsOptions
 ): Promise<Page<Operation>> {
-  const { items, next } = await listOperations(address, options);
-  return { items, next: next || undefined };
+  const { items, next } = await listOperations(address, options)
+  return { items, next: next || undefined }
 }
 
 /**
@@ -137,17 +140,17 @@ async function operations(
  */
 export function envelopeFromAnyXDR(
   input: string,
-  format: "hex" | "base64",
+  format: 'hex' | 'base64'
 ): xdr.TransactionEnvelope {
   try {
-    return xdr.TransactionEnvelope.fromXDR(input, format);
+    return xdr.TransactionEnvelope.fromXDR(input, format)
   } catch (envelopeError) {
     try {
-      return signatureBaseToEnvelope(xdr.TransactionSignaturePayload.fromXDR(input, format));
+      return signatureBaseToEnvelope(xdr.TransactionSignaturePayload.fromXDR(input, format))
     } catch (signatureBaseError) {
       throw new Error(
-        `Failed decoding transaction as an envelope (${envelopeError}) or as a signature base: (${signatureBaseError})`,
-      );
+        `Failed decoding transaction as an envelope (${envelopeError}) or as a signature base: (${signatureBaseError})`
+      )
     }
   }
 }
@@ -158,16 +161,16 @@ export function envelopeFromAnyXDR(
  * @param signatureBase deserialized `TransactionSignaturePayload`
  */
 function signatureBaseToEnvelope(
-  signatureBase: xdr.TransactionSignaturePayload,
+  signatureBase: xdr.TransactionSignaturePayload
 ): xdr.TransactionEnvelope {
-  const tx = signatureBase.taggedTransaction().value();
+  const tx = signatureBase.taggedTransaction().value()
   if (tx instanceof xdr.Transaction) {
     return xdr.TransactionEnvelope.envelopeTypeTx(
-      new xdr.TransactionV1Envelope({ tx, signatures: [] }),
-    );
+      new xdr.TransactionV1Envelope({ tx, signatures: [] })
+    )
   } else {
     return xdr.TransactionEnvelope.envelopeTypeTxFeeBump(
-      new xdr.FeeBumpTransactionEnvelope({ tx, signatures: [] }),
-    );
+      new xdr.FeeBumpTransactionEnvelope({ tx, signatures: [] })
+    )
   }
 }

package/src/api/index_error.test.ts

@@ -1,32 +1,55 @@
-import type { CoinModuleApi } from "@ledgerhq/coin-module-framework/api/index";
-import nock from "nock";
-import { LedgerAPI4xx } from "@ledgerhq/errors";
-import { StellarMemo } from "../types";
-import { createApi } from ".";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-describe("Stellar Api", () => {
-  let module: CoinModuleApi<StellarMemo>;
-  const ADDRESS = "GBAUZBDXMVV7HII4JWBGFMLVKVJ6OLQAKOCGXM5E2FM4TAZB6C7JO2L7";
+import type { CoinModuleApi } from '@ledgerhq/coin-module-framework/api/index'
+import { Horizon } from '@stellar/stellar-sdk'
+import { StellarMemo } from '../types'
+import { createApi } from '.'
 
-  beforeAll(() => {
-    nock("https://horizon-testnet.stellar.org")
-      .get(/.*/)
-      .reply(() => {
-        return [429, { error: "whatever, only status code is important" }];
-      });
+/**
+ * Minimal chainable stub of a Horizon call builder: every builder method returns
+ * the builder itself, and `call()` rejects with the configured error.
+ */
+function rejectingBuilder(error: unknown): unknown {
+  const builder: unknown = new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (prop === 'call') return () => Promise.reject(error)
+        return () => builder
+      },
+    }
+  )
+  return builder
+}
+
+describe('Stellar Api', () => {
+  let module: CoinModuleApi<StellarMemo>
+  const ADDRESS = 'GBAUZBDXMVV7HII4JWBGFMLVKVJ6OLQAKOCGXM5E2FM4TAZB6C7JO2L7'
 
+  beforeAll(() => {
     module = createApi({
       explorer: {
-        url: "https://horizon-testnet.stellar.org/",
+        url: 'https://horizon-testnet.stellar.org/',
       },
-    });
-  });
+    })
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  describe('listOperations propagates 429 errors to caller', () => {
+    it('throws LedgerAPI4xx on rate limit', async () => {
+      // Horizon surfaces a 429 as a NetworkError whose message is the "Too Many Requests"
+      // status text, which fetchOperations maps to the rate-limit-specific LedgerAPI4xx.
+      jest
+        .spyOn(Horizon.Server.prototype, 'operations')
+        .mockReturnValue(rejectingBuilder(new Error('Too Many Requests')) as never)
 
-  describe("listOperations propagates 429 errors to caller", () => {
-    it("throws LedgerAPI4xx on rate limit", async () => {
-      await expect(module.listOperations(ADDRESS, { minHeight: 0, order: "asc" })).rejects.toThrow(
-        LedgerAPI4xx,
-      );
-    });
-  });
-});
+      await expect(
+        module.listOperations(ADDRESS, { minHeight: 0, order: 'asc' })
+      ).rejects.toMatchObject({ name: 'LedgerAPI4xx', status: 429 })
+    })
+  })
+})

package/src/config.ts

@@ -1,22 +1,25 @@
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
 import buildCoinConfig, {
   type CoinConfig,
   type CurrencyConfig,
-} from "@ledgerhq/coin-module-framework/config";
+} from '@ledgerhq/coin-module-framework/config'
 
 export type StellarConfig = {
   explorer: {
-    url: string;
-    fetchLimit?: number;
-  };
-  useStaticFees?: boolean;
-  enableNetworkLogs?: boolean;
-};
+    url: string
+    fetchLimit?: number
+  }
+  useStaticFees?: boolean
+  enableNetworkLogs?: boolean
+}
 
-export type StellarCoinConfig = CurrencyConfig & StellarConfig;
+export type StellarCoinConfig = CurrencyConfig & StellarConfig
 
 const coinConfig: {
-  setCoinConfig: (config: CoinConfig<StellarCoinConfig>) => void;
-  getCoinConfig: (currencyId?: string) => StellarCoinConfig;
-} = buildCoinConfig<StellarCoinConfig>();
+  setCoinConfig: (config: CoinConfig<StellarCoinConfig>) => void
+  getCoinConfig: (currencyId?: string) => StellarCoinConfig
+} = buildCoinConfig<StellarCoinConfig>()
 
-export default coinConfig;
+export default coinConfig

package/src/constants.ts

@@ -1 +1,4 @@
-export const STELLAR_DUMMY_ADDRESS = "GDYPMQMYW2JTLPWAUAHIDY3E4VHP5SGTFC5SMA45L7ZPOTHWQ2PHEW3E";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+export const STELLAR_DUMMY_ADDRESS = 'GDYPMQMYW2JTLPWAUAHIDY3E4VHP5SGTFC5SMA45L7ZPOTHWQ2PHEW3E'

package/src/globals.d.ts

@@ -1,7 +1,9 @@
-/* eslint-disable no-var */
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-export {};
+/* eslint-disable no-var */
 
-declare global {
-  var HermesInternal: any | undefined;
-}
+// Ambient global declaration (script file, no imports/exports) so `global.HermesInternal`
+// resolves on `typeof globalThis`. Kept export-free on purpose: an `export {}` module marker
+// gets stripped by oxfmt, which would break the augmentation.
+declare var HermesInternal: any | undefined