@ledgerhq/coin-stellar 6.26.0 → 6.26.1

package/src/logic/networkWrappers.test.ts

@@ -1,42 +1,45 @@
-import { fetchBaseFee, broadcastTransaction, getLastBlock } from "../network";
-import { broadcast } from "./broadcast";
-import { estimateFees } from "./estimateFees";
-import { lastBlock } from "./lastBlock";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-jest.mock("../network", () => ({
+import { fetchBaseFee, broadcastTransaction, getLastBlock } from '../network'
+import { broadcast } from './broadcast'
+import { estimateFees } from './estimateFees'
+import { lastBlock } from './lastBlock'
+
+jest.mock('../network', () => ({
   fetchBaseFee: jest.fn(),
   broadcastTransaction: jest.fn(),
   getLastBlock: jest.fn(),
-}));
+}))
 
-describe("network wrapper helpers", () => {
+describe('network wrapper helpers', () => {
   beforeEach(() => {
-    jest.clearAllMocks();
-  });
+    jest.clearAllMocks()
+  })
 
-  it("broadcast delegates to broadcastTransaction", async () => {
-    (broadcastTransaction as jest.Mock).mockResolvedValue("tx-hash");
+  it('broadcast delegates to broadcastTransaction', async () => {
+    ;(broadcastTransaction as jest.Mock).mockResolvedValue('tx-hash')
 
-    await expect(broadcast("signed-xdr")).resolves.toBe("tx-hash");
-    expect(broadcastTransaction).toHaveBeenCalledWith("signed-xdr");
-  });
+    await expect(broadcast('signed-xdr')).resolves.toBe('tx-hash')
+    expect(broadcastTransaction).toHaveBeenCalledWith('signed-xdr')
+  })
 
-  it("estimateFees converts recommended fee to bigint", async () => {
-    (fetchBaseFee as jest.Mock).mockResolvedValue({ recommendedFee: 100, baseFee: 100 });
+  it('estimateFees converts recommended fee to bigint', async () => {
+    ;(fetchBaseFee as jest.Mock).mockResolvedValue({ recommendedFee: 100, baseFee: 100 })
 
-    await expect(estimateFees()).resolves.toBe(100n);
-    expect(fetchBaseFee).toHaveBeenCalledTimes(1);
-  });
+    await expect(estimateFees()).resolves.toBe(100n)
+    expect(fetchBaseFee).toHaveBeenCalledTimes(1)
+  })
 
-  it("lastBlock delegates to getLastBlock", async () => {
+  it('lastBlock delegates to getLastBlock', async () => {
     const block = {
       height: 123,
-      hash: "block-hash",
-      time: new Date("2026-01-01T00:00:00.000Z"),
-    };
-    (getLastBlock as jest.Mock).mockResolvedValue(block);
-
-    await expect(lastBlock()).resolves.toEqual(block);
-    expect(getLastBlock).toHaveBeenCalledTimes(1);
-  });
-});
+      hash: 'block-hash',
+      time: new Date('2026-01-01T00:00:00.000Z'),
+    }
+    ;(getLastBlock as jest.Mock).mockResolvedValue(block)
+
+    await expect(lastBlock()).resolves.toEqual(block)
+    expect(getLastBlock).toHaveBeenCalledTimes(1)
+  })
+})

package/src/logic/sdkWrapper.ts

