@ledgerhq/coin-celo 1.1.0-next.0

package/src/bridge/index.ts

@@ -0,0 +1,77 @@
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import {
+  getSerializedAddressParameters,
+  updateTransaction,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getPreloadStrategy, preload, hydrate } from "./preload";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { prepareTransaction } from "./prepareTransaction";
+import { createTransaction } from "./createTransaction";
+import {
+  assignFromAccountRaw,
+  assignToAccountRaw,
+  toOperationExtraRaw,
+  fromOperationExtraRaw,
+} from "./serialization";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import resolver from "../signer/hw-getAddress";
+import type { CeloAccount, Transaction, TransactionStatus } from "../types";
+import { broadcast } from "./broadcast";
+
+import { EvmSigner } from "@ledgerhq/coin-evm/types/signer";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { getAccountShape } from "./synchronisation";
+import { buildSignOperation } from "./signOperation";
+import { sync } from "./synchronisation";
+import { CeloSigner } from "../signer/signer";
+
+export function buildCurrencyBridge(signerContext: SignerContext<CeloSigner>): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddressWrapper(getAddress),
+  });
+
+  return {
+    getPreloadStrategy,
+    preload,
+    hydrate,
+    scanAccounts,
+  };
+}
+
+export function buildAccountBridge(
+  signerContext: SignerContext<CeloSigner>,
+): AccountBridge<Transaction, CeloAccount, TransactionStatus> {
+  const getAddress = resolver(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction,
+    getTransactionStatus,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+    getSerializedAddressParameters,
+    assignFromAccountRaw,
+    assignToAccountRaw,
+    toOperationExtraRaw,
+    fromOperationExtraRaw,
+  };
+}
+
+export function createBridges(signerContext: SignerContext<CeloSigner>) {
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge/preload.ts

@@ -0,0 +1,75 @@
+import { BigNumber } from "bignumber.js";
+import { Observable, Subject } from "rxjs";
+import { log } from "@ledgerhq/logs";
+import { PRELOAD_MAX_AGE } from "../logic";
+import type { CeloPreloadData, CeloValidatorGroup } from "../types";
+import { getValidatorGroups } from "../network/validators";
+
+let currentCeloPreloadedData: CeloPreloadData = {
+  validatorGroups: [],
+};
+
+function fromHydrateValidator(
+  validatorGroupRaw: Record<string, string | number>,
+): CeloValidatorGroup {
+  return {
+    address: validatorGroupRaw.address.toString(),
+    name: validatorGroupRaw.name.toString(),
+    votes: new BigNumber(validatorGroupRaw.votes),
+  };
+}
+
+function fromHydratePreloadData(data: unknown): CeloPreloadData {
+  let validatorGroups: CeloValidatorGroup[] = [];
+  if (typeof data === "object" && data && "validatorGroups" in data) {
+    if (Array.isArray(data.validatorGroups)) {
+      validatorGroups = data.validatorGroups.map(fromHydrateValidator);
+    }
+  }
+
+  return {
+    validatorGroups,
+  };
+}
+
+const updates = new Subject<CeloPreloadData>();
+export function getCurrentCeloPreloadData(): CeloPreloadData {
+  return currentCeloPreloadedData;
+}
+function setCeloPreloadData(data: CeloPreloadData) {
+  if (data === currentCeloPreloadedData) return;
+  currentCeloPreloadedData = data;
+  updates.next(data);
+}
+export function getCeloPreloadDataUpdates(): Observable<CeloPreloadData> {
+  return updates.asObservable();
+}
+
+export const getPreloadStrategy = () => ({
+  preloadMaxAge: PRELOAD_MAX_AGE,
+});
+
+export const preload = async (): Promise<CeloPreloadData> => {
+  const { validatorGroups: previousValidatorGroups } = currentCeloPreloadedData;
+  let validatorGroups = previousValidatorGroups;
+
+  if (!validatorGroups || !validatorGroups.length) {
+    log("celo/preload", "refreshing celo validatorGroups...");
+
+    try {
+      validatorGroups = await getValidatorGroups();
+    } catch (error) {
+      log("celo/preload", "failed to fetch validatorGroups", {
+        error,
+      });
+    }
+  }
+
+  return { validatorGroups };
+};
+
+export const hydrate = (data: unknown) => {
+  const hydrated = fromHydratePreloadData(data);
+  log("celo/preload", "hydrate " + hydrated.validatorGroups.length + " celo validatorGroups");
+  setCeloPreloadData(hydrated);
+};

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,33 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { isValidAddress } from "@celo/utils/lib/address";
+import getFeesForTransaction from "./getFeesForTransaction";
+import { CeloAccount, Transaction } from "../types";
+
+const sameFees = (a: BigNumber | null | undefined, b: BigNumber) => (!a || !b ? a === b : a.eq(b));
+
+export const prepareTransaction: AccountBridge<
+  Transaction,
+  CeloAccount
+>["prepareTransaction"] = async (account, transaction) => {
+  if (transaction.recipient && !isValidAddress(transaction.recipient)) return transaction;
+
+  if (["send", "vote"].includes(transaction.mode) && !transaction.recipient) return transaction;
+
+  if (
+    transaction.mode === "vote" &&
+    !transaction.useAllAmount &&
+    new BigNumber(transaction.amount).lte(0)
+  )
+    return transaction;
+
+  const fees = await getFeesForTransaction({ account, transaction });
+
+  if (!sameFees(transaction.fees, fees)) {
+    return { ...transaction, fees };
+  }
+
+  return transaction;
+};
+
+export default prepareTransaction;

package/src/bridge/serialization.ts

@@ -0,0 +1,114 @@
+import {
+  isCeloOperationExtra,
+  isCeloOperationExtraRaw,
+  type CeloAccount,
+  type CeloAccountRaw,
+  type CeloOperationExtra,
+  type CeloOperationExtraRaw,
+  type CeloResources,
+  type CeloResourcesRaw,
+} from "../types";
+import { BigNumber } from "bignumber.js";
+import { Account, AccountRaw, OperationExtra, OperationExtraRaw } from "@ledgerhq/types-live";
+
+export function toCeloResourcesRaw(r: CeloResources): CeloResourcesRaw {
+  const {
+    registrationStatus,
+    lockedBalance,
+    nonvotingLockedBalance,
+    pendingWithdrawals,
+    votes,
+    electionAddress,
+    lockedGoldAddress,
+    maxNumGroupsVotedFor,
+  } = r ?? {};
+  return {
+    registrationStatus,
+    lockedBalance: lockedBalance?.toString(),
+    nonvotingLockedBalance: nonvotingLockedBalance?.toString(),
+    pendingWithdrawals: pendingWithdrawals?.map(withdrawal => ({
+      value: withdrawal.value.toString(),
+      time: withdrawal.time.toString(),
+      index: withdrawal.index.toString(),
+    })),
+    votes: votes?.map(vote => ({
+      validatorGroup: vote.validatorGroup.toString(),
+      amount: vote.amount.toString(),
+      activatable: vote.activatable,
+      revokable: vote.revokable,
+      type: vote.type,
+      index: vote.index,
+    })),
+    electionAddress,
+    lockedGoldAddress,
+    maxNumGroupsVotedFor: maxNumGroupsVotedFor?.toString(),
+  };
+}
+
+export function fromCeloResourcesRaw(r: CeloResourcesRaw): CeloResources {
+  return {
+    registrationStatus: r.registrationStatus,
+    lockedBalance: new BigNumber(r.lockedBalance),
+    nonvotingLockedBalance: new BigNumber(r.nonvotingLockedBalance),
+    pendingWithdrawals: r.pendingWithdrawals?.map(u => ({
+      value: new BigNumber(u.value),
+      time: new BigNumber(u.time),
+      index: Number(u.index),
+    })),
+    votes: r.votes?.map(vote => ({
+      validatorGroup: vote.validatorGroup,
+      amount: new BigNumber(vote.amount),
+      activatable: vote.activatable,
+      revokable: vote.revokable,
+      type: vote.type,
+      index: vote.index,
+    })),
+    electionAddress: r.electionAddress,
+    lockedGoldAddress: r.lockedGoldAddress,
+    maxNumGroupsVotedFor: new BigNumber(r.maxNumGroupsVotedFor),
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw) {
+  const celoAccount = account as CeloAccount;
+  if (celoAccount.celoResources)
+    (accountRaw as CeloAccountRaw).celoResources = toCeloResourcesRaw(celoAccount.celoResources);
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const celoResourcesRaw = (accountRaw as CeloAccountRaw).celoResources;
+  if (celoResourcesRaw)
+    (account as CeloAccount).celoResources = fromCeloResourcesRaw(celoResourcesRaw);
+}
+
+export function fromOperationExtraRaw(extraRaw: OperationExtraRaw): OperationExtra {
+  if (!isCeloOperationExtraRaw(extraRaw)) {
+    throw new Error("Unsupported OperationExtra");
+  }
+
+  const extra: CeloOperationExtra = {
+    celoOperationValue: new BigNumber(extraRaw.celoOperationValue),
+  };
+
+  if (extraRaw.celoSourceValidator) {
+    extra.celoSourceValidator = extraRaw.celoSourceValidator;
+  }
+
+  return extra;
+}
+
+export function toOperationExtraRaw(extra: OperationExtra): OperationExtraRaw {
+  if (!isCeloOperationExtra(extra)) {
+    throw new Error("Unsupported OperationExtra");
+  }
+
+  const extraRaw: CeloOperationExtraRaw = {
+    celoOperationValue: extra.celoOperationValue.toString(),
+  };
+
+  if (extra.celoSourceValidator) {
+    extraRaw.celoSourceValidator = extra.celoSourceValidator;
+  }
+
+  return extraRaw;
+}

package/src/bridge/signOperation.ts

@@ -0,0 +1,121 @@
+import { BigNumber } from "bignumber.js";
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import type { Account, AccountBridge, DeviceId, SignOperationEvent } from "@ledgerhq/types-live";
+import { encodeTransaction, recoverTransaction } from "@celo/wallet-base";
+
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import type { Transaction, CeloAccount } from "../types/types";
+import buildTransaction from "./buildTransaction";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { EvmSignature } from "@ledgerhq/coin-evm/types/signer";
+import { determineFees } from "../network/sdk";
+import { CeloSigner } from "../signer";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const buildSignOperation =
+  (signerContext: SignerContext<CeloSigner>): AccountBridge<Transaction>["signOperation"] =>
+  ({
+    account,
+    transaction,
+    deviceId,
+  }: {
+    account: Account;
+    transaction: Transaction;
+    deviceId: DeviceId;
+  }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      let cancelled: boolean;
+
+      async function main() {
+        const { fees } = transaction;
+        if (!fees) throw new FeeNotLoaded();
+        const unsignedTransaction = await buildTransaction(account as CeloAccount, transaction);
+        const { chainId, to } = unsignedTransaction;
+
+        await signerContext(deviceId, signer => {
+          return signer.verifyTokenInfo(to!, chainId!);
+        });
+        await determineFees(unsignedTransaction);
+
+        const rlpEncodedTransaction = await signerContext(deviceId, signer => {
+          return signer.rlpEncodedTxForLedger(unsignedTransaction);
+        });
+        o.next({ type: "device-signature-requested" });
+
+        const response = (await signerContext(deviceId, signer => {
+          return signer.signTransaction(
+            account.freshAddressPath,
+            trimLeading0x(rlpEncodedTransaction.rlpEncode),
+          );
+        })) as EvmSignature;
+
+        const { address } = await signerContext(deviceId, signer => {
+          return signer.getAddress(account.freshAddressPath);
+        });
+        const convertedResponse = { ...response, v: response.v.toString() };
+        if (cancelled) return;
+
+        const signature = parseSigningResponse(convertedResponse, chainId!);
+
+        o.next({ type: "device-signature-granted" });
+        const encodedTransaction = await encodeTransaction(rlpEncodedTransaction, signature);
+        const [_, recoveredAddress] = recoverTransaction(encodedTransaction.raw);
+        if (recoveredAddress !== address) {
+          throw new Error(
+            "celo: there was a signing error, the recovered address doesn't match the your ledger address, the operation was cancelled",
+          );
+        }
+        const operation = buildOptimisticOperation(
+          account as CeloAccount,
+          transaction,
+          transaction.fees ?? new BigNumber(0),
+        );
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: encodedTransaction.raw,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+      return () => {
+        cancelled = true;
+      };
+    });
+
+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;
+
+  eip155V = sigV;
+
+  return {
+    s: Buffer.from(response.s, "hex"),
+    v: eip155V,
+    r: Buffer.from(response.r, "hex"),
+  };
+};
+
+export default buildSignOperation;

package/src/bridge/synchronisation.ts

@@ -0,0 +1,60 @@
+import { getAccountRegistrationStatus, getPendingWithdrawals, getVotes } from "../network/sdk";
+import { makeSync, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import type { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account";
+import { getAccountDetails } from "../network";
+import { CeloAccount } from "../types/types";
+import { celoKit } from "../network/sdk";
+
+const kit = celoKit();
+
+export const getAccountShape: GetAccountShape<CeloAccount> = async info => {
+  const { address, currency, initialAccount, derivationMode } = info;
+  const oldOperations = initialAccount?.operations || [];
+  const election = await kit.contracts.getElection();
+  const electionConfig = await election.getConfig();
+  const lockedGold = await kit.contracts.getLockedGold();
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+  const {
+    blockHeight,
+    balance,
+    spendableBalance,
+    operations: newOperations,
+    lockedBalance,
+    nonvotingLockedBalance,
+  } = await getAccountDetails(address, accountId);
+
+  const accountRegistrationStatus = await getAccountRegistrationStatus(address);
+
+  const pendingWithdrawals = accountRegistrationStatus ? await getPendingWithdrawals(address) : [];
+
+  const votes = accountRegistrationStatus ? await getVotes(address) : [];
+
+  const operations = mergeOps(oldOperations, newOperations);
+  const shape = {
+    id: accountId,
+    balance,
+    spendableBalance,
+    operationsCount: operations.length,
+    blockHeight,
+    celoResources: {
+      registrationStatus: accountRegistrationStatus,
+      lockedBalance,
+      nonvotingLockedBalance,
+      pendingWithdrawals,
+      votes,
+      electionAddress: election.address,
+      lockedGoldAddress: lockedGold.address,
+      maxNumGroupsVotedFor: electionConfig.maxNumGroupsVotedFor,
+    },
+  };
+  return { ...shape, operations };
+};
+
+export const sync = makeSync({ getAccountShape });

package/src/bridge/transaction.ts

@@ -0,0 +1,53 @@
+import type { Transaction, TransactionRaw } from "../types/types";
+import { BigNumber } from "bignumber.js";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { Account } from "@ledgerhq/types-live";
+export const formatTransaction = (t: Transaction, account: Account): string => `
+SEND ${
+  t.useAllAmount
+    ? "MAX CELO"
+    : formatCurrencyUnit(getAccountCurrency(account).units[0], 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,
+    mode: tr.mode,
+    index: tr.index,
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  return {
+    ...common,
+    family: t.family,
+    fees: t.fees?.toString() || null,
+    mode: t.mode,
+    index: t.index,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/config.ts

@@ -0,0 +1,12 @@
+import { ConfigInfo } from "@ledgerhq/live-config/LiveConfig";
+
+export const celoConfig: Record<string, ConfigInfo> = {
+  config_currency_celo: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+    },
+  },
+};