@ledgerhq/coin-celo 1.1.0-next.0

package/src/network/sdk.ts

@@ -0,0 +1,101 @@
+import { ContractKit, newKit } from "@celo/contractkit";
+import { makeLRUCache } from "@ledgerhq/live-network/cache";
+import { getEnv } from "@ledgerhq/live-env";
+import { CeloVote } from "../types/types";
+import { CeloTx } from "@celo/connect";
+
+let kit: ContractKit;
+export const celoKit = () => {
+  if (!kit) kit = newKit(getEnv("API_CELO_NODE"));
+  return kit;
+};
+
+/**
+ * Fetch account registered status. To lock any Celo, account needs to be registered first
+ */
+export const getAccountRegistrationStatus = async (address: string): Promise<boolean> => {
+  const accounts = await celoKit().contracts.getAccounts();
+  return await accounts.isAccount(address);
+};
+
+export const determineFees = async (txParams: CeloTx): Promise<void> => {
+  const {
+    connection: { setFeeMarketGas },
+  } = celoKit();
+
+  await setFeeMarketGas(txParams);
+};
+
+/**
+ * Fetch pending withdrawals, with an index
+ */
+export const getPendingWithdrawals = async (address: string) => {
+  const lockedGold = await celoKit().contracts.getLockedGold();
+  const pendingWithdrawals = await lockedGold.getPendingWithdrawals(address);
+  const pendingWithdrawalsWithIndexes = pendingWithdrawals
+    .map((withdrawal, index) => ({
+      ...withdrawal,
+      index,
+    }))
+    .sort((a, b) => a.time.minus(b.time).toNumber());
+  return pendingWithdrawalsWithIndexes;
+};
+
+/**
+ * Fetch all votes
+ */
+export const getVotes = async (address: string): Promise<CeloVote[]> => {
+  const election = await celoKit().contracts.getElection();
+  const voter = await election.getVoter(await voteSignerAccount(address));
+  const activates = await getActivateTransactionObjects(address);
+  const activatableValidatorGroups = activates.map(activate => activate.txo.arguments[0]);
+
+  const votes: CeloVote[] = [];
+  voter.votes.forEach(vote => {
+    let activeVoteRevokable = true;
+    if (vote.pending.gt(0)) {
+      // If there's a pending vote, it has to be revoked first
+      activeVoteRevokable = false;
+      votes.push({
+        validatorGroup: vote.group,
+        amount: vote.pending,
+        // Not all pending votes can be activated, 24h has to pass
+        activatable: activatableValidatorGroups.includes(vote.group),
+        revokable: true,
+        index: 0,
+        type: "pending",
+      });
+    }
+    if (vote.active.gt(0))
+      votes.push({
+        validatorGroup: vote.group,
+        amount: vote.active,
+        activatable: false,
+        revokable: activeVoteRevokable,
+        index: 1,
+        type: "active",
+      });
+  });
+
+  return votes;
+};
+
+const getActivateTransactionObjects = async (address: string) => {
+  const election = await celoKit().contracts.getElection();
+  return await election.activate(await voteSignerAccount(address));
+};
+
+/**
+ * Fetch and cache address of a vote signer account
+ * Cache it for 1h since vote signer is usually the same account as our address
+ */
+export const voteSignerAccount = makeLRUCache(
+  async (address: string): Promise<string> => {
+    const accounts = await celoKit().contracts.getAccounts();
+    return await accounts.voteSignerToAccount(address);
+  },
+  address => address,
+  {
+    ttl: 60 * 60 * 1000, // 1 hour
+  },
+);

package/src/network/validators.ts

@@ -0,0 +1 @@
+export { getValidatorGroups } from ".";

package/src/signer/hw-getAddress.ts

@@ -0,0 +1,27 @@
+import eip55 from "eip55";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { CeloSigner } from ".";
+
+/*
+NOTE: we should use the evm resolver for celo, but due to the signer types conflicting for now 
+we are using a separate resolver
+*/
+const resolver = (signerContext: SignerContext<CeloSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify, currency }: GetAddressOptions) => {
+    const { address, publicKey } = await signerContext(deviceId, signer => {
+      /* istanbul ignore next: optional chaining + undefined is a valid value */
+      const chainId = currency?.ethereumLikeInfo?.chainId.toString();
+      return signer.getAddress(path, verify, false, chainId);
+    });
+
+    return {
+      address: eip55.encode(address),
+      publicKey,
+      path,
+    };
+  };
+};
+
+export default resolver;

package/src/signer/index.ts

@@ -0,0 +1 @@
+export * from "./signer";

package/src/signer/signer.ts