@@ -1,32 +1,35 @@
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
 import {
   Account as StellarSdkAccount,
   Operation as StellarSdkOperation,
   TransactionBuilder,
   Networks,
   Asset,
-} from "@stellar/stellar-sdk";
-import { stellarUnit } from "./common";
+} from '@stellar/stellar-sdk'
+import { stellarUnit } from './common'
 
 export function buildTransactionBuilder(source: StellarSdkAccount, fee: bigint) {
-  const formattedFee = fee.toString();
+  const formattedFee = fee.toString()
   return new TransactionBuilder(source, {
     fee: formattedFee,
     networkPassphrase: Networks.PUBLIC,
-  });
+  })
 }
 
 export function buildChangeTrustOperation(assetCode: string, assetIssuer: string) {
   return StellarSdkOperation.changeTrust({
     asset: new Asset(assetCode, assetIssuer),
-  });
+  })
 }
 
 export function buildCreateAccountOperation(destination: string, amount: bigint) {
-  const formattedAmount = getFormattedAmount(amount);
+  const formattedAmount = getFormattedAmount(amount)
   return StellarSdkOperation.createAccount({
     destination: destination,
     startingBalance: formattedAmount,
-  });
+  })
 }
 
 export function buildPaymentOperation({
@@ -35,24 +38,24 @@ export function buildPaymentOperation({
   assetCode,
   assetIssuer,
 }: {
-  destination: string;
-  amount: bigint;
-  assetCode: string | undefined;
-  assetIssuer: string | undefined;
+  destination: string
+  amount: bigint
+  assetCode: string | undefined
+  assetIssuer: string | undefined
 }) {
-  const formattedAmount = getFormattedAmount(amount);
+  const formattedAmount = getFormattedAmount(amount)
   // Non-native assets should always have asset code and asset issuer. If an
   // asset doesn't have both, we assume it is native asset.
-  const asset = assetCode && assetIssuer ? new Asset(assetCode, assetIssuer) : Asset.native();
+  const asset = assetCode && assetIssuer ? new Asset(assetCode, assetIssuer) : Asset.native()
   return StellarSdkOperation.payment({
     destination: destination,
     amount: formattedAmount,
     asset,
-  });
+  })
 }
 
 function getFormattedAmount(amount: bigint) {
-  const div = 10 ** stellarUnit.magnitude;
+  const div = 10 ** stellarUnit.magnitude
   // BigInt division is always an integer, never a float. We need to convert first to a Number.
-  return (Number(amount) / div).toString();
+  return (Number(amount) / div).toString()
 }

package/src/logic/utils.ts

@@ -1,11 +1,14 @@
-import { StrKey } from "@stellar/stellar-sdk";
-import { fetchSigners } from "../network";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-export const STELLAR_BURN_ADDRESS = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
+import { StrKey } from '@stellar/stellar-sdk'
+import { fetchSigners } from '../network'
+
+export const STELLAR_BURN_ADDRESS = 'GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF'
 
 export async function isAccountMultiSign(account: string): Promise<boolean> {
-  const signers = await fetchSigners(account);
-  return signers.length > 1;
+  const signers = await fetchSigners(account)
+  return signers.length > 1
 }
 
 /**
@@ -14,19 +17,19 @@ export async function isAccountMultiSign(account: string): Promise<boolean> {
  * @param {*} address
  */
 export function isAddressValid(address: string): boolean {
-  if (!address) return false;
+  if (!address) return false
 
   // FIXME Workaround for burn address, see https://ledgerhq.atlassian.net/browse/LIVE-4014
-  if (address === STELLAR_BURN_ADDRESS) return false;
+  if (address === STELLAR_BURN_ADDRESS) return false
 
   try {
-    return StrKey.isValidEd25519PublicKey(address) || StrKey.isValidMed25519PublicKey(address);
+    return StrKey.isValidEd25519PublicKey(address) || StrKey.isValidMed25519PublicKey(address)
   } catch {
-    return false;
+    return false
   }
 }
 
 /** Compile-time exhaustiveness helper: call when a value should be `never`. */
 export function assertUnreachable(_: never): never {
-  throw new Error("unreachable assertion failed");
+  throw new Error('unreachable assertion failed')
 }

package/src/logic/validateAddress.test.ts

@@ -1,27 +1,30 @@
-import { isAddressValid } from "./utils";
-import { validateAddress } from "./validateAddress";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-jest.mock("./utils");
+import { isAddressValid } from './utils'
+import { validateAddress } from './validateAddress'
 
-describe("validateAddress", () => {
-  const mockedIsAddressValid = jest.mocked(isAddressValid);
+jest.mock('./utils')
+
+describe('validateAddress', () => {
+  const mockedIsAddressValid = jest.mocked(isAddressValid)
 
   beforeEach(() => {
-    mockedIsAddressValid.mockClear();
-  });
+    mockedIsAddressValid.mockClear()
+  })
 
   it.each([true, false])(
-    "should call isAddressValid and return expected value (%s)",
+    'should call isAddressValid and return expected value (%s)',
     async (expectedValue: boolean) => {
-      mockedIsAddressValid.mockReturnValueOnce(expectedValue);
+      mockedIsAddressValid.mockReturnValueOnce(expectedValue)
 
-      const address = "some random address";
-      const parameters = {};
-      const result = await validateAddress(address, parameters);
-      expect(result).toEqual(expectedValue);
+      const address = 'some random address'
+      const parameters = {}
+      const result = await validateAddress(address, parameters)
+      expect(result).toEqual(expectedValue)
 
-      expect(mockedIsAddressValid).toHaveBeenCalledTimes(1);
-      expect(mockedIsAddressValid).toHaveBeenCalledWith(address);
-    },
-  );
-});
+      expect(mockedIsAddressValid).toHaveBeenCalledTimes(1)
+      expect(mockedIsAddressValid).toHaveBeenCalledWith(address)
+    }
+  )
+})

