@ledgerhq/live-common 34.51.0-nightly.1 → 34.51.0-nightly.2

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

@@ -186,6 +186,14 @@ export const getNetworkAlpacaApi = (networkFamily: string) =>
     listOperations: buildListOperations(networkFamily),
     lastBlock: buildLastBlock(networkFamily),
     craftTransaction: buildCraftTransaction(networkFamily),
+    craftRawTransaction: (
+      _transaction: string,
+      _sender: string,
+      _publicKey: string,
+      _sequence: number,
+    ): Promise<CraftedTransaction> => {
+      throw new Error("craftRawTransaction is not supported");
+    },
     getBlock(_height): Promise<Block> {
       throw new Error("getBlock is not supported");
     },

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

@@ -7,10 +7,6 @@ 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);
-}
-
 function assetInfosFallback(transaction: GenericTransaction): {
   assetReference: string;
   assetOwner: string;
@@ -26,86 +22,67 @@ export function genericPrepareTransaction(
   kind,
 ): AccountBridge<GenericTransaction, Account>["prepareTransaction"] {
   return async (account, transaction: GenericTransaction) => {
-    const { getAssetFromToken, computeIntentType, estimateFees, validateIntent } = getAlpacaApi(
+    const { getAssetFromToken, computeIntentType, estimateFees } = getAlpacaApi(
       account.currency.id,
       kind,
     );
     const { assetReference, assetOwner } = getAssetFromToken
       ? getAssetInfos(transaction, account.freshAddress, getAssetFromToken)
       : assetInfosFallback(transaction);
-    const customParametersFees = transaction.customFees?.parameters?.fees;
-    let fees: BigNumber | bigint | null = customParametersFees || null;
-    if (fees === null) {
-      fees = (
-        await estimateFees(
-          transactionToIntent(
-            account,
-            {
-              ...transaction,
-            },
-            computeIntentType,
-          ),
-        )
-      ).value;
+
+    const next: GenericTransaction = {
+      ...transaction,
+      assetOwner,
+      assetReference,
+    };
+
+    const useAllAmount = !!next.useAllAmount || ["stake", "unstake"].includes(next.mode ?? "");
+
+    // Anticipate use cases where token amounts impact fee calculuses
+    if (useAllAmount && next.subAccountId) {
+      const subAccount = account.subAccounts?.find(sub => sub.id === next.subAccountId);
+
+      next.amount = subAccount?.spendableBalance ?? new BigNumber(0);
     }
 
-    if (!bnEq(transaction.fees, new BigNumber(fees.toString()))) {
-      const next: GenericTransaction = {
-        ...transaction,
-        fees: new BigNumber(fees.toString()),
-        assetReference,
-        assetOwner,
-        customFees: {
-          parameters: {
-            fees: customParametersFees ? new BigNumber(customParametersFees.toString()) : undefined,
-          },
-        },
-      };
-
-      // 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());
-        }
+    const intent = transactionToIntent(account, next, computeIntentType);
+    const estimation = await estimateFees(intent);
+    const customFeesValue = next.customFees?.parameters?.fees; // e.g. Stellar
+
+    next.fees = customFeesValue ?? new BigNumber(estimation.value.toString());
+
+    const fieldsToPropagate = ["storageLimit"] as const;
+
+    for (const field of fieldsToPropagate) {
+      const parameter = estimation.parameters?.[field];
+
+      if (
+        typeof parameter === "bigint" ||
+        typeof parameter === "number" ||
+        typeof parameter === "string"
+      ) {
+        next[field] = new BigNumber(parameter.toString());
       }
+    }
 
-      // align with stellar/xrp: when send max (or staking intents), reflect validated amount in UI
+    // Fees are now fixed, compute max spendable native
+    if (useAllAmount && !next.subAccountId) {
+      // Check if the estimation has been done for a custom amount
+      const estimatedAmount = estimation.parameters?.amount;
       if (
-        transaction.useAllAmount ||
-        transaction["mode"] === "stake" ||
-        transaction["mode"] === "unstake"
+        typeof estimatedAmount === "bigint" ||
+        typeof estimatedAmount === "number" ||
+        typeof estimatedAmount === "string"
       ) {
-        const { amount } = await validateIntent(
-          transactionToIntent(
-            account,
-            {
-              ...transaction,
-            },
-            computeIntentType,
-          ),
-        );
-        next.amount = new BigNumber(amount.toString());
+        next.amount = new BigNumber(estimatedAmount.toString());
+      } else {
+        next.amount = account.spendableBalance.gt(next.fees)
+          ? account.spendableBalance.minus(next.fees)
+          : new BigNumber(0);
       }
-      return next;
     }
 
-    return transaction;
+    return next;
   };
 }
 

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

@@ -8,7 +8,6 @@ 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 { log } from "@ledgerhq/logs";
-import BigNumber from "bignumber.js";
 import { GenericTransaction } from "./types";
 
 /**
@@ -86,25 +85,6 @@ export const genericSignOperation =
         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 || "",
-            subAccountId: transaction.subAccountId || "",
-            family: transaction.family,
-            feesStrategy: transaction.feesStrategy,
-            data: transaction.data,
-          };
-          const { amount } = await alpacaApi.validateIntent(
-            transactionToIntent(account, draftTransaction, alpacaApi.computeIntentType),
-            { value: fees },
-          );
-          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;

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

@@ -0,0 +1,86 @@
+import { Observable } from "rxjs";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { Account, DeviceId, SignOperationEvent, AccountBridge } from "@ledgerhq/types-live";
+import { getAlpacaApi } from "./alpaca";
+import { buildOptimisticOperation } from "./utils";
+import { Result } from "@ledgerhq/coin-framework/derivation";
+import { log } from "@ledgerhq/logs";
+import BigNumber from "bignumber.js";
+import { GenericTransaction } from "./types";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const genericSignRawOperation =
+  (network, kind) =>
+  (signerContext: SignerContext<any>): AccountBridge<GenericTransaction>["signRawOperation"] =>
+  ({
+    account,
+    transaction,
+    deviceId,
+  }: {
+    account: Account;
+    transaction: string;
+    deviceId: DeviceId;
+  }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      async function main() {
+        const alpacaApi = getAlpacaApi(account.currency.id, kind);
+        const signedInfo = await signerContext(deviceId, async signer => {
+          const derivationPath = account.freshAddressPath;
+          const { publicKey } = (await signer.getAddress(derivationPath)) as Result;
+
+          const sender = account.freshAddress;
+
+          // TODO: should compute it and pass it down to craftTransaction (duplicate call right now)
+          const sequenceNumber = await alpacaApi.getSequence(sender);
+
+          /* Craft unsigned blob via Alpaca */
+          const { transaction: unsigned } = await alpacaApi.craftRawTransaction(
+            transaction,
+            sender,
+            publicKey,
+            sequenceNumber,
+          );
+
+          /* Notify UI that the device is now showing the tx */
+          o.next({ type: "device-signature-requested" });
+          /* Sign on Ledger device */
+          const txnSig = await signer.signTransaction(derivationPath, unsigned);
+          return { unsigned, txnSig, publicKey, sequence: sequenceNumber };
+        });
+
+        /* If the user cancelled inside signerContext */
+        if (!signedInfo) return;
+        o.next({ type: "device-signature-granted" });
+
+        /* Combine payload + signature for broadcast */
+        const combined = await alpacaApi.combine(
+          signedInfo.unsigned,
+          signedInfo.txnSig,
+          signedInfo.publicKey,
+        );
+        const operation = buildOptimisticOperation(
+          account,
+          { family: account.currency.family, amount: new BigNumber(0), recipient: "" },
+          signedInfo.sequence,
+        );
+        if (!operation.id) {
+          log("Generic alpaca", "buildOptimisticOperation", operation);
+        }
+        // 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({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: combined,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

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

@@ -48,6 +48,7 @@ jest.mock("../buildSubAccounts", () => ({
 const chains = [
   { currency: { id: "stellar", name: "Stellar" }, network: "testnet" },
   { currency: { id: "ripple", name: "XRP" }, network: "mainnet" },
+  { currency: { id: "tezos", name: "Tezos" }, network: "mainnet" },
 ];
 
 describe("genericGetAccountShape (stellar & xrp)", () => {

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

@@ -1,172 +1,254 @@
 import { genericPrepareTransaction } from "../prepareTransaction";
 import { getAlpacaApi } from "../alpaca";
-import { transactionToIntent } from "../utils";
 import BigNumber from "bignumber.js";
+import * as accountModule from "@ledgerhq/coin-framework/account/index";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { Account } from "@ledgerhq/types-live";
 
 jest.mock("../alpaca", () => ({
   getAlpacaApi: jest.fn(),
 }));
 
-jest.mock("../utils", () => ({
-  transactionToIntent: jest.fn(),
-}));
-
 describe("genericPrepareTransaction", () => {
   const network = "testnet";
   const kind = "local";
 
-  const account = {
-    id: "test-account",
-    address: "0xabc",
-    currency: { id: "ethereum" },
-  } as any;
-
-  const baseTransaction = {
-    amount: new BigNumber(100_000),
-    fees: new BigNumber(500),
-    recipient: "0xrecipient",
-    family: "family",
-  };
-
-  const txIntent = { mock: "intent" };
-
   beforeEach(() => {
     jest.clearAllMocks();
-    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
   });
 
-  it("updates fees if they differ", async () => {
-    const newFee = new BigNumber(700);
-
+  it("embeds assets info, if existing", async () => {
     (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
+      estimateFees: jest.fn().mockResolvedValue({ value: 500n }),
+      getAssetFromToken: jest.fn().mockImplementation((token, owner) => {
+        return {
+          assetOwner: owner,
+          assetReference: token.contractAddress,
+        };
+      }),
     });
+    jest.spyOn(accountModule, "decodeTokenAccountId").mockImplementation(accountId => {
+      const token =
+        accountId === "ethereum_usdc_sub_account"
+          ? ({ contractAddress: "usdc_contract" } as TokenCurrency)
+          : undefined;
 
-    const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, { ...baseTransaction });
+      return { accountId, token };
+    });
 
-    expect((result as any).fees.toString()).toBe(newFee.toString());
-    expect(transactionToIntent).toHaveBeenCalledWith(
-      account,
-      expect.objectContaining(baseTransaction),
-      undefined,
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const resultUsdcToken = await prepareTransaction(
+      { currency: { id: "ethereum", units: [{}] }, freshAddress: "0xabc" } as Account,
+      {
+        amount: new BigNumber(100_000),
+        fees: new BigNumber(500),
+        recipient: "0xrecipient",
+        family: "family",
+        subAccountId: "ethereum_usdc_sub_account",
+      },
     );
-  });
-
-  it("returns original transaction if fees are the same", async () => {
-    const sameFee = baseTransaction.fees;
 
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: sameFee }),
+    expect(resultUsdcToken).toEqual({
+      amount: new BigNumber(100_000),
+      fees: new BigNumber(500),
+      recipient: "0xrecipient",
+      family: "family",
+      assetReference: "usdc_contract",
+      assetOwner: "0xabc",
+      subAccountId: "ethereum_usdc_sub_account",
     });
 
-    const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, baseTransaction);
+    const resultUnknownToken = await prepareTransaction(
+      { currency: { id: "ethereum", units: [{}] } } as Account,
+      {
+        amount: new BigNumber(100_000),
+        fees: new BigNumber(500),
+        recipient: "0xrecipient",
+        family: "family",
+        subAccountId: "ethereum_unknown_sub_account",
+      },
+    );
 
-    expect(result).toBe(baseTransaction);
+    expect(resultUnknownToken).toEqual({
+      amount: new BigNumber(100_000),
+      fees: new BigNumber(500),
+      recipient: "0xrecipient",
+      family: "family",
+      assetReference: "",
+      assetOwner: "",
+      subAccountId: "ethereum_unknown_sub_account",
+    });
   });
 
-  it("sets fee if original fees are undefined", async () => {
-    const newFee = new BigNumber(1234);
+  it.each([
+    ["all native amount", { useAllAmount: true }, new BigNumber(42)],
+    ["all native amount on staking scenarios", { mode: "stake" }, new BigNumber(42)],
+    ["all native amount on unstaking scenarios", { mode: "unstake" }, new BigNumber(42)],
+    [
+      "all token amount",
+      { subAccountId: "ethereum_usdc_sub_account", useAllAmount: true },
+      new BigNumber(5),
+    ],
+    [
+      "all token amount on staking scenarios",
+      { subAccountId: "ethereum_usdc_sub_account", mode: "stake" },
+      new BigNumber(5),
+    ],
+    [
+      "all token amount on unstaking scenarios",
+      { subAccountId: "ethereum_usdc_sub_account", mode: "unstake" },
+      new BigNumber(5),
+    ],
+  ] as const)("uses %s, updating the amount", async (_s, partialTransaction, expectedAmount) => {
     (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
+      estimateFees: jest.fn().mockResolvedValue({ value: 8n }),
+      getAssetFromToken: jest.fn().mockImplementation((token, owner) => {
+        return {
+          assetOwner: owner,
+          assetReference: token.contractAddress,
+        };
+      }),
+    });
+    jest.spyOn(accountModule, "decodeTokenAccountId").mockImplementation(accountId => {
+      const token =
+        accountId === "ethereum_usdc_sub_account"
+          ? ({ contractAddress: "usdc_contract" } as TokenCurrency)
+          : undefined;
+
+      return { accountId, token };
     });
 
-    const txWithoutFees = { ...baseTransaction, fees: undefined as any };
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, txWithoutFees);
+    const result = await prepareTransaction(
+      {
+        currency: { id: "ethereum", units: [{}] },
+        spendableBalance: new BigNumber(50),
+        subAccounts: [{ id: "ethereum_usdc_sub_account", spendableBalance: new BigNumber(5) }],
+      } as Account,
+      {
+        amount: new BigNumber(0),
+        recipient: "0xrecipient",
+        family: "family",
+        ...partialTransaction,
+      },
+    );
 
-    expect((result as any).fees.toString()).toBe(newFee.toString());
-    expect(result).not.toBe(txWithoutFees);
+    expect(result).toMatchObject({
+      amount: expectedAmount,
+      fees: new BigNumber(8),
+      recipient: "0xrecipient",
+      family: "family",
+    });
   });
 
-  it("returns original if fees are BigNumber-equal but different instance", async () => {
-    const sameValue = new BigNumber(baseTransaction.fees.toString()); // different instance
+  it("updates fees from the estimation", async () => {
     (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: sameValue }),
+      estimateFees: jest.fn().mockResolvedValue({ value: 700n }),
     });
 
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, baseTransaction);
+    const result = await prepareTransaction(
+      { currency: { id: "ethereum", units: [{}] } } as Account,
+      {
+        amount: new BigNumber(100_000),
+        fees: new BigNumber(500),
+        recipient: "0xrecipient",
+        family: "family",
+      },
+    );
 
-    expect(result).toBe(baseTransaction); // still same reference
+    expect(result).toEqual({
+      amount: new BigNumber(100_000),
+      fees: new BigNumber(700),
+      recipient: "0xrecipient",
+      family: "family",
+      assetReference: "",
+      assetOwner: "",
+    });
   });
 
-  it("propagates storageLimit from second estimation", async () => {
-    const estimatedFee = new BigNumber(491);
-
-    const estimateFeesFirstCall = jest.fn().mockResolvedValue({
-      value: estimatedFee,
-      parameters: { storageLimit: 300 },
+  it("updates fees from the existing custom", async () => {
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: 700n }),
     });
 
-    const estimateFeesSecondCall = jest.fn().mockResolvedValue({
-      value: estimatedFee,
-      parameters: { storageLimit: 0 },
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(
+      { currency: { id: "ethereum", units: [{}] } } as Account,
+      {
+        amount: new BigNumber(100_000),
+        fees: new BigNumber(500),
+        recipient: "0xrecipient",
+        family: "family",
+        customFees: { parameters: { fees: new BigNumber(600) } },
+      },
+    );
+
+    expect(result).toEqual({
+      amount: new BigNumber(100_000),
+      fees: new BigNumber(600),
+      customFees: { parameters: { fees: new BigNumber(600) } },
+      recipient: "0xrecipient",
+      family: "family",
+      assetReference: "",
+      assetOwner: "",
     });
+  });
 
+  it("propagates estimated 'storageLimit'", async () => {
     (getAlpacaApi as jest.Mock).mockReturnValue({
       estimateFees: jest
         .fn()
-        .mockImplementationOnce(() => estimateFeesFirstCall())
-        .mockImplementationOnce(() => estimateFeesSecondCall()),
+        .mockResolvedValue({ value: 700n, parameters: { storageLimit: 277n } }),
     });
 
-    const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, txWithoutCustomFees);
-
-    expect(result).toEqual(
-      expect.objectContaining({
-        fees: estimatedFee,
-        storageLimit: new BigNumber(0),
-        customFees: {
-          parameters: {
-            fees: undefined,
-          },
-        },
-      }),
+    const result = await prepareTransaction(
+      { currency: { id: "ethereum", units: [{}] } } as Account,
+      {
+        amount: new BigNumber(100_000),
+        fees: new BigNumber(500),
+        recipient: "0xrecipient",
+        family: "family",
+      },
     );
 
-    expect((getAlpacaApi as jest.Mock)().estimateFees).toHaveBeenCalledTimes(2);
-  });
-
-  it("propagates storageLimit showing new account scenario", async () => {
-    const estimatedFee = new BigNumber(491);
-
-    const estimateFeesFirstCall = jest.fn().mockResolvedValue({
-      value: estimatedFee,
-      parameters: { storageLimit: 300 },
-    });
-
-    const estimateFeesSecondCall = jest.fn().mockResolvedValue({
-      value: estimatedFee,
-      parameters: { storageLimit: 277 },
+    expect(result).toEqual({
+      amount: new BigNumber(100_000),
+      fees: new BigNumber(700),
+      storageLimit: new BigNumber(277),
+      recipient: "0xrecipient",
+      family: "family",
+      assetReference: "",
+      assetOwner: "",
     });
+  });
 
+  it("keeps the amount used during the estimation when using all native amount", async () => {
     (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest
-        .fn()
-        .mockImplementationOnce(() => estimateFeesFirstCall())
-        .mockImplementationOnce(() => estimateFeesSecondCall()),
+      estimateFees: jest.fn().mockResolvedValue({ value: 700n, parameters: { amount: 1000n } }),
     });
 
-    const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, txWithoutCustomFees);
-
-    expect(result).toEqual(
-      expect.objectContaining({
-        fees: estimatedFee,
-        storageLimit: new BigNumber(277),
-        customFees: {
-          parameters: {
-            fees: undefined,
-          },
-        },
-      }),
+    const result = await prepareTransaction(
+      { currency: { id: "ethereum", units: [{}] } } as Account,
+      {
+        amount: new BigNumber(0),
+        fees: new BigNumber(500),
+        recipient: "0xrecipient",
+        family: "family",
+        useAllAmount: true,
+      },
     );
 
-    expect((getAlpacaApi as jest.Mock)().estimateFees).toHaveBeenCalledTimes(2);
+    expect(result).toEqual({
+      amount: new BigNumber(1000),
+      fees: new BigNumber(700),
+      recipient: "0xrecipient",
+      family: "family",
+      assetReference: "",
+      assetOwner: "",
+      useAllAmount: true,
+    });
   });
 });

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

@@ -134,6 +134,7 @@ export function transactionToIntent(
   const res: TransactionIntent & { memo?: { type: string; value?: string } } & {
     data?: { type: string; value?: unknown };
   } = {
+    intentType: isStaking ? "staking" : "transaction",
     type: intentType,
     sender: account.freshAddress,
     recipient: transaction.recipient,