@ledgerhq/live-common 21.30.1 → 21.32.2

package/src/families/celo/js-createTransaction.ts

@@ -0,0 +1,12 @@
+import { Transaction } from "./types";
+import { BigNumber } from "bignumber.js";
+
+const createTransaction = (): Transaction => ({
+  family: "celo",
+  amount: new BigNumber(0),
+  recipient: "",
+  useAllAmount: false,
+  fees: null,
+});
+
+export default createTransaction;

package/src/families/celo/js-estimateMaxSpendable.ts

@@ -0,0 +1,28 @@
+import { Account, AccountLike } from "../../types";
+import { Transaction } from "./types";
+import { BigNumber } from "bignumber.js";
+import { getMainAccount } from "../../account";
+import getTransactionStatus from "./js-getTransactionStatus";
+import prepareTransaction from "./js-prepareTransaction";
+import createTransaction from "./js-createTransaction";
+
+const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account;
+  transaction: Transaction;
+}): Promise<BigNumber> => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const t = await prepareTransaction(mainAccount, {
+    ...createTransaction(),
+    ...transaction,
+    useAllAmount: true,
+  });
+  const s = await getTransactionStatus(mainAccount, t);
+  return s.amount;
+};
+
+export default estimateMaxSpendable;

package/src/families/celo/js-getFeesForTransaction.ts

@@ -0,0 +1,38 @@
+import { BigNumber } from "bignumber.js";
+import { Account, Transaction } from "../../types";
+import { celoKit } from "./api/sdk";
+
+const getFeesForTransaction = async ({
+  account,
+  transaction,
+}: {
+  account: Account;
+  transaction: Transaction;
+}): Promise<BigNumber> => {
+  const { amount } = transaction;
+  const kit = celoKit();
+
+  // A workaround - estimating gas throws an error if value > funds
+  const value = transaction.useAllAmount
+    ? account.spendableBalance
+    : BigNumber.minimum(amount, account.spendableBalance);
+
+  const celoToken = await kit.contracts.getGoldToken();
+
+  const celoTransaction = {
+    from: account.freshAddress,
+    to: celoToken.address,
+    data: celoToken
+      .transfer(transaction.recipient, value.toFixed())
+      .txo.encodeABI(),
+  };
+
+  const gasPrice = new BigNumber(await kit.connection.gasPrice());
+  const gas = await kit.connection.estimateGasWithInflationFactor(
+    celoTransaction
+  );
+
+  return gasPrice.times(gas);
+};
+
+export default getFeesForTransaction;

package/src/families/celo/js-getTransactionStatus.ts