package/src/logic/validateAddress.ts

@@ -1,9 +1,12 @@
-import type { AddressValidationCurrencyParameters } from "@ledgerhq/coin-module-framework/api/types";
-import { isAddressValid } from "./utils";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AddressValidationCurrencyParameters } from '@ledgerhq/coin-module-framework/api/types'
+import { isAddressValid } from './utils'
 
 export async function validateAddress(
   address: string,
-  _parameters: Partial<AddressValidationCurrencyParameters>,
+  _parameters: Partial<AddressValidationCurrencyParameters>
 ): Promise<boolean> {
-  return isAddressValid(address);
+  return isAddressValid(address)
 }

package/src/logic/validateIntent.test.ts

@@ -1,86 +1,89 @@
-import { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-module-framework/api/types";
-import BigNumber from "bignumber.js";
-import * as network from "../network";
-import * as horizon from "../network/horizon";
-import { NetworkInfo, StellarMemo, StellarMemoKind, StellarWrongMemoFormat } from "../types";
-import * as utils from "./utils";
-import { validateIntent } from "./validateIntent";
-import * as logicValidateMemo from "./validateMemo";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-jest.mock("../network/horizon");
-jest.mock("./validateMemo");
-jest.mock("./utils");
+import { FeeEstimation, TransactionIntent } from '@ledgerhq/coin-module-framework/api/types'
+import BigNumber from 'bignumber.js'
+import * as network from '../network'
+import * as horizon from '../network/horizon'
+import { NetworkInfo, StellarMemo, StellarMemoKind, StellarWrongMemoFormat } from '../types'
+import * as utils from './utils'
+import { validateIntent } from './validateIntent'
+import * as logicValidateMemo from './validateMemo'
 
-describe("validateIntent", () => {
-  const spiedValidateMemo = logicValidateMemo.validateMemo as jest.Mock;
-  const spiedFetchAccount = jest.spyOn(horizon, "fetchAccount");
-  const spiedFetchAccountNetworkInfo = jest.spyOn(network, "fetchAccountNetworkInfo");
-  const spiedIsAccountMultiSign = jest.spyOn(utils, "isAccountMultiSign");
+jest.mock('../network/horizon')
+jest.mock('./validateMemo')
+jest.mock('./utils')
+
+describe('validateIntent', () => {
+  const spiedValidateMemo = logicValidateMemo.validateMemo as jest.Mock
+  const spiedFetchAccount = jest.spyOn(horizon, 'fetchAccount')
+  const spiedFetchAccountNetworkInfo = jest.spyOn(network, 'fetchAccountNetworkInfo')
+  const spiedIsAccountMultiSign = jest.spyOn(utils, 'isAccountMultiSign')
 
   beforeEach(() => {
-    spiedValidateMemo.mockClear();
-    spiedFetchAccount.mockClear();
-    spiedFetchAccountNetworkInfo.mockClear();
-    spiedIsAccountMultiSign.mockClear();
+    spiedValidateMemo.mockClear()
+    spiedFetchAccount.mockClear()
+    spiedFetchAccountNetworkInfo.mockClear()
+    spiedIsAccountMultiSign.mockClear()
 
     spiedFetchAccount.mockResolvedValue({
       spendableBalance: BigNumber(0),
       balance: BigNumber(0),
       blockHeight: 0,
       assets: [],
-    });
+    })
     spiedFetchAccountNetworkInfo.mockResolvedValue({
       baseFee: BigNumber(0),
       fees: BigNumber(0),
-    } as NetworkInfo);
-    spiedIsAccountMultiSign.mockResolvedValue(false);
-  });
+    } as NetworkInfo)
+    spiedIsAccountMultiSign.mockResolvedValue(false)
+  })
 
