@ledgerhq/coin-tezos 6.6.0-nightly.1 → 6.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/coin-tezos",
-  "version": "6.6.0-nightly.1",
+  "version": "6.6.0",
   "description": "Tezos Coin integration",
   "keywords": [
     "Ledger",
@@ -56,8 +56,8 @@
       "default": "./lib-es/test/bot-specs.js"
     },
     "./transaction": {
-      "require": "./lib/transaction.js",
-      "default": "./lib-es/transaction.js"
+      "require": "./lib/bridge/transaction.js",
+      "default": "./lib-es/bridge/transaction.js"
     },
     "./*": {
       "require": "./lib/*.js",
@@ -72,20 +72,24 @@
     "@taquito/taquito": "^23.0.0-RC.0",
     "@taquito/utils": "^23.0.0-RC.0",
     "bignumber.js": "^9.1.2",
+    "@noble/hashes": "1.8.0",
+    "bs58check": "^3.0.1",
     "invariant": "^2.2.4",
     "lodash": "^4.17.21",
     "rxjs": "^7.8.1",
-    "@ledgerhq/coin-framework": "^6.6.0-nightly.1",
-    "@ledgerhq/cryptoassets": "^13.30.0-nightly.0",
-    "@ledgerhq/devices": "8.6.0",
-    "@ledgerhq/errors": "^6.26.0-nightly.0",
-    "@ledgerhq/live-network": "^2.0.18",
+    "@ledgerhq/coin-framework": "^6.6.0",
+    "@ledgerhq/cryptoassets": "^13.30.0",
+    "@ledgerhq/devices": "8.6.1",
+    "@ledgerhq/errors": "^6.26.0",
+    "@ledgerhq/live-network": "^2.0.19",
     "@ledgerhq/logs": "^6.13.0",
-    "@ledgerhq/types-live": "^6.86.0-nightly.0"
+    "@ledgerhq/types-cryptoassets": "^7.28.0",
+    "@ledgerhq/types-live": "^6.86.0"
   },
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",
     "@taquito/local-forging": "^23.0.0-RC.0",
+    "@types/bs58check": "^2.1.2",
     "@types/invariant": "^2.2.37",
     "@types/jest": "^29.5.12",
     "@types/lodash": "^4.17.4",
@@ -93,8 +97,7 @@
     "msw": "^2.7.3",
     "ts-jest": "^29.1.4",
     "typescript": "^5.4.5",