@@ -0,0 +1,67 @@
+import { Account, TransactionStatus } from "../../types";
+import { Transaction } from "./types";
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { BigNumber } from "bignumber.js";
+import { isValidAddress } from "@celo/utils/lib/address";
+
+const getTransactionStatus = async (
+  account: Account,
+  transaction: Transaction
+): Promise<TransactionStatus> => {
+  const errors: any = {};
+  const warnings: any = {};
+  const useAllAmount = !!transaction.useAllAmount;
+
+  if (account.freshAddress === transaction.recipient) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  if (!transaction.fees || !transaction.fees.gt(0)) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  const estimatedFees = transaction.fees || new BigNumber(0);
+
+  const amount = useAllAmount
+    ? account.spendableBalance.minus(estimatedFees)
+    : new BigNumber(transaction.amount);
+
+  if (amount.lte(0) && !transaction.useAllAmount) {
+    errors.amount = new AmountRequired();
+  }
+
+  const totalSpent = amount.plus(estimatedFees);
+
+  if (totalSpent.gt(account.spendableBalance)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  if (!errors.amount && account.spendableBalance.lt(estimatedFees)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  if (!transaction.recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (!isValidAddress(transaction.recipient)) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  });
+};
+
+export default getTransactionStatus;

package/src/families/celo/js-prepareTransaction.ts

@@ -0,0 +1,28 @@
+import { Account } from "../../types";
+import { Transaction } from "./types";
+import getFeesForTransaction from "./js-getFeesForTransaction";
+import { isValidAddress } from "@celo/utils/lib/address";
+
+const sameFees = (a, b) => (!a || !b ? a === b : a.eq(b));
+
+const prepareTransaction = async (
+  account: Account,
+  transaction: Transaction
+) => {
+  if (
+    !transaction.recipient ||
+    (transaction.recipient && !isValidAddress(transaction.recipient))
+  ) {
+    return transaction;
+  }
+
+  const fees = await getFeesForTransaction({ account, transaction });
+
+  if (!sameFees(transaction.fees, fees)) {
+    return { ...transaction, fees };
+  }
+
+  return transaction;
+};
+
+export default prepareTransaction;

package/src/families/celo/js-signOperation.ts

@@ -0,0 +1,149 @@
+import { BigNumber } from "bignumber.js";
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import type { Transaction } from "./types";
+import type { Account, Operation, SignOperationEvent } from "../../types";
+import { encodeOperationId } from "../../operation";
+import { CeloApp } from "./hw-app-celo";
+import buildTransaction from "./js-buildTransaction";
+import { rlpEncodedTx, encodeTransaction } from "@celo/wallet-base";
+import { tokenInfoByAddressAndChainId } from "@celo/wallet-ledger/lib/tokens";
+import { withDevice } from "../../hw/deviceAccess";
+
+const buildOptimisticOperation = (
+  account: Account,
+  transaction: Transaction,
+  fee: BigNumber
+): Operation => {
+  const type = "OUT";
+
+  const value = new BigNumber(transaction.amount).plus(fee);
+
+  const operation: Operation = {
+    id: encodeOperationId(account.id, "", type),
+    hash: "",
+    type,
+    value,
+    fee,
+    blockHash: null,
+    blockHeight: null,
+    senders: [account.freshAddress],
+    recipients: [transaction.recipient].filter(Boolean),
+    accountId: account.id,
+    date: new Date(),
+    extra: { additionalField: transaction.amount },
+  };
+
+  return operation;
+};
+
+const trimLeading0x = (input: string) =>
+  input.startsWith("0x") ? input.slice(2) : input;
+
+const parseSigningResponse = (
+  response: {
+    s: string;
+    v: string;
+    r: string;
+  },
+  chainId: number
+): {
+  s: Buffer;
+  v: number;
+  r: Buffer;
+} => {
+  // EIP155
+  const sigV = parseInt(response.v, 16);
+  let eip155V = chainId * 2 + 35;
+  if (sigV !== eip155V && (sigV & eip155V) !== sigV) {
+    eip155V += 1;
+  }
+
+  return {
+    s: Buffer.from(response.s, "hex"),
+    v: eip155V,
+    r: Buffer.from(response.r, "hex"),
+  };
+};
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+const signOperation = ({
+  account,
+  deviceId,
+  transaction,
+}: {
+  account: Account;
+  deviceId: any;
+  transaction: Transaction;
+}): Observable<SignOperationEvent> =>
+  withDevice(deviceId)(
+    (transport) =>
+      new Observable((o) => {
+        let cancelled;
+
+        async function main() {
+          if (!transaction.fees) {
+            throw new FeeNotLoaded();
+          }
+
+          const celo = new CeloApp(transport);
+          const unsignedTransaction = await buildTransaction(
+            account,
+            transaction
+          );
+          const { chainId, to } = unsignedTransaction;
+          const rlpEncodedTransaction = rlpEncodedTx(unsignedTransaction);
+
+          const tokenInfo = tokenInfoByAddressAndChainId(to!, chainId!);
+          if (tokenInfo) {
+            await celo.provideERC20TokenInformation(tokenInfo);
+          }
+
+          o.next({ type: "device-signature-requested" });
+
+          const response = await celo.signTransaction(
+            account.freshAddressPath,
+            trimLeading0x(rlpEncodedTransaction.rlpEncode)
+          );
+
+          if (cancelled) return;
+
+          const signature = parseSigningResponse(response, chainId!);
+
+          o.next({ type: "device-signature-granted" });
+
+          const encodedTransaction = await encodeTransaction(
+            rlpEncodedTransaction,
+            signature
+          );
+
+          const operation = buildOptimisticOperation(
+            account,
+            transaction,
+            transaction.fees ?? new BigNumber(0)
+          );
+
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature: encodedTransaction.raw,
+              expirationDate: null,
+            },
+          });
+        }
+
+        main().then(
+          () => o.complete(),
+          (e) => o.error(e)
+        );
+
+        return () => {
+          cancelled = true;
+        };
+      })
+  );
+
+export default signOperation;

package/src/families/celo/js-synchronisation.ts

@@ -0,0 +1,40 @@
+import type { Account } from "../../types";
+import { encodeAccountId } from "../../account";
+import type { GetAccountShape } from "../../bridge/jsHelpers";
+import { makeSync, makeScanAccounts, mergeOps } from "../../bridge/jsHelpers";
+import { getAccountDetails } from "./api";
+
+const getAccountShape: GetAccountShape = async (info) => {
+  const { address, currency, initialAccount, derivationMode } = info;
+  const oldOperations = initialAccount?.operations || [];
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+  const {
+    blockHeight,
+    balance,
+    spendableBalance,
+    operations: newOperations,
+  } = await getAccountDetails(address, accountId);
+  const operations = mergeOps(oldOperations, newOperations);
+  const shape = {
+    id: accountId,
+    balance,
+    spendableBalance,
+    operationsCount: operations.length,
+    blockHeight,
+  };
+  return { ...shape, operations };
+};
+
+const postSync = (_initial: Account, parent: Account) => {
+  return parent;
+};
+
+export const scanAccounts = makeScanAccounts(getAccountShape);
+export const sync = makeSync(getAccountShape, postSync);

