@ledgerhq/live-common 21.29.0 → 21.32.0-hotfix.0

package/src/families/celo/api/hubble.ts

@@ -0,0 +1,93 @@
+import { BigNumber } from "bignumber.js";
+import network from "../../../network";
+import { getEnv } from "../../../env";
+import { Operation, OperationType } from "../../../types";
+import { encodeOperationId } from "../../../operation";
+
+const DEFAULT_TRANSACTIONS_LIMIT = 200;
+const getUrl = (route): string => `${getEnv("API_CELO_INDEXER")}${route || ""}`;
+
+// Indexer returns both account data and transactions in one call.
+// Transactions are just limited, there's no block height offset
+const fetchAccountDetails = async (
+  address: string,
+  transactionsLimit: number = DEFAULT_TRANSACTIONS_LIMIT
+) => {
+  const { data } = await network({
+    method: "GET",
+    url: getUrl(`/account_details/${address}?limit=${transactionsLimit}`),
+  });
+  return data;
+};
+
+const fetchStatus = async () => {
+  const { data } = await network({
+    method: "GET",
+    url: getUrl(`/status`),
+  });
+  return data;
+};
+
+const getOperationType = (type: string): OperationType => {
+  switch (type) {
+    case "InternalTransferSent":
+      return "OUT";
+    case "InternalTransferReceived":
+      return "IN";
+    case "AccountSlashed":
+      return "SLASH";
+    default:
+      return "NONE";
+  }
+};
+
+const transactionToOperation = (
+  address: string,
+  accountId: string,
+  transaction
+): Operation => {
+  const type: OperationType = getOperationType(transaction.kind);
+  const hasFailed = transaction.data.success
+    ? !transaction.data.success
+    : false;
+  const senders = transaction.data.from ? [transaction.data.from] : [];
+  const recipients = transaction.data.to ? [transaction.data.to] : [];
+
+  return {
+    id: encodeOperationId(accountId, transaction.transaction_hash, type),
+    hash: transaction.transaction_hash,
+    accountId,
+    fee: new BigNumber(0),
+    value: new BigNumber(transaction.amount),
+    type,
+    blockHeight: transaction.height,
+    date: new Date(transaction.time),
+    senders,
+    recipients,
+    hasFailed,
+    blockHash: null,
+    extra: {},
+  };
+};
+
+export const getAccountDetails = async (address: string, accountId: string) => {
+  const accountDetails = await fetchAccountDetails(address);
+  const spendableBalance = new BigNumber(accountDetails.gold_balance);
+  const lockedBalance = new BigNumber(accountDetails.total_locked_gold);
+  const balance = spendableBalance.plus(lockedBalance);
+  const indexerStatus = await fetchStatus();
+
+  const allTransactions = accountDetails.internal_transfers.concat(
+    accountDetails.transactions
+  );
+  const operations = allTransactions.map((transaction) =>
+    transactionToOperation(address, accountId, transaction)
+  );
+
+  return {
+    blockHeight: indexerStatus.last_indexed_height,
+    balance,
+    spendableBalance,
+    operations,
+  };
+};

package/src/families/celo/api/index.ts

@@ -0,0 +1 @@
+export { getAccountDetails } from "./hubble";

package/src/families/celo/api/sdk.ts

@@ -0,0 +1,8 @@
+import { ContractKit, newKit } from "@celo/contractkit";
+import { getEnv } from "../../../env";
+
+let kit: ContractKit;
+export const celoKit = () => {
+  if (!kit) kit = newKit(getEnv("API_CELO_NODE"));
+  return kit;
+};

package/src/families/celo/bridge/js.ts

@@ -0,0 +1,38 @@
+import type { AccountBridge, CurrencyBridge } from "../../../types";
+import type { Transaction } from "../types";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+import { sync, scanAccounts } from "../js-synchronisation";
+import signOperation from "../js-signOperation";
+import getTransactionStatus from "../js-getTransactionStatus";
+import broadcast from "../js-broadcast";
+import estimateMaxSpendable from "../js-estimateMaxSpendable";
+import prepareTransaction from "../js-prepareTransaction";
+import createTransaction from "../js-createTransaction";
+
+const updateTransaction = (t, patch) => ({ ...t, ...patch });
+
+const receive = makeAccountBridgeReceive();
+
+const preload = async () => Promise.resolve({});
+const hydrate = (): void => {};
+
+const currencyBridge: CurrencyBridge = {
+  preload,
+  hydrate,
+  scanAccounts,
+};
+const accountBridge: AccountBridge<Transaction> = {
+  estimateMaxSpendable,
+  createTransaction,
+  updateTransaction,
+  getTransactionStatus,
+  prepareTransaction,
+  sync,
+  receive,
+  signOperation,
+  broadcast,
+};
+export default {
+  currencyBridge,
+  accountBridge,
+};