@@ -0,0 +1,36 @@
+import type { CeloTx, RLPEncodedTx, LegacyEncodedTx } from "../types";
+import { EvmSignature, EvmAddress } from "@ledgerhq/coin-evm/types/signer";
+import { LoadConfig, ResolutionConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
+import { EIP712Message } from "@ledgerhq/types-live";
+
+// TODO: this should use EvmSigner
+export interface CeloSigner {
+  getAddress: (
+    path: string,
+    boolDisplay?: boolean,
+    boolChaincode?: boolean,
+    chainId?: string,
+  ) => Promise<EvmAddress>;
+  signTransaction: (path: string, rawTxHex: string, resolution?: any) => Promise<EvmSignature>;
+  signPersonalMessage: (path: string, messageHex: string) => Promise<EvmSignature>;
+  signEIP712Message(
+    path: string,
+    jsonMessage: EIP712Message,
+    fullImplem?: boolean,
+  ): Promise<EvmSignature>;
+  setLoadConfig: (config: LoadConfig) => void;
+  clearSignTransaction: (
+    path: string,
+    rawTxHex: string,
+    resolutionConfig: ResolutionConfig,
+    throwOnError: boolean,
+  ) => Promise<EvmSignature>;
+  signEIP712HashedMessage: (
+    path: string,
+    domainSeparatorHex: string,
+    hashStructMessageHex: string,
+  ) => Promise<EvmSignature>;
+  // Celo specific
+  verifyTokenInfo(to: string, chainId: number): Promise<void>;
+  rlpEncodedTxForLedger(txParams: CeloTx): Promise<RLPEncodedTx | LegacyEncodedTx>;
+}

package/src/test/bot-specs.ts

@@ -0,0 +1,55 @@
+import { DeviceModelId } from "@ledgerhq/devices";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import {
+  minimalAmount,
+  createLockMutation,
+  createRegisterAccountMutation,
+  createSend50PercentMutation,
+  createSendMaxMutation,
+  createUnlockMutation,
+  createVoteMutation,
+  createActivateVoteMutation,
+  createRevokeVoteMutation,
+  createWithdrawMutation,
+} from "./specs/index";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "../types";
+import { acceptTransaction } from "./speculos-deviceActions";
+
+const currency = getCryptoCurrencyById("celo");
+const send50PercentMutation = createSend50PercentMutation();
+const sendMaxMutation = createSendMaxMutation();
+const registerAccountMutation = createRegisterAccountMutation();
+const unlockMutation = createUnlockMutation();
+const lockMutation = createLockMutation();
+const voteMutation = createVoteMutation();
+const activateVoteMutation = createActivateVoteMutation();
+const revokeVoteMutation = createRevokeVoteMutation();
+const withdrawMutation = createWithdrawMutation();
+
+const celo: AppSpec<Transaction> = {
+  name: "Celo",
+  currency,
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Celo",
+  },
+  testTimeout: 4 * 60 * 1000,
+  genericDeviceAction: acceptTransaction,
+  minViableAmount: minimalAmount,
+  mutations: [
+    send50PercentMutation,
+    sendMaxMutation,
+    registerAccountMutation,
+    unlockMutation,
+    lockMutation,
+    voteMutation,
+    activateVoteMutation,
+    revokeVoteMutation,
+    withdrawMutation,
+  ],
+};
+
+export default {
+  celo,
+};

package/src/test/bridgeDatasetTest.ts

@@ -0,0 +1,10 @@
+import celo from "../datasets/celo.scanAccounts.1";
+import type { Transaction } from "../types";
+import type { DatasetTest } from "@ledgerhq/types-live";
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    celo,
+  },
+};

package/src/test/cli-transaction.ts

@@ -0,0 +1,70 @@
+import type { Account, AccountLike, AccountLikeArray } from "@ledgerhq/types-live";
+
+import { from } from "rxjs";
+import { map } from "rxjs/operators";
+import { getValidatorGroups } from "../network";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import type { Transaction } from "../types";
+
+const options = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send, lock, unlock, withdraw, vote, revoke, activate, register",
+  },
+  {
+    name: "transactionIndex",
+    type: String,
+    desc: "transaction index of a pending withdraw in case of withdraw mode",
+  },
+];
+
+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;
+  }>,
+  opts: Record<string, any>,
+): Transaction[] {
+  const mode = opts.mode || "send";
+  invariant(
+    ["send", "lock", "unlock", "withdraw", "vote", "revoke", "activate", "register"].includes(mode),
+    `Unexpected mode: ${mode}`,
+  );
+
+  return flatMap(transactions, ({ transaction }) => {
+    invariant(transaction.family === "celo", "celo family");
+
+    return {
+      ...transaction,
+      family: "celo",
+      mode,
+      index: opts.transactionIndex || null,
+    } as Transaction;
+  });
+}
+
+const celoValidatorGroups = {
+  args: [],
+  job: () => from(getValidatorGroups()).pipe(map(validatorGroup => JSON.stringify(validatorGroup))),
+};
+
+export default function makeCliTools() {
+  return {
+    options,
+    inferAccounts,
+    inferTransactions,
+    commands: {
+      celoValidatorGroups,
+    },
+  };
+}

