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

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,

package/src/bridge/mockHelpers.ts

@@ -183,3 +183,60 @@ export const makeAccountBridgeReceive: () => (
     path: account.freshAddressPath,
     publicKey: "mockPublickKey", // We could probably keep the publicKey in `account.freshPublicKey`
   });
+
+export const signRawOperation: AccountBridge<any>["signRawOperation"] = ({ account }) =>
+  new Observable(o => {
+    let cancelled = false;
+
+    async function main() {
+      await delay(1000);
+      if (cancelled) return;
+
+      for (let i = 0; i <= 1; i += 0.1) {
+        o.next({
+          type: "device-streaming",
+          progress: i,
+          index: i,
+          total: 10,
+        });
+        await delay(300);
+      }
+
+      o.next({
+        type: "device-signature-requested",
+      });
+      await delay(2000);
+      if (cancelled) return;
+      o.next({
+        type: "device-signature-granted",
+      });
+      const rng = new Prando("");
+      const op = genOperation(account, account, account.operations, rng);
+      op.type = "OUT";
+      op.value = new BigNumber(0);
+      op.blockHash = null;
+      op.blockHeight = null;
+      op.senders = [account.freshAddress];
+      op.recipients = [];
+      op.blockHeight = account.blockHeight;
+      op.date = new Date();
+      await delay(1000);
+      if (cancelled) return;
+      broadcasted[account.id] = (broadcasted[account.id] || []).concat(op);
+      o.next({
+        type: "signed",
+        signedOperation: {
+          operation: { ...op },
+          signature: "",
+        },
+      });
+    }
+
+    main().then(
+      () => o.complete(),
+      e => o.error(e),
+    );
+    return () => {
+      cancelled = true;
+    };
+  });