@ledgerhq/coin-celo 1.1.0-next.0

package/package.json

@@ -0,0 +1,156 @@
+{
+  "name": "@ledgerhq/coin-celo",
+  "version": "1.1.0-next.0",
+  "description": "celo coin integration",
+  "keywords": [
+    "Ledger",
+    "LedgerWallet",
+    "Celo",
+    "Hardware Wallet"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LedgerHQ/ledger-live.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LedgerHQ/ledger-live/issues"
+  },
+  "homepage": "https://github.com/LedgerHQ/ledger-live/tree/develop/libs/coin-modules/coin-celo",
+  "publishConfig": {
+    "access": "public"
+  },
+  "typesVersions": {
+    "*": {
+      "lib/*": [
+        "lib/*"
+      ],
+      "lib-es/*": [
+        "lib-es/*"
+      ],
+      "deviceTransactionConfig": [
+        "lib/bridge/deviceTransactionConfig"
+      ],
+      "specs": [
+        "lib/test/bot-specs"
+      ],
+      "transaction": [
+        "lib/bridge/transaction"
+      ],
+      "types": [
+        "lib/types/index"
+      ],
+      "*": [
+        "lib/*",
+        "lib/bridge/*",
+        "lib/logic/*",
+        "lib/signer/*",
+        "lib/test/*",
+        "lib/types/*"
+      ]
+    }
+  },
+  "exports": {
+    "./lib/*": "./lib/*.js",
+    "./lib-es/*": "./lib-es/*.js",
+    "./api": {
+      "require": "./lib/api/index.js",
+      "default": "./lib-es/api/index.js"
+    },
+    "./transaction": {
+      "require": "./lib/bridge/transaction.js",
+      "default": "./lib-es/bridge/transaction.js"
+    },
+    "./cli-transaction": {
+      "require": "./lib/test/cli-transaction.js",
+      "default": "./lib-es/test/cli-transaction.js"
+    },
+    "./hw-getAddress": {
+      "require": "./lib/signer/hw-getAddress.js",
+      "default": "./lib-es/signer/hw-getAddress.js"
+    },
+    "./preload": {
+      "require": "./lib/bridge/preload.js",
+      "default": "./lib-es/bridge/preload.js"
+    },
+    "./deviceTransactionConfig": {
+      "require": "./lib/bridge/deviceTransactionConfig.js",
+      "default": "./lib-es/bridge/deviceTransactionConfig.js"
+    },
+    "./types": {
+      "require": "./lib/types/index.js",
+      "default": "./lib-es/types/index.js"
+    },
+    "./bridge": {
+      "require": "./lib/bridge/index.js",
+      "default": "./lib-es/bridge/index.js"
+    },
+    "./signer": {
+      "require": "./lib/signer/index.js",
+      "default": "./lib-es/signer/index.js"
+    },
+    "./specs": {
+      "require": "./lib/test/bot-specs.js",
+      "default": "./lib-es/test/bot-specs.js"
+    },
+    "./*": {
+      "require": "./lib/*.js",
+      "default": "./lib-es/*.js"
+    },
+    ".": {
+      "require": "./lib/index.js",
+      "default": "./lib-es/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "bignumber.js": "^9.1.2",
+    "invariant": "^2.2.4",
+    "eip55": "^2.1.1",
+    "lodash": "^4.17.21",
+    "rxjs": "^7.8.1",
+    "@celo/connect": "^6.0.2",
+    "@celo/contractkit": "^8.3.1",
+    "@celo/utils": "^7.0.0",
+    "@celo/wallet-base": "^6.0.3",
+    "@celo/wallet-ledger": "^6.0.3",
+    "@ledgerhq/coin-framework": "^3.0.1-next.0",
+    "@ledgerhq/coin-evm": "^2.19.0-next.0",
+    "@ledgerhq/cryptoassets": "^13.15.0",
+    "@ledgerhq/devices": "^8.4.4",
+    "@ledgerhq/errors": "^6.19.1",
+    "@ledgerhq/live-network": "^2.0.7",
+    "@ledgerhq/live-env": "^2.8.0",
+    "@ledgerhq/logs": "^6.12.0",
+    "@ledgerhq/types-live": "^6.68.0-next.0",
+    "@ledgerhq/hw-app-eth": "^6.45.2-next.0",
+    "@ledgerhq/live-config": "^3.1.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.179",
+    "@types/invariant": "^2.2.37",
+    "@types/jest": "^29.5.12",
+    "dotenv": "^16.4.5",
+    "expect": "^27.4.6",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.4.5",
+    "@ledgerhq/types-cryptoassets": "^7.22.0"
+  },
+  "scripts": {
+    "clean": "rimraf lib lib-es",
+    "build": "tsc && tsc -m esnext --moduleResolution bundler --outDir lib-es",
+    "coverage": "jest --coverage --testPathIgnorePatterns='/bridge.integration.test.ts|node_modules|lib-es|lib/' --passWithNoTests && mv coverage/coverage-final.json coverage/coverage-celo.json",
+    "prewatch": "pnpm build",
+    "watch": "tsc --watch",
+    "watch:es": "tsc --watch -m esnext --moduleResolution bundler --outDir lib-es",
+    "doc": "documentation readme src/** --section=API --pe ts --re ts --re d.ts",
+    "lint": "eslint ./src --no-error-on-unmatched-pattern --ext .ts,.tsx --cache",
+    "lint:fix": "pnpm lint --fix",
+    "test": "jest",
+    "test-integ": "jest --config=jest.integ.config.js",
+    "test-integ:debug": "node --inspect-brk ./node_modules/jest/bin/jest.js --runInBand --config=jest.integ.config.js",
+    "typecheck": "tsc --noEmit",
+    "unimported": "unimported"
+  }
+}

package/src/bridge/broadcast.ts

@@ -0,0 +1,14 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { Transaction } from "../types";
+import { celoKit } from "../network/sdk";
+
+export const broadcast: AccountBridge<Transaction>["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/bridge/buildOptimisticOperation.ts

@@ -0,0 +1,53 @@
+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";
+
+const MODE_TO_TYPE: { [key in CeloOperationMode | "default"]: OperationType } = {
+  send: "OUT",
+  lock: "LOCK",
+  unlock: "UNLOCK",
+  withdraw: "WITHDRAW",
+  vote: "VOTE",
+  revoke: "REVOKE",
+  activate: "ACTIVATE",
+  register: "REGISTER",
+  default: "FEES",
+};
+
+export const buildOptimisticOperation = (
+  account: CeloAccount,
+  transaction: Transaction,
+  fee: BigNumber,
+): CeloOperation => {
+  const type = MODE_TO_TYPE[transaction.mode] ?? MODE_TO_TYPE.default;
+
+  const value =
+    type === "OUT" || type === "LOCK"
+      ? new BigNumber(transaction.amount).plus(fee)
+      : new BigNumber(transaction.amount);
+
+  const operation: CeloOperation = {
+    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: {
+      celoOperationValue: new BigNumber(transaction.amount),
+      ...(["ACTIVATE", "VOTE", "REVOKE"].includes(type)
+        ? {
+            celoSourceValidator: transaction.recipient,
+          }
+        : {}),
+    },
+  };
+
+  return operation;
+};

package/src/bridge/buildTransaction.ts

@@ -0,0 +1,154 @@
+import type { CeloAccount, Transaction } from "../types";
+import { CeloTx } from "@celo/connect";
+import { celoKit } from "../network/sdk";
+import { BigNumber } from "bignumber.js";
+import { getPendingStakingOperationAmounts, getVote } from "../logic";
+
+const buildTransaction = async (account: CeloAccount, transaction: Transaction) => {
+  const kit = celoKit();
+
+  const value = transactionValue(account, transaction);
+
+  let celoTransaction: CeloTx;
+
+  if (transaction.mode === "lock") {
+    const lockedGold = await kit.contracts.getLockedGold();
+    celoTransaction = {
+      from: account.freshAddress,
+      value: value.toFixed(),
+      to: lockedGold.address,
+      data: lockedGold.lock().txo.encodeABI(),
+      gas: await lockedGold.lock().txo.estimateGas({
+        from: account.freshAddress,
+        value: value.toFixed(),
+      }),
+    };
+  } else if (transaction.mode === "unlock") {
+    const lockedGold = await kit.contracts.getLockedGold();
+    celoTransaction = {
+      from: account.freshAddress,
+      to: lockedGold.address,
+      data: lockedGold.unlock(value).txo.encodeABI(),
+      gas: await lockedGold.unlock(value).txo.estimateGas({
+        from: account.freshAddress,
+      }),
+    };
+  } else if (transaction.mode === "withdraw") {
+    const lockedGold = await kit.contracts.getLockedGold();
+
+    celoTransaction = {
+      from: account.freshAddress,
+      to: lockedGold.address,
+      data: lockedGold.withdraw(transaction.index || 0).txo.encodeABI(),
+      gas: await lockedGold.withdraw(transaction.index || 0).txo.estimateGas({
+        from: account.freshAddress,
+        value: value.toFixed(),
+      }),
+    };
+  } else if (transaction.mode === "vote") {
+    const election = await kit.contracts.getElection();
+    const vote = await election.vote(transaction.recipient, new BigNumber(value));
+
+    celoTransaction = {
+      from: account.freshAddress,
+      to: election.address,
+      data: vote.txo.encodeABI(),
+      gas: await vote.txo.estimateGas({ from: account.freshAddress }),
+    };
+  } else if (transaction.mode === "revoke") {
+    const election = await kit.contracts.getElection();
+    const accounts = await kit.contracts.getAccounts();
+    const voteSignerAccount = await accounts.voteSignerToAccount(account.freshAddress);
+
+    const revokes = await election.revoke(
+      voteSignerAccount,
+      transaction.recipient,
+      new BigNumber(value),
+    );
+
+    const revoke = revokes.find(transactionObject => {
+      return (
+        (transactionObject.txo as any)._method.name ===
+        (transaction.index === 0 ? "revokePending" : "revokeActive")
+      );
+    });
+    if (!revoke) throw new Error("No votes to revoke");
+
+    celoTransaction = {
+      from: account.freshAddress,
+      to: election.address,
+      data: revoke.txo.encodeABI(),
+      gas: await revoke.txo.estimateGas({ from: account.freshAddress }),
+    };
+  } else if (transaction.mode === "activate") {
+    const election = await kit.contracts.getElection();
+    const accounts = await kit.contracts.getAccounts();
+    const voteSignerAccount = await accounts.voteSignerToAccount(account.freshAddress);
+
+    const activates = await election.activate(voteSignerAccount);
+    const activate = activates.find(a => a.txo.arguments[0] === transaction.recipient);
+    if (!activate) throw new Error("No votes to activate");
+
+    celoTransaction = {
+      from: account.freshAddress,
+      to: election.address,
+      data: activate.txo.encodeABI(),
+      gas: await activate.txo.estimateGas({
+        from: account.freshAddress,
+      }),
+    };
+  } else if (transaction.mode === "register") {
+    const accounts = await kit.contracts.getAccounts();
+    celoTransaction = {
+      from: account.freshAddress,
+      to: accounts.address,
+      data: accounts.createAccount().txo.encodeABI(),
+      gas: await accounts.createAccount().txo.estimateGas({ from: account.freshAddress }),
+    };
+  } else {
+    // Send
+
+    celoTransaction = {
+      from: account.freshAddress,
+      to: transaction.recipient,
+      value: value.toFixed(),
+    };
+    const gas = await kit.connection.estimateGasWithInflationFactor(celoTransaction);
+
+    celoTransaction = {
+      ...celoTransaction,
+      gas,
+    };
+  }
+  const tx: CeloTx = {
+    ...celoTransaction,
+    chainId: await kit.connection.chainId(),
+    nonce: await kit.connection.nonce(account.freshAddress),
+  };
+
+  return tx;
+};
+
+const transactionValue = (account: CeloAccount, transaction: Transaction): BigNumber => {
+  let value = transaction.amount;
+
+  if (transaction.useAllAmount) {
+    if ((transaction.mode === "unlock" || transaction.mode === "vote") && account.celoResources) {
+      // Deduct the amount of pending vote transactions from
+      // the total non-voting locked balance to get the true non-voting locked balance.
+      const pendingOperationAmounts = getPendingStakingOperationAmounts(account);
+      const pendingOperationAmount =
+        transaction.mode === "vote" ? pendingOperationAmounts.vote : new BigNumber(0);
+      value = account.celoResources.nonvotingLockedBalance.minus(pendingOperationAmount);
+    } else if (transaction.mode === "revoke" && account.celoResources) {
+      const revoke = getVote(account, transaction.recipient, transaction.index);
+      if (revoke?.amount) value = revoke.amount;
+    } else {
+      value = account.spendableBalance.minus(transaction.fees || 0);
+    }
+  }
+
+  return value;
+};
+
+export default buildTransaction;

package/src/bridge/createTransaction.ts

@@ -0,0 +1,15 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+import { BigNumber } from "bignumber.js";
+
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => ({
+  family: "celo",
+  amount: new BigNumber(0),
+  recipient: "",
+  useAllAmount: false,
+  fees: null,
+  mode: "send",
+  index: null,
+});
+
+export default createTransaction;

package/src/bridge/deviceTransactionConfig.ts

@@ -0,0 +1,19 @@
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+
+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/bridge/estimateMaxSpendable.ts

@@ -0,0 +1,22 @@
+import type { AccountBridge } from "@ledgerhq/types-live";
+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";
+
+export const estimateMaxSpendable: AccountBridge<
+  Transaction,
+  CeloAccount
+>["estimateMaxSpendable"] = async ({ account, parentAccount, transaction }) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const t = await prepareTransaction(mainAccount, {
+    ...createTransaction(account),
+    ...transaction,
+    useAllAmount: true,
+  });
+  const { amount } = await getTransactionStatus(mainAccount, t);
+  return amount;
+};
+
+export default estimateMaxSpendable;

package/src/bridge/getFeesForTransaction.ts

@@ -0,0 +1,115 @@
+import { BigNumber } from "bignumber.js";
+import type { CeloAccount, Transaction } from "../types";
+import { celoKit } from "../network/sdk";
+import { getPendingStakingOperationAmounts, getVote } from "../logic";
+
+const getFeesForTransaction = async ({
+  account,
+  transaction,
+}: {
+  account: CeloAccount;
+  transaction: Transaction;
+}): Promise<BigNumber> => {
+  const { amount, index } = transaction;
+  const kit = celoKit();
+
+  // A workaround - estimating gas throws an error if value > funds
+  let value: BigNumber = new BigNumber(0);
+
+  const pendingOperationAmounts = getPendingStakingOperationAmounts(account);
+  const lockedGold = await kit.contracts.getLockedGold();
+  const nonvotingLockedGoldBalance = await lockedGold.getAccountNonvotingLockedGold(
+    account.freshAddress,
+  );
+  // Deduct pending vote operations from the non-voting locked balance
+  const totalNonVotingLockedBalance = nonvotingLockedGoldBalance.minus(
+    pendingOperationAmounts.vote,
+  );
+  // Deduct pending lock operations from the spendable balance
+  const totalSpendableBalance = account.spendableBalance.minus(pendingOperationAmounts.lock);
+
+  if ((transaction.mode === "unlock" || transaction.mode === "vote") && account.celoResources) {
+    value = transaction.useAllAmount
+      ? totalNonVotingLockedBalance
+      : BigNumber.minimum(amount, totalNonVotingLockedBalance);
+  } else if (transaction.mode === "revoke" && account.celoResources) {
+    const vote = getVote(account, transaction.recipient, transaction.index);
+    if (vote) {
+      value = transaction.useAllAmount ? vote.amount : BigNumber.minimum(amount, vote.amount);
+    }
+  } else {
+    value = transaction.useAllAmount
+      ? totalSpendableBalance
+      : BigNumber.minimum(amount, totalSpendableBalance);
+  }
+
+  let gas: number | null = null;
+  if (transaction.mode === "lock") {
+    gas = await lockedGold
+      .lock()
+      .txo.estimateGas({ from: account.freshAddress, value: value.toFixed() });
+  } else if (transaction.mode === "unlock") {
+    const lockedGold = await kit.contracts.getLockedGold();
+
+    gas = await lockedGold.unlock(value).txo.estimateGas({ from: account.freshAddress });
+  } else if (transaction.mode === "withdraw") {
+    const lockedGold = await kit.contracts.getLockedGold();
+
+    gas = await lockedGold.withdraw(index || 0).txo.estimateGas({ from: account.freshAddress });
+  } else if (transaction.mode === "vote") {
+    const election = await kit.contracts.getElection();
+
+    const vote = await election.vote(transaction.recipient, new BigNumber(value));
+
+    gas = await vote.txo.estimateGas({ from: account.freshAddress });
+  } else if (transaction.mode === "revoke") {
+    const election = await kit.contracts.getElection();
+    const accounts = await kit.contracts.getAccounts();
+    const voteSignerAccount = await accounts.voteSignerToAccount(account.freshAddress);
+    const revokeTxs = await election.revoke(
+      voteSignerAccount,
+      transaction.recipient,
+      new BigNumber(value),
+    );
+
+    const revokeTx = revokeTxs.find(transactionObject => {
+      return (
+        (transactionObject.txo as any)._method.name ===
+        (transaction.index === 0 ? "revokePending" : "revokeActive")
+      );
+    });
+    if (!revokeTx) return new BigNumber(0);
+
+    gas = await revokeTx.txo.estimateGas({ from: account.freshAddress });
+  } else if (transaction.mode === "activate") {
+    const election = await kit.contracts.getElection();
+    const accounts = await kit.contracts.getAccounts();
+    const voteSignerAccount = await accounts.voteSignerToAccount(account.freshAddress);
+
+    const activates = await election.activate(voteSignerAccount);
+
+    const activate = activates.find(a => a.txo.arguments[0] === transaction.recipient);
+    if (!activate) return new BigNumber(0);
+
+    gas = await activate.txo.estimateGas({ from: account.freshAddress });
+  } else if (transaction.mode === "register") {
+    const accounts = await kit.contracts.getAccounts();
+
+    gas = await accounts.createAccount().txo.estimateGas({ from: account.freshAddress });
+  } else {
+    const celoToken = await kit.contracts.getGoldToken();
+
+    const celoTransaction = {
+      from: account.freshAddress,
+      to: celoToken.address,
+      data: celoToken.transfer(transaction.recipient, value.toFixed()).txo.encodeABI(),
+    };
+
+    gas = await kit.connection.estimateGasWithInflationFactor(celoTransaction);
+  }
+
+  const gasPrice = new BigNumber(await kit.connection.gasPrice());
+  return gasPrice.times(gas);
+};
+
+export default getFeesForTransaction;

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,120 @@
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { BigNumber } from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { isValidAddress } from "@celo/utils/lib/address";
+import { getPendingStakingOperationAmounts, getVote } from "../logic";
+import { CeloAccount, Transaction, TransactionStatus } from "../types";
+import { CeloAllFundsWarning } from "../errors";
+import { celoKit } from "../network/sdk";
+
+const kit = celoKit();
+
+// Arbitrary buffer for paying fees of next transactions. 0.05 Celo for ~100 transactions
+const FEES_SAFETY_BUFFER = new BigNumber(5000000000000000);
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  CeloAccount,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  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 pendingOperationAmounts = getPendingStakingOperationAmounts(account);
+  const lockedGold = await kit.contracts.getLockedGold();
+  const nonvotingLockedGoldBalance = await lockedGold.getAccountNonvotingLockedGold(
+    account.freshAddress,
+  );
+  // Deduct pending vote operations from the non-voting locked balance
+  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);
+
+  let amount: BigNumber = new BigNumber(0);
+  if (useAllAmount && (transaction.mode === "unlock" || transaction.mode === "vote")) {
+    amount = totalNonVotingLockedBalance ?? new BigNumber(0);
+  } else if (useAllAmount && transaction.mode === "revoke") {
+    const revoke = getVote(account, transaction.recipient, transaction.index);
+    if (revoke?.amount) amount = revoke.amount;
+  } else if (useAllAmount) {
+    amount = totalSpendableBalance.minus(estimatedFees);
+  } else {
+    amount = new BigNumber(transaction.amount);
+  }
+
+  if (amount.lt(0)) amount = new BigNumber(0);
+
+  if (
+    (account.celoResources?.lockedBalance.gt(0) ||
+      !!account.celoResources?.pendingWithdrawals?.length) &&
+    (transaction.useAllAmount || totalSpendableBalance.minus(amount).lt(FEES_SAFETY_BUFFER)) &&
+    ["send", "lock"].includes(transaction.mode)
+  ) {
+    warnings.amount = new CeloAllFundsWarning();
+  }
+
+  if (!["register", "withdraw", "activate"].includes(transaction.mode)) {
+    if (!errors.amount && amount.lte(0) && !useAllAmount) {
+      errors.amount = new AmountRequired();
+    }
+  }
+
+  const totalSpent = amount.plus(estimatedFees);
+
+  if (transaction.mode === "unlock" || transaction.mode === "vote") {
+    if (!errors.amount && totalNonVotingLockedBalance && amount.gt(totalNonVotingLockedBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  } else if (transaction.mode === "revoke") {
+    const revoke = getVote(account, transaction.recipient, transaction.index);
+    if (!errors.amount && revoke?.amount && amount.gt(revoke.amount))
+      errors.amount = new NotEnoughBalance();
+  } else {
+    if (!errors.amount && totalSpent.gt(totalSpendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  if (!errors.amount && totalSpendableBalance.lt(estimatedFees)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  if (transaction.mode === "send") {
+    if (!transaction.recipient) {
+      errors.recipient = new RecipientRequired();
+    } else if (!isValidAddress(transaction.recipient)) {
+      errors.recipient = new InvalidAddress("", {
+        currencyName: account.currency.name,
+      });
+    }
+  }
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};
+
+export default getTransactionStatus;