@ledgerhq/live-common 21.21.3 → 21.23.0

package/src/families/algorand/specs.ts

@@ -1,6 +1,6 @@
 import expect from "expect";
 import invariant from "invariant";
-import type { Transaction } from "./types";
+import type { AlgorandTransaction } from "./types";
 import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
 import { isAccountEmpty } from "../../account";
 import { pickSiblings } from "../../bot/specs";
@@ -12,18 +12,9 @@ import { listTokensForCryptoCurrency } from "../../currencies";
 import { extractTokenId } from "./tokens";
 import { DeviceModelId } from "@ledgerhq/devices";
 const currency = getCryptoCurrencyById("algorand");
-// Minimum fees
-const minFees = parseCurrencyUnit(currency.units[0], "0.001");
 // Minimum balance required for a new non-ASA account
 const minBalanceNewAccount = parseCurrencyUnit(currency.units[0], "0.1");
 
-// Spendable balance for a non-ASA account
-const getSpendableBalance = (maxSpendable) => {
-  maxSpendable = maxSpendable.minus(minFees);
-  invariant(maxSpendable.gt(0), "Spendable balance is too low");
-  return maxSpendable;
-};
-
 // Ensure that, when the recipient corresponds to an empty account,
 // the amount to send is greater or equal to the required minimum
 // balance for such a recipient
@@ -74,7 +65,7 @@ const getRandomAssetId = (account) => {
   return sample(diff);
 };
 