-    "@ledgerhq/disable-network-setup": "^0.0.0",
-    "@ledgerhq/types-cryptoassets": "^7.28.0-nightly.0"
+    "@ledgerhq/disable-network-setup": "^0.0.0"
   },
   "overrides": {
     "@taquito/ledger-signer": {

package/src/api/index.test.ts

@@ -24,18 +24,11 @@ jest.mock("../logic", () => ({
   rawEncode: () => Promise.resolve("tz1heMGVHQnx7ALDcDKqez8fan64Eyicw4DJ"),
 }));
 
-jest.spyOn(networkApi, "getAccountByAddress").mockResolvedValue({
-  type: "user",
-  balance: 1000,
-  revealed: true,
-  address: "tz1test",
-  publicKey: "edpktest",
-  counter: 0,
-  delegationLevel: 0,
-  delegationTime: "2021-01-01T00:00:00Z",
-  numTransactions: 0,
-  firstActivityTime: "2021-01-01T00:00:00Z",
-} as APIAccount);
+jest
+  .spyOn(networkApi, "getAccountByAddress")
+  .mockImplementation((_adress: string) =>
+    Promise.resolve({ type: "user", balance: 1000 } as APIAccount),
+  );
 
 const api = createApi({
   baker: {
@@ -101,27 +94,12 @@ describe("Testing craftTransaction function", () => {
   beforeEach(() => jest.clearAllMocks());
 
   it("should use estimated fees when user does not provide them for crafting a transaction ", async () => {
-    logicEstimateFees.mockResolvedValue({
-      estimatedFees: DEFAULT_ESTIMATED_FEES,
-      gasLimit: DEFAULT_GAS_LIMIT,
-      storageLimit: DEFAULT_STORAGE_LIMIT,
-    });
-    await api.craftTransaction({
-      type: "send",
-      sender: "tz1test",
-      recipient: "tz1recipient",
-      amount: 1000n,
-    } as TezosTransactionIntent);
+    logicEstimateFees.mockResolvedValue({ estimatedFees: DEFAULT_ESTIMATED_FEES });
+    await api.craftTransaction({ type: "send", sender: {} } as TezosTransactionIntent);
     expect(logicEstimateFees).toHaveBeenCalledTimes(1);
     expect(logicCraftTransactionMock).toHaveBeenCalledWith(
-      expect.objectContaining({ address: "tz1test" }),
-      expect.objectContaining({
-        fee: expect.objectContaining({
-          fees: DEFAULT_ESTIMATED_FEES.toString(),
-          gasLimit: DEFAULT_GAS_LIMIT.toString(),
-          storageLimit: DEFAULT_STORAGE_LIMIT.toString(),
-        }),
-      }),
+      expect.any(Object),
+      expect.objectContaining({ fee: { fees: DEFAULT_ESTIMATED_FEES.toString() } }),
     );
   });
 
@@ -132,22 +110,10 @@ describe("Testing craftTransaction function", () => {
         estimatedFees: DEFAULT_ESTIMATED_FEES,
         gasLimit: DEFAULT_GAS_LIMIT,
         storageLimit: DEFAULT_STORAGE_LIMIT,
-        parameters: {
-          gasLimit: DEFAULT_GAS_LIMIT,
-          storageLimit: DEFAULT_STORAGE_LIMIT,
-        },
       });
-      await api.craftTransaction(
-        {
-          type: "send",
-          sender: "tz1test",
-          recipient: "tz1recipient",
-          amount: 1000n,
-        } as TezosTransactionIntent,
-        {
-          value: customFees,
-        },
-      );
+      await api.craftTransaction({ type: "send", sender: {} } as TezosTransactionIntent, {
+        value: customFees,
+      });
       expect(logicEstimateFees).toHaveBeenCalledTimes(1);
       expect(logicCraftTransactionMock).toHaveBeenCalledWith(
         expect.any(Object),
@@ -172,12 +138,7 @@ describe("Testing estimateFees function", () => {
       gasLimit: DEFAULT_GAS_LIMIT,
       storageLimit: DEFAULT_STORAGE_LIMIT,
     });
-    const result = await api.estimateFees({
-      type: "send",
-      sender: "tz1test",
-      recipient: "tz1recipient",
-      amount: 1000n,
-    } as TezosTransactionIntent);
+    const result = await api.estimateFees({ type: "send", sender: {} } as TezosTransactionIntent);
     expect(result).toEqual({
       value: DEFAULT_ESTIMATED_FEES,
       parameters: {
@@ -188,42 +149,9 @@ describe("Testing estimateFees function", () => {
   });
 
   it("should throw taquito errors", async () => {
-    logicEstimateFees.mockResolvedValue({
-      estimatedFees: DEFAULT_ESTIMATED_FEES,
-      gasLimit: DEFAULT_GAS_LIMIT,
-      storageLimit: DEFAULT_STORAGE_LIMIT,
-      taquitoError: "test",
-    });
+    logicEstimateFees.mockResolvedValue({ taquitoError: "test" });
     await expect(
-      api.estimateFees({
-        type: "send",
-        sender: "tz1test",
-        recipient: "tz1recipient",
-        amount: 1000n,
-      } as TezosTransactionIntent),
+      api.estimateFees({ type: "send", sender: {} } as TezosTransactionIntent),
     ).rejects.toThrow("Fees estimation failed: test");
   });
-
-  it("should not throw for delegate.unchanged errors", async () => {
-    logicEstimateFees.mockResolvedValue({
-      estimatedFees: DEFAULT_ESTIMATED_FEES,
-      gasLimit: DEFAULT_GAS_LIMIT,
-      storageLimit: DEFAULT_STORAGE_LIMIT,
-      taquitoError: "proto.022-PsRiotum.delegate.unchanged",
-    });
-    const result = await api.estimateFees({
-      type: "delegate",
-      sender: "tz1test",
-      recipient: "tz1validator",
-      amount: 0n,
-    } as TezosTransactionIntent);
-
-    expect(result).toEqual({
-      value: DEFAULT_ESTIMATED_FEES,
-      parameters: {
-        gasLimit: DEFAULT_GAS_LIMIT,
-        storageLimit: DEFAULT_STORAGE_LIMIT,
-      },
-    });
-  });
 });

package/src/api/index.ts

@@ -21,20 +21,11 @@ import {
   lastBlock,
   listOperations,
   rawEncode,
-  validateIntent,
-  getStakes,
 } from "../logic";
 import api from "../network/tzkt";
 import type { TezosApi, TezosFeeEstimation } from "./types";
-import type { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
-import { RecommendUndelegation } from "@ledgerhq/errors";
-import { validatePublicKey, ValidationResult, getPkhfromPk } from "@taquito/utils";
-import { getRevealFee } from "@taquito/taquito";
-import {
-  DUST_MARGIN_MUTEZ,
-  mapIntentTypeToTezosMode,
-  normalizePublicKeyForAddress,
-} from "../utils";
+import { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import { TezosOperationMode } from "../types";
 
 export function createApi(config: TezosConfig): TezosApi {
   coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
@@ -47,54 +38,31 @@ export function createApi(config: TezosConfig): TezosApi {
     getBalance: balance,
     lastBlock,
     listOperations: operations,
-    getStakes,
-    validateIntent,
-    // required by signer to compute next valid sequence/counter
-    getSequence: async (address: string) => {
-      const accountInfo = await api.getAccountByAddress(address);
-      return accountInfo.type === "user" ? accountInfo.counter + 1 : 0;
-    },
     getBlock(_height): Promise<Block> {
       throw new Error("getBlock is not supported");
     },
     getBlockInfo(_height: number): Promise<BlockInfo> {
       throw new Error("getBlockInfo is not supported");
     },
+    getStakes(_address: string, _cursor?: Cursor): Promise<Page<Stake>> {
+      throw new Error("getStakes is not supported");
+    },
     getRewards(_address: string, _cursor?: Cursor): Promise<Page<Reward>> {
       throw new Error("getRewards is not supported");
     },
   };
 }
 
-function isTezosTransactionType(
-  type: string,
-): type is "send" | "delegate" | "undelegate" | "stake" | "unstake" {
-  return ["send", "delegate", "undelegate", "stake", "unstake"].includes(type);
+function isTezosTransactionType(type: string): type is "send" | "delegate" | "undelegate" {
+  return ["send", "delegate", "undelegate"].includes(type);
 }
 
 async function balance(address: string): Promise<Balance[]> {
   const value = await getBalance(address);
-  const accountInfo = await api.getAccountByAddress(address);
-  // tzkt returns `type: "empty"` for untouched accounts; legacy logic returns -1 in that case
-  // the generic bridge expects non-negative balances
-  const normalized = value < 0n ? 0n : value;
-  // include stake information so ui can reflect delegation on account page
-  const stake: Stake | undefined =
-    accountInfo.type === "user" && accountInfo.delegate?.address
-      ? {
-          uid: address,
-          address,
-          delegate: accountInfo.delegate.address,
-          state: "active",
-          asset: { type: "native" },
-          amount: BigInt(accountInfo.balance ?? 0),
-        }
-      : undefined;
   return [
     {
-      value: normalized,
+      value,
       asset: { type: "native" },
-      stake,
     },
   ];
 }
@@ -107,180 +75,64 @@ async function craft(
     throw new IncorrectTypeError(transactionIntent.type);
   }
 
-  // Always estimate to get gasLimit/storageLimit
-  const estimation = await estimate(transactionIntent);
-  const fee = {
-    fees: (customFees?.value ?? estimation.value).toString(),
-    gasLimit: estimation.parameters?.gasLimit?.toString(),
-    storageLimit: estimation.parameters?.storageLimit?.toString(),
-  };
-
-  // Map generic staking intents to tezos modes
-  const mappedType = mapIntentTypeToTezosMode(transactionIntent.type);
-
-  // Guard: send max is incompatible with delegated accounts
-  let amountToUse = transactionIntent.amount;
-  if (mappedType === "send" && transactionIntent.useAllAmount) {
-    const senderInfo = await api.getAccountByAddress(transactionIntent.sender);
-    if (senderInfo.type === "user" && senderInfo.delegate?.address) {
-      throw new RecommendUndelegation();
-    }
-    if (senderInfo.type === "user") {
-      // Use the amount calculated by the estimation which includes proper buffers and adjustments
-      if (estimation.parameters?.amount !== undefined) {
-        amountToUse = estimation.parameters.amount;
-      } else {
-        // Fallback to the original calculation if estimation doesn't provide amount
-        const bal = BigInt(senderInfo.balance);
-        const feeBI = BigInt(fee.fees || "0");
-        const dustMargin = BigInt(DUST_MARGIN_MUTEZ);
-        const totalToDeduct = feeBI + dustMargin;
-        amountToUse = bal > totalToDeduct ? bal - totalToDeduct : 0n;
-      }
-    } else {
-      amountToUse = 0n;
-    }
-  }
+  // note that an estimation is always necessary to get gasLimit and storageLimit, if even using custom fees
+  const fee = await estimate(transactionIntent).then(fees => ({
+    fees: (customFees?.value ?? fees.value).toString(),
+    gasLimit: fees.parameters?.gasLimit?.toString(),
+    storageLimit: fees.parameters?.storageLimit?.toString(),
+  }));
 
-  const accountForCraft = {
-    address: transactionIntent.sender,
-  };
-  const senderApiAcc = await api.getAccountByAddress(transactionIntent.sender);
-  const needsReveal = senderApiAcc.type === "user" && !senderApiAcc.revealed;
-  const totalFee = Number(fee.fees || "0");
-
-  let txFee: number;
-  if (customFees) {
-    txFee = totalFee;
-  } else if (estimation.parameters?.txFee !== undefined) {
-    txFee = Number(estimation.parameters.txFee);
-  } else {
-    txFee = needsReveal ? Math.max(totalFee - getRevealFee(transactionIntent.sender), 0) : totalFee;
-  }
-
-  const txForCraft = {
-    type: mappedType,
-    recipient: transactionIntent.recipient,
-    amount: amountToUse,
-    fee: { ...fee, fees: txFee.toString() },
-  };
-  const publicKeyForCraft =
-    needsReveal && transactionIntent.senderPublicKey
-      ? (() => {
-          // Accept either base58 or hex from device, and map curve using sender address
-          let pk = transactionIntent.senderPublicKey;
-          if (validatePublicKey(pk) !== ValidationResult.VALID) {
-            pk = normalizePublicKeyForAddress(pk, transactionIntent.sender) || pk;
-          }
-          // Verify the public key matches the sender address to avoid inconsistent_hash
-          let isPublicKeyValid = false;
-          try {
-            const derived = getPkhfromPk(pk);
-            isPublicKeyValid = derived === transactionIntent.sender;
-          } catch {
-            // getPkhfromPk failed = will fallback to basic validation below
-            isPublicKeyValid = false;
-          }
+  const { contents } = await craftTransaction(
+    { address: transactionIntent.sender },
+    {
+      type: transactionIntent.type,
+      recipient: transactionIntent.recipient,
+      amount: transactionIntent.amount,
+      fee,
+    },
+  );
 
-          if (!isPublicKeyValid) {
-            // If derivation failed/doesn't match, check if the key is atleast valid format
-            if (validatePublicKey(pk) !== ValidationResult.VALID) {
-              throw new Error("Unable to normalize sender public key");
-            }
-          }
-          return { publicKey: pk, publicKeyHash: transactionIntent.sender };
-        })()
-      : undefined;
-  const { contents } = await craftTransaction(accountForCraft, txForCraft, publicKeyForCraft);
   const tx = await rawEncode(contents);
+
   return { transaction: tx };
 }
 
 async function estimate(transactionIntent: TransactionIntent): Promise<TezosFeeEstimation> {
-  // avoid taquito error when estimating a 0-amount transfer during input
-  if (
-    transactionIntent.type === "send" &&
-    transactionIntent.amount === 0n &&
-    !transactionIntent.useAllAmount
-  ) {
-    return {
-      value: BigInt(DUST_MARGIN_MUTEZ),
-      parameters: {
-        gasLimit: 10000n,
-        storageLimit: 300n,
-        amount: 0n,
-        txFee: BigInt(DUST_MARGIN_MUTEZ),
-      },
-    };
-  }
   const senderAccountInfo = await api.getAccountByAddress(transactionIntent.sender);
-  // If the sender is not a user account, return default estimation values
-  if (senderAccountInfo.type !== "user") {
-    return {
-      value: BigInt(DUST_MARGIN_MUTEZ),
-      parameters: {
-        gasLimit: 10000n,
-        storageLimit: 300n,
-        amount: 0n,
-        txFee: BigInt(DUST_MARGIN_MUTEZ),
-      },
-    };
-  }
 
-  try {
-    const estimation = await estimateFees({
-      account: {
-        address: transactionIntent.sender,
-        revealed: senderAccountInfo.revealed,
-        balance: BigInt(senderAccountInfo.balance),
-        // try intent public key first and fallback to tzkt public key
-        xpub: transactionIntent.senderPublicKey ?? senderAccountInfo.publicKey,
-      },
-      transaction: {
-        // reuse the same mapping as craft
-        mode: mapIntentTypeToTezosMode(transactionIntent.type),
-        recipient: transactionIntent.recipient,
-        amount: transactionIntent.amount,
-        // legacy estimator needs this flag to pre-estimate fees
-        useAllAmount: !!transactionIntent.useAllAmount,
-      },
-    });
-
-    if (
-      estimation.taquitoError &&
-      !estimation.taquitoError.includes("delegate.unchanged") &&
-      !estimation.taquitoError.includes("subtraction_underflow") &&
-      !estimation.taquitoError.includes("balance_too_low")
-    ) {
-      throw new Error(`Fees estimation failed: ${estimation.taquitoError}`);
-    }
+  const {
+    estimatedFees: value,
+    gasLimit,
+    storageLimit,
+    taquitoError,
+  } = await estimateFees({
+    account: {
+      address: transactionIntent.sender,
+      revealed: senderAccountInfo.type === "user" && senderAccountInfo.revealed,
+      balance: BigInt(senderAccountInfo.type === "user" ? senderAccountInfo.balance : 0),
+      // NOTE: previously we checked for .sender.xpub
+      xpub:
+        transactionIntent.senderPublicKey ??
+        (senderAccountInfo.type === "user" ? senderAccountInfo.publicKey : undefined),
+    },
+    transaction: {
+      mode: transactionIntent.type as TezosOperationMode,
+      recipient: transactionIntent.recipient,
+      amount: transactionIntent.amount,
+    },
+  });
 
-    return {
-      value: estimation.estimatedFees,
-      parameters: {
-        gasLimit: estimation.gasLimit,
-        storageLimit: estimation.storageLimit,
-        amount: estimation.amount,
-        txFee: estimation.fees,
-      },
-    };
-  } catch (error: any) {
-    // Handle PublicKeyNotFoundError
-    if (error?.message?.includes("Public key not found")) {
-      return {
-        value: 1000n, // Safe default with reveal fees (500 + 374 reveal + buffer)
-        parameters: {
-          gasLimit: 10000n,
-          storageLimit: 300n,
-          amount: 0n,
-          txFee: 1000n,
-        },
-      };
-    } else {
-      // Re-throw other errors
-      throw error;
-    }
+  if (taquitoError !== undefined) {
+    throw new Error(`Fees estimation failed: ${taquitoError}`);
   }
+
+  return {
+    value,
+    parameters: {
+      gasLimit,
+      storageLimit,
+    },
+  };
 }
 
 async function operations(
@@ -293,6 +145,5 @@ async function operations(
     sort: pagination.order === "asc" ? "Ascending" : "Descending",
     minHeight: pagination.minHeight,
   });
-
   return [operations, newNextCursor || ""];
 }

package/src/api/types.ts

@@ -1,16 +1,11 @@
-import type { Api, FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import { AlpacaApi, FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
 
-export type TezosFeeParameters = {
-  gasLimit: bigint;
-  storageLimit: bigint;
-  amount?: bigint;
-  txFee?: bigint;
-};
-export type TezosFeeEstimation = FeeEstimation & {
-  parameters?: TezosFeeParameters & Record<string, unknown>;
-};
+export type TezosFeeParameters = { gasLimit: bigint; storageLimit: bigint };
+export type TezosFeeEstimation = FeeEstimation;
 
 export type TezosSender = { address: string; xpub?: string };
 export type TezosTransactionIntent = TransactionIntent;
 
-export type TezosApi = Api;
+export type TezosApi = AlpacaApi & {
+  estimateFees: (transactionIntent: TezosTransactionIntent) => Promise<TezosFeeEstimation>;
+};

package/src/bridge/broadcast.test.ts

@@ -0,0 +1,36 @@
+import { SignedOperation } from "@ledgerhq/types-live";
+import { createFixtureOperation } from "../types/bridge.fixture";
+import config, { type TezosCoinConfig } from "../config";
+import { broadcast } from "./broadcast";
+import { mockConfig } from "../test/config";
+
+const mockInjectOperation = jest.fn();
+jest.mock("@taquito/taquito", () => ({
+  TezosToolkit: jest.fn().mockReturnValue({
+    rpc: {
+      injectOperation: () => mockInjectOperation(),
+    },
+  }),
+}));
+
+describe("broadcast", () => {
+  beforeAll(() => {
+    config.setCoinConfig((): TezosCoinConfig => mockConfig as TezosCoinConfig);
+  });
+
+  it("calls 'injectOperation' from TezosToolkit and returns its hash computation", async () => {
+    // GIVEN
+    const signedOperation: SignedOperation = {
+      operation: createFixtureOperation(),
+      signature: "SIGNATURE",
+    };
+    mockInjectOperation.mockResolvedValue("SIGN_HASH");
+
+    // WHEN
+    const op = await broadcast({ signedOperation, account: {} as any });
+
+    // THEN
+    expect(mockInjectOperation).toHaveBeenCalledTimes(1);
+    expect(op.hash).toEqual("SIGN_HASH");
+  });
+});

package/src/bridge/broadcast.ts

@@ -0,0 +1,13 @@
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { AccountBridge, SignedOperation } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+import { broadcast as logicBroadcast } from "../logic";
+
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation: { operation, signature },
+}: {
+  signedOperation: SignedOperation;
+}) => {
+  const hash = await logicBroadcast(signature);
+  return patchOperationWithHash(operation, hash);
+};

package/src/bridge/buildOptimisticOperation.ts

@@ -0,0 +1,28 @@
+import { OperationType } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { TezosAccount, TezosOperation, Transaction } from "../types";
+import BigNumber from "bignumber.js";
+
+export const buildOptimisticOperation = (
+  account: TezosAccount,
+  transaction: Transaction,
+  operationType: OperationType,
+): TezosOperation => {
+  const txHash = ""; // resolved at broadcast time
+  const { id: accountId } = account;
+
+  return {
+    id: encodeOperationId(accountId, txHash, operationType),
+    hash: txHash,
+    type: operationType,
+    value: transaction.amount,
+    fee: transaction.fees || new BigNumber(0),
+    extra: {},
+    blockHash: null,
+    blockHeight: null,
+    senders: [account.freshAddress],
+    recipients: [transaction.recipient],
+    accountId,
+    date: new Date(),
+  };
+};

package/src/bridge/createTransaction.ts

@@ -0,0 +1,19 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => {
+  return {
+    family: "tezos",
+    mode: "send",
+    amount: new BigNumber(0),
+    fees: null,
+    gasLimit: null,
+    storageLimit: null,
+    recipient: "",
+    networkInfo: null,
+    useAllAmount: false,
+    taquitoError: null,
+    estimatedFees: null,
+  };
+};

package/src/bridge/estimateMaxSpendable.ts

@@ -0,0 +1,37 @@
+import BigNumber from "bignumber.js";
+import { Account, AccountBridge, AccountLike } from "@ledgerhq/types-live";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import { TezosAccount, Transaction } from "../types";
+import { prepareTransaction } from "./prepareTransaction";
+import { createTransaction } from "./createTransaction";
+import getEstimatedFees from "./getFeesForTransaction";
+
+const TEZOS_BURN_ADDRESS = "tz1burnburnburnburnburnburnburjAYjjX";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account | undefined;
+  transaction: Transaction;
+}): Promise<BigNumber> => {
+  const mainAccount = getMainAccount(account, parentAccount) as TezosAccount;
+  const tx = await prepareTransaction(mainAccount, {
+    ...createTransaction(account),
+    ...transaction,
+    // estimate using a burn address that exists so we don't enter into NotEnoughBalanceBecauseDestinationNotCreated
+    recipient: transaction?.recipient || TEZOS_BURN_ADDRESS,
+    useAllAmount: true,
+  });
+  const estimation = await getEstimatedFees({
+    account: mainAccount,
+    transaction: tx,
+  });
+
+  // As we use `useAllAmount`, we know we will receive an amount value.
+  return estimation.amount!;
+};
+
+export default estimateMaxSpendable;