-  it.each(["MEMO_TEXT", "MEMO_ID", "MEMO_HASH", "MEMO_RETURN"])(
-    "should not set error on transaction when memo is validated for type %s",
+  it.each(['MEMO_TEXT', 'MEMO_ID', 'MEMO_HASH', 'MEMO_RETURN'])(
+    'should not set error on transaction when memo is validated for type %s',
     async (type: string) => {
-      spiedValidateMemo.mockReturnValue(true);
+      spiedValidateMemo.mockReturnValue(true)
 
       const intent = {
-        asset: { type: "native" },
-        memo: { type, value: "random memo for unit test" },
-      } as TransactionIntent<{ type: Exclude<StellarMemoKind, "NO_MEMO">; value: string }>;
-      const fees = {} as FeeEstimation;
-      const status = await validateIntent(intent, [], fees);
-      expect(status.errors.transaction).not.toBeDefined();
+        asset: { type: 'native' },
+        memo: { type, value: 'random memo for unit test' },
+      } as TransactionIntent<{ type: Exclude<StellarMemoKind, 'NO_MEMO'>; value: string }>
+      const fees = {} as FeeEstimation
+      const status = await validateIntent(intent, [], fees)
+      expect(status.errors.transaction).not.toBeDefined()
 
-      expect(spiedValidateMemo).toHaveBeenCalledWith(intent.memo.value, intent.memo.type);
-    },
-  );
+      expect(spiedValidateMemo).toHaveBeenCalledWith(intent.memo.value, intent.memo.type)
+    }
+  )
 
-  it.each(["MEMO_TEXT", "MEMO_ID", "MEMO_HASH", "MEMO_RETURN"])(
-    "should set error on transaction when memo is invalidated for type %s",
+  it.each(['MEMO_TEXT', 'MEMO_ID', 'MEMO_HASH', 'MEMO_RETURN'])(
+    'should set error on transaction when memo is invalidated for type %s',
     async (type: string) => {
-      spiedValidateMemo.mockReturnValue(false);
+      spiedValidateMemo.mockReturnValue(false)
 
       const intent = {
-        asset: { type: "native" },
-        memo: { type, value: "random memo for unit test" },
-      } as TransactionIntent<{ type: Exclude<StellarMemoKind, "NO_MEMO">; value: string }>;
-      const fees = {} as FeeEstimation;
-      const status = await validateIntent(intent, [], fees);
-      expect(status.errors.transaction).toBeInstanceOf(StellarWrongMemoFormat);
+        asset: { type: 'native' },
+        memo: { type, value: 'random memo for unit test' },
+      } as TransactionIntent<{ type: Exclude<StellarMemoKind, 'NO_MEMO'>; value: string }>
+      const fees = {} as FeeEstimation
+      const status = await validateIntent(intent, [], fees)
+      expect(status.errors.transaction).toBeInstanceOf(StellarWrongMemoFormat)
 
-      expect(spiedValidateMemo).toHaveBeenCalledWith(intent.memo.value, intent.memo.type);
-    },
-  );
+      expect(spiedValidateMemo).toHaveBeenCalledWith(intent.memo.value, intent.memo.type)
+    }
+  )
 
-  it("should not validate memo when type is NO_MEMO", async () => {
-    spiedValidateMemo.mockReturnValue(true);
+  it('should not validate memo when type is NO_MEMO', async () => {
+    spiedValidateMemo.mockReturnValue(true)
 
     const intent = {
-      asset: { type: "native" },
-      memo: { type: "NO_MEMO" },
-    } as TransactionIntent<StellarMemo>;
-    const fees = {} as FeeEstimation;
-    const status = await validateIntent(intent, [], fees);
-    expect(status.errors.transaction).not.toBeDefined();
+      asset: { type: 'native' },
+      memo: { type: 'NO_MEMO' },
+    } as TransactionIntent<StellarMemo>
+    const fees = {} as FeeEstimation
+    const status = await validateIntent(intent, [], fees)
+    expect(status.errors.transaction).not.toBeDefined()
 
-    expect(spiedValidateMemo).not.toHaveBeenCalled();
-  });
-});
+    expect(spiedValidateMemo).not.toHaveBeenCalled()
+  })
+})