package/src/families/celo/cli-transaction.ts

@@ -0,0 +1,41 @@
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+
+import type {
+  Transaction,
+  Account,
+  AccountLike,
+  AccountLikeArray,
+} from "../../types";
+
+const options = [];
+
+function inferAccounts(account: Account): AccountLikeArray {
+  invariant(account.currency.family === "celo", "celo family");
+
+  const accounts: Account[] = [account];
+  return accounts;
+}
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+    mainAccount: Account;
+  }>
+): Transaction[] {
+  return flatMap(transactions, ({ transaction }) => {
+    invariant(transaction.family === "celo", "celo family");
+
+    return {
+      ...transaction,
+      family: "celo",
+    } as Transaction;
+  });
+}
+
+export default {
+  options,
+  inferAccounts,
+  inferTransactions,
+};

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

@@ -0,0 +1,20 @@
+import type { CurrenciesData } from "../../../types";
+import type { Transaction } from "../types";
+
+const dataset: CurrenciesData<Transaction> = {
+  scanAccounts: [
+    {
+      name: "celo seed 1",
+      apdus: `
+      => e002000009028000002c8000ce10
+      <= 41040106794f46b69e1ae56dff904510959e59074a37341f8cc740e9ce7a0b24421c42e7023481f5ef03926739baa6bb26cac7bf48f249a24793264711d48499499528433235323935323541463035434134313939633236413838623438393463383342303330433733399000
+      => e002000015058000002c8000ce10800000000000000000000000
+      <= 41044f4998c3f81966645f25e95082f9fe7d104b1ba4286486a8ecd8fd11f79ef02bd8110f086b390a418ab619a650f3df59a3c84912ce1ea125386d7aa7732fcd0b28393634313334336638346535304143304334434133626644313244433063346231653732363544359000
+      => e002000015058000002c8000ce10800000010000000000000000
+      <= 4104630b6447b0f690520a5612f1dc57da90b84f6b59dfeb375bed1113fb34a8d0f9181ec63e40f9fde05761084dbd022ba76711eb2b36442cf4b5d2bc19def9156428343435306565646238623532333931354534393639633239646241653944354563303646453837349000
+      `,
+    },
+  ],
+};
+
+export default dataset;

package/src/families/celo/deviceTransactionConfig.ts

@@ -0,0 +1,19 @@
+import type { DeviceTransactionField } from "../../transaction";
+
+function getDeviceTransactionConfig(): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "amount",
+    label: "Amount",
+  });
+
+  fields.push({
+    type: "fees",
+    label: "Fees",
+  });
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/families/celo/hw-app-celo.ts

