@ledgerhq/coin-celo 1.3.0 → 1.3.1-nightly.0

package/src/__tests__/bridge/prepareTransaction.test.ts

@@ -0,0 +1,261 @@
+import BigNumber from "bignumber.js";
+import {
+  accountFixture,
+  accountWithTokenAccountFixture,
+  tokenTransactionFixture,
+  transactionFixture,
+} from "../../bridge/fixtures";
+import prepareTransaction from "../../bridge/prepareTransaction";
+
+const chainIdMock = jest.fn();
+const nonceMock = jest.fn();
+
+jest.mock("../../network/sdk", () => {
+  return {
+    celoKit: jest.fn(() => ({
+      contracts: {
+        getLockedGold: jest.fn(async () => ({
+          address: "address",
+          lock: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => "0x6C6F636B5F64617461"), // lock_data
+              estimateGas: jest.fn(async () => 2),
+            },
+          })),
+          unlock: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => "0x756E6C6F636B5F64617461"), // unlock_data
+              estimateGas: jest.fn(async () => 3),
+            },
+          })),
+          withdraw: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => "0x77697468647261775F64617461"), // withdraw_data
+              estimateGas: jest.fn(async () => 3),
+            },
+          })),
+          vote: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => "0x766F74655F64617461"), // vote_data
+              estimateGas: jest.fn(async () => 3),
+            },
+          })),
+          getAccountNonvotingLockedGold: jest.fn(() => BigNumber(0)),
+        })),
+        getGoldToken: jest.fn(async () => ({
+          address: "gold_token_address",
+          transfer: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => "0x73656E645F64617461"), // send_data
+            },
+          })),
+        })),
+        getStableToken: jest.fn(async () => ({
+          address: "stable_token_address",
+          transfer: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => "0x73656E645F746F6B656E5F64617461"), // stable_token_data
+            },
+          })),
+        })),
+        getErc20: jest.fn(async () => ({
+          address: "erc20_token_address",
+          transfer: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => "0x73656E645F65726332305F746F6B656E5F64617461"), // send_erc20_token_data
+            },
+          })),
+        })),
+      },
+      connection: {
+        chainId: chainIdMock,
+        nonce: nonceMock,
+        estimateGasWithInflationFactor: jest.fn().mockReturnValue(3),
+        gasPrice: jest.fn(async () => BigNumber(2)),
+        web3: { eth: { getBlock: jest.fn().mockResolvedValue({ baseFeePerGas: 10 }) } },
+        getMaxPriorityFeePerGas: jest.fn().mockResolvedValue(1),
+      },
+    })),
+  };
+});
+
+describe("prepareTransaction", () => {
+  it("should return the transaction if the address is invalid", async () => {
+    const transaction = await prepareTransaction(accountFixture, transactionFixture);
+    expect(transaction).toMatchObject({
+      amount: BigNumber(10),
+      recipient: "recipient",
+      useAllAmount: false,
+      family: "celo",
+      mode: "send",
+      index: 0,
+      fees: null,
+    });
+  });
+
+  it("should return the transaction if it doesn't have a recipient", async () => {
+    const transaction = await prepareTransaction(accountFixture, {
+      ...transactionFixture,
+      recipient: "",
+    });
+    expect(transaction).toMatchObject({
+      amount: BigNumber(10),
+      recipient: "",
+      useAllAmount: false,
+      family: "celo",
+      mode: "send",
+      index: 0,
+      fees: null,
+    });
+  });
+
+  it("should return the vote transaction if it doesn't have a recipient", async () => {
+    const transaction = await prepareTransaction(accountFixture, {
+      ...transactionFixture,
+      recipient: "",
+      mode: "vote",
+    });
+    expect(transaction).toMatchObject({
+      amount: BigNumber(10),
+      recipient: "",
+      useAllAmount: false,
+      family: "celo",
+      mode: "vote",
+      index: 0,
+      fees: null,
+    });
+  });
+
+  it("should return the vote transaction if the amount is less than or equal to zero", async () => {
+    const transaction = await prepareTransaction(accountFixture, {
+      ...transactionFixture,
+      recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+      mode: "vote",
+      amount: BigNumber(0),
+    });
+    expect(transaction).toMatchObject({
+      amount: BigNumber(0),
+      recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+      useAllAmount: false,
+      family: "celo",
+      mode: "vote",
+      index: 0,
+      fees: null,
+    });
+  });
+
+  it("should return the prepared transaction", async () => {
+    const transaction = await prepareTransaction(
+      { ...accountFixture, balance: BigNumber(222222), spendableBalance: BigNumber(222222) },
+      {
+        ...transactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+        amount: BigNumber(22),
+      },
+    );
+    expect(transaction).toMatchObject({
+      amount: BigNumber(22),
+      recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+      useAllAmount: false,
+      family: "celo",
+      mode: "send",
+      index: 0,
+      fees: BigNumber(24),
+    });
+  });
+
+  it("should return the prepared stable token transaction", async () => {
+    const transaction = await prepareTransaction(
+      {
+        ...accountWithTokenAccountFixture,
+        balance: BigNumber(222222),
+        spendableBalance: BigNumber(222222),
+        subAccounts: [
+          {
+            ...accountWithTokenAccountFixture.subAccounts[0],
+            token: {
+              ...accountWithTokenAccountFixture.subAccounts[0].token,
+              id: "cEUR",
+            },
+          },
+        ],
+      },
+      {
+        ...tokenTransactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+        amount: BigNumber(22),
+      },
+    );
+    expect(transaction).toMatchObject({
+      amount: BigNumber(22),
+      recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+      useAllAmount: false,
+      family: "celo",
+      mode: "send",
+      index: 0,
+      fees: BigNumber(24),
+      subAccountId: "subAccountId",
+      maxFeePerGas: "1000000010",
+      maxPriorityFeePerGas: 1,
+      data: Buffer.from("0x73656E645F746F6B656E5F64617461"),
+    });
+  });
+
+  it("should return the prepared token transaction", async () => {
+    const transaction = await prepareTransaction(
+      {
+        ...accountWithTokenAccountFixture,
+        balance: BigNumber(222222),
+        spendableBalance: BigNumber(222222),
+      },
+      {
+        ...tokenTransactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+        amount: BigNumber(22),
+      },
+    );
+    expect(transaction).toMatchObject({
+      amount: BigNumber(22),
+      recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+      useAllAmount: false,
+      family: "celo",
+      mode: "send",
+      index: 0,
+      fees: BigNumber(24),
+      subAccountId: "subAccountId",
+      maxFeePerGas: "1000000010",
+      maxPriorityFeePerGas: 1,
+      data: Buffer.from("0x73656E645F65726332305F746F6B656E5F64617461"),
+    });
+  });
+
+  it("should return the prepared token transaction with useAllAmount", async () => {
+    const transaction = await prepareTransaction(
+      {
+        ...accountWithTokenAccountFixture,
+        balance: BigNumber(222222),
+        spendableBalance: BigNumber(222222),
+      },
+      {
+        ...tokenTransactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+        amount: BigNumber(22),
+        useAllAmount: true,
+      },
+    );
+
+    expect(transaction).toMatchObject({
+      amount: BigNumber(212),
+      recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+      useAllAmount: true,
+      family: "celo",
+      mode: "send",
+      index: 0,
+      fees: BigNumber(24),
+      subAccountId: "subAccountId",
+      maxFeePerGas: "1000000010",
+      maxPriorityFeePerGas: 1,
+      data: Buffer.from("0x73656E645F65726332305F746F6B656E5F64617461"),
+    });
+  });
+});

