@ledgerhq/live-common 34.45.0-nightly.2 → 34.45.0

package/src/bridge/generic-alpaca/signOperation.ts

@@ -12,69 +12,12 @@ import { buildOptimisticOperation, transactionToIntent } from "./utils";
 import { FeeNotLoaded } from "@ledgerhq/errors";
 import { Result } from "@ledgerhq/coin-framework/derivation";
 import { MapMemo, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
-import { StellarMemo } from "@ledgerhq/coin-stellar/types/bridge";
-import BigNumber from "bignumber.js";
 
-/**
- * Applies memo information to transaction intent
- * Handles both destination tags (XRP-like) and Stellar-style memos
- */
-function applyMemoToIntent(
-  transactionIntent: TransactionIntent<any>,
-  transaction: TransactionCommon,
-): TransactionIntent<any> {
-  // Handle destination tag memo (for XRP-like chains)
-  if (transaction["tag"]) {
-    const txWithMemoTag = transactionIntent as TransactionIntent<MapMemo<string, string>>;
-    const txMemo = String(transaction["tag"]);
-
-    txWithMemoTag.memo = {
-      type: "map",
-      memos: new Map(),
-    };
-    txWithMemoTag.memo.memos.set("destinationTag", txMemo);
-
-    return txWithMemoTag;
-  }
-
-  // Handle Stellar-style memo
-  if (transaction["memoType"] && transaction["memoValue"]) {
-    const txWithMemo = transactionIntent as TransactionIntent<StellarMemo>;
-    const txMemoType = String(transaction["memoType"]);
-    const txMemoValue = String(transaction["memoValue"]);
-
-    txWithMemo.memo = {
-      type: txMemoType as "NO_MEMO" | "MEMO_TEXT" | "MEMO_ID" | "MEMO_HASH" | "MEMO_RETURN",
-      value: txMemoValue,
-    };
-
-    return txWithMemo;
-  }
-
-  return transactionIntent;
-}
-
-/**
- * Enriches transaction intent with memo and asset information
- */
-function enrichTransactionIntent(
-  transactionIntent: TransactionIntent<any>,
-  transaction: TransactionCommon,
-  publicKey: string,
-): TransactionIntent<any> {
-  // Set sender public key
-  transactionIntent.senderPublicKey = publicKey;
-
-  // Apply memo information
-  transactionIntent = applyMemoToIntent(transactionIntent, transaction);
-
-  return transactionIntent;
-}
 /**
  * Sign Transaction with Ledger hardware
  */
 export const genericSignOperation =
-  (network, kind) =>
+  (network: string, kind: "local" | "remote") =>
   (signerContext: SignerContext<any>): AccountBridge<TransactionCommon>["signOperation"] =>
   ({
     account,
@@ -87,40 +30,30 @@ export const genericSignOperation =
   }): Observable<SignOperationEvent> =>
     new Observable(o => {
       async function main() {
-        // NOTE: checking field that's not inside TransactionCommon, improve
         if (!transaction["fees"]) throw new FeeNotLoaded();
-        const fees = BigInt(transaction["fees"]?.toString() || "0");
-        if (transaction["useAllAmount"]) {
-          const draftTransaction = {
-            recipient: transaction.recipient,
-            amount: transaction.amount ?? 0,
-            fees: fees,
-            useAllAmount: !!transaction.useAllAmount,
-            assetReference: transaction?.["assetReference"] || "",
-            assetOwner: transaction?.["assetOwner"] || "",
-            subAccountId: transaction.subAccountId || "",
-          };
-          const { amount } = await getAlpacaApi(network, kind).validateIntent(
-            transactionToIntent(account, draftTransaction),
-          );
-          transaction.amount = new BigNumber(amount.toString());
-        }
+
         const signedInfo = await signerContext(deviceId, async signer => {
           const derivationPath = account.freshAddressPath;
+
           const { publicKey } = (await signer.getAddress(derivationPath)) as Result;
 
-          let transactionIntent = transactionToIntent(account, { ...transaction, fees });
+          const transactionIntent = transactionToIntent(account, transaction);
           transactionIntent.senderPublicKey = publicKey;
-
-          // Enrich with memo and asset information
-          transactionIntent = enrichTransactionIntent(transactionIntent, transaction, publicKey);
-
-          // TODO: should compute it and pass it down to craftTransaction (duplicate call right now)
-          const sequenceNumber = await getAlpacaApi(network, kind).getSequence(
+          // NOTE: is setting the memo here instead of transactionToIntent sensible?
+          const txWithMemo = transactionIntent as TransactionIntent<MapMemo<string, string>>;
+          if (transaction["tag"]) {
+            const txMemo = String(transaction["tag"]);
+            txWithMemo.memo = {
+              type: "map",
+              memos: new Map(),
+            };
+            txWithMemo.memo.memos.set("destinationTag", txMemo);
+          }
+
+          const accountInfo = await getAlpacaApi(network, kind).getAccountInfo(
             transactionIntent.sender,
           );
-          transactionIntent.sequence = sequenceNumber;
-
+          transactionIntent.sequence = accountInfo.sequence;
           /* Craft unsigned blob via Alpaca */
           const unsigned: string = await getAlpacaApi(network, kind).craftTransaction(
             transactionIntent,
@@ -143,8 +76,8 @@ export const genericSignOperation =
           signedInfo.txnSig,
           signedInfo.publicKey,
         );
-        const operation = buildOptimisticOperation(account, transaction, signedInfo.sequence);
 
+        const operation = buildOptimisticOperation(account, transaction, signedInfo.sequence);
         // NOTE: we set the transactionSequenceNumber before on the operation
         // now that we create it in craftTransaction, we might need to return it back from craftTransaction also
         o.next({

package/src/bridge/generic-alpaca/signer/index.ts

@@ -1,15 +1,12 @@
 import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
 import xrpGetAddress from "@ledgerhq/coin-xrp/signer/getAddress";
-import stellarGetAddress from "@ledgerhq/coin-stellar/signer/getAddress";
 import { CreateSigner, executeWithSigner } from "../../setup";
 import Xrp from "@ledgerhq/hw-app-xrp";
-import Stellar from "@ledgerhq/hw-app-str";
 
 import Transport from "@ledgerhq/hw-transport";
-import { signTransaction, stellarSignTransaction } from "./signTransaction";
+import { signTransaction } from "./signTransaction";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { SignTransactionOptions } from "./types";
-import { StrKey } from "@stellar/stellar-sdk";
 
 export type AlpacaSigner = {
   getAddress: GetAddressFn;
@@ -18,50 +15,17 @@ export type AlpacaSigner = {
   context: SignerContext<any>;
 };
 
-const createSignerXrp: CreateSigner<Xrp> = (transport: Transport) => {
-  return new Xrp(transport);
-};
-const signerContextXrp = executeWithSigner(createSignerXrp);
-
-const createSignerStellar: CreateSigner<Stellar> = (transport: Transport) => {
-  const stellar = new Stellar(transport);
-  const originalSignTransaction = stellar.signTransaction;
-  // Return the original Stellar instance with overridden methods
-  return Object.assign(stellar, {
-    signTransaction: async (path: string, transaction: string) => {
-      const unsignedPayload: Buffer = Buffer.from(transaction, "base64");
-      const { signature } = await originalSignTransaction(path, unsignedPayload);
-      return signature.toString("base64");
-    },
-    getAddress: async (path: string, verify?: boolean) => {
-      const { rawPublicKey } = await stellar.getPublicKey(path, verify);
-      const publicKey = StrKey.encodeEd25519PublicKey(rawPublicKey);
-      return {
-        path,
-        address: publicKey,
-        publicKey: publicKey,
-      };
-    },
-  });
-};
-
-const signerContextStellar = executeWithSigner(createSignerStellar);
-
-export function getSigner(network): AlpacaSigner {
+export function getSigner(network: string): AlpacaSigner {
   switch (network) {
     case "ripple":
     case "xrp": {
-      return {
-        getAddress: xrpGetAddress(signerContextXrp),
-        signTransaction: signTransaction(signerContextXrp),
-        context: signerContextXrp,
+      const createSigner: CreateSigner<Xrp> = (transport: Transport) => {
+        return new Xrp(transport);
       };
-    }
-    case "stellar": {
       return {
-        getAddress: stellarGetAddress(signerContextStellar),
-        signTransaction: stellarSignTransaction(signerContextStellar),
-        context: signerContextStellar,
+        getAddress: xrpGetAddress(executeWithSigner(createSigner)),
+        signTransaction: signTransaction(executeWithSigner(createSigner)),
+        context: executeWithSigner(createSigner),
       };
     }
   }

package/src/bridge/generic-alpaca/signer/signTransaction.ts

@@ -1,7 +1,6 @@
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { XrpSigner } from "@ledgerhq/coin-xrp/index";
 import { SignTransactionOptions } from "./types";
-import { StellarSigner } from "@ledgerhq/coin-stellar/types/signer";
 
 export const signTransaction = (signerContext: SignerContext<XrpSigner>) => {
   return async (deviceId: string, { path, rawTxHex }: SignTransactionOptions) => {
@@ -12,13 +11,3 @@ export const signTransaction = (signerContext: SignerContext<XrpSigner>) => {
     return signedTx;
   };
 };
-
-export const stellarSignTransaction = (signerContext: SignerContext<StellarSigner>) => {
-  return async (deviceId: string, { path, transaction }: SignTransactionOptions) => {
-    const signedTx = await signerContext(deviceId, signer =>
-      signer.signTransaction(path, transaction),
-    );
-
-    return signedTx.signature.toString("base64"); // It should return a Buffer
-  };
-};

package/src/bridge/generic-alpaca/signer/types.ts

@@ -1,5 +1,4 @@
 export type SignTransactionOptions = {
   rawTxHex: string;
   path: string;
-  transaction: Buffer;
 };

package/src/bridge/generic-alpaca/tests/estimateMaxSpendable.test.ts

@@ -11,91 +11,66 @@ jest.mock("../alpaca", () => ({
 const mockedGetAlpacaApi = alpaca.getAlpacaApi as jest.Mock;
 
 // Dummy data
-const dummyAccounts = [
-  {
-    id: "js:2:ripple:r123:",
-    type: "Account",
-    spendableBalance: new BigNumber(50000000),
-    balance: new BigNumber(60000000),
-    currency: { id: "ripple", family: "xrp", name: "XRP", units: [{ name: "XRP", magnitude: 6 }] },
-    freshAddress: "r123",
-    pendingOperations: [],
-  },
-  {
-    id: "js:2:stellar:s123:",
-    type: "Account",
-    spendableBalance: new BigNumber(50000000),
-    balance: new BigNumber(60000000),
-    currency: {
-      id: "stellar",
-      family: "stellar",
-      name: "Stellar",
-      units: [{ name: "XLM", magnitude: 7 }],
-    },
-    freshAddress: "s123",
-    pendingOperations: [],
-  },
-] as unknown as Account[];
+const dummyAccount = {
+  id: "js:2:ripple:r123:",
+  type: "Account", // <-- this is mandatory for getMainAccount to work
+  spendableBalance: new BigNumber(50000000),
+  currency: { id: "ripple", name: "XRP", units: [{ name: "XRP", magnitude: 6 }] },
+  freshAddress: "r123",
+} as unknown as Account;
 
-["xrp", "stellar"].forEach((currencyName, idx) => {
-  describe(`genericEstimateMaxSpendable for ${currencyName}`, () => {
-    const dummyAccount = dummyAccounts[idx];
+describe("genericEstimateMaxSpendable", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
 
-    afterEach(() => {
-      jest.clearAllMocks();
+  it("subtracts estimated fee from spendable balance", async () => {
+    mockedGetAlpacaApi.mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: 10000n }), // 0.01 XRP
     });
 
-    it("subtracts estimated fee from spendable balance", async () => {
-      mockedGetAlpacaApi.mockReturnValue({
-        estimateFees: jest.fn().mockResolvedValue({ value: 10000n }),
-        validateIntent: jest.fn().mockResolvedValue({ amount: 49990000n }),
-      });
-
-      const estimate = genericEstimateMaxSpendable(currencyName, "local");
-      const result = await estimate({
-        account: dummyAccount,
-        parentAccount: null,
-        transaction: {},
-      });
-
-      expect(result.toString()).toBe("49990000");
+    const estimate = genericEstimateMaxSpendable("xrp", "local");
+    const result = await estimate({
+      account: dummyAccount,
+      parentAccount: null,
+      transaction: {},
     });
 
-    it("returns 0 if fee is higher than spendable", async () => {
-      const poorAccount = {
-        ...dummyAccount,
-        spendableBalance: new BigNumber(5000),
-      };
+    expect(result.toString()).toBe("49990000"); // 50_000_000 - 10_000
+  });
 
-      mockedGetAlpacaApi.mockReturnValue({
-        estimateFees: jest.fn().mockResolvedValue({ value: 10000n }),
-        validateIntent: jest.fn().mockResolvedValue({ amount: 0n }),
-      });
+  it("returns 0 if fee is higher than spendable", async () => {
+    const poorAccount = {
+      ...dummyAccount,
+      spendableBalance: new BigNumber(5000), // very low
+    };
 
-      const estimate = genericEstimateMaxSpendable(currencyName, "local");
-      const result = await estimate({
-        account: poorAccount,
-        parentAccount: null,
-        transaction: {},
-      });
+    mockedGetAlpacaApi.mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: 10000n }),
+    });
 
-      expect(result.toString()).toBe("0");
+    const estimate = genericEstimateMaxSpendable("xrp", "local");
+    const result = await estimate({
+      account: poorAccount,
+      parentAccount: null,
+      transaction: {},
     });
 
-    it("returns full spendable balance if fee is 0", async () => {
-      mockedGetAlpacaApi.mockReturnValue({
-        estimateFees: jest.fn().mockResolvedValue({ value: 0n }),
-        validateIntent: jest.fn().mockResolvedValue({ amount: 50000000n }),
-      });
+    expect(result.toString()).toBe("0");
+  });
 
-      const estimate = genericEstimateMaxSpendable(currencyName, "local");
-      const result = await estimate({
-        account: dummyAccount,
-        parentAccount: null,
-        transaction: {},
-      });
+  it("returns full spendable balance if fee is 0", async () => {
+    mockedGetAlpacaApi.mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: 0n }),
+    });
 
-      expect(result.toString()).toBe("50000000");
+    const estimate = genericEstimateMaxSpendable("xrp", "local");
+    const result = await estimate({
+      account: dummyAccount,
+      parentAccount: null,
+      transaction: {},
     });
+
+    expect(result.toString()).toBe("50000000");
   });
 });

package/src/bridge/generic-alpaca/tests/prepareTransaction.test.ts

@@ -47,7 +47,7 @@ describe("genericPrepareTransaction", () => {
     expect((result as any).fees.toString()).toBe(newFee.toString());
     expect(transactionToIntent).toHaveBeenCalledWith(
       account,
-      expect.objectContaining({ ...baseTransaction, fees: 500n }),
+      expect.objectContaining(baseTransaction),
     );
   });
 

package/src/bridge/generic-alpaca/tests/signOperation.test.ts

@@ -13,8 +13,9 @@ jest.mock("../utils", () => ({
   buildOptimisticOperation: jest.fn(),
   transactionToIntent: jest.fn(),
 }));
+
 describe("genericSignOperation", () => {
-  const networks = ["xrp", "stellar"];
+  const network = "xrp";
   const kind = "local";
 
   const mockSignerContext = jest.fn();
@@ -54,7 +55,6 @@ describe("genericSignOperation", () => {
       craftTransaction: jest.fn().mockResolvedValue(unsignedTx),
       getAccountInfo: jest.fn().mockResolvedValue(pubKey),
       combine: jest.fn().mockResolvedValue(signedTx),
-      getSequence: jest.fn().mockResolvedValue(1),
     });
 
     (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
@@ -65,35 +65,33 @@ describe("genericSignOperation", () => {
     mockSignerContext.mockImplementation(async (_deviceId, cb) => cb(mockSigner));
   });
 
-  networks.forEach(network => {
-    it(`emits full sign operation flow for ${network}`, async () => {
-      const signOperation = genericSignOperation(network, kind)(mockSignerContext);
-      const observable = signOperation({ account, transaction, deviceId });
-
-      const events = await lastValueFrom(observable.pipe(toArray()));
-
-      expect(events[0]).toEqual({ type: "device-signature-requested" });
-      expect(events[1]).toEqual({ type: "device-signature-granted" });
-      expect(events[2]).toEqual({
-        type: "signed",
-        signedOperation: {
-          operation: { id: "mock-op" },
-          signature: signedTx,
-        },
-      });
-
-      expect(transactionToIntent).toHaveBeenCalledWith(account, transaction);
-      expect(txIntent.memo.memos.get("destinationTag")).toBe("1234");
+  it("emits full sign operation flow", async () => {
+    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
+    const observable = signOperation({ account, transaction, deviceId });
+
+    const events = await lastValueFrom(observable.pipe(toArray()));
+
+    expect(events[0]).toEqual({ type: "device-signature-requested" });
+    expect(events[1]).toEqual({ type: "device-signature-granted" });
+    expect(events[2]).toEqual({
+      type: "signed",
+      signedOperation: {
+        operation: { id: "mock-op" },
+        signature: signedTx,
+      },
     });
 
-    it(`throws FeeNotLoaded if fees are missing for ${network}`, async () => {
-      const txWithoutFees = { ...transaction };
-      delete txWithoutFees.fees;
+    expect(transactionToIntent).toHaveBeenCalledWith(account, transaction);
+    expect(txIntent.memo.memos.get("destinationTag")).toBe("1234");
+  });
 
-      const signOperation = genericSignOperation(network, kind)(mockSignerContext);
-      const observable = signOperation({ account, transaction: txWithoutFees, deviceId });
+  it("throws FeeNotLoaded if fees are missing", async () => {
+    const txWithoutFees = { ...transaction };
+    delete txWithoutFees.fees;
 
-      await expect(observable.toPromise()).rejects.toThrow(FeeNotLoaded);
-    });
+    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
+    const observable = signOperation({ account, transaction: txWithoutFees, deviceId });
+
+    await expect(observable.toPromise()).rejects.toThrow(FeeNotLoaded);
   });
 });

package/src/bridge/generic-alpaca/{tests/utils.test.ts → utils.test.ts}

@@ -1,4 +1,4 @@
-import { extractBalance } from "../utils";
+import { extractBalance } from "./utils";
 
 describe("Alpaca utils", () => {
   describe("extractBalance", () => {