@ledgerhq/coin-stellar 6.26.0 → 6.26.1

package/src/logic/broadcast.integ.test.ts

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
 import {
   Keypair,
   TransactionBuilder,
@@ -6,24 +9,24 @@ import {
   BASE_FEE,
   Asset,
   Account,
-} from "@stellar/stellar-sdk";
-import { broadcast } from "./broadcast";
-import coinConfig from "../config";
-import { StellarBroadcastFailedError } from "../types";
+} from '@stellar/stellar-sdk'
+import coinConfig from '../config'
+import { StellarBroadcastFailedError } from '../types'
+import { broadcast } from './broadcast'
 
-describe("Broadcast", () => {
+describe('Broadcast', () => {
   beforeAll(() => {
     coinConfig.setCoinConfig(() => ({
-      status: { type: "active" },
+      status: { type: 'active' },
       explorer: {
-        url: "https://stellar.coin.ledger.com",
+        url: 'https://stellar.coin.ledger.com',
       },
-    }));
-  });
+    }))
+  })
 
-  it("throws on insufficient funds", async () => {
-    const source = Keypair.random();
-    const account = new Account(source.publicKey(), "0");
+  it('throws on insufficient funds', async () => {
+    const source = Keypair.random()
+    const account = new Account(source.publicKey(), '0')
 
     const tx = new TransactionBuilder(account, {
       fee: BASE_FEE,
@@ -33,13 +36,13 @@ describe("Broadcast", () => {
         Operation.payment({
           destination: source.publicKey(),
           asset: Asset.native(),
-          amount: "1",
-        }),
+          amount: '1',
+        })
       )
       .setTimeout(0)
-      .build();
-    tx.sign(source);
+      .build()
+    tx.sign(source)
 
-    await expect(broadcast(tx.toXDR())).rejects.toThrow(StellarBroadcastFailedError);
-  });
-});
+    await expect(broadcast(tx.toXDR())).rejects.toThrow(StellarBroadcastFailedError)
+  })
+})

package/src/logic/broadcast.ts

@@ -1,5 +1,8 @@
-import { broadcastTransaction } from "../network";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { broadcastTransaction } from '../network'
 
 export async function broadcast(signature: string): Promise<string> {
-  return broadcastTransaction(signature);
+  return broadcastTransaction(signature)
 }

package/src/logic/combine.test.ts

@@ -1,24 +1,27 @@
-import { Networks, Transaction as StellarSdkTransaction } from "@stellar/stellar-sdk";
-import { combine } from "./combine";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-jest.mock("@stellar/stellar-sdk", () => ({
+import { Networks, Transaction as StellarSdkTransaction } from '@stellar/stellar-sdk'
+import { combine } from './combine'
+
+jest.mock('@stellar/stellar-sdk', () => ({
   Networks: {
-    PUBLIC: "PUBLIC",
+    PUBLIC: 'PUBLIC',
   },
   Transaction: jest.fn().mockImplementation(() => ({
     addSignature: jest.fn(),
-    toXDR: jest.fn().mockReturnValue("signed-xdr"),
+    toXDR: jest.fn().mockReturnValue('signed-xdr'),
   })),
-}));
+}))
 
-describe("combine", () => {
-  it("creates a transaction, adds signature and returns xdr", () => {
-    const result = combine("unsigned-xdr", "signature", "public-key");
+describe('combine', () => {
+  it('creates a transaction, adds signature and returns xdr', () => {
+    const result = combine('unsigned-xdr', 'signature', 'public-key')
 
-    expect(StellarSdkTransaction).toHaveBeenCalledWith("unsigned-xdr", Networks.PUBLIC);
+    expect(StellarSdkTransaction).toHaveBeenCalledWith('unsigned-xdr', Networks.PUBLIC)
 
-    const txInstance = (StellarSdkTransaction as unknown as jest.Mock).mock.results[0].value;
-    expect(txInstance.addSignature).toHaveBeenCalledWith("public-key", "signature");
-    expect(result).toBe("signed-xdr");
-  });
-});
+    const txInstance = (StellarSdkTransaction as unknown as jest.Mock).mock.results[0].value
+    expect(txInstance.addSignature).toHaveBeenCalledWith('public-key', 'signature')
+    expect(result).toBe('signed-xdr')
+  })
+})