package/src/bridge/buildOptimisticOperation.ts

@@ -2,6 +2,7 @@ import BigNumber from "bignumber.js";
 import { OperationType } from "@ledgerhq/types-live";
 import { CeloAccount, CeloOperation, CeloOperationMode, Transaction } from "../types";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
 
 const MODE_TO_TYPE: { [key in CeloOperationMode | "default"]: OperationType } = {
   send: "OUT",
@@ -22,9 +23,12 @@ export const buildOptimisticOperation = (
 ): CeloOperation => {
   const type = MODE_TO_TYPE[transaction.mode] ?? MODE_TO_TYPE.default;
 
+  const tokenAccount = findSubAccountById(account, transaction.subAccountId || "");
+  const isTokenTransaction = tokenAccount?.type === "TokenAccount";
+
   const value =
     type === "OUT" || type === "LOCK"
-      ? new BigNumber(transaction.amount).plus(fee)
+      ? new BigNumber(transaction.amount).plus(isTokenTransaction ? 0 : fee)
       : new BigNumber(transaction.amount);
 
   const operation: CeloOperation = {
@@ -37,7 +41,7 @@ export const buildOptimisticOperation = (
     blockHeight: null,
     senders: [account.freshAddress],
     recipients: [transaction.recipient].filter(Boolean),
-    accountId: account.id,
+    accountId: isTokenTransaction ? tokenAccount.id : account.id,
     date: new Date(),
     extra: {
       celoOperationValue: new BigNumber(transaction.amount),

package/src/bridge/buildTransaction.ts

@@ -3,12 +3,21 @@ import { CeloTx } from "@celo/connect";
 import { celoKit } from "../network/sdk";
 import { BigNumber } from "bignumber.js";
 import { getPendingStakingOperationAmounts, getVote } from "../logic";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
+import {
+  CELO_STABLE_TOKENS,
+  getStableTokenEnum,
+  MAX_FEES_THRESHOLD_MULTIPLIER,
+  MAX_PRIORITY_FEE_PER_GAS,
+} from "../constants";
 
 const buildTransaction = async (account: CeloAccount, transaction: Transaction) => {
   const kit = celoKit();
 
-  const value = transactionValue(account, transaction);
+  const tokenAccount = findSubAccountById(account, transaction.subAccountId || "");
+  const isTokenTransaction = tokenAccount?.type === "TokenAccount";
 
+  let value = transactionValue(account, transaction);
   let celoTransaction: CeloTx;
 
   if (transaction.mode === "lock") {
@@ -105,23 +114,45 @@ const buildTransaction = async (account: CeloAccount, transaction: Transaction)
       data: accounts.createAccount().txo.encodeABI(),
       gas: await accounts.createAccount().txo.estimateGas({ from: account.freshAddress }),
     };
-  } else {
-    // Send
+  } else if (isTokenTransaction) {
+    value = transaction.useAllAmount ? tokenAccount.balance : transaction.amount;
+
+    const block = await kit.connection.web3.eth.getBlock("latest");
+    const baseFee = BigInt(block.baseFeePerGas || MAX_PRIORITY_FEE_PER_GAS);
+    const maxFeePerGas = baseFee + MAX_PRIORITY_FEE_PER_GAS;
+
+    let token;
+    if (CELO_STABLE_TOKENS.includes(tokenAccount.token.id)) {
+      token = await kit.contracts.getStableToken(getStableTokenEnum(tokenAccount.token.id));
+    } else {
+      token = await kit.contracts.getErc20(tokenAccount.token.contractAddress);
+    }
 
     celoTransaction = {
       from: account.freshAddress,
       to: transaction.recipient,
+      data: token.transfer(transaction.recipient, value.toFixed()).txo.encodeABI(),
+      maxFeePerGas: maxFeePerGas.toString(),
+      maxPriorityFeePerGas: await kit.connection.getMaxPriorityFeePerGas(),
       value: value.toFixed(),
     };
-    const gas = await kit.connection.estimateGasWithInflationFactor(celoTransaction);
-
+  } else {
+    // Send
     celoTransaction = {
-      ...celoTransaction,
-      gas,
+      from: account.freshAddress,
+      to: transaction.recipient,
+      value: value.toFixed(),
     };
   }
+
+  const gas = (
+    (await kit.connection.estimateGasWithInflationFactor(celoTransaction)) *
+    MAX_FEES_THRESHOLD_MULTIPLIER
+  ).toFixed();
+
   const tx: CeloTx = {
     ...celoTransaction,
+    gas,
     chainId: await kit.connection.chainId(),
     nonce: await kit.connection.nonce(account.freshAddress),
   };

package/src/bridge/estimateMaxSpendable.ts

@@ -3,20 +3,36 @@ import { CeloAccount, Transaction } from "../types";
 import getTransactionStatus from "./getTransactionStatus";
 import prepareTransaction from "./prepareTransaction";
 import createTransaction from "./createTransaction";
-import { getMainAccount } from "@ledgerhq/coin-framework/account/helpers";
+import {
+  findSubAccountById,
+  getMainAccount,
+  isTokenAccount,
+} from "@ledgerhq/coin-framework/account/helpers";
+import BigNumber from "bignumber.js";
 
 export const estimateMaxSpendable: AccountBridge<
   Transaction,
   CeloAccount
 >["estimateMaxSpendable"] = async ({ account, parentAccount, transaction }) => {
   const mainAccount = getMainAccount(account, parentAccount);
+
+  const tokenAccount = findSubAccountById(mainAccount, transaction?.subAccountId ?? "");
+  const fromTokenAccount = tokenAccount && isTokenAccount(tokenAccount);
+
   const t = await prepareTransaction(mainAccount, {
     ...createTransaction(account),
     ...transaction,
     useAllAmount: true,
   });
+
   const { amount } = await getTransactionStatus(mainAccount, t);
-  return amount;
+  const fees = t.fees ?? BigNumber(0);
+
+  return fromTokenAccount
+    ? tokenAccount.spendableBalance
+    : account.spendableBalance.gt(fees)
+      ? amount.minus(fees)
+      : new BigNumber(0);
 };
 
 export default estimateMaxSpendable;

package/src/bridge/fixtures.ts

@@ -0,0 +1,103 @@
+import { CeloAccount, Transaction } from "../types";
+import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/lib/currencies";
+import BigNumber from "bignumber.js";
+import { faker } from "@faker-js/faker";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { TokenAccount } from "@ledgerhq/types-live";
+
+const currency = getCryptoCurrencyById("celo");
+
+const accountFixture: CeloAccount = {
+  type: "Account",
+  id: faker.string.uuid(),
+  seedIdentifier: faker.string.uuid(),
+  derivationMode: "",
+  index: faker.number.int(),
+  freshAddress: "address",
+  freshAddressPath: "derivationPath",
+  used: true,
+  balance: new BigNumber(0),
+  spendableBalance: new BigNumber(0),
+  creationDate: faker.date.past(),
+  blockHeight: faker.number.int({ min: 100_000, max: 200_000 }),
+  currency,
+  operationsCount: 0,
+  operations: [],
+  pendingOperations: [],
+  lastSyncDate: new Date(),
+  balanceHistoryCache: emptyHistoryCache,
+  swapHistory: [],
+  celoResources: {
+    registrationStatus: false,
+    lockedBalance: BigNumber(0),
+    nonvotingLockedBalance: BigNumber(0),
+    pendingWithdrawals: null,
+    votes: null,
+    electionAddress: null,
+    lockedGoldAddress: null,
+    maxNumGroupsVotedFor: BigNumber(0),
+  },
+};
+
+const subAccounts = [
+  {
+    id: "subAccountId",
+    type: "TokenAccount",
+    parentId: accountFixture.id,
+    token: {
+      type: "TokenCurrency",
+      id: "celoToken",
+      contractAddress: "contract_address",
+      parentCurrency: currency,
+    } as TokenCurrency,
+    balance: BigNumber(212),
+    spendableBalance: BigNumber(212),
+    creationDate: faker.date.past(),
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    balanceHistoryCache: {
+      HOUR: {
+        latestDate: null,
+        balances: [],
+      },
+      DAY: {
+        latestDate: null,
+        balances: [],
+      },
+      WEEK: {
+        latestDate: null,
+        balances: [],
+      },
+    },
+    swapHistory: [],
+  },
+] as TokenAccount[];
+
+const accountWithTokenAccountFixture = {
+  ...accountFixture,
+  subAccounts,
+};
+
+const transactionFixture: Transaction = {
+  amount: new BigNumber(10),
+  recipient: "recipient",
+  useAllAmount: false,
+  family: "celo",
+  mode: "send",
+  index: 0,
+  fees: null,
+};
+
+const tokenTransactionFixture: Transaction = {
+  ...transactionFixture,
+  subAccountId: "subAccountId",
+};
+
+export {
+  accountFixture,
+  accountWithTokenAccountFixture,
+  transactionFixture,
+  tokenTransactionFixture,
+};

package/src/bridge/getFeesForTransaction.ts

@@ -1,7 +1,15 @@
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
 import { BigNumber } from "bignumber.js";
 import type { CeloAccount, Transaction } from "../types";
 import { celoKit } from "../network/sdk";
 import { getPendingStakingOperationAmounts, getVote } from "../logic";
+import buildTransaction from "./buildTransaction";
+import {
+  CELO_STABLE_TOKENS,
+  getStableTokenEnum,
+  MAX_FEES_THRESHOLD_MULTIPLIER,
+  MAX_PRIORITY_FEE_PER_GAS,
+} from "../constants";
 
 const getFeesForTransaction = async ({
   account,
@@ -28,6 +36,9 @@ const getFeesForTransaction = async ({
   // Deduct pending lock operations from the spendable balance
   const totalSpendableBalance = account.spendableBalance.minus(pendingOperationAmounts.lock);
 
+  const tokenAccount = findSubAccountById(account, transaction.subAccountId || "");
+  const isTokenTransaction = tokenAccount?.type === "TokenAccount";
+
   if ((transaction.mode === "unlock" || transaction.mode === "vote") && account.celoResources) {
     value = transaction.useAllAmount
       ? totalNonVotingLockedBalance
@@ -96,16 +107,39 @@ const getFeesForTransaction = async ({
     const accounts = await kit.contracts.getAccounts();
 
     gas = await accounts.createAccount().txo.estimateGas({ from: account.freshAddress });
-  } else {
-    const celoToken = await kit.contracts.getGoldToken();
+  } else if (isTokenTransaction) {
+    value = transaction.useAllAmount ? tokenAccount.balance : transaction.amount;
+
+    const block = await kit.connection.web3.eth.getBlock("latest");
+    const baseFee = BigInt(block.baseFeePerGas || MAX_PRIORITY_FEE_PER_GAS);
+    const maxFeePerGas = baseFee + MAX_PRIORITY_FEE_PER_GAS;
+
+    let token;
+    if (CELO_STABLE_TOKENS.includes(tokenAccount.token.id)) {
+      token = await kit.contracts.getStableToken(getStableTokenEnum(tokenAccount.token.id));
+    } else {
+      token = await kit.contracts.getErc20(tokenAccount.token.contractAddress);
+    }
 
     const celoTransaction = {
       from: account.freshAddress,
-      to: celoToken.address,
-      data: celoToken.transfer(transaction.recipient, value.toFixed()).txo.encodeABI(),
+      to: transaction.recipient,
+      data: token.transfer(transaction.recipient, value.toFixed()).txo.encodeABI(),
+      maxFeePerGas: maxFeePerGas.toString(),
+      maxPriorityFeePerGas: await kit.connection.getMaxPriorityFeePerGas(),
+      value: value.toFixed(),
     };
 
-    gas = await kit.connection.estimateGasWithInflationFactor(celoTransaction);
+    gas = Number(
+      (
+        (await kit.connection.estimateGasWithInflationFactor(celoTransaction)) *
+        MAX_FEES_THRESHOLD_MULTIPLIER
+      ).toFixed(),
+    );
+  } else {
+    // Send
+    const tx = await buildTransaction(account, transaction);
+    gas = tx.gas ? Number(tx.gas) : 0;
   }
 
   const gasPrice = new BigNumber(await kit.connection.gasPrice());

package/src/bridge/getTransactionStatus.ts

@@ -13,6 +13,7 @@ import { getPendingStakingOperationAmounts, getVote } from "../logic";
 import { CeloAccount, Transaction, TransactionStatus } from "../types";
 import { CeloAllFundsWarning } from "../errors";
 import { celoKit } from "../network/sdk";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
 
 const kit = celoKit();
 
@@ -45,10 +46,14 @@ export const getTransactionStatus: AccountBridge<
   const totalNonVotingLockedBalance = nonvotingLockedGoldBalance.minus(
     pendingOperationAmounts.vote,
   );
+
   // Deduct pending lock operations from the spendable balance
   const totalSpendableBalance = account.spendableBalance.minus(pendingOperationAmounts.lock);
   const estimatedFees = transaction.fees || new BigNumber(0);
 
+  const tokenAccount = findSubAccountById(account, transaction.subAccountId || "");
+  const isTokenTransaction = tokenAccount?.type === "TokenAccount";
+
   let amount: BigNumber = new BigNumber(0);
   if (useAllAmount && (transaction.mode === "unlock" || transaction.mode === "vote")) {
     amount = totalNonVotingLockedBalance ?? new BigNumber(0);
@@ -56,7 +61,9 @@ export const getTransactionStatus: AccountBridge<
     const revoke = getVote(account, transaction.recipient, transaction.index);
     if (revoke?.amount) amount = revoke.amount;
   } else if (useAllAmount) {
-    amount = totalSpendableBalance.minus(estimatedFees);
+    amount = isTokenTransaction
+      ? tokenAccount.spendableBalance
+      : totalSpendableBalance.minus(estimatedFees);
   } else {
     amount = new BigNumber(transaction.amount);
   }
@@ -73,7 +80,7 @@ export const getTransactionStatus: AccountBridge<
   }
 
   if (!["register", "withdraw", "activate"].includes(transaction.mode)) {
-    if (!errors.amount && amount.lte(0) && !useAllAmount) {
+    if (amount.lte(0) && !useAllAmount) {
       errors.amount = new AmountRequired();
     }
   }
@@ -99,13 +106,23 @@ export const getTransactionStatus: AccountBridge<
   }
 
   if (transaction.mode === "send") {
-    if (!transaction.recipient) {
+    if (!transaction.recipient && !errors.recipient) {
       errors.recipient = new RecipientRequired();
-    } else if (!isValidAddress(transaction.recipient)) {
+    } else if (!isValidAddress(transaction.recipient) && !errors.recipient) {
       errors.recipient = new InvalidAddress("", {
         currencyName: account.currency.name,
       });
     }
+
+    if (isTokenTransaction) {
+      return {
+        errors,
+        warnings,
+        estimatedFees,
+        amount,
+        totalSpent: amount,
+      };
+    }
   }
 
   return {

package/src/bridge/index.ts

@@ -21,7 +21,6 @@ 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";