package/src/test/please-add-coverage.test.ts

@@ -0,0 +1,3 @@
+describe("Celo", () => {
+  it.todo("should be tested");
+});

package/src/test/specs/createActivateVoteMutation.ts

@@ -0,0 +1,37 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
+import { MutationSpec } from "@ledgerhq/coin-framework/bot/types";
+import type { CeloAccount, Transaction } from "../../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createActivateVoteMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Activate Vote",
+  feature: "staking",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    const { celoResources } = account as CeloAccount;
+    invariant(celoResources?.registrationStatus, "Celo: Activate Vote | Account is not registered");
+    invariant(maxSpendable.gt(minimalAmount), "Celo:  Activate Vote | balance is too low");
+
+    const activatableVote = celoResources?.votes?.find(vote => vote.activatable);
+
+    invariant(!!activatableVote, "Celo: Activate Vote | No activatable votes");
+
+    const transaction = {
+      recipient: activatableVote!.validatorGroup,
+    };
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          mode: "activate",
+        },
+        transaction,
+      ],
+    };
+  },
+});

package/src/test/specs/createLockMutation.ts

@@ -0,0 +1,38 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
+import { MutationSpec } from "@ledgerhq/coin-framework/bot/types";
+import type { CeloAccount, Transaction } from "../../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.005");
+
+export const createLockMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Lock",
+  feature: "staking",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    const { celoResources } = account as CeloAccount;
+    invariant(celoResources?.registrationStatus, "Celo: Lock Vote | Account is not registered");
+
+    invariant(maxSpendable.gt(minimalAmount), "Celo:  Lock | balance is too low");
+
+    const amount = minimalAmount.times(Math.random()).integerValue().precision(8);
+
+    invariant(amount.gt(0), "Celo: Lock | Not enough funds to lock tokens");
+
+    const transaction = {
+      amount,
+    };
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          mode: "lock",
+        },
+        transaction,
+      ],
+    };
+  },
+});

package/src/test/specs/createRegisterAccountMutation.ts

@@ -0,0 +1,35 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
+import { MutationSpec } from "@ledgerhq/coin-framework/bot/types";
+import type { CeloAccount, Transaction } from "../../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createRegisterAccountMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Register Account",
+  feature: "staking",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    const { celoResources } = account as CeloAccount;
+
+    invariant(
+      !celoResources?.registrationStatus,
+      "Celo: Register Account | Celo account is already registered",
+    );
+    invariant(
+      maxSpendable.gt(minimalAmount),
+      "Celo: Register Account | Celo account balance is too low to register account",
+    );
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          mode: "register",
+        },
+      ],
+    };
+  },
+});

package/src/test/specs/createRevokeVoteMutation.ts

@@ -0,0 +1,38 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
+import { MutationSpec } from "@ledgerhq/coin-framework/bot/types";
+import type { CeloAccount, Transaction } from "../../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createRevokeVoteMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: RevokeVote",
+  feature: "staking",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    invariant(maxSpendable.gt(minimalAmount), "Celo:  Revoke Vote | balance is too low");
+
+    const { celoResources } = account as CeloAccount;
+    invariant(celoResources?.registrationStatus, "Celo: RevokeVote | Account is not registered");
+
+    const revokableVote = celoResources?.votes?.find(vote => vote.revokable);
+
+    invariant(!!revokableVote, "Celo: RevokeVote |  Revokable vote not found");
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          mode: "revoke",
+          recipient: revokableVote!.validatorGroup,
+          group: revokableVote!.validatorGroup,
+          address: (account as CeloAccount).celoResources?.electionAddress,
+          index: revokableVote!.index,
+          amount: revokableVote!.amount,
+        },
+      ],
+    };
+  },
+});

package/src/test/specs/createSendMutation.ts

@@ -0,0 +1,41 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
+import { pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import { MutationSpec } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "../../types";
+
+const maxAccount = 10;
+const currency = getCryptoCurrencyById("celo");
+export const minimalAmount = parseCurrencyUnit(currency.units[0], "0.01");
+
+export const createSend50PercentMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Move 50% to another account",
+  feature: "send",
+  maxRun: 1,
+  transaction: ({ account, siblings, bridge, maxSpendable }) => {
+    invariant(maxSpendable.gt(minimalAmount), "Celo:  Move 50% | 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 }],
+    };
+  },
+});
+
+export const createSendMaxMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Send max to another account",
+  feature: "sendMax",
+  maxRun: 1,
+  transaction: ({ account, siblings, bridge, maxSpendable }) => {
+    invariant(maxSpendable.gt(minimalAmount), "Celo: Send Max | Balance is too low");
+    const sibling = pickSiblings(siblings, maxAccount);
+    const recipient = sibling.freshAddress;
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [{ recipient }, { useAllAmount: true }],
+    };
+  },
+});