package/src/families/celo/specs.ts

@@ -0,0 +1,53 @@
+import invariant from "invariant";
+import type { Transaction } from "./types";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
+import { pickSiblings } from "../../bot/specs";
+import type { AppSpec } from "../../bot/types";
+import { DeviceModelId } from "@ledgerhq/devices";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+const maxAccount = 3;
+
+const celo: AppSpec<Transaction> = {
+  name: "Celo",
+  currency,
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Celo",
+  },
+  testTimeout: 2 * 60 * 1000,
+  mutations: [
+    {
+      name: "move 50% to another account",
+      maxRun: 2,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minimalAmount), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        const amount = maxSpendable.div(2).integerValue();
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ recipient }, { amount }],
+        };
+      },
+    },
+    {
+      name: "send max to another account",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minimalAmount), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ recipient }, { useAllAmount: true }],
+        };
+      },
+    },
+  ],
+};
+
+export default {
+  celo,
+};

package/src/families/celo/speculos-deviceActions.ts

@@ -0,0 +1,50 @@
+import type { DeviceAction } from "../../bot/types";
+import type { Transaction } from "./types";
+import { deviceActionFlow } from "../../bot/specs";
+import { formatCurrencyUnit } from "../../currencies";
+const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Review",
+      button: "Rr",
+    },
+    {
+      title: "Amount",
+      button: "Rr",
+      expectedValue: ({ account, status }) => {
+        const formattedValue =
+          "CELO " +
+          formatCurrencyUnit(account.unit, status.amount, {
+            disableRounding: true,
+          });
+
+        if (!formattedValue.includes(".")) {
+          // if the value is pure integer, in the app it will automatically add an .0
+          return formattedValue + ".0";
+        }
+
+        return formattedValue;
+      },
+    },
+    {
+      title: "Address",
+      button: "Rr",
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Max Fees",
+      button: "Rr",
+    },
+    {
+      title: "No Gateway Fee",
+      button: "Rr",
+    },
+    {
+      title: "Accept",
+      button: "LRlr",
+    },
+  ],
+});
+export default {
+  acceptTransaction,
+};

package/src/families/celo/transaction.ts

@@ -0,0 +1,39 @@
+import type { Transaction, TransactionRaw } from "./types";
+import { BigNumber } from "bignumber.js";
+import {
+  fromTransactionCommonRaw,
+  toTransactionCommonRaw,
+} from "../../transaction/common";
+import type { Account } from "../../types";
+import { getAccountUnit } from "../../account";
+import { formatCurrencyUnit } from "../../currencies";
+export const formatTransaction = (t: Transaction, account: Account): string => `
+SEND ${formatCurrencyUnit(getAccountUnit(account), t.amount, {
+  showCode: true,
+  disableRounding: true,
+})}
+TO ${t.recipient}`;
+
+const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    family: tr.family,
+    fees: tr.fees ? new BigNumber(tr.fees) : null,
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  return {
+    ...common,
+    family: t.family,
+    fees: t.fees?.toString() || null,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+};

package/src/families/celo/types.ts

@@ -0,0 +1,20 @@
+import { BigNumber } from "bignumber.js";
+import type {
+  TransactionCommon,
+  TransactionCommonRaw,
+} from "../../types/transaction";
+
+export type Transaction = TransactionCommon & {
+  family: "celo";
+  fees: BigNumber | null | undefined;
+};
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "celo";
+  fees: string | null | undefined;
+};
+
+export type CoreStatics = Record<string, never>;
+export type CoreAccountSpecifics = Record<string, never>;
+export type CoreOperationSpecifics = Record<string, never>;
+export type CoreCurrencySpecifics = Record<string, never>;
+export const reflect = (_declare: any) => {};

package/src/families/ethereum/datasets/ethereum.scanAccounts.1.ts