package/src/logic/combine.ts

@@ -1,11 +1,14 @@
-import { Networks, Transaction as StellarSdkTransaction, xdr } from "@stellar/stellar-sdk";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { Networks, Transaction as StellarSdkTransaction, xdr } from '@stellar/stellar-sdk'
 
 export function combine(
   transaction: string | xdr.TransactionEnvelope,
   signature: string,
-  publicKey: string,
+  publicKey: string
 ): string {
-  const unsignedTx = new StellarSdkTransaction(transaction, Networks.PUBLIC);
-  unsignedTx.addSignature(publicKey, signature);
-  return unsignedTx.toXDR();
+  const unsignedTx = new StellarSdkTransaction(transaction, Networks.PUBLIC)
+  unsignedTx.addSignature(publicKey, signature)
+  return unsignedTx.toXDR()
 }

package/src/logic/common.ts

@@ -1,9 +1,12 @@
-import { parseCurrencyUnit } from "@ledgerhq/coin-module-framework/currencies";
-import BigNumber from "bignumber.js";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { parseCurrencyUnit } from '@ledgerhq/coin-module-framework/currencies'
+import BigNumber from 'bignumber.js'
 
 export const stellarUnit = {
-  name: "Lumen",
-  code: "XLM",
+  name: 'Lumen',
+  code: 'XLM',
   magnitude: 7,
-};
-export const parseAPIValue = (value: string): BigNumber => parseCurrencyUnit(stellarUnit, value);
+}
+export const parseAPIValue = (value: string): BigNumber => parseCurrencyUnit(stellarUnit, value)

package/src/logic/craftTransaction.test.ts

@@ -1,145 +1,146 @@
-import { NetworkDown } from "@ledgerhq/errors";
-import { Horizon, Memo } from "@stellar/stellar-sdk";
-import { getRecipientAccount, loadAccount } from "../network";
-import { StellarAssetRequired, StellarMuxedAccountNotExist } from "../types";
-import { craftTransaction } from "./craftTransaction";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { NetworkDown } from '@ledgerhq/errors'
+import { Horizon, Memo } from '@stellar/stellar-sdk'
+import { getRecipientAccount, loadAccount } from '../network'
+import { StellarAssetRequired, StellarMuxedAccountNotExist } from '../types'
+import { craftTransaction } from './craftTransaction'
 import {
   buildChangeTrustOperation,
   buildCreateAccountOperation,
   buildPaymentOperation,
   buildTransactionBuilder,
-} from "./sdkWrapper";
+} from './sdkWrapper'
 
-jest.mock("../network", () => ({
+jest.mock('../network', () => ({
   loadAccount: jest.fn(),
   getRecipientAccount: jest.fn(),
-}));
+}))
 
-jest.mock("./sdkWrapper", () => ({
+jest.mock('./sdkWrapper', () => ({
   buildChangeTrustOperation: jest.fn(),
   buildCreateAccountOperation: jest.fn(),
   buildPaymentOperation: jest.fn(),
   buildTransactionBuilder: jest.fn(),
-}));
+}))
 