@@ -0,0 +1,108 @@
+import type Transport from "@ledgerhq/hw-transport";
+import { decode, encode } from "rlp";
+
+/**
+ * Heavily inspiried by celo-web-wallet
+ * https://github.com/celo-tools/celo-web-wallet/blob/master/src/features/ledger/CeloLedgerApp.ts
+ */
+export class CeloApp {
+  transport: Transport;
+
+  constructor(transport: any) {
+    this.transport = transport;
+  }
+
+  async signTransaction(
+    path: string,
+    rawTxHex: string
+  ): Promise<{
+    s: string;
+    v: string;
+    r: string;
+  }> {
+    const paths = splitPath(path);
+    const rawTx = Buffer.from(rawTxHex, "hex");
+    let offset = 0;
+    let response;
+
+    const rlpTx = decode(rawTx);
+    let rlpOffset = 0;
+    if (rlpTx.length > 6) {
+      const rlpVrs = encode(rlpTx.slice(-3));
+      rlpOffset = rawTx.length - (rlpVrs.length - 1);
+    }
+
+    while (offset !== rawTx.length) {
+      const first = offset === 0;
+      const maxChunkSize = first ? 150 - 1 - paths.length * 4 : 150;
+      let chunkSize =
+        offset + maxChunkSize > rawTx.length
+          ? rawTx.length - offset
+          : maxChunkSize;
+      if (rlpOffset != 0 && offset + chunkSize == rlpOffset) {
+        // Make sure that the chunk doesn't end right on the EIP 155 marker if set
+        chunkSize--;
+      }
+      const buffer = Buffer.alloc(
+        first ? 1 + paths.length * 4 + chunkSize : chunkSize
+      );
+      if (first) {
+        buffer[0] = paths.length;
+        paths.forEach((element, index) => {
+          buffer.writeUInt32BE(element, 1 + 4 * index);
+        });
+        rawTx.copy(buffer, 1 + 4 * paths.length, offset, offset + chunkSize);
+      } else {
+        rawTx.copy(buffer, 0, offset, offset + chunkSize);
+      }
+
+      response = await this.transport
+        .send(0xe0, 0x04, first ? 0x00 : 0x80, 0x00, buffer)
+        .catch((e) => {
+          throw e;
+        });
+
+      offset += chunkSize;
+    }
+
+    const v = response.slice(0, 1).toString("hex");
+    const r = response.slice(1, 1 + 32).toString("hex");
+    const s = response.slice(1 + 32, 1 + 32 + 32).toString("hex");
+    return { v, r, s };
+  }
+
+  provideERC20TokenInformation({ data }: { data: Buffer }): Promise<boolean> {
+    return provideERC20TokenInformation(this.transport, data);
+  }
+}
+
+function splitPath(path: string): number[] {
+  const result: number[] = [];
+  const components = path.split("/");
+  components.forEach((element) => {
+    let number = parseInt(element, 10);
+    if (isNaN(number)) {
+      return; // FIXME shouldn't it throws instead?
+    }
+    if (element.length > 1 && element[element.length - 1] === "'") {
+      number += 0x80000000;
+    }
+    result.push(number);
+  });
+  return result;
+}
+
+function provideERC20TokenInformation(
+  transport: Transport,
+  data: Buffer
+): Promise<boolean> {
+  return transport.send(0xe0, 0x0a, 0x00, 0x00, data).then(
+    () => true,
+    (e) => {
+      if (e && e.statusCode === 0x6d00) {
+        return false;
+      }
+      throw e;
+    }
+  );
+}

package/src/families/celo/hw-getAddress.ts

@@ -0,0 +1 @@
+export { default } from "../ethereum/hw-getAddress";

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

@@ -0,0 +1,12 @@
+import { patchOperationWithHash } from "../../operation";
+import { celoKit } from "./api/sdk";
+
+const broadcast = async ({ signedOperation: { operation, signature } }) => {
+  const kit = celoKit();
+  const { transactionHash } = await kit.web3.eth.sendSignedTransaction(
+    signature
+  );
+  return patchOperationWithHash(operation, transactionHash);
+};
+
+export default broadcast;

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

@@ -0,0 +1,32 @@
+import type { Transaction } from "./types";
+import type { Account } from "../../types";
+import { CeloTx } from "@celo/connect";
+import { celoKit } from "./api/sdk";
+
+const buildTransaction = async (account: Account, transaction: Transaction) => {
+  const kit = celoKit();
+  const { amount } = transaction;
+  const value = transaction.useAllAmount
+    ? account.spendableBalance.minus(transaction.fees || 0)
+    : amount;
+
+  const celoToken = await kit.contracts.getGoldToken();
+
+  const celoTransaction = {
+    from: account.freshAddress,
+    to: celoToken.address,
+    data: celoToken
+      .transfer(transaction.recipient, value.toFixed())
+      .txo.encodeABI(),
+  };
+
+  return {
+    ...celoTransaction,
+    chainId: await kit.connection.chainId(),
+    nonce: await kit.connection.nonce(account.freshAddress),
+    gas: await kit.connection.estimateGasWithInflationFactor(celoTransaction),
+    gasPrice: await kit.connection.gasPrice(),
+  } as CeloTx;
+};
+
+export default buildTransaction;

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;