@ledgerhq/live-common 34.48.0 → 34.49.0-nightly.0

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

@@ -1,27 +1,17 @@
-import { AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
+import { AccountBridge } from "@ledgerhq/types-live";
 import { AccountAwaitingSendPendingOperations } from "@ledgerhq/errors";
 import BigNumber from "bignumber.js";
 import { getAlpacaApi } from "./alpaca";
 import { transactionToIntent } from "./utils";
+import { GenericTransaction } from "./types";
 
 // => alpaca validateIntent
 export function genericGetTransactionStatus(
   network,
   kind,
 ): AccountBridge<any>["getTransactionStatus"] {
-  return async (
-    account,
-    transaction: TransactionCommon & {
-      fees: BigNumber | null | undefined;
-      assetReference?: string;
-      assetOwner?: string;
-      mode?: string;
-      subAccountId?: string;
-      memoType?: string;
-      memoValue?: string;
-    },
-  ) => {
-    const alpacaApi = getAlpacaApi(network, kind);
+  return async (account, transaction: GenericTransaction) => {
+    const alpacaApi = getAlpacaApi(account.currency.id, kind);
     const draftTransaction = {
       mode: transaction?.mode,
       recipient: transaction.recipient,
@@ -32,6 +22,7 @@ export function genericGetTransactionStatus(
       subAccountId: transaction.subAccountId || "",
       memoType: transaction.memoType || "",
       memoValue: transaction.memoValue || "",
+      family: transaction.family,
     };
 
     if (alpacaApi.getChainSpecificRules) {

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

@@ -1,24 +1,17 @@
-import { Account, AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
 import { getAlpacaApi } from "./alpaca";
 import { transactionToIntent } from "./utils";
 import BigNumber from "bignumber.js";
-import { AssetInfo, FeeEstimation } from "@ledgerhq/coin-framework/api/types";
+import { AssetInfo } from "@ledgerhq/coin-framework/api/types";
 import { decodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
 import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { GenericTransaction } from "./types";
 
 function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
   return !a && !b ? true : !a || !b ? false : a.eq(b);
 }
 
-type TransactionParam = TransactionCommon & {
-  fees: BigNumber | null | undefined;
-  customFees?: FeeEstimation;
-  assetReference?: string;
-  assetOwner?: string;
-  subAccountId?: string;
-};
-
-function assetInfosFallback(transaction: TransactionParam): {
+function assetInfosFallback(transaction: GenericTransaction): {
   assetReference: string;
   assetOwner: string;
 } {
@@ -31,17 +24,17 @@ function assetInfosFallback(transaction: TransactionParam): {
 export function genericPrepareTransaction(
   network: string,
   kind,
-): AccountBridge<TransactionCommon, Account, any, any>["prepareTransaction"] {
-  return async (account, transaction: TransactionParam) => {
-    const { getAssetFromToken } = getAlpacaApi(network, kind);
+): AccountBridge<GenericTransaction, Account>["prepareTransaction"] {
+  return async (account, transaction: GenericTransaction) => {
+    const { getAssetFromToken } = getAlpacaApi(account.currency.id, kind);
     const { assetReference, assetOwner } = getAssetFromToken
       ? getAssetInfos(transaction, account.freshAddress, getAssetFromToken)
       : assetInfosFallback(transaction);
 
-    let fees = transaction.customFees?.parameters?.fees || null;
+    let fees: BigNumber | bigint | null = transaction.customFees?.parameters?.fees || null;
     if (fees === null) {
       fees = (
-        await getAlpacaApi(network, kind).estimateFees(
+        await getAlpacaApi(account.currency.id, kind).estimateFees(
           transactionToIntent(account, {
             ...transaction,
           }),
@@ -68,7 +61,7 @@ export function genericPrepareTransaction(
 }
 
 export function getAssetInfos(
-  tr: TransactionParam,
+  tr: GenericTransaction,
   owner: string,
   getAssetFromToken: (token: TokenCurrency, owner: string) => AssetInfo,
 ): {

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

@@ -1,12 +1,6 @@
 import { Observable } from "rxjs";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import type {
-  Account,
-  DeviceId,
-  SignOperationEvent,
-  AccountBridge,
-  TransactionCommon,
-} from "@ledgerhq/types-live";
+import type { Account, DeviceId, SignOperationEvent, AccountBridge } from "@ledgerhq/types-live";
 import { getAlpacaApi } from "./alpaca";
 import { buildOptimisticOperation, transactionToIntent } from "./utils";
 import { FeeNotLoaded } from "@ledgerhq/errors";
@@ -15,6 +9,7 @@ import { MapMemo, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
 import { StellarMemo } from "@ledgerhq/coin-stellar/types/bridge";
 import { log } from "@ledgerhq/logs";
 import BigNumber from "bignumber.js";
+import { GenericTransaction } from "./types";
 
 /**
  * Applies memo information to transaction intent
@@ -22,12 +17,12 @@ import BigNumber from "bignumber.js";
  */
 function applyMemoToIntent(
   transactionIntent: TransactionIntent<any>,
-  transaction: TransactionCommon,
+  transaction: GenericTransaction,
 ): TransactionIntent<any> {
   // Handle destination tag memo (for XRP-like chains)
-  if (transaction["tag"]) {
+  if (transaction.tag) {
     const txWithMemoTag = transactionIntent as TransactionIntent<MapMemo<string, string>>;
-    const txMemo = String(transaction["tag"]);
+    const txMemo = String(transaction.tag);
 
     txWithMemoTag.memo = {
       type: "map",
@@ -39,10 +34,10 @@ function applyMemoToIntent(
   }
 
   // Handle Stellar-style memo
-  if (transaction["memoType"] && transaction["memoValue"]) {
+  if (transaction.memoType && transaction.memoValue) {
     const txWithMemo = transactionIntent as TransactionIntent<StellarMemo>;
-    const txMemoType = String(transaction["memoType"]);
-    const txMemoValue = String(transaction["memoValue"]);
+    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",
@@ -60,7 +55,7 @@ function applyMemoToIntent(
  */
 function enrichTransactionIntent(
   transactionIntent: TransactionIntent<any>,
-  transaction: TransactionCommon,
+  transaction: GenericTransaction,
   publicKey: string,
 ): TransactionIntent<any> {
   // Set sender public key
@@ -76,31 +71,33 @@ function enrichTransactionIntent(
  */
 export const genericSignOperation =
   (network, kind) =>
-  (signerContext: SignerContext<any>): AccountBridge<TransactionCommon>["signOperation"] =>
+  (signerContext: SignerContext<any>): AccountBridge<GenericTransaction>["signOperation"] =>
   ({
     account,
     transaction,
     deviceId,
   }: {
     account: Account;
-    transaction: TransactionCommon;
+    transaction: GenericTransaction;
     deviceId: DeviceId;
   }): 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 alpacaApi = getAlpacaApi(account.currency.id, kind);
+        if (!transaction.fees) throw new FeeNotLoaded();
+        const fees = BigInt(transaction.fees?.toString() || "0");
+        if (transaction.useAllAmount) {
           const draftTransaction = {
+            mode: transaction.mode,
             recipient: transaction.recipient,
             amount: transaction.amount ?? 0,
             useAllAmount: !!transaction.useAllAmount,
-            assetReference: transaction?.["assetReference"] || "",
-            assetOwner: transaction?.["assetOwner"] || "",
+            assetReference: transaction?.assetReference || "",
+            assetOwner: transaction?.assetOwner || "",
             subAccountId: transaction.subAccountId || "",
+            family: transaction.family,
           };
-          const { amount } = await getAlpacaApi(network, kind).validateIntent(
+          const { amount } = await alpacaApi.validateIntent(
             transactionToIntent(account, draftTransaction),
             { value: fees },
           );
@@ -117,16 +114,13 @@ export const genericSignOperation =
           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,
-          );
+          const sequenceNumber = await alpacaApi.getSequence(transactionIntent.sender);
           transactionIntent.sequence = sequenceNumber;
 
           /* Craft unsigned blob via Alpaca */
-          const { transaction: unsigned } = await getAlpacaApi(network, kind).craftTransaction(
-            transactionIntent,
-            { value: fees },
-          );
+          const { transaction: unsigned } = await alpacaApi.craftTransaction(transactionIntent, {
+            value: fees,
+          });
 
           /* Notify UI that the device is now showing the tx */
           o.next({ type: "device-signature-requested" });
@@ -140,7 +134,7 @@ export const genericSignOperation =
         o.next({ type: "device-signature-granted" });
 
         /* Combine payload + signature for broadcast */
-        const combined = await getAlpacaApi(network, kind).combine(
+        const combined = await alpacaApi.combine(
           signedInfo.unsigned,
           signedInfo.txnSig,
           signedInfo.publicKey,

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

@@ -0,0 +1,70 @@
+import { filter, firstValueFrom } from "rxjs";
+import { EvmAddress, EvmSignature, EvmSigner } from "@ledgerhq/coin-evm/types/signer";
+import { CreateSigner } from "../../setup";
+import { DeviceManagementKit } from "@ledgerhq/device-management-kit";
+import { DmkSignerEth, LegacySignerEth } from "@ledgerhq/live-signer-evm";
+import Transport from "@ledgerhq/hw-transport";
+import { getEnv } from "@ledgerhq/live-env";
+import { ResolutionConfig, LoadConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
+import { Signature } from "ethers";
+
+export type Signer = {
+  getAddress: (path: string) => Promise<EvmAddress>;
+  signTransaction: (path: string, tx: string) => Promise<string>;
+};
+
+const isDmkTransport = (
+  transport: Transport,
+): transport is Transport & { dmk: DeviceManagementKit; sessionId: string } => {
+  return (
+    "dmk" in transport &&
+    transport.dmk !== undefined &&
+    "sessionId" in transport &&
+    transport.sessionId !== undefined
+  );
+};
+
+const createLiveSigner: CreateSigner<EvmSigner> = (transport: Transport) => {
+  if (isDmkTransport(transport)) {
+    return new DmkSignerEth(transport.dmk, transport.sessionId);
+  }
+
+  return new LegacySignerEth(transport);
+};
+
+export const createSigner: CreateSigner<Signer> = (transport: Transport) => {
+  const signer = createLiveSigner(transport);
+
+  return {
+    getAddress: signer.getAddress.bind(signer),
+    signTransaction: async (path, tx) => {
+      // Configure type of resolutions necessary for the clear signing
+      const resolutionConfig: ResolutionConfig = {
+        externalPlugins: true,
+        erc20: true,
+        nft: false,
+        uniswapV3: true,
+      };
+      const loadConfig: LoadConfig = {
+        cryptoassetsBaseURL: getEnv("DYNAMIC_CAL_BASE_URL"),
+        nftExplorerBaseURL: getEnv("NFT_METADATA_SERVICE") + "/v1/ethereum",
+      };
+
+      signer.setLoadConfig(loadConfig);
+
+      const observable = signer.clearSignTransaction(path, tx.substring(2), resolutionConfig, true);
+      const event = observable.pipe(
+        filter((event): event is { type: "signer.evm.signed"; value: EvmSignature } => {
+          return event.type === "signer.evm.signed";
+        }),
+      );
+      const { value } = await firstValueFrom(event);
+
+      return Signature.from({
+        r: "0x" + value.r,
+        s: "0x" + value.s,
+        v: typeof value.v === "number" ? value.v : parseInt(value.v, 16),
+      }).serialized;
+    },
+  };
+};

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

@@ -1,22 +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 { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { SignTransactionOptions } from "./types";
 import { StrKey } from "@stellar/stellar-sdk";
-
-export type AlpacaSigner = {
-  getAddress: GetAddressFn;
-  signTransaction?: (deviceId: string, opts: SignTransactionOptions) => Promise<string>;
-  signMessage?: (message: string) => Promise<string>;
-  context: SignerContext<any>;
-};
+import { CreateSigner, executeWithSigner } from "../../setup";
+import Xrp from "@ledgerhq/hw-app-xrp";
+import Transport from "@ledgerhq/hw-transport";
+import { AlpacaSigner } from "./types";
 
 const createSignerXrp: CreateSigner<Xrp> = (transport: Transport) => {
   return new Xrp(transport);
@@ -47,7 +37,7 @@ const createSignerStellar: CreateSigner<Stellar> = (transport: Transport) => {
 
 const signerContextStellar = executeWithSigner(createSignerStellar);
 
-export function getSigner(network): AlpacaSigner {
+export function getSigner(network: string): AlpacaSigner {
   switch (network) {
     case "ripple":
     case "xrp": {

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

@@ -1,9 +1,10 @@
 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";
+import { LegacySigner, SignTransactionOptions } from "./types";
 
-export const signTransaction = (signerContext: SignerContext<XrpSigner>) => {
+export const signTransaction = <Signer extends LegacySigner>(
+  signerContext: SignerContext<Signer>,
+) => {
   return async (deviceId: string, { path, rawTxHex }: SignTransactionOptions) => {
     const signedTx = await signerContext(deviceId, signer =>
       signer.signTransaction(path, rawTxHex),

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

@@ -1,3 +1,17 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+
+export type LegacySigner = {
+  signTransaction: (path: string, rawTxHex: string) => Promise<string>;
+};
+
+export type AlpacaSigner<S = unknown> = {
+  getAddress: GetAddressFn;
+  signTransaction?: (deviceId: string, opts: SignTransactionOptions) => Promise<string>;
+  signMessage?: (message: string) => Promise<string>;
+  context: SignerContext<S>;
+};
+
 export type SignTransactionOptions = {
   rawTxHex: string;
   path: string;

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

@@ -0,0 +1,173 @@
+import BigNumber from "bignumber.js";
+import { genericGetAccountShape } from "../getAccountShape";
+
+jest.mock("@ledgerhq/coin-framework/account/index", () => ({
+  encodeAccountId: jest.fn(() => "accId"),
+}));
+
+const mergeOpsMock = jest.fn();
+jest.mock("@ledgerhq/coin-framework/bridge/jsHelpers", () => ({
+  mergeOps: (...args: any[]) => mergeOpsMock(...args),
+}));
+
+const listOperationsMock = jest.fn();
+const getBalanceMock = jest.fn();
+const lastBlockMock = jest.fn();
+const getTokenFromAssetMock = jest.fn();
+const chainSpecificGetAccountShapeMock = jest.fn();
+jest.mock("../alpaca", () => ({
+  getAlpacaApi: () => ({
+    lastBlock: (...a: any[]) => lastBlockMock(...a),
+    getBalance: (...a: any[]) => getBalanceMock(...a),
+    listOperations: (...a: any[]) => listOperationsMock(...a),
+    getTokenFromAsset: (...a: any[]) => getTokenFromAssetMock(...a),
+    getChainSpecificRules: () => ({
+      getAccountShape: (...a: any[]) => chainSpecificGetAccountShapeMock(...a),
+    }),
+  }),
+}));
+
+const adaptCoreOperationToLiveOperationMock = jest.fn();
+const extractBalanceMock = jest.fn();
+jest.mock("../utils", () => ({
+  adaptCoreOperationToLiveOperation: (...a: any[]) => adaptCoreOperationToLiveOperationMock(...a),
+  extractBalance: (...a: any[]) => extractBalanceMock(...a),
+}));
+
+const inferSubOperationsMock = jest.fn();
+jest.mock("@ledgerhq/coin-framework/serialization", () => ({
+  inferSubOperations: (...a: any[]) => inferSubOperationsMock(...a),
+}));
+
+const buildSubAccountsMock = jest.fn();
+jest.mock("../buildSubAccounts", () => ({
+  buildSubAccounts: (...a: any[]) => buildSubAccountsMock(...a),
+}));
+
+// Test matrix for Stellar & XRP
+const chains = [
+  { currency: { id: "stellar", name: "Stellar" }, network: "testnet" },
+  { currency: { id: "ripple", name: "XRP" }, network: "mainnet" },
+];
+
+describe("genericGetAccountShape (stellar & xrp)", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe.each(chains)("$currency.id", ({ currency, network }) => {
+    test("builds account shape with existing operations, pagination and sub accounts", async () => {
+      const oldOp = {
+        hash: "h1",
+        blockHeight: 10,
+        type: "OPT_IN",
+        extra: { pagingToken: "pt1", assetReference: "ar1", assetOwner: "ow1" },
+      };
+      const initialAccount = { operations: [oldOp], blockHeight: 10 };
+
+      extractBalanceMock.mockReturnValue({ value: "1000", locked: "300" });
+      getBalanceMock.mockResolvedValue([
+        { asset: { type: "native" }, value: "1000", locked: "300" },
+        { asset: { type: "token", symbol: "TOK1" }, value: "42" },
+        { asset: { type: "token", symbol: "TOK_IGNORE" }, value: "5" },
+      ]);
+
+      getTokenFromAssetMock.mockImplementation(asset =>
+        asset.symbol === "TOK1" ? { id: `${currency.id}_token1` } : null,
+      );
+
+      const coreOp = { hash: "h2", height: 12 };
+      listOperationsMock.mockResolvedValue([[coreOp]]);
+
+      adaptCoreOperationToLiveOperationMock.mockImplementation((_accId, op) => ({
+        hash: op.hash,
+        type: "IN",
+        blockHeight: 12,
+        extra: { assetReference: "ar2", assetOwner: "ow2" },
+      }));
+
+      mergeOpsMock.mockImplementation((oldOps, newOps) => [...newOps, ...oldOps]);
+
+      buildSubAccountsMock.mockReturnValue([
+        { id: `${currency.id}_subAcc1`, type: "TokenAccount" },
+      ]);
+
+      inferSubOperationsMock.mockImplementation(hash =>
+        hash === "h2" ? [{ id: `${currency.id}_subOp1` }] : [],
+      );
+
+      lastBlockMock.mockResolvedValue({ height: 123 });
+
+      const getShape = genericGetAccountShape(network, currency.id);
+      const result = await getShape(
+        {
+          address: `${currency.id}_addr1`,
+          initialAccount,
+          currency,
+          derivationMode: "",
+        } as any,
+        { paginationConfig: {} as any },
+      );
+
+      expect(chainSpecificGetAccountShapeMock).toHaveBeenCalledWith(`${currency.id}_addr1`);
+
+      expect(listOperationsMock).toHaveBeenCalledWith(`${currency.id}_addr1`, {
+        minHeight: 11,
+        order: "asc",
+        lastPagingToken: "pt1",
+      });
+
+      const assetsBalancePassed = buildSubAccountsMock.mock.calls[0][0].assetsBalance;
+      expect(assetsBalancePassed).toHaveLength(1);
+      expect(assetsBalancePassed[0].asset.symbol).toBe("TOK1");
+
+      const assetOpsPassed = buildSubAccountsMock.mock.calls[0][0].operations;
+      expect(assetOpsPassed).toHaveLength(1);
+      expect(assetOpsPassed[0].hash).toBe("h2");
+
+      expect(result).toMatchObject({
+        balance: new BigNumber(1000),
+        spendableBalance: new BigNumber(700),
+        blockHeight: 123,
+        operationsCount: 2,
+        subAccounts: [{ id: `${currency.id}_subAcc1`, type: "TokenAccount" }],
+        operations: [
+          {
+            hash: "h2",
+            type: "IN",
+            blockHeight: 12,
+            subOperations: [{ id: `${currency.id}_subOp1` }],
+            extra: { assetReference: "ar2", assetOwner: "ow2" },
+          },
+          oldOp,
+        ],
+      });
+    });
+
+    test("handles empty operations (no old ops, no new ops) and blockHeight=0", async () => {
+      getBalanceMock.mockResolvedValue([{ asset: { type: "native" }, value: "0", locked: "0" }]);
+      extractBalanceMock.mockReturnValue({ value: "0", locked: "0" });
+      listOperationsMock.mockResolvedValue([[]]);
+      buildSubAccountsMock.mockReturnValue([]);
+
+      const getShape = genericGetAccountShape(network, currency.id);
+      const result = await getShape(
+        {
+          address: `${currency.id}_addr2`,
+          initialAccount: undefined,
+          currency,
+          derivationMode: "",
+        } as any,
+        { paginationConfig: {} as any },
+      );
+      expect(result).toMatchObject({
+        operations: [], // Empty array check for `operations`
+        blockHeight: 0,
+        operationsCount: 0,
+        subAccounts: [], // Empty array check for `subAccounts`
+        balance: new BigNumber(0),
+        spendableBalance: new BigNumber(0),
+      });
+    });
+  });
+});

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

@@ -2,7 +2,6 @@ import { genericPrepareTransaction } from "../prepareTransaction";
 import { getAlpacaApi } from "../alpaca";
 import { transactionToIntent } from "../utils";
 import BigNumber from "bignumber.js";
-import type { TransactionCommon } from "@ledgerhq/types-live";
 
 jest.mock("../alpaca", () => ({
   getAlpacaApi: jest.fn(),
@@ -19,12 +18,14 @@ describe("genericPrepareTransaction", () => {
   const account = {
     id: "test-account",
     address: "0xabc",
+    currency: { id: "ethereum" },
   } as any;
 
-  const baseTransaction: TransactionCommon & { fees: BigNumber } = {
+  const baseTransaction = {
     amount: new BigNumber(100_000),
     fees: new BigNumber(500),
     recipient: "0xrecipient",
+    family: "family",
   };
 
   const txIntent = { mock: "intent" };

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

@@ -23,11 +23,6 @@ describe("genericSignOperation", () => {
     signTransaction: jest.fn(),
   };
 
-  const account = {
-    freshAddressPath: "44'/144'/0'/0/0",
-    address: "rTestAddress",
-  } as any;
-
   const transaction = {
     amount: 100_000n,
     fees: 500n,
@@ -66,6 +61,12 @@ describe("genericSignOperation", () => {
   });
 
   networks.forEach(network => {
+    const account = {
+      freshAddressPath: "44'/144'/0'/0/0",
+      address: "rTestAddress",
+      currency: { id: network },
+    } as any;
+
     it(`emits full sign operation flow for ${network}`, async () => {
       const signOperation = genericSignOperation(network, kind)(mockSignerContext);
       const observable = signOperation({ account, transaction, deviceId });

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

@@ -0,0 +1,23 @@
+import { TransactionCommon } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+
+type NetworkInfo = {
+  fees: BigNumber;
+};
+
+export type GenericTransaction = TransactionCommon & {
+  family: string;
+  fees?: BigNumber | null;
+  customFees?: {
+    parameters: { fees?: BigNumber | null };
+  };
+  tag?: number | null | undefined;
+  feeCustomUnit?: Unit | null | undefined;
+  memoType?: string | null;
+  memoValue?: string | null;
+  mode?: "send" | "changeTrust" | "send-legacy" | "send-eip1559";
+  assetReference?: string;
+  assetOwner?: string;
+  networkInfo?: NetworkInfo | null;
+};

package/src/bridge/generic-alpaca/utils.test.ts

@@ -1,8 +1,36 @@
-import { adaptCoreOperationToLiveOperation, extractBalance } from "./utils";
+import {
+  adaptCoreOperationToLiveOperation,
+  extractBalance,
+  findCryptoCurrencyByNetwork,
+} from "./utils";
 import BigNumber from "bignumber.js";
 import { Operation as CoreOperation } from "@ledgerhq/coin-framework/api/types";
 
 describe("Alpaca utils", () => {
+  describe("findCryptoCurrencyByNetwork", () => {
+    it("finds a crypto currency by id", () => {
+      expect(findCryptoCurrencyByNetwork("ethereum")).toMatchObject({
+        id: "ethereum",
+        family: "evm",
+      });
+    });
+
+    it("takes currency remapping into account", () => {
+      expect(findCryptoCurrencyByNetwork("ripple")).toMatchObject({
+        id: "ripple",
+        family: "xrp",
+      });
+      expect(findCryptoCurrencyByNetwork("xrp")).toMatchObject({
+        id: "ripple",
+        family: "xrp",
+      });
+    });
+
+    it("does not find non existing currencies", () => {
+      expect(findCryptoCurrencyByNetwork("non_existing_currency")).toBeUndefined();
+    });
+  });
+
   describe("extractBalance", () => {
     it("extracts an existing balance", () => {
       expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type1")).toEqual({