-describe("craftTransaction", () => {
-  const account = { address: "GABC" };
+describe('craftTransaction', () => {
+  const account = { address: 'GABC' }
   const transaction = {
-    type: "payment",
-    recipient: "GRECIPIENT",
+    type: 'payment',
+    recipient: 'GRECIPIENT',
     amount: 10000000n,
     fee: 100n,
-  };
+  }
 
   const craftedTransaction = {
-    toXDR: jest.fn().mockReturnValue("tx-xdr"),
-    signatureBase: jest.fn().mockReturnValue(Buffer.from("signature-base")),
-  };
+    toXDR: jest.fn().mockReturnValue('tx-xdr'),
+    signatureBase: jest.fn().mockReturnValue(Buffer.from('signature-base')),
+  }
 
   const txBuilder = {
     addOperation: jest.fn(),
     addMemo: jest.fn(),
     setTimeout: jest.fn(),
     build: jest.fn().mockReturnValue(craftedTransaction),
-  };
+  }
 
   beforeEach(() => {
-    jest.clearAllMocks();
-    txBuilder.setTimeout.mockReturnValue(txBuilder);
+    jest.clearAllMocks()
+    txBuilder.setTimeout.mockReturnValue(txBuilder)
     jest
       .mocked(buildTransactionBuilder)
-      .mockReturnValue(txBuilder as unknown as ReturnType<typeof buildTransactionBuilder>);
-    jest.mocked(loadAccount).mockResolvedValue({ id: "source-account" } as Horizon.AccountResponse);
+      .mockReturnValue(txBuilder as unknown as ReturnType<typeof buildTransactionBuilder>)
+    jest.mocked(loadAccount).mockResolvedValue({ id: 'source-account' } as Horizon.AccountResponse)
     jest.mocked(getRecipientAccount).mockResolvedValue({
-      id: "GRECIPIENT",
+      id: 'GRECIPIENT',
       isMuxedAccount: false,
       assetIds: [],
-    });
+    })
     jest
       .mocked(buildPaymentOperation)
-      .mockReturnValue("payment-op" as unknown as ReturnType<typeof buildPaymentOperation>);
+      .mockReturnValue('payment-op' as unknown as ReturnType<typeof buildPaymentOperation>)
     jest
       .mocked(buildCreateAccountOperation)
       .mockReturnValue(
-        "create-account-op" as unknown as ReturnType<typeof buildCreateAccountOperation>,
-      );
+        'create-account-op' as unknown as ReturnType<typeof buildCreateAccountOperation>
+      )
     jest
       .mocked(buildChangeTrustOperation)
-      .mockReturnValue(
-        "change-trust-op" as unknown as ReturnType<typeof buildChangeTrustOperation>,
-      );
-  });
+      .mockReturnValue('change-trust-op' as unknown as ReturnType<typeof buildChangeTrustOperation>)
+  })
 
-  it("throws NetworkDown when source account cannot be loaded", async () => {
-    jest.mocked(loadAccount).mockResolvedValue(null);
+  it('throws NetworkDown when source account cannot be loaded', async () => {
+    jest.mocked(loadAccount).mockResolvedValue(null)
 
-    await expect(craftTransaction(account, transaction)).rejects.toThrow(NetworkDown);
-  });
+    await expect(craftTransaction(account, transaction)).rejects.toThrow(NetworkDown)
+  })
 
-  it("throws StellarAssetRequired for changeTrust without asset code and issuer", async () => {
+  it('throws StellarAssetRequired for changeTrust without asset code and issuer', async () => {
     await expect(
       craftTransaction(account, {
         ...transaction,
-        type: "changeTrust",
+        type: 'changeTrust',
         assetCode: undefined,
         assetIssuer: undefined,
-      }),
-    ).rejects.toThrow(StellarAssetRequired);
-  });
+      })
+    ).rejects.toThrow(StellarAssetRequired)
+  })
 