package/src/test/specs/createUnlockMutation.ts

@@ -0,0 +1,35 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
+import { MutationSpec } from "@ledgerhq/coin-framework/lib-es/bot/types";
+import type { CeloAccount, Transaction } from "../../types";
+import BigNumber from "bignumber.js";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createUnlockMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Unlock",
+  feature: "staking",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    invariant(maxSpendable.gt(minimalAmount), "Celo:  Unlock | balance is too low");
+
+    const { celoResources } = account as CeloAccount;
+    invariant(celoResources?.registrationStatus, "Celo: Unlock | Account is not registered");
+    const nonvotingLockedBalance = celoResources?.nonvotingLockedBalance || new BigNumber(0);
+    invariant(nonvotingLockedBalance.gt(0), "Celo: Unlock | No non voting locked balance");
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          mode: "unlock",
+        },
+        {
+          amount: nonvotingLockedBalance.dividedBy(2).integerValue(),
+        },
+      ],
+    };
+  },
+});

package/src/test/specs/createVoteMutation.ts

@@ -0,0 +1,55 @@
+import invariant from "invariant";
+import BigNumber from "bignumber.js";
+import sampleSize from "lodash/sampleSize";
+import { MutationSpec } from "@ledgerhq/coin-framework/bot/types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
+import { getCurrentCeloPreloadData } from "../../bridge/preload";
+import { getValidatorGroupsWithoutVotes } from "../../logic";
+import type { CeloAccount, CeloResources, Transaction } from "../../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createVoteMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Vote",
+  feature: "staking",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    invariant(maxSpendable.gt(minimalAmount), "Celo:  Vote | balance is too low");
+
+    const { celoResources } = account as CeloAccount;
+    invariant(celoResources?.registrationStatus, "Celo: Vote | Account is not registered");
+
+    const nonvotingLockedBalance = celoResources?.nonvotingLockedBalance || new BigNumber(0);
+    invariant(nonvotingLockedBalance.gt(0), "Celo: Vote | No non voting locked balance");
+
+    const votes = (celoResources as CeloResources).votes || [];
+    const { validatorGroups } = getCurrentCeloPreloadData();
+
+    // Get a random validator group that the account does not have locked tokens for.
+    const validatorGroupWithoutVotes = sampleSize(
+      getValidatorGroupsWithoutVotes(validatorGroups, votes),
+      1,
+    )[0];
+
+    const amount = nonvotingLockedBalance.times(0.5).precision(8).integerValue();
+
+    invariant(amount.gt(0), "Celo: Vote | Not enough funds to vote");
+
+    const transaction = {
+      recipient: validatorGroupWithoutVotes.address,
+      amount,
+    };
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          mode: "vote",
+        },
+        transaction,
+      ],
+    };
+  },
+});

package/src/test/specs/createWithdrawMutation.ts

@@ -0,0 +1,37 @@
+import invariant from "invariant";
+import { MutationSpec } from "@ledgerhq/coin-framework/bot/types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
+import { availablePendingWithdrawals } from "../../logic";
+import type { CeloAccount, Transaction } from "../../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createWithdrawMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Withdraw",
+  feature: "staking",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    const celoAccount = account as CeloAccount;
+    const { celoResources } = celoAccount;
+    invariant(celoResources?.registrationStatus, "Celo: Withdraw | Account is not registered");
+
+    const pendingWithdrawals = availablePendingWithdrawals(celoAccount);
+
+    invariant(pendingWithdrawals.length > 0, "Celo: Withdraw | No withdrawable balance");
+
+    invariant(maxSpendable.gt(minimalAmount), "Celo:  Withdraw Vote | balance is too low");
+
+    return {
+      transaction: bridge.createTransaction(celoAccount),
+      updates: [
+        {
+          mode: "withdraw",
+          recipient: celoAccount.celoResources!.lockedGoldAddress!,
+          index: pendingWithdrawals[0].index,
+        },
+      ],
+    };
+  },
+});

package/src/test/specs/index.ts

@@ -0,0 +1,8 @@
+export * from "./createSendMutation";
+export * from "./createLockMutation";
+export * from "./createUnlockMutation";
+export * from "./createRegisterAccountMutation";
+export * from "./createVoteMutation";
+export * from "./createActivateVoteMutation";
+export * from "./createRevokeVoteMutation";
+export * from "./createWithdrawMutation";