-const algorand: AppSpec<Transaction> = {
+const algorand: AppSpec<AlgorandTransaction> = {
   name: "Algorand",
   currency,
   appQuery: {
@@ -86,11 +77,11 @@ const algorand: AppSpec<Transaction> = {
       name: "move ~50%",
       maxRun: 2,
       transaction: ({ account, siblings, bridge, maxSpendable }) => {
-        const spendableBalance = getSpendableBalance(maxSpendable);
+        invariant(maxSpendable.gt(0), "Spendable balance is too low");
         const sibling = pickSiblings(siblings, 4);
         const recipient = sibling.freshAddress;
         const transaction = bridge.createTransaction(account);
-        const amount = spendableBalance
+        const amount = maxSpendable
           .div(1.9 + 0.2 * Math.random())
           .integerValue();
         checkSendableToEmptyAccount(amount, sibling);
@@ -119,10 +110,10 @@ const algorand: AppSpec<Transaction> = {
       name: "send max",
       maxRun: 1,
       transaction: ({ account, siblings, bridge, maxSpendable }) => {
-        const spendableBalance = getSpendableBalance(maxSpendable);
+        invariant(maxSpendable.gt(0), "Spendable balance is too low");
         const sibling = pickSiblings(siblings, 4);
         // Send the full spendable balance
-        const amount = spendableBalance;
+        const amount = maxSpendable;
         checkSendableToEmptyAccount(amount, sibling);
         return {
           transaction: bridge.createTransaction(account),
@@ -147,7 +138,7 @@ const algorand: AppSpec<Transaction> = {
       name: "send ASA ~50%",
       maxRun: 2,
       transaction: ({ account, siblings, bridge, maxSpendable }) => {
-        invariant(maxSpendable.gt(minFees), "Spendable balance is too low");
+        invariant(maxSpendable.gt(0), "Spendable balance is too low");
         const subAccount = sample(getAssetsWithBalance(account));
         invariant(
           subAccount && subAccount.type === "TokenAccount",
@@ -161,7 +152,7 @@ const algorand: AppSpec<Transaction> = {
         const amount = subAccount.balance
           .div(1.9 + 0.2 * Math.random())
           .integerValue();
-        const updates: Array<Partial<Transaction>> = [
+        const updates: Array<Partial<AlgorandTransaction>> = [
           {
             mode,
             subAccountId: subAccount.id,
@@ -196,10 +187,13 @@ const algorand: AppSpec<Transaction> = {
       name: "opt-In ASA available",
       maxRun: 1,
       transaction: ({ account, bridge, maxSpendable }) => {
-        // maxSpendable is expected to be greater than 100,000 micro-Algos (+ 1,000 for fees)
+        // maxSpendable is expected to be greater than 100,000 micro-Algos
         // corresponding to the requirement that the main account will have
         // one more ASA after the opt-in; its minimum balance is updated accordingly
-        invariant(maxSpendable.gt(new BigNumber(101000)), "balance is too low");
+        invariant(
+          maxSpendable.gt(new BigNumber(100000)),
+          "Spendable balance is too low"
+        );
         const transaction = bridge.createTransaction(account);
         const mode = "optIn";
         const assetId = getRandomAssetId(account);
@@ -207,7 +201,7 @@ const algorand: AppSpec<Transaction> = {
           ? account.subAccounts.find((a) => a.id.includes(assetId as string))
           : null;
         invariant(!subAccount, "already opt-in");
-        const updates: Array<Partial<Transaction>> = [
+        const updates: Array<Partial<AlgorandTransaction>> = [
           {
             mode,
           },
@@ -241,10 +235,10 @@ const algorand: AppSpec<Transaction> = {
         invariant(rewards && rewards.gt(0), "No pending rewards");
         // Ensure that the rewards can effectively be claimed
         // (fees have to be paid in order to claim the rewards)
-        invariant(maxSpendable.gt(minFees), "Spendable balance is too low");
+        invariant(maxSpendable.gt(0), "Spendable balance is too low");
         const transaction = bridge.createTransaction(account);
         const mode = "claimReward";
-        const updates: Array<Partial<Transaction>> = [
+        const updates: Array<Partial<AlgorandTransaction>> = [
           {
             mode,
           },

package/src/families/algorand/speculos-deviceActions.ts

@@ -1,5 +1,5 @@
 import type { DeviceAction } from "../../bot/types";
-import type { Transaction } from "./types";
+import type { AlgorandTransaction } from "./types";
 import { formatCurrencyUnit, findTokenById } from "../../currencies";
 import { deviceActionFlow } from "../../bot/specs";
 import { extractTokenId, addPrefixToken } from "./tokens";
@@ -11,88 +11,93 @@ const expectedAmount = ({ account, status }) =>
     disableRounding: true,
   });
 
-const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
-  steps: [
-    {
-      title: "Txn Type",
-      button: "Rr",
-      expectedValue: ({ transaction }) =>
-        transaction.subAccountId ? "Asset xfer" : "Payment",
-    },
-    {
-      title: "Asset xfer",
-      button: "Rr",
-    },
-    {
-      title: "Payment",
-      button: "Rr",
-    },
-    {
-      title: "Fee",
-      button: "Rr",
-      expectedValue: ({ account, status }) =>
-        formatCurrencyUnit(account.unit, status.estimatedFees, {
-          disableRounding: true,
-        }),
-    },
-    {
-      title: "Asset ID",
-      button: "Rr",
-      expectedValue: ({ transaction }) => {
-        const id = transaction.assetId
-          ? extractTokenId(transaction.assetId)
-          : transaction.subAccountId
-          ? extractTokenId(transaction.subAccountId)
-          : "";
-        const token = findTokenById(addPrefixToken(id));
-        return token ? displayTokenValue(token) : `#${id}`;
+const acceptTransaction: DeviceAction<AlgorandTransaction, any> =
+  deviceActionFlow({
+    steps: [
+      {
+        title: "Txn Type",
+        button: "Rr",
+        expectedValue: ({ transaction }) =>
+          transaction.subAccountId ? "Asset xfer" : "Payment",
       },
-    },
-    {
-      title: "Asset amt",
-      button: "Rr",
-      expectedValue: ({ transaction, status }) =>
-        transaction.mode === "optIn" ? "0" : status.amount.toString(),
-    },
-    {
-      title: "Receiver",
-      button: "Rr",
-      expectedValue: ({ transaction }) => transaction.recipient,
-    },
-    {
-      title: "Asset dst",
-      button: "Rr",
-      expectedValue: ({ transaction }) => transaction.recipient,
-    },
-    {
-      title: "Amount",
-      button: "Rr",
-      expectedValue: ({ account, status, transaction }) =>
-        transaction.mode === "claimReward"
-          ? "0"
-          : expectedAmount({
-              account,
-              status,
-            }),
-    },
-    {
-      title: "Sign",
-      button: "LRlr",
-    },
-    {
-      title: "Review",
-      button: "Rr",
-    },
-    {
-      title: "Genesis ID",
-      button: "Rr",
-    }, // Only on testnet
-    {
-      title: "Genesis hash",
-      button: "Rr",
-    }, // Only on testnet
-  ],
-});
+      {
+        title: "Asset xfer",
+        button: "Rr",
+      },
+      {
+        title: "Payment",
+        button: "Rr",
+      },
+      {
+        title: "Fee",
+        button: "Rr",
+        expectedValue: ({ account, status }) =>
+          formatCurrencyUnit(account.unit, status.estimatedFees, {
+            disableRounding: true,
+          }),
+      },
+      {
+        title: "Asset ID",
+        button: "Rr",
+        expectedValue: ({ transaction }) => {
+          const id = transaction.assetId
+            ? extractTokenId(transaction.assetId)
+            : transaction.subAccountId
+            ? extractTokenId(transaction.subAccountId)
+            : "";
+          const token = findTokenById(addPrefixToken(id));
+          return token ? displayTokenValue(token) : `#${id}`;
+        },
+      },
+      {
+        title: "Asset amt",
+        button: "Rr",
+        expectedValue: ({ transaction, status }) =>
+          transaction.mode === "optIn" ? "0" : status.amount.toString(),
+      },
+      {
+        title: "Sender",
+        button: "Rr",
+      },
+      {
+        title: "Receiver",
+        button: "Rr",
+        expectedValue: ({ transaction }) => transaction.recipient,
+      },
+      {
+        title: "Asset dst",
+        button: "Rr",
+        expectedValue: ({ transaction }) => transaction.recipient,
+      },
+      {
+        title: "Amount",
+        button: "Rr",
+        expectedValue: ({ account, status, transaction }) =>
+          transaction.mode === "claimReward"
+            ? "0"
+            : expectedAmount({
+                account,
+                status,
+              }),
+      },
+      {
+        title: "Sign",
+        button: "LRlr",
+      },
+      {
+        title: "Review",
+        button: "Rr",
+      },
+      {
+        title: "Genesis ID",
+        button: "Rr",
+      }, // Only on testnet
+      {
+        title: "Genesis hash",
+        button: "Rr",
+      }, // Only on testnet
+    ],
+  });
 export default {
   acceptTransaction,
 };

package/src/families/algorand/test-dataset.ts

@@ -6,19 +6,18 @@ import {
   NotEnoughBalanceBecauseDestinationNotCreated,
 } from "@ledgerhq/errors";
 import { AlgorandASANotOptInInRecipient } from "../../errors";
-import type { Transaction } from "./types";
+import type { AlgorandTransaction } from "./types";
 // const notCreatedAlgorandAddress =
 //   "ZBILW5BPM7AQU54YQZICSGS4J7KJ2XV6OC3DFUQ7BB4DVLYKKUEVWDDBGM";
-const dataset: DatasetTest<Transaction> = {
+const dataset: DatasetTest<AlgorandTransaction> = {
   implementations: ["libcore"],
   // test disabled. FIXME ctx LL-5485
   currencies: {} || {
     algorand: {
       FIXME_ignoreAccountFields: [
-        "algorandResources.rewards", // We cant keep track of this since it's always move
-        "algorandResources.rewardsAccumulated", // same
-        "balance", // I think rewards are included
-        "spendableBalance", // same since the rewards are included here
+        "algorandResources.rewards", // We cant keep track of this since it's always moving
+        "balance", // Rewards are included, same as above
+        "spendableBalance", // Same since the rewards are included here too
       ],
       scanAccounts: [
         {

package/src/families/algorand/tokens.ts

@@ -1,4 +1,5 @@
 export const addPrefixToken = (tokenId: string) => `algorand/asa/${tokenId}`;
+
 export const extractTokenId = (tokenId: string) => {
   return tokenId.split("/")[2];
 };

package/src/families/algorand/transaction.ts

@@ -1,5 +1,5 @@
 import { BigNumber } from "bignumber.js";
-import type { Transaction, TransactionRaw } from "./types";
+import type { AlgorandTransaction, AlgorandTransactionRaw } from "./types";
 import {
   fromTransactionCommonRaw,
   toTransactionCommonRaw,
@@ -8,7 +8,14 @@ import type { Account } from "../../types";
 import { getAccountUnit } from "../../account";
 import { formatCurrencyUnit } from "../../currencies";
 export const formatTransaction = (
-  { mode, subAccountId, amount, recipient, fees, useAllAmount }: Transaction,
+  {
+    mode,
+    subAccountId,
+    amount,
+    recipient,
+    fees,
+    useAllAmount,
+  }: AlgorandTransaction,
   mainAccount: Account
 ): string => {
   const account =
@@ -41,7 +48,9 @@ export const formatTransaction = (
     }`;
 };
 
-const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+const fromTransactionRaw = (
+  tr: AlgorandTransactionRaw
+): AlgorandTransaction => {
   const common = fromTransactionCommonRaw(tr);
   return {
     ...common,
@@ -53,7 +62,7 @@ const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
   };
 };
 
-const toTransactionRaw = (t: Transaction): TransactionRaw => {
+const toTransactionRaw = (t: AlgorandTransaction): AlgorandTransactionRaw => {
   const common = toTransactionCommonRaw(t);
   return {
     ...common,

package/src/families/algorand/types.ts

@@ -95,34 +95,39 @@ declare class CoreAlgorandOperation {
 }
 
 export type CoreCurrencySpecifics = Record<string, never>;
+
 export type AlgorandResources = {
   rewards: BigNumber;
-  rewardsAccumulated: BigNumber;
+  // Ledger Live only supports a limited list of ASA (defined here https://github.com/LedgerHQ/ledgerjs/blob/master/packages/cryptoassets/data/asa.js)
+  // This is the actual number of ASA opted-in for the Algo account
+  nbAssets: number;
 };
 export type AlgorandResourcesRaw = {
   rewards: string;
-  rewardsAccumulated: string;
+  nbAssets: number;
 };
-export type AlgorandOperationMode = "send" | "optIn" | "claimReward" | "optOut";
+export type AlgorandOperationMode = "send" | "optIn" | "claimReward";
 export type {
   CoreAlgorandOperation,
   CoreAlgorandAccount,
   CoreAlgorandTransaction,
 };
-export type Transaction = TransactionCommon & {
+export type AlgorandTransaction = TransactionCommon & {
   family: "algorand";
   mode: AlgorandOperationMode;
   fees: BigNumber | null | undefined;
   assetId: string | null | undefined;
   memo: string | null | undefined;
 };
-export type TransactionRaw = TransactionCommonRaw & {
+export type AlgorandTransactionRaw = TransactionCommonRaw & {
   family: "algorand";
   mode: AlgorandOperationMode;
   fees: string | null | undefined;
   assetId: string | null | undefined;
   memo: string | null | undefined;
 };
+export type Transaction = AlgorandTransaction;
+export type TransactionRaw = AlgorandTransactionRaw;
 export type AlgorandOperation = Operation & {
   extra: AlgorandExtraTxInfo;
 };

package/src/families/bitcoin/js-prepareTransaction.ts

@@ -18,8 +18,9 @@ const prepareTransaction = async (
   const feePerByte = inferFeePerByte(t, networkInfo);
 
   if (
-    t.networkInfo === networkInfo &&
-    (feePerByte === t.feePerByte || feePerByte.eq(t.feePerByte || 0))
+    (t.networkInfo === networkInfo &&
+      (feePerByte === t.feePerByte || feePerByte.eq(t.feePerByte || 0))) ||
+    t.feesStrategy === "custom"
   ) {
     // nothing changed
     return t;

package/src/families/bitcoin/js-synchronisation.ts

@@ -140,8 +140,9 @@ const mapTxToOperations = (
       if (!accountAddresses.includes(output.address)) {
         // The output doesn't belong to this account
         if (
-          tx.outputs.length === 1 || // The transaction has only 1 output
-          output.output_index < changeOutputIndex // The output isn't the change output
+          accountInputs.length > 0 && // It's a SEND operation
+          (tx.outputs.length === 1 || // The transaction has only 1 output
+            output.output_index < changeOutputIndex) // The output isn't the change output
         ) {
           recipients.push(
             syncReplaceAddress

package/src/families/bitcoin/wallet-btc/crypto/decred.ts

@@ -60,12 +60,11 @@ class BIP32 {
   hmacSHA512(key, data) {
     return createHmac("sha512", key).update(data).digest();
   }
-  hash160(buffer) {
-    const sha256Hash = createHash("sha256").update(buffer).digest();
-    return createHash("rmd160").update(sha256Hash).digest();
+  hashSHA256(buffer) {
+    return createHash("sha256").update(buffer).digest();
   }
   fingerprint() {
-    return this.hash160(this.pk()).slice(0, 4);
+    return this.hashSHA256(this.pk()).slice(0, 4);
   }
 
   toBase58() {

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

@@ -6,7 +6,6 @@ import {
   NotEnoughBalance,
   NotEnoughBalanceToDelegate,
   FeeTooHigh,
-  NotSupportedLegacyAddress,
   InvalidAddressBecauseDestinationIsAlsoSource,
   RecommendUndelegation,
 } from "@ledgerhq/errors";
@@ -45,6 +44,7 @@ const createTransaction: () => Transaction = () => ({
   networkInfo: null,
   useAllAmount: false,
   taquitoError: null,
+  estimatedFees: null,
 });
 
 const updateTransaction = (t, patch) => ({ ...t, ...patch });
@@ -65,7 +65,7 @@ const getTransactionStatus = async (
     recipient?: Error;
   } = {};
 
-  let estimatedFees = new BigNumber(t.fees || 0);
+  const estimatedFees = t.estimatedFees || new BigNumber(0);
 
   const { tezosResources } = account;
   if (!tezosResources) throw new Error("tezosResources is missing");
@@ -90,17 +90,6 @@ const getTransactionStatus = async (
       }
     }
 
-    if (t.recipient.startsWith("KT") && !errors.recipient) {
-      errors.recipient = new NotSupportedLegacyAddress();
-    }
-
-    // no fee / not enough balance already handled by taquitoError
-    if (!tezosResources.revealed) {
-      // FIXME
-      // https://github.com/ecadlabs/taquito/commit/48a11cfaffe4c6bdfa6f04ebbd0b756f4b135865#diff-3b138622526cbaa55605b79011aa411652367136a3e92e43faecc654da3854e7
-      estimatedFees = estimatedFees.plus(374 || DEFAULT_FEE.REVEAL);
-    }
-
     if (t.mode === "send") {
       if (!errors.amount && t.amount.eq(0)) {
         errors.amount = new AmountRequired();
@@ -120,7 +109,11 @@ const getTransactionStatus = async (
           .lt(thresholdWarning)
       ) {
         if (isAccountDelegating(account)) {
-          warnings.amount = new RecommendUndelegation();
+          if (t.useAllAmount) {
+            errors.amount = new RecommendUndelegation();
+          } else {
+            warnings.amount = new RecommendUndelegation();
+          }
         }
       }
     }
@@ -128,15 +121,22 @@ const getTransactionStatus = async (
     log("taquitoerror", String(t.taquitoError));
 
     // remap taquito errors
-    if (t.taquitoError === "proto.010-PtGRANAD.contract.balance_too_low") {
+    if (t.taquitoError.endsWith("balance_too_low")) {
       if (t.mode === "send") {
         errors.amount = new NotEnoughBalance();
       } else {
         errors.amount = new NotEnoughBalanceToDelegate();
       }
+    } else {
+      // unidentified error case
+      errors.amount = new Error(t.taquitoError);
     }
   }
 
+  if (!errors.amount && account.balance.lte(0)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
   const result = {
     errors,
     warnings,
@@ -154,8 +154,25 @@ const prepareTransaction = async (
   const { tezosResources } = account;
   if (!tezosResources) throw new Error("tezosResources is missing");
 
-  const tezos = new TezosToolkit(getEnv("API_TEZOS_NODE"));
+  if (account.balance.lte(0)) {
+    return Promise.resolve(transaction);
+  }
 
+  // basic check to confirm the transaction is "complete"
+  if (transaction.mode !== "undelegate") {
+    if (!transaction.recipient) {
+      return Promise.resolve(transaction);
+    }
+    const { recipientError } = await validateRecipient(
+      account.currency,
+      transaction.recipient
+    );
+    if (recipientError) {
+      return Promise.resolve(transaction);
+    }
+  }
+
+  const tezos = new TezosToolkit(getEnv("API_TEZOS_NODE"));
   tezos.setProvider({
     signer: {
       publicKeyHash: async () => account.freshAddress,
@@ -165,20 +182,21 @@ const prepareTransaction = async (
     },
   });
 
-  try {
-    if (transaction.useAllAmount) {
-      // taquito does not accept 0, so we do 1
-      // only failing case is when the account precisely has fees + 1. which is
-      // unlikely
-      transaction.amount = new BigNumber(1);
-    }
+  if (transaction.useAllAmount) {
+    // taquito does not accept 0, so we do 1
+    // only failing case is when the account precisely has fees + 1. which is
+    // unlikely
+    transaction.amount = new BigNumber(1);
+  }
 
+  try {
     let out;
     switch (transaction.mode) {
       case "send":
         out = await tezos.estimate.transfer({
+          mutez: true,
           to: transaction.recipient,
-          amount: transaction.amount.div(10 ** 6).toNumber(),
+          amount: transaction.amount.toNumber(),
         });
         break;
       case "delegate":
@@ -193,14 +211,15 @@ const prepareTransaction = async (
         });
         break;
       default:
-        throw "unsuported";
+        throw new Error("unsupported mode=" + transaction.mode);
     }
 
-    transaction.fees = new BigNumber(out.suggestedFeeMutez);
-    transaction.gasLimit = new BigNumber(out.gasLimit);
-    transaction.storageLimit = new BigNumber(out.storageLimit);
-
     if (transaction.useAllAmount) {
+      const totalFees = out.suggestedFeeMutez + out.burnFeeMutez;
+      const maxAmount = account.balance
+        .minus(totalFees + (tezosResources.revealed ? 0 : DEFAULT_FEE.REVEAL))
+        .toNumber();
+      // from https://github.com/ecadlabs/taquito/blob/a70c64c4b105381bb9f1d04c9c70e8ef26e9241c/integration-tests/contract-empty-implicit-account-into-new-implicit-account.spec.ts#L33
       // Temporary fix, see https://gitlab.com/tezos/tezos/-/issues/1754
       // we need to increase the gasLimit and fee returned by the estimation
       const gasBuffer = 500;
@@ -208,15 +227,37 @@ const prepareTransaction = async (
       const increasedFee = (gasBuffer: number, opSize: number) => {
         return gasBuffer * MINIMAL_FEE_PER_GAS_MUTEZ + opSize;
       };
-      transaction.fees = transaction.fees.plus(
-        increasedFee(gasBuffer, Number(out.opSize))
+      const incr = increasedFee(gasBuffer, Number(out.opSize));
+      transaction.fees = new BigNumber(out.suggestedFeeMutez + incr);
+      transaction.gasLimit = new BigNumber(out.gasLimit + gasBuffer);
+      transaction.amount = new BigNumber(maxAmount - incr);
+    } else {
+      transaction.fees = new BigNumber(out.suggestedFeeMutez);
+      transaction.gasLimit = new BigNumber(out.gasLimit);
+      transaction.storageLimit = new BigNumber(out.storageLimit);
+    }
+
+    transaction.storageLimit = new BigNumber(out.storageLimit);
+    transaction.estimatedFees = transaction.fees;
+    if (!tezosResources.revealed) {
+      transaction.estimatedFees = transaction.estimatedFees.plus(
+        DEFAULT_FEE.REVEAL
+      );
+    }
+  } catch (e) {
+    if (typeof e !== "object" || !e) throw e;
+    if ("id" in e) {
+      transaction.taquitoError = (e as { id: string }).id;
+    } else if ("status" in e) {
+      // in case of http 400, log & ignore (more case to handle)
+      log(
+        "taquito-network-error",
+        String((e as { message: string }).message || ""),
+        { transaction }
       );
-      transaction.gasLimit = transaction.gasLimit.plus(gasBuffer);
-      const s = await getTransactionStatus(account, transaction);
-      transaction.amount = account.balance.minus(s.estimatedFees);
+    } else {
+      throw e;
     }
-  } catch (e: any) {
-    transaction.taquitoError = e.id;
   }
 
   return transaction;

package/src/families/tezos/bridge/libcore.ts

@@ -90,6 +90,7 @@ const createTransaction = (): Transaction => ({
   networkInfo: null,
   useAllAmount: false,
   taquitoError: null,
+  estimatedFees: null,
 });
 
 const updateTransaction = (t, patch) => ({ ...t, ...patch });