@@ -1,5 +1,6 @@
 export default {
   name: "ethereum seed 1",
+  unstableAccounts: true, // FIXME LL-9155
   apdus: `
     => e00200000d038000002c8000003c80000000
     <= 410469877df9567b58e6ef8f6cf1fb8a8e1bf28a327dee31b183a6b9cd1f3da063af0924506a9912793ef31e41df19f8653fa31bb1fecc32d2e41abdddb22ccb621028373561453661383832363036353137343345356546433033373937313136413335363539663638359000

package/src/families/ethereum/modules/erc1155.ts

@@ -14,6 +14,9 @@ import { prepareTransaction } from "./erc721";
 const notOwnedNft = createCustomErrorClass("NotOwnedNft");
 const notEnoughNftOwned = createCustomErrorClass("NotEnoughNftOwned");
 const notTokenIdsProvided = createCustomErrorClass("NotTokenIdsProvided");
+const quantityNeedsToBePositive = createCustomErrorClass(
+  "QuantityNeedsToBePositive"
+);
 
 export type Modes = "erc1155.transfer";
 
@@ -43,6 +46,12 @@ const erc1155Transfer: ModeModule = {
         result.errors.amount = new NotEnoughBalanceInParentAccount();
       }
 
+      t.quantities?.forEach((quantity) => {
+        if (quantity.isLessThan(1)) {
+          result.errors.amount = new quantityNeedsToBePositive();
+        }
+      });
+
       const enoughTokensOwned: true | Error =
         t.tokenIds?.reduce((acc, tokenId, index) => {
           if (acc instanceof Error) {

package/src/families/ethereum/signOperation.ts

@@ -2,6 +2,7 @@ import invariant from "invariant";
 import { Observable, from, of } from "rxjs";
 import { mergeMap } from "rxjs/operators";
 import eip55 from "eip55";
+import { encode } from "rlp";
 import { BigNumber } from "bignumber.js";
 import { log } from "@ledgerhq/logs";
 import { FeeNotLoaded } from "@ledgerhq/errors";
@@ -17,6 +18,7 @@ import { modes } from "./modules";
 import { isNFTActive } from "../../nft";
 import { getEnv } from "../../env";
 import { LoadConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
+import { Transaction as EthereumTx } from "@ethereumjs/tx";
 export const signOperation = ({
   account,
   deviceId,
@@ -54,18 +56,16 @@ export const signOperation = ({
                 throw new FeeNotLoaded();
               }
 
-              const { tx, fillTransactionDataResult } = buildEthereumTx(
-                account,
-                transaction,
-                nonce
-              );
-              const to = eip55.encode("0x" + tx.to.toString("hex"));
+              const { ethTxObject, tx, common, fillTransactionDataResult } =
+                buildEthereumTx(account, transaction, nonce);
+              const to = eip55.encode((tx.to || "").toString());
               const value = new BigNumber(
                 "0x" + (tx.value.toString("hex") || "0")
               );
-
-              const txHex = tx.serialize().toString("hex");
-
+              // rawData Format: `rlp([nonce, gasPrice, gasLimit, to, value, data, v, r, s])`
+              const rawData = tx.raw();
+              rawData[6] = Buffer.from([common.chainIdBN().toNumber()]);
+              const txHex = encode(rawData).toString("hex");
               const loadConfig: LoadConfig = {};
               if (isNFTActive(account.currency)) {
                 loadConfig.nftExplorerBaseURL =
@@ -106,26 +106,27 @@ export const signOperation = ({
                 }
               }
 
-              o.next({
-                type: "device-signature-requested",
-              });
+              o.next({ type: "device-signature-requested" });
               const result = await eth.signTransaction(
                 freshAddressPath,
                 txHex,
                 resolution
               );
               if (cancelled) return;
-              o.next({
-                type: "device-signature-granted",
-              });
+              o.next({ type: "device-signature-granted" });
               // Second, we re-set some tx fields from the device signature
-              const v = result.v;
+              const v = `0x${result.v}`;
+              const r = `0x${result.r}`;
+              const s = `0x${result.s}`;
+
+              const signedTx = new EthereumTx(
+                { ...ethTxObject, v, r, s },
+                { common }
+              );
 
-              tx.v = Buffer.from(v, "hex");
-              tx.r = Buffer.from(result.r, "hex");
-              tx.s = Buffer.from(result.s, "hex");
               // Generate the signature ready to be broadcasted
-              const signature = `0x${tx.serialize().toString("hex")}`;
+              const signature = `0x${signedTx.serialize().toString("hex")}`;
+
               // build optimistic operation
               const txHash = ""; // resolved at broadcast time
 

package/src/families/ethereum/specs.ts

@@ -118,7 +118,6 @@ const ethereum: AppSpec<Transaction> = {
   appQuery: {
     model: DeviceModelId.nanoS,
     appName: "Ethereum",
-    appVersion: "1.5.0-rc3",
   },
   testTimeout: 4 * 60 * 1000,
   transactionCheck: ({ maxSpendable }) => {
@@ -380,7 +379,6 @@ const ethereumRopsten: AppSpec<Transaction> = {
   appQuery: {
     model: DeviceModelId.nanoS,
     appName: "Ethereum",
-    appVersion: "1.5.0-rc3",
   },
   testTimeout: 2 * 60 * 1000,
   transactionCheck: ({ maxSpendable }) => {