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

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

@@ -26,7 +26,10 @@ export function genericPrepareTransaction(
   kind,
 ): AccountBridge<GenericTransaction, Account>["prepareTransaction"] {
   return async (account, transaction: GenericTransaction) => {
-    const { getAssetFromToken } = getAlpacaApi(account.currency.id, kind);
+    const { getAssetFromToken, computeIntentType, estimateFees, validateIntent } = getAlpacaApi(
+      account.currency.id,
+      kind,
+    );
     const { assetReference, assetOwner } = getAssetFromToken
       ? getAssetInfos(transaction, account.freshAddress, getAssetFromToken)
       : assetInfosFallback(transaction);
@@ -34,16 +37,20 @@ export function genericPrepareTransaction(
     let fees: BigNumber | bigint | null = transaction.customFees?.parameters?.fees || null;
     if (fees === null) {
       fees = (
-        await getAlpacaApi(account.currency.id, kind).estimateFees(
-          transactionToIntent(account, {
-            ...transaction,
-          }),
+        await estimateFees(
+          transactionToIntent(
+            account,
+            {
+              ...transaction,
+            },
+            computeIntentType,
+          ),
         )
       ).value;
     }
 
     if (!bnEq(transaction.fees, new BigNumber(fees.toString()))) {
-      return {
+      const next: GenericTransaction = {
         ...transaction,
         fees: new BigNumber(fees.toString()),
         assetReference,
@@ -54,6 +61,52 @@ export function genericPrepareTransaction(
           },
         },
       };
+
+      // propagate storageLimit fee parameter when present (ex: tezos)
+      const feeEstimation = await estimateFees(
+        transactionToIntent(
+          account,
+          {
+            ...transaction,
+          },
+          computeIntentType,
+        ),
+      );
+      const params = feeEstimation?.parameters;
+      if (params) {
+        const storageLimit = params["storageLimit"];
+        if (
+          storageLimit !== undefined &&
+          (typeof storageLimit === "bigint" ||
+            typeof storageLimit === "number" ||
+            typeof storageLimit === "string")
+        ) {
+          next.storageLimit = new BigNumber(storageLimit.toString());
+          // Add storageLimit to customFees parameters
+          if (next.customFees?.parameters) {
+            next.customFees.parameters.storageLimit = new BigNumber(storageLimit.toString());
+          }
+        }
+      }
+
+      // align with stellar/xrp: when send max (or staking intents), reflect validated amount in UI
+      if (
+        transaction.useAllAmount ||
+        transaction["mode"] === "stake" ||
+        transaction["mode"] === "unstake"
+      ) {
+        const { amount } = await validateIntent(
+          transactionToIntent(
+            account,
+            {
+              ...transaction,
+            },
+            computeIntentType,
+          ),
+        );
+        next.amount = new BigNumber(amount.toString());
+      }
+      return next;
     }
 
     return transaction;

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

@@ -96,9 +96,11 @@ export const genericSignOperation =
             assetOwner: transaction?.assetOwner || "",
             subAccountId: transaction.subAccountId || "",
             family: transaction.family,
+            feesStrategy: transaction.feesStrategy,
+            data: transaction.data,
           };
           const { amount } = await alpacaApi.validateIntent(
-            transactionToIntent(account, draftTransaction),
+            transactionToIntent(account, draftTransaction, alpacaApi.computeIntentType),
             { value: fees },
           );
           transaction.amount = new BigNumber(amount.toString());
@@ -107,7 +109,11 @@ export const genericSignOperation =
           const derivationPath = account.freshAddressPath;
           const { publicKey } = (await signer.getAddress(derivationPath)) as Result;
 
-          let transactionIntent = transactionToIntent(account, { ...transaction });
+          let transactionIntent = transactionToIntent(
+            account,
+            { ...transaction },
+            alpacaApi.computeIntentType,
+          );
           transactionIntent.senderPublicKey = publicKey;
 
           // Enrich with memo and asset information

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

@@ -1,12 +1,15 @@
 import xrpGetAddress from "@ledgerhq/coin-xrp/signer/getAddress";
 import stellarGetAddress from "@ledgerhq/coin-stellar/signer/getAddress";
 import Stellar from "@ledgerhq/hw-app-str";
-import { signTransaction, stellarSignTransaction } from "./signTransaction";
+import { signTransaction, stellarSignTransaction, tezosSignTransaction } from "./signTransaction";
 import { StrKey } from "@stellar/stellar-sdk";
 import { CreateSigner, executeWithSigner } from "../../setup";
 import Xrp from "@ledgerhq/hw-app-xrp";
 import Transport from "@ledgerhq/hw-transport";
 import { AlpacaSigner } from "./types";
+import { DerivationType, LedgerSigner as TaquitoLedgerSigner } from "@taquito/ledger-signer";
+import tezosGetAddress from "@ledgerhq/coin-tezos/signer/getAddress";
+import Tezos from "@ledgerhq/hw-app-tezos";
 
 const createSignerXrp: CreateSigner<Xrp> = (transport: Transport) => {
   return new Xrp(transport);
@@ -37,6 +40,39 @@ const createSignerStellar: CreateSigner<Stellar> = (transport: Transport) => {
 
 const signerContextStellar = executeWithSigner(createSignerStellar);
 
+const createSignerTezos: CreateSigner<
+  Tezos & { createLedgerSigner: (path: string, prompt: boolean, derivationType: number) => any }
+> = (transport: Transport) => {
+  const tezos = new Tezos(transport);
+  // align with genericSignOperation that calls signer.signTransaction
+  return Object.assign(tezos, {
+    async signTransaction(path: string, rawTxHex: string) {
+      const { signature } = await tezos.signOperation(path, rawTxHex, {});
+      return signature;
+    },
+    async getAddress(path: string, { verify }: { verify?: boolean } = {}) {
+      // Use Taquito LedgerSigner to retrieve base58 public key and matching pkh (like oldbridge)
+      const ledgerSigner = new TaquitoLedgerSigner(
+        transport,
+        path,
+        !!verify,
+        DerivationType.ED25519,
+      );
+      const address = await ledgerSigner.publicKeyHash();
+      const publicKey = await ledgerSigner.publicKey();
+      return { path, address, publicKey };
+    },
+    createLedgerSigner(path: string, prompt: boolean, derivationType: number) {
+      // Map 0 -> ED25519, 1 -> SECP256K1, 2 -> P256 by convention
+      let dt: DerivationType = DerivationType.ED25519;
+      if (derivationType === 1) dt = DerivationType.SECP256K1;
+      else if (derivationType === 2) dt = DerivationType.P256;
+      return new TaquitoLedgerSigner(transport, path, prompt, dt);
+    },
+  });
+};
+const signerContextTezos = executeWithSigner(createSignerTezos);
+
 export function getSigner(network: string): AlpacaSigner {
   switch (network) {
     case "ripple":
@@ -54,6 +90,13 @@ export function getSigner(network: string): AlpacaSigner {
         context: signerContextStellar,
       };
     }
+    case "tezos": {
+      return {
+        getAddress: tezosGetAddress(signerContextTezos),
+        signTransaction: tezosSignTransaction(executeWithSigner(createSignerTezos)),
+        context: signerContextTezos,
+      };
+    }
   }
   throw new Error(`signer for ${network} not implemented`);
 }

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

@@ -1,5 +1,6 @@
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { StellarSigner } from "@ledgerhq/coin-stellar/types/signer";
+import { TezosSigner } from "@ledgerhq/coin-tezos/types/signer";
 import { LegacySigner, SignTransactionOptions } from "./types";
 
 export const signTransaction = <Signer extends LegacySigner>(
@@ -23,3 +24,12 @@ export const stellarSignTransaction = (signerContext: SignerContext<StellarSigne
     return signedTx.signature.toString("base64"); // It should return a Buffer
   };
 };
+
+export const tezosSignTransaction = (signerContext: SignerContext<TezosSigner>) => {
+  return async (deviceId: string, { path, rawTxHex }: SignTransactionOptions) => {
+    const signed = await signerContext(deviceId, signer =>
+      signer.signOperation(path, rawTxHex, {}),
+    );
+    return signed.signature;
+  };
+};

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

@@ -35,9 +35,23 @@ const dummyAccounts = [
     freshAddress: "s123",
     pendingOperations: [],
   },
+  {
+    id: "js:2:tezos:t123",
+    type: "Account",
+    spendableBalance: new BigNumber(50000000),
+    balance: new BigNumber(60000000),
+    currency: {
+      id: "tezos",
+      family: "tezos",
+      name: "Tezos",
+      units: [{ name: "XTZ", magnitude: 6 }],
+    },
+    freshAddress: "t123",
+    pendingOperations: [],
+  },
 ] as unknown as Account[];
 
-["xrp", "stellar"].forEach((currencyName, idx) => {
+["xrp", "stellar", "tezos"].forEach((currencyName, idx) => {
   describe(`genericEstimateMaxSpendable for ${currencyName}`, () => {
     const dummyAccount = dummyAccounts[idx];
 

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

@@ -49,6 +49,7 @@ describe("genericPrepareTransaction", () => {
     expect(transactionToIntent).toHaveBeenCalledWith(
       account,
       expect.objectContaining(baseTransaction),
+      undefined,
     );
   });
 

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

@@ -14,7 +14,7 @@ jest.mock("../utils", () => ({
   transactionToIntent: jest.fn(),
 }));
 describe("genericSignOperation", () => {
-  const networks = ["xrp", "stellar"];
+  const networks = ["xrp", "stellar", "tezos"];
   const kind = "local";
 
   const mockSignerContext = jest.fn();
@@ -83,7 +83,7 @@ describe("genericSignOperation", () => {
         },
       });
 
-      expect(transactionToIntent).toHaveBeenCalledWith(account, transaction);
+      expect(transactionToIntent).toHaveBeenCalledWith(account, transaction, undefined);
       expect(txIntent.memo.memos.get("destinationTag")).toBe("1234");
     });
 

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

@@ -9,14 +9,25 @@ type NetworkInfo = {
 export type GenericTransaction = TransactionCommon & {
   family: string;
   fees?: BigNumber | null;
+  storageLimit?: BigNumber | null;
   customFees?: {
-    parameters: { fees?: BigNumber | null };
+    parameters: { fees?: BigNumber | null; storageLimit?: BigNumber | null };
   };
   tag?: number | null | undefined;
   feeCustomUnit?: Unit | null | undefined;
   memoType?: string | null;
   memoValue?: string | null;
-  mode?: "send" | "changeTrust" | "send-legacy" | "send-eip1559";
+  data?: Buffer;
+  mode?:
+    | "send"
+    | "changeTrust"
+    | "send-legacy"
+    | "send-eip1559"
+    | "delegate"
+    | "stake"
+    | "undelegate"
+    | "unstake";
+  type?: number;
   assetReference?: string;
   assetOwner?: string;
   networkInfo?: NetworkInfo | null;

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

@@ -2,11 +2,76 @@ import {
   adaptCoreOperationToLiveOperation,
   extractBalance,
   findCryptoCurrencyByNetwork,
+  transactionToIntent,
 } from "./utils";
 import BigNumber from "bignumber.js";
 import { Operation as CoreOperation } from "@ledgerhq/coin-framework/api/types";
+import { Account } from "@ledgerhq/types-live";
+import { GenericTransaction } from "./types";
 
 describe("Alpaca utils", () => {
+  describe("transactionToIntent", () => {
+    describe("type", () => {
+      it("fallbacks to 'Payment' without a transaction mode", () => {
+        expect(
+          transactionToIntent(
+            { currency: { name: "ethereum", units: [{}] } } as Account,
+            { mode: undefined } as GenericTransaction,
+          ),
+        ).toMatchObject({
+          type: "Payment",
+        });
+      });
+
+      it.each([
+        ["changeTrust", "changeTrust"],
+        ["send", "send"],
+        ["send-legacy", "send-legacy"],
+        ["send-eip1559", "send-eip1559"],
+        ["stake", "stake"],
+        ["unstake", "unstake"],
+        ["delegate", "stake"],
+        ["undelegate", "unstake"],
+      ])(
+        "by default, associates '%s' transaction mode to '%s' intent type",
+        (mode, expectedType) => {
+          expect(
+            transactionToIntent(
+              { currency: { name: "ethereum", units: [{}] } } as Account,
+              { mode } as GenericTransaction,
+            ),
+          ).toMatchObject({
+            type: expectedType,
+          });
+        },
+      );
+
+      it("rejects other modes", () => {
+        expect(() =>
+          transactionToIntent(
+            { currency: { name: "ethereum", units: [{}] } } as Account,
+            { mode: "any" as unknown } as GenericTransaction,
+          ),
+        ).toThrow("Unsupported transaction mode: any");
+      });
+
+      it("supersedes the logic with a custom function", () => {
+        const computeIntentType = (transaction: GenericTransaction) =>
+          transaction.mode === "send" && transaction.type === 2 ? "send-eip1559" : "send-legacy";
+
+        expect(
+          transactionToIntent(
+            { currency: { name: "ethereum", units: [{}] } } as Account,
+            { mode: "send", type: 2 } as GenericTransaction,
+            computeIntentType,
+          ),
+        ).toMatchObject({
+          type: "send-eip1559",
+        });
+      });
+    });
+  });
+
   describe("findCryptoCurrencyByNetwork", () => {
     it("finds a crypto currency by id", () => {
       expect(findCryptoCurrencyByNetwork("ethereum")).toMatchObject({

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

@@ -78,6 +78,25 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
   return res;
 }
 
+/**
+ * Default implementation of `computeIntentType` is a simple whitelist
+ * with a fallback to "Payment"
+ */
+function defaultComputeIntentType(transaction: GenericTransaction): string {
+  if (!transaction.mode) return "Payment"; // NOTE: assuming payment by default here, can be changed based on transaction.mode
+
+  const modeRemap = {
+    delegate: "stake",
+    undelegate: "unstake",
+  };
+  const mode = modeRemap[transaction.mode] ?? transaction.mode;
+
+  if (["changeTrust", "send", "send-legacy", "send-eip1559", "stake", "unstake"].includes(mode))
+    return mode;
+
+  throw new Error(`Unsupported transaction mode: ${transaction.mode}`);
+}
+
 /**
  * Converts a transaction object into a `TransactionIntent` object, which is used to represent
  * the intent of a transaction in a standardized format.
@@ -92,6 +111,7 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
  *   - `fees` (optional): The fees associated with the transaction.
  *   - `memoType` (optional): The type of memo to attach to the transaction.
  *   - `memoValue` (optional): The value of the memo to attach to the transaction.
+ * @param computeIntentType - An optional function to compute the intent type that supersedes the default implementation if present
  *
  * @returns A `TransactionIntent` object containing the standardized representation of the transaction.
  *   - Includes details such as type, sender, recipient, amount, fees, asset, and an optional memo.
@@ -103,41 +123,34 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
 export function transactionToIntent(
   account: Account,
   transaction: GenericTransaction,
-): TransactionIntent<any> & { memo?: { type: string; value?: string } } {
-  let transactionType = "Payment"; // NOTE: assuming payment by default here, can be changed based on transaction.mode
-  if (transaction.mode) {
-    switch (transaction.mode) {
-      case "changeTrust":
-        transactionType = "changeTrust";
-        break;
-      case "send":
-        transactionType = "send";
-        break;
-      case "send-legacy":
-        transactionType = "send-legacy";
-        break;
-      case "send-eip1559":
-        transactionType = "send-eip1559";
-        break;
-      default:
-        throw new Error(`Unsupported transaction mode: ${transaction.mode}`);
-    }
-  }
-  const res: TransactionIntent & { memo?: { type: string; value?: string } } = {
-    type: transactionType,
+  computeIntentType?: (transaction: GenericTransaction) => string,
+): TransactionIntent & { memo?: { type: string; value?: string } } & {
+  data?: { type: string; value?: unknown };
+} {
+  const intentType = (computeIntentType ?? defaultComputeIntentType)(transaction);
+  const isStaking = ["stake", "unstake"].includes(intentType);
+  const amount = isStaking ? 0n : fromBigNumberToBigInt(transaction.amount, 0n);
+  const useAllAmount = isStaking || !!transaction.useAllAmount;
+  const res: TransactionIntent & { memo?: { type: string; value?: string } } & {
+    data?: { type: string; value?: unknown };
+  } = {
+    type: intentType,
     sender: account.freshAddress,
     recipient: transaction.recipient,
-    amount: fromBigNumberToBigInt(transaction.amount, BigInt(0)),
+    amount,
     asset: { type: "native", name: account.currency.name, unit: account.currency.units[0] },
-    useAllAmount: !!transaction.useAllAmount,
+    useAllAmount,
+    feesStrategy:
+      transaction.feesStrategy === "custom" ? undefined : transaction.feesStrategy ?? undefined,
+    data: Buffer.isBuffer(transaction.data)
+      ? { type: "buffer", value: transaction.data }
+      : { type: "none" },
   };
   if (transaction.assetReference && transaction.assetOwner) {
     const { subAccountId } = transaction;
     const { subAccounts } = account;
 
-    const tokenAccount = !subAccountId
-      ? null
-      : subAccounts && subAccounts.find(ta => ta.id === subAccountId);
+    const tokenAccount = subAccountId ? subAccounts?.find(ta => ta.id === subAccountId) : null;
 
     res.asset = {
       type: tokenAccount?.token.tokenType ?? "token",
@@ -155,6 +168,7 @@ export function transactionToIntent(
   } else {
     res.memo = { type: "NO_MEMO" };
   }
+
   return res;
 }
 
@@ -188,9 +202,7 @@ export const buildOptimisticOperation = (
     },
   };
 
-  const tokenAccount = !subAccountId
-    ? null
-    : subAccounts && subAccounts.find(ta => ta.id === subAccountId);
+  const tokenAccount = subAccountId ? subAccounts?.find(ta => ta.id === subAccountId) : null;
   if (tokenAccount && subAccountId) {
     operation.subOperations = [
       {

package/src/bridge/impl.ts

@@ -27,6 +27,7 @@ import { getCryptoAssetsStore, setCryptoAssetsStore } from "./crypto-assets";
 const alpacaized = {
   xrp: true,
   stellar: true,
+  tezos: true,
 };
 
 // let accountBridgeInstance: AccountBridge<any> | null = null;

package/src/bridge/react/BridgeSync.tsx

@@ -12,6 +12,7 @@ import type { SyncAction, SyncState, BridgeSyncState } from "./types";
 import { BridgeSyncContext, BridgeSyncStateContext } from "./context";
 import type { Account, TokenAccount } from "@ledgerhq/types-live";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { createSyncSessionManager } from "../syncSessionManager";
 
 export type Props = {
   // this is a wrapping component that you need to put in your tree
@@ -52,6 +53,7 @@ export const BridgeSync = ({
     accounts,
     hydrateCurrency,
   });
+  const sessionManager = useRef(createSyncSessionManager(trackAnalytics)).current;
   const [syncQueue, syncState] = useSyncQueue({
     accounts,
     prepareCurrency,
@@ -59,10 +61,12 @@ export const BridgeSync = ({
     trackAnalytics,
     updateAccountWithUpdater,
     blacklistedTokenIds,
+    sessionManager,
   });
   const sync = useSync({
     syncQueue,
     accounts,
+    sessionManager,
   });
   useSyncBackground({
     sync,
@@ -111,6 +115,7 @@ function useSyncQueue({
   trackAnalytics,
   updateAccountWithUpdater,
   blacklistedTokenIds,
+  sessionManager,
 }) {
   const [bridgeSyncState, setBridgeSyncState]: [BridgeSyncState, any] = useState({});
   const setAccountSyncState = useCallback((accountId: string, s: SyncState) => {
@@ -204,6 +209,7 @@ function useSyncQueue({
               pending: false,
               error: null,
             });
+            sessionManager.onAccountSyncDone(accountId, accounts);
             next();
           },
           error: (raw: Error) => {
@@ -215,6 +221,7 @@ function useSyncQueue({
                 pending: false,
                 error: null,
               });
+              sessionManager.onAccountSyncDone(accountId, accounts);
               next();
               return;
             }
@@ -223,6 +230,7 @@ function useSyncQueue({
               pending: false,
               error,
             });
+            sessionManager.onAccountSyncDone(accountId, accounts, true);
             next();
           },
         });
@@ -231,6 +239,7 @@ function useSyncQueue({
           pending: false,
           error,
         });
+        sessionManager.onAccountSyncDone(accountId, accounts, true);
         next();
       }
     },
@@ -243,6 +252,7 @@ function useSyncQueue({
       trackAnalytics,
       updateAccountWithUpdater,
       blacklistedTokenIds,
+      sessionManager,
     ],
   );
   const synchronizeRef = useRef(synchronize);
@@ -259,7 +269,7 @@ function useSyncQueue({
 }
 
 // useSync: returns a sync function with the syncQueue
-function useSync({ syncQueue, accounts }) {
+function useSync({ syncQueue, accounts, sessionManager }) {
   const skipUnderPriority = useRef(-1);
   const sync = useMemo(() => {
     const schedule = (ids: string[], priority: number, reason: string) => {
@@ -267,6 +277,10 @@ function useSync({ syncQueue, accounts }) {
       // by convention we remove concurrent tasks with same priority
       // FIXME this is somehow a hack. ideally we should just dedup the account ids in the pending queue...
       syncQueue.remove(o => priority === o.priority);
+      // start a global session only if initial + all accounts
+      if (reason === "initial" && ids.length === accounts.length) {
+        sessionManager.start(ids, reason);
+      }
       log("bridge", "schedule " + ids.join(", "));
       syncQueue.push(
         ids.map(accountId => ({
@@ -289,7 +303,7 @@ function useSync({ syncQueue, accounts }) {
       SET_SKIP_UNDER_PRIORITY: ({ priority }: { priority: number }) => {
         if (priority === skipUnderPriority.current) return;
         skipUnderPriority.current = priority;
-        syncQueue.remove(({ priority }) => priority < skipUnderPriority);
+        syncQueue.remove(({ priority }) => priority < skipUnderPriority.current);
 
         if (priority === -1 && !accounts.every(isUpToDateAccount)) {
           // going back to -1 priority => retriggering a background sync if it is "Paused"
@@ -338,7 +352,7 @@ function useSync({ syncQueue, accounts }) {
         });
       }
     };
-  }, [accounts, syncQueue]);
+  }, [accounts, syncQueue, sessionManager]);
   const ref = useRef(sync);
   useEffect(() => {
     ref.current = sync;