-  it("builds a changeTrust operation when type is changeTrust", async () => {
+  it('builds a changeTrust operation when type is changeTrust', async () => {
     const result = await craftTransaction(account, {
       ...transaction,
-      type: "changeTrust",
-      assetCode: "USDC",
-      assetIssuer: "GISSUER",
-    });
+      type: 'changeTrust',
+      assetCode: 'USDC',
+      assetIssuer: 'GISSUER',
+    })
 
-    expect(buildChangeTrustOperation).toHaveBeenCalledWith("USDC", "GISSUER");
-    expect(txBuilder.addOperation).toHaveBeenCalledWith("change-trust-op");
-    expect(getRecipientAccount).not.toHaveBeenCalled();
-    expect(result.xdr).toBe("tx-xdr");
-    expect(result.signatureBase).toBe("c2lnbmF0dXJlLWJhc2U=");
-  });
+    expect(buildChangeTrustOperation).toHaveBeenCalledWith('USDC', 'GISSUER')
+    expect(txBuilder.addOperation).toHaveBeenCalledWith('change-trust-op')
+    expect(getRecipientAccount).not.toHaveBeenCalled()
+    expect(result.xdr).toBe('tx-xdr')
+    expect(result.signatureBase).toBe('c2lnbmF0dXJlLWJhc2U=')
+  })
 
-  it("builds a payment operation and memo when recipient exists", async () => {
-    const memoTextSpy = jest.spyOn(Memo, "text");
+  it('builds a payment operation and memo when recipient exists', async () => {
+    const memoTextSpy = jest.spyOn(Memo, 'text')
 
     await craftTransaction(account, {
       ...transaction,
-      memoType: "MEMO_TEXT",
-      memoValue: "hello",
-    });
+      memoType: 'MEMO_TEXT',
+      memoValue: 'hello',
+    })
 
     expect(buildPaymentOperation).toHaveBeenCalledWith({
-      destination: "GRECIPIENT",
+      destination: 'GRECIPIENT',
       amount: 10000000n,
       assetCode: undefined,
       assetIssuer: undefined,
-    });
-    expect(txBuilder.addOperation).toHaveBeenCalledWith("payment-op");
-    expect(memoTextSpy).toHaveBeenCalledWith("hello");
-    expect(txBuilder.addMemo).toHaveBeenCalledTimes(1);
-  });
+    })
+    expect(txBuilder.addOperation).toHaveBeenCalledWith('payment-op')
+    expect(memoTextSpy).toHaveBeenCalledWith('hello')
+    expect(txBuilder.addMemo).toHaveBeenCalledTimes(1)
+  })
 
-  it("throws StellarMuxedAccountNotExist when missing muxed recipient account", async () => {
+  it('throws StellarMuxedAccountNotExist when missing muxed recipient account', async () => {
     jest
       .mocked(getRecipientAccount)
-      .mockResolvedValue({ id: null, isMuxedAccount: true, assetIds: [] });
+      .mockResolvedValue({ id: null, isMuxedAccount: true, assetIds: [] })
 
     await expect(craftTransaction(account, transaction)).rejects.toThrow(
-      StellarMuxedAccountNotExist,
-    );
-  });
+      StellarMuxedAccountNotExist
+    )
+  })
 
-  it("builds createAccount operation when recipient does not exist and is not muxed", async () => {
+  it('builds createAccount operation when recipient does not exist and is not muxed', async () => {
     jest
       .mocked(getRecipientAccount)
-      .mockResolvedValue({ id: null, isMuxedAccount: false, assetIds: [] });
+      .mockResolvedValue({ id: null, isMuxedAccount: false, assetIds: [] })
 
-    await craftTransaction(account, transaction);
+    await craftTransaction(account, transaction)
 
-    expect(buildCreateAccountOperation).toHaveBeenCalledWith("GRECIPIENT", 10000000n);
-    expect(txBuilder.addOperation).toHaveBeenCalledWith("create-account-op");
-  });
-});
+    expect(buildCreateAccountOperation).toHaveBeenCalledWith('GRECIPIENT', 10000000n)
+    expect(txBuilder.addOperation).toHaveBeenCalledWith('create-account-op')
+  })
+})

package/src/logic/craftTransaction.ts

@@ -1,55 +1,58 @@
-import { NetworkDown } from "@ledgerhq/errors";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { NetworkDown } from '@ledgerhq/errors'
 import {
   Memo,
   Operation as StellarSdkOperation,
   Transaction as StellarSdkTransaction,
   xdr,
-} from "@stellar/stellar-sdk";
-import { getRecipientAccount, loadAccount } from "../network";
-import { StellarAssetRequired, StellarMuxedAccountNotExist } from "../types";
+} from '@stellar/stellar-sdk'
+import { getRecipientAccount, loadAccount } from '../network'
+import { StellarAssetRequired, StellarMuxedAccountNotExist } from '../types'
 import {
   buildChangeTrustOperation,
   buildCreateAccountOperation,
   buildPaymentOperation,
   buildTransactionBuilder,
-} from "./sdkWrapper";
+} from './sdkWrapper'
 
 export async function craftTransaction(
   account: {
-    address: string;
+    address: string
   },
   transaction: {
-    type: string;
-    recipient: string;
-    amount: bigint;
-    fee: bigint;
-    assetCode?: string | undefined;
-    assetIssuer?: string | undefined;
-    memoType?: string | null | undefined;
-    memoValue?: string | null | undefined;
-  },
+    type: string
+    recipient: string
+    amount: bigint
+    fee: bigint
+    assetCode?: string | undefined
+    assetIssuer?: string | undefined
+    memoType?: string | null | undefined
+    memoValue?: string | null | undefined
+  }
 ): Promise<{ transaction: StellarSdkTransaction; xdr: string; signatureBase: string }> {
-  const { amount, recipient, fee, memoType, memoValue, type, assetCode, assetIssuer } = transaction;
-  const source = await loadAccount(account.address);
+  const { amount, recipient, fee, memoType, memoValue, type, assetCode, assetIssuer } = transaction
+  const source = await loadAccount(account.address)
 
   if (!source) {
-    throw new NetworkDown();
+    throw new NetworkDown()
   }
 
-  const transactionBuilder = buildTransactionBuilder(source, fee);
-  let operation: xdr.Operation<StellarSdkOperation.ChangeTrust> | null = null;
+  const transactionBuilder = buildTransactionBuilder(source, fee)
+  let operation: xdr.Operation<StellarSdkOperation.ChangeTrust> | null = null
 
-  if (type === "changeTrust") {
+  if (type === 'changeTrust') {
     if (!assetCode || !assetIssuer) {
-      throw new StellarAssetRequired("");
+      throw new StellarAssetRequired('')
     }
 
-    operation = buildChangeTrustOperation(assetCode, assetIssuer);
+    operation = buildChangeTrustOperation(assetCode, assetIssuer)
   } else {
     // Payment
     const recipientAccount = await getRecipientAccount({
       recipient,
-    });
+    })
 
     if (recipientAccount?.id) {
       operation = buildPaymentOperation({
@@ -57,46 +60,46 @@ export async function craftTransaction(
         amount,
         assetCode,
         assetIssuer,
-      });
+      })
     } else {
       if (recipientAccount?.isMuxedAccount) {
-        throw new StellarMuxedAccountNotExist("");
+        throw new StellarMuxedAccountNotExist('')
       }
 
-      operation = buildCreateAccountOperation(recipient, amount);
+      operation = buildCreateAccountOperation(recipient, amount)
     }
   }
 
-  transactionBuilder.addOperation(operation);
+  transactionBuilder.addOperation(operation)
 
-  const memo = buildMemo(memoType, memoValue);
+  const memo = buildMemo(memoType, memoValue)
   if (memo) {
-    transactionBuilder.addMemo(memo);
+    transactionBuilder.addMemo(memo)
   }
 
-  const craftedTransaction = transactionBuilder.setTimeout(0).build();
+  const craftedTransaction = transactionBuilder.setTimeout(0).build()
   return {
     transaction: craftedTransaction,
     xdr: craftedTransaction.toXDR(),
-    signatureBase: craftedTransaction.signatureBase().toString("base64"),
-  };
+    signatureBase: craftedTransaction.signatureBase().toString('base64'),
+  }
 }
 
 function buildMemo(
   memoType?: string | null | undefined,
-  memoValue?: string | null | undefined,
+  memoValue?: string | null | undefined
 ): Memo | null {
   if (memoType && memoValue) {
     switch (memoType) {
-      case "MEMO_TEXT":
-        return Memo.text(memoValue);
-      case "MEMO_ID":
-        return Memo.id(memoValue);
-      case "MEMO_HASH":
-        return Memo.hash(memoValue);
-      case "MEMO_RETURN":
-        return Memo.return(memoValue);
+      case 'MEMO_TEXT':
+        return Memo.text(memoValue)
+      case 'MEMO_ID':
+        return Memo.id(memoValue)
+      case 'MEMO_HASH':
+        return Memo.hash(memoValue)
+      case 'MEMO_RETURN':
+        return Memo.return(memoValue)
     }
   }
-  return null;
+  return null
 }

package/src/logic/estimateFees.ts

@@ -1,10 +1,13 @@
-import { fetchBaseFee } from "../network";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { fetchBaseFee } from '../network'
 
 /**
  * Estimate the fees for one transaction
  * @see {@link https://developers.stellar.org/docs/learn/fundamentals/fees-resource-limits-metering#inclusion-fee}
  */
 export async function estimateFees(): Promise<bigint> {
-  const baseFee = await fetchBaseFee();
-  return BigInt(baseFee.recommendedFee);
+  const baseFee = await fetchBaseFee()
+  return BigInt(baseFee.recommendedFee)
 }

package/src/logic/getBalance.test.ts

@@ -1,61 +1,64 @@
-import { fetchAccount } from "../network";
-import { getBalance } from "./getBalance";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-jest.mock("../network", () => ({
+import { fetchAccount } from '../network'
+import { getBalance } from './getBalance'
+
+jest.mock('../network', () => ({
   fetchAccount: jest.fn(),
-}));
+}))
 
-describe("getBalance", () => {
-  it("returns native balance when no assets are present", async () => {
-    (fetchAccount as jest.Mock).mockResolvedValue({
+describe('getBalance', () => {
+  it('returns native balance when no assets are present', async () => {
+    ;(fetchAccount as jest.Mock).mockResolvedValue({
       balance: 100000000,
       spendableBalance: 99999990,
       assets: [],
-    });
+    })
 
-    const result = await getBalance("test-address");
+    const result = await getBalance('test-address')
 
     expect(result).toEqual([
       {
         value: BigInt(100000000),
-        asset: { type: "native" },
+        asset: { type: 'native' },
         locked: BigInt(10),
       },
-    ]);
-  });
+    ])
+  })
 
-  it("returns native and asset balances when assets are present", async () => {
-    (fetchAccount as jest.Mock).mockResolvedValue({
+  it('returns native and asset balances when assets are present', async () => {
+    ;(fetchAccount as jest.Mock).mockResolvedValue({
       balance: 100000000,
       spendableBalance: 99999990,
       assets: [
         {
-          asset_type: "credit_alphanum4",
-          asset_code: "USDC",
-          asset_issuer: "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN",
-          balance: "50.1234567",
+          asset_type: 'credit_alphanum4',
+          asset_code: 'USDC',
+          asset_issuer: 'GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN',
+          balance: '50.1234567',
         },
       ],
-    });
+    })
 
-    const result = await getBalance("test-address");
+    const result = await getBalance('test-address')
 
     expect(result).toEqual([
       {
         value: BigInt(100000000),
-        asset: { type: "native" },
+        asset: { type: 'native' },
         locked: BigInt(10),
       },
       {
         value: BigInt(501234567),
         asset: {
-          type: "credit_alphanum4",
-          assetReference: "USDC",
-          assetOwner: "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN",
+          type: 'credit_alphanum4',
+          assetReference: 'USDC',
+          assetOwner: 'GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN',
         },
       },
-    ]);
+    ])
 
-    expect(fetchAccount).toHaveBeenCalledWith("test-address");
-  });
-});
+    expect(fetchAccount).toHaveBeenCalledWith('test-address')
+  })
+})