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

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

@@ -2,6 +2,7 @@ import { Account, AccountBridge, TransactionCommon } from "@ledgerhq/types-live"
 import { getAlpacaApi } from "./alpaca";
 import { transactionToIntent } from "./utils";
 import BigNumber from "bignumber.js";
+import { NetworkInfo } from "./createTransaction";
 
 function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
   return !a && !b ? true : !a || !b ? false : a.eq(b);
@@ -9,18 +10,51 @@ function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined):
 
 export function genericPrepareTransaction(
   network: string,
-  kind: "local" | "remote",
+  kind,
 ): AccountBridge<TransactionCommon, Account, any, any>["prepareTransaction"] {
-  return async (account, transaction: TransactionCommon & { fees: BigNumber }) => {
+  return async (
+    account,
+    transaction: TransactionCommon & {
+      fees: BigNumber | null | undefined;
+      assetReference?: string;
+      assetOwner?: string;
+      subAccountId?: string;
+      networkInfo?: NetworkInfo | null;
+    },
+  ) => {
+    const [assetReference, assetOwner] = getAssetInfos(transaction);
     const fees = await getAlpacaApi(network, kind).estimateFees(
-      transactionToIntent(account, transaction),
+      transactionToIntent(account, {
+        ...transaction,
+        fees: transaction.fees ? BigInt(transaction.fees.toString()) : 0n,
+      }),
     );
-    const bnFee = BigNumber(fees.value.toString());
-
-    if (!bnEq(transaction.fees, bnFee)) {
-      return { ...transaction, fees: bnFee };
+    // NOTE: this is problematic, we should maybe have a method / object that lists what field warrant an update per chain
+    // for reference, stellar checked this:
+    // transaction.networkInfo !== networkInfo ||
+    // transaction.baseReserve !== baseReserve
+    if (!bnEq(transaction.fees, new BigNumber(fees.value.toString()))) {
+      return {
+        ...transaction,
+        fees: new BigNumber(fees.value.toString()),
+        assetReference,
+        assetOwner,
+        networkInfo: {
+          fees: new BigNumber(fees.value.toString()),
+        },
+      };
     }
 
     return transaction;
   };
 }
+
+export function getAssetInfos(
+  tr: TransactionCommon & { assetReference?: string; assetOwner?: string },
+): string[] {
+  if (tr.subAccountId) {
+    const assetString = tr.subAccountId.split("+")[1];
+    return assetString.split(":");
+  }
+  return [tr.assetReference || "", tr.assetOwner || ""];
+}

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

@@ -12,12 +12,69 @@ 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: string, kind: "local" | "remote") =>
+  (network, kind) =>
   (signerContext: SignerContext<any>): AccountBridge<TransactionCommon>["signOperation"] =>
   ({
     account,
@@ -30,30 +87,40 @@ 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;
 
-          const transactionIntent = transactionToIntent(account, transaction);
+          let transactionIntent = transactionToIntent(account, { ...transaction, fees });
           transactionIntent.senderPublicKey = publicKey;
-          // 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(
+
+          // 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(
             transactionIntent.sender,
           );
-          transactionIntent.sequence = accountInfo.sequence;
+          transactionIntent.sequence = sequenceNumber;
+
           /* Craft unsigned blob via Alpaca */
           const unsigned: string = await getAlpacaApi(network, kind).craftTransaction(
             transactionIntent,
@@ -76,8 +143,8 @@ export const genericSignOperation =
           signedInfo.txnSig,
           signedInfo.publicKey,
         );
-
         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,12 +1,15 @@
 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 } from "./signTransaction";
+import { signTransaction, stellarSignTransaction } from "./signTransaction";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { SignTransactionOptions } from "./types";
+import { StrKey } from "@stellar/stellar-sdk";
 
 export type AlpacaSigner = {
   getAddress: GetAddressFn;
@@ -15,17 +18,50 @@ export type AlpacaSigner = {
   context: SignerContext<any>;
 };
 
-export function getSigner(network: string): AlpacaSigner {
+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 {
   switch (network) {
     case "ripple":
     case "xrp": {
-      const createSigner: CreateSigner<Xrp> = (transport: Transport) => {
-        return new Xrp(transport);
+      return {
+        getAddress: xrpGetAddress(signerContextXrp),
+        signTransaction: signTransaction(signerContextXrp),
+        context: signerContextXrp,
       };
+    }
+    case "stellar": {
       return {
-        getAddress: xrpGetAddress(executeWithSigner(createSigner)),
-        signTransaction: signTransaction(executeWithSigner(createSigner)),
-        context: executeWithSigner(createSigner),
+        getAddress: stellarGetAddress(signerContextStellar),
+        signTransaction: stellarSignTransaction(signerContextStellar),
+        context: signerContextStellar,
       };
     }
   }

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

@@ -1,6 +1,7 @@
 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) => {
@@ -11,3 +12,13 @@ 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,4 +1,5 @@
 export type SignTransactionOptions = {
   rawTxHex: string;
   path: string;
+  transaction: Buffer;
 };

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

@@ -11,66 +11,91 @@ jest.mock("../alpaca", () => ({
 const mockedGetAlpacaApi = alpaca.getAlpacaApi as jest.Mock;
 
 // Dummy data
-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;
+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[];
 
-describe("genericEstimateMaxSpendable", () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
+["xrp", "stellar"].forEach((currencyName, idx) => {
+  describe(`genericEstimateMaxSpendable for ${currencyName}`, () => {
+    const dummyAccount = dummyAccounts[idx];
 
-  it("subtracts estimated fee from spendable balance", async () => {
-    mockedGetAlpacaApi.mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 10000n }), // 0.01 XRP
+    afterEach(() => {
+      jest.clearAllMocks();
     });
 
-    const estimate = genericEstimateMaxSpendable("xrp", "local");
-    const result = await estimate({
-      account: dummyAccount,
-      parentAccount: null,
-      transaction: {},
+    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");
     });
 
-    expect(result.toString()).toBe("49990000"); // 50_000_000 - 10_000
-  });
+    it("returns 0 if fee is higher than spendable", async () => {
+      const poorAccount = {
+        ...dummyAccount,
+        spendableBalance: new BigNumber(5000),
+      };
 
-  it("returns 0 if fee is higher than spendable", async () => {
-    const poorAccount = {
-      ...dummyAccount,
-      spendableBalance: new BigNumber(5000), // very low
-    };
+      mockedGetAlpacaApi.mockReturnValue({
+        estimateFees: jest.fn().mockResolvedValue({ value: 10000n }),
+        validateIntent: jest.fn().mockResolvedValue({ amount: 0n }),
+      });
 
-    mockedGetAlpacaApi.mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 10000n }),
-    });
+      const estimate = genericEstimateMaxSpendable(currencyName, "local");
+      const result = await estimate({
+        account: poorAccount,
+        parentAccount: null,
+        transaction: {},
+      });
 
-    const estimate = genericEstimateMaxSpendable("xrp", "local");
-    const result = await estimate({
-      account: poorAccount,
-      parentAccount: null,
-      transaction: {},
+      expect(result.toString()).toBe("0");
     });
 
-    expect(result.toString()).toBe("0");
-  });
+    it("returns full spendable balance if fee is 0", async () => {
+      mockedGetAlpacaApi.mockReturnValue({
+        estimateFees: jest.fn().mockResolvedValue({ value: 0n }),
+        validateIntent: jest.fn().mockResolvedValue({ amount: 50000000n }),
+      });
 
-  it("returns full spendable balance if fee is 0", async () => {
-    mockedGetAlpacaApi.mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 0n }),
-    });
+      const estimate = genericEstimateMaxSpendable(currencyName, "local");
+      const result = await estimate({
+        account: dummyAccount,
+        parentAccount: null,
+        transaction: {},
+      });
 
-    const estimate = genericEstimateMaxSpendable("xrp", "local");
-    const result = await estimate({
-      account: dummyAccount,
-      parentAccount: null,
-      transaction: {},
+      expect(result.toString()).toBe("50000000");
     });
-
-    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),
+      expect.objectContaining({ ...baseTransaction, fees: 500n }),
     );
   });
 

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

@@ -13,9 +13,8 @@ jest.mock("../utils", () => ({
   buildOptimisticOperation: jest.fn(),
   transactionToIntent: jest.fn(),
 }));
-
 describe("genericSignOperation", () => {
-  const network = "xrp";
+  const networks = ["xrp", "stellar"];
   const kind = "local";
 
   const mockSignerContext = jest.fn();
@@ -55,6 +54,7 @@ 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,33 +65,35 @@ describe("genericSignOperation", () => {
     mockSignerContext.mockImplementation(async (_deviceId, cb) => cb(mockSigner));
   });
 
-  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,
-      },
+  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");
     });
 
-    expect(transactionToIntent).toHaveBeenCalledWith(account, transaction);
-    expect(txIntent.memo.memos.get("destinationTag")).toBe("1234");
-  });
-
-  it("throws FeeNotLoaded if fees are missing", async () => {
-    const txWithoutFees = { ...transaction };
-    delete txWithoutFees.fees;
+    it(`throws FeeNotLoaded if fees are missing for ${network}`, async () => {
+      const txWithoutFees = { ...transaction };
+      delete txWithoutFees.fees;
 
-    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
-    const observable = signOperation({ account, transaction: txWithoutFees, deviceId });
+      const signOperation = genericSignOperation(network, kind)(mockSignerContext);
+      const observable = signOperation({ account, transaction: txWithoutFees, deviceId });
 
-    await expect(observable.toPromise()).rejects.toThrow(FeeNotLoaded);
+      await expect(observable.toPromise()).rejects.toThrow(FeeNotLoaded);
+    });
   });
 });

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

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