@ledgerhq/live-common 21.21.3 → 21.23.0

package/src/data/icons/reactNative/sol.tsx

@@ -7,7 +7,7 @@ interface Props {
             };
 
 function sol({ size, color }: Props) {
-  return <Svg width={size} height={size} viewBox="0 0 24 24" fill="none"><Path d="M9.925 18.687a.59.59 0 01.415-.17h14.366a.29.29 0 01.207.497l-2.838 2.815a.59.59 0 01-.415.171H7.294a.291.291 0 01-.207-.498l2.838-2.815zm0-10.517A.59.59 0 0110.34 8h14.366c.261 0 .392.314.207.498l-2.838 2.815a.59.59 0 01-.415.17H7.294a.291.291 0 01-.207-.497L9.925 8.17zm12.15 5.225a.59.59 0 00-.415-.17H7.294a.291.291 0 00-.207.498l2.838 2.815c.11.109.26.17.415.17h14.366a.291.291 0 00.207-.498l-2.838-2.815z" fill={color} fillRule="nonzero" /></Svg>;
+  return <Svg width={size} height={size} viewBox="0 0 24 24"><Path d="M2.41,7.77H18.09a.51.51,0,0,0,.37-.16l3.43-3.67a.4.4,0,0,0-.3-.67H5.91a.51.51,0,0,0-.37.16L2.11,7.1A.4.4,0,0,0,2.41,7.77Z" /><Path d="M2.41,20.77H18.09a.51.51,0,0,0,.37-.16l3.43-3.67a.4.4,0,0,0-.3-.67H5.91a.51.51,0,0,0-.37.16L2.11,20.1A.4.4,0,0,0,2.41,20.77Z" /><Path d="M21.59,14.27H5.91a.51.51,0,0,1-.37-.16L2.11,10.44a.4.4,0,0,1,.3-.67H18.09a.51.51,0,0,1,.37.16l3.43,3.67A.4.4,0,0,1,21.59,14.27Z" /></Svg>;
 }
 
 export default sol;

package/src/data/icons/svg/SOL.svg

@@ -1,3 +1 @@
-<svg width="24" height="24" viewBox="0 0 24 24" fill="none">
-<path d="M9.925 18.687a.59.59 0 01.415-.17h14.366a.29.29 0 01.207.497l-2.838 2.815a.59.59 0 01-.415.171H7.294a.291.291 0 01-.207-.498l2.838-2.815zm0-10.517A.59.59 0 0110.34 8h14.366c.261 0 .392.314.207.498l-2.838 2.815a.59.59 0 01-.415.17H7.294a.291.291 0 01-.207-.497L9.925 8.17zm12.15 5.225a.59.59 0 00-.415-.17H7.294a.291.291 0 00-.207.498l2.838 2.815c.11.109.26.17.415.17h14.366a.291.291 0 00.207-.498l-2.838-2.815z" fill="#FFF" fill-rule="nonzero"/>
-</svg>
+<svg width="24" height="24" viewBox="0 0 24 24"><path d="M2.41,7.77H18.09a.51.51,0,0,0,.37-.16l3.43-3.67a.4.4,0,0,0-.3-.67H5.91a.51.51,0,0,0-.37.16L2.11,7.1A.4.4,0,0,0,2.41,7.77Z"/><path d="M2.41,20.77H18.09a.51.51,0,0,0,.37-.16l3.43-3.67a.4.4,0,0,0-.3-.67H5.91a.51.51,0,0,0-.37.16L2.11,20.1A.4.4,0,0,0,2.41,20.77Z"/><path d="M21.59,14.27H5.91a.51.51,0,0,1-.37-.16L2.11,10.44a.4.4,0,0,1,.3-.67H18.09a.51.51,0,0,1,.37.16l3.43,3.67A.4.4,0,0,1,21.59,14.27Z"/></svg>

package/src/derivation.ts

@@ -59,8 +59,6 @@ const extraConfigPerCurrency: Record<string, LibcoreConfig> = {
   algorand: {
     BLOCKCHAIN_EXPLORER_API_ENDPOINT: () =>
       getEnv("API_ALGORAND_BLOCKCHAIN_EXPLORER_API_ENDPOINT"),
-    BLOCKCHAIN_EXPLORER_API_KEY: () =>
-      getEnv("API_ALGORAND_BLOCKCHAIN_EXPLORER_API_KEY"),
   },
 };
 const modes = Object.freeze({

package/src/env.ts

@@ -40,11 +40,6 @@ const envDefinitions = {
     parser: stringParser,
     desc: "Node API endpoint for algorand",
   },
-  API_ALGORAND_BLOCKCHAIN_EXPLORER_API_KEY: {
-    def: "",
-    parser: stringParser,
-    desc: "Node API key for algorand",
-  },
   API_COSMOS_BLOCKCHAIN_EXPLORER_API_ENDPOINT: {
     def: "https://cosmoshub4.coin.ledger.com/",
     parser: stringParser,
@@ -111,7 +106,7 @@ const envDefinitions = {
     desc: "Ledger explorer API for tezos",
   },
   API_TEZOS_TZKT_API: {
-    def: "http://xtz-tzkt-explorer.api-01.live.ledger-stg.com",
+    def: "https://xtz-tzkt-explorer.api.live.ledger.com",
     parser: stringParser,
     desc: "tzkt.io explorer",
   },

package/src/families/algorand/account.ts

@@ -46,15 +46,6 @@ function formatAccountSpecifics(account: Account): string {
       ) + " rewards. ";
   }
 
-  if ((algorandResources as AlgorandResources).rewardsAccumulated.gt(0)) {
-    str +=
-      formatCurrencyUnit(
-        unit,
-        (algorandResources as AlgorandResources).rewardsAccumulated,
-        formatConfig
-      ) + " rewardsAccumulated. ";
-  }
-
   return str;
 }
 

package/src/families/algorand/api/algodv2.ts

@@ -0,0 +1,68 @@
+import { BigNumber } from "bignumber.js";
+import { getEnv } from "../../../env";
+import network from "../../../network";
+import {
+  AlgoAccount,
+  AlgoAsset,
+  AlgoTransactionParams,
+  AlgoTransactionBroadcastResponse,
+} from "./algodv2.types";
+
+const BASE_URL = getEnv("API_ALGORAND_BLOCKCHAIN_EXPLORER_API_ENDPOINT");
+const NODE_URL = `${BASE_URL}/ps2/v2`;
+
+const fullUrl = (route: string): string => `${NODE_URL}${route}`;
+
+export const getAccount = async (address: string): Promise<AlgoAccount> => {
+  const { data } = await network({
+    method: "GET",
+    url: fullUrl(`/accounts/${address}`),
+  });
+
+  const assets: AlgoAsset[] = data.assets
+    ? data.assets.map((a): AlgoAsset => {
+        return {
+          assetId: a["asset-id"].toString(),
+          balance: new BigNumber(a.amount),
+        };
+      })
+    : [];
+
+  return {
+    round: data.round,
+    address: data.address,
+    balance: new BigNumber(data.amount),
+    pendingRewards: new BigNumber(data["pending-rewards"]),
+    assets,
+  };
+};
+
+// TODO Cache
+export const getTransactionParams =
+  async (): Promise<AlgoTransactionParams> => {
+    const { data } = await network({
+      method: "GET",
+      url: fullUrl(`/transactions/params`),
+    });
+
+    return {
+      fee: data["fee"],
+      minFee: data["min-fee"],
+      firstRound: data["first-round"] ?? 0,
+      lastRound: data["last-round"],
+      genesisID: data["genesis-id"],
+      genesisHash: data["genesis-hash"],
+    };
+  };
+
+export const broadcastTransaction = async (
+  payload: string
+): Promise<string> => {
+  const { data }: { data: AlgoTransactionBroadcastResponse } = await network({
+    method: "POST",
+    url: fullUrl(`/transactions`),
+    data: payload,
+  });
+
+  return data.txId;
+};

package/src/families/algorand/api/algodv2.types.ts

@@ -0,0 +1,27 @@
+import { BigNumber } from "bignumber.js";
+
+export interface AlgoAccount {
+  round: number;
+  address: string;
+  balance: BigNumber;
+  pendingRewards: BigNumber;
+  assets: AlgoAsset[];
+}
+
+export interface AlgoAsset {
+  assetId: string;
+  balance: BigNumber;
+}
+
+export interface AlgoTransactionParams {
+  fee: number;
+  minFee: number;
+  firstRound: number;
+  lastRound: number;
+  genesisHash: string;
+  genesisID: string;
+}
+
+export interface AlgoTransactionBroadcastResponse {
+  txId: string;
+}

package/src/families/algorand/api/index.ts

@@ -0,0 +1,4 @@
+export * from "./algodv2.types";
+export * from "./algodv2";
+export * from "./indexer.types";
+export * from "./indexer";

package/src/families/algorand/api/indexer.ts

@@ -0,0 +1,99 @@
+import { BigNumber } from "bignumber.js";
+import { getEnv } from "../../../env";
+import network from "../../../network";
+import {
+  AlgoTransaction,
+  AlgoTransactionDetails,
+  AlgoPaymentInfo,
+  AlgoAssetTransferInfo,
+} from "./indexer.types";
+
+const LIMIT = 100; // Max nb of transactions per request
+
+const BASE_URL = getEnv("API_ALGORAND_BLOCKCHAIN_EXPLORER_API_ENDPOINT");
+const INDEXER_URL = `${BASE_URL}/idx2/v2`;
+
+const fullUrl = (route: string): string =>
+  `${INDEXER_URL}${route}?limit=${LIMIT}`;
+
+export const getAccountTransactions = async (
+  address: string,
+  startAt?: number
+): Promise<AlgoTransaction[]> => {
+  const url = fullUrl(`/accounts/${address}/transactions`);
+
+  let nextToken: string | undefined;
+  let newRawTxs: any[] = [];
+  const mergedTxs: AlgoTransaction[] = [];
+  do {
+    let nextUrl: string = url;
+    if (startAt) {
+      nextUrl = nextUrl.concat(`&min-round=${startAt}`);
+    }
+    if (nextToken) {
+      nextUrl = nextUrl.concat(`&next=${nextToken}`);
+    }
+    const { data }: { data: { transactions: any[] } } = await network({
+      method: "GET",
+      url: nextUrl,
+    });
+    nextToken = data["next-token"];
+    newRawTxs = data.transactions;
+    newRawTxs.map(parseRawTransaction).forEach((tx) => mergedTxs.push(tx));
+  } while (newRawTxs.length >= LIMIT);
+
+  return mergedTxs;
+};
+
+const parseRawTransaction = (tx: any): AlgoTransaction => {
+  let details: AlgoTransactionDetails | undefined = undefined;
+  if (tx["tx-type"] === "pay") {
+    const info = tx["payment-transaction"];
+    const paymentInfo: AlgoPaymentInfo = {
+      amount: new BigNumber(info.amount),
+      recipientAddress: info.receiver,
+      closeAmount:
+        info["close-amount"] === undefined
+          ? undefined
+          : new BigNumber(info["close-amount"]),
+      closeToAddress: info["close-remainder-to"],
+    };
+    details = paymentInfo;
+  } else if (tx["tx-type"] === "axfer") {
+    const info = tx["asset-transfer-transaction"];
+    const assetTransferInfo: AlgoAssetTransferInfo = {
+      assetAmount: new BigNumber(info.amount),
+      assetId: info["asset-id"],
+      assetRecipientAddress: info.receiver,
+      assetSenderAddress: info.sender,
+      assetCloseAmount:
+        info["close-amount"] === undefined
+          ? undefined
+          : new BigNumber(info["close-amount"]),
+      assetCloseToAddress: tx["close-to"],
+    };
+    details = assetTransferInfo;
+  }
+
+  return {
+    id: tx.id,
+    timestamp: tx["round-time"],
+    round: tx["confirmed-round"],
+    senderAddress: tx.sender,
+    senderRewards: new BigNumber(tx["sender-rewards"]),
+    recipientRewards: new BigNumber(tx["receiver-rewards"]),
+    closeRewards:
+      tx["close-rewards"] === undefined
+        ? undefined
+        : new BigNumber(tx["close-rewards"]),
+    closeAmount:
+      tx["closing-amount"] === undefined
+        ? undefined
+        : new BigNumber(tx["closing-amount"]),
+    fee: new BigNumber(tx.fee),
+    note: tx.note,
+
+    type: tx["tx-type"],
+    details,
+  };
+};

package/src/families/algorand/api/indexer.types.ts

@@ -0,0 +1,41 @@
+import { BigNumber } from "bignumber.js";
+
+export type AlgoTransactionDetails = AlgoPaymentInfo | AlgoAssetTransferInfo;
+
+// Define only types we explicitely support
+export enum AlgoTransactionType {
+  PAYMENT = "pay",
+  ASSET_TRANSFER = "axfer",
+}
+
+export interface AlgoTransaction {
+  id: string;
+  timestamp: string; // 'round-time': 1597933539,
+  round: number; // 'confirmed-round': 8575676,
+  senderAddress: string; // sender: 'RGX5XA7DWZOZ5SLG4WQSNIFKIG4CNX4VOH23YCEX56523DQEAL3QL56XZM',
+  senderRewards: BigNumber; // 'sender-rewards': 0,
+  recipientRewards: BigNumber; //'receiver-rewards': 0,
+  closeRewards?: BigNumber; // 'close-rewards': 0,
+  closeAmount?: BigNumber; //'closing-amount': 0,
+  fee: BigNumber;
+  note: string;
+
+  type: string; // 'tx-type': 'pay'
+  details?: AlgoTransactionDetails;
+}
+
+export interface AlgoPaymentInfo {
+  amount: BigNumber;
+  recipientAddress: string; // receiver
+  closeAmount?: BigNumber; // close-amount
+  closeToAddress?: string; // close-remainder-to
+}
+
+export interface AlgoAssetTransferInfo {
+  assetId: string; // asset-id
+  assetAmount: BigNumber; // amount
+  assetRecipientAddress: string; // receiver
+  assetSenderAddress?: string; // sender
+  assetCloseAmount?: BigNumber; // close-amount
+  assetCloseToAddress?: string; // close-to
+}

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

@@ -0,0 +1,46 @@
+import type { AccountBridge, CurrencyBridge } from "../../../types";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+
+import type { AlgorandTransaction } from "../types";
+import { sync, scanAccounts } from "../js-synchronization";
+import {
+  createTransaction,
+  prepareTransaction,
+} from "../js-prepareTransaction";
+import { estimateMaxSpendable } from "../js-estimateMaxSpendable";
+import { getTransactionStatus } from "../js-getTransactionStatus";
+import { signOperation } from "../js-signOperation";
+import { broadcast } from "../js-broadcast";
+
+const receive = makeAccountBridgeReceive();
+
+const updateTransaction = (t, patch) => {
+  return { ...t, ...patch };
+};
+
+const preload = async () => Promise.resolve({});
+
+const hydrate = () => {};
+
+const currencyBridge: CurrencyBridge = {
+  preload,
+  hydrate,
+  scanAccounts,
+};
+
+const accountBridge: AccountBridge<AlgorandTransaction> = {
+  createTransaction,
+  updateTransaction,
+  prepareTransaction,
+  getTransactionStatus,
+  sync,
+  receive,
+  signOperation,
+  broadcast,
+  estimateMaxSpendable,
+};
+
+export default {
+  currencyBridge,
+  accountBridge,
+};

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

@@ -13,7 +13,7 @@ import {
 import { AlgorandASANotOptInInRecipient } from "../../../errors";
 import { validateRecipient } from "../../../bridge/shared";
 import type { AccountBridge, CurrencyBridge, Account } from "../../../types";
-import type { AlgorandResources, Transaction } from "../types";
+import type { AlgorandResources, AlgorandTransaction } from "../types";
 import { AlgorandOperationTypeEnum } from "../types";
 import { scanAccounts } from "../../../libcore/scanAccounts";
 import { sync } from "../../../libcore/syncAccount";
@@ -34,7 +34,7 @@ const receive = makeAccountBridgeReceive();
 export const calculateFees: CacheRes<
   Array<{
     a: Account;
-    t: Transaction;
+    t: AlgorandTransaction;
   }>,
   {
     estimatedFees: BigNumber;
@@ -72,7 +72,7 @@ const getSpendableMaxForOptIn = async (account) =>
     return spendableBalance;
   });
 
-const createTransaction = (): Transaction => ({
+const createTransaction = (): AlgorandTransaction => ({
   family: "algorand",
   amount: new BigNumber(0),
   fees: null,
@@ -328,7 +328,7 @@ const currencyBridge: CurrencyBridge = {
   hydrate,
   scanAccounts,
 };
-const accountBridge: AccountBridge<Transaction> = {
+const accountBridge: AccountBridge<AlgorandTransaction> = {
   createTransaction,
   updateTransaction,
   prepareTransaction,

package/src/families/algorand/bridge/mock.ts

@@ -5,7 +5,7 @@ import {
   InvalidAddress,
   FeeTooHigh,
 } from "@ledgerhq/errors";
-import type { Transaction } from "../types";
+import type { AlgorandTransaction } from "../types";
 import type { AccountBridge, CurrencyBridge } from "../../../types";
 import {
   scanAccounts,
@@ -20,7 +20,7 @@ const receive = makeAccountBridgeReceive();
 
 const defaultGetFees = (a, t) => t.fees || new BigNumber(0);
 
-const createTransaction = (): Transaction => ({
+const createTransaction = (): AlgorandTransaction => ({
   family: "algorand",
   mode: "send",
   amount: new BigNumber(0),
@@ -88,7 +88,7 @@ const prepareTransaction = async (a, t) => {
   return t;
 };
 
-const accountBridge: AccountBridge<Transaction> = {
+const accountBridge: AccountBridge<AlgorandTransaction> = {
   estimateMaxSpendable,
   createTransaction,
   updateTransaction,

package/src/families/algorand/buildTransaction.ts

@@ -0,0 +1,100 @@
+import { encode as msgpackEncode } from "algo-msgpack-with-bigint";
+import type {
+  SuggestedParams as AlgoSuggestedParams,
+  Transaction as AlgoTransaction,
+  EncodedTransaction as AlgoTransactionPayload,
+  EncodedSignedTransaction as AlgoSignedTransactionPayload,
+} from "algosdk";
+import {
+  makePaymentTxnWithSuggestedParams,
+  makeAssetTransferTxnWithSuggestedParams,
+} from "algosdk";
+
+import type { Account } from "../../types";
+import type { Transaction } from "./types";
+
+import { extractTokenId } from "./tokens";
+import { getTransactionParams } from "./api";
+
+export const buildTransactionPayload = async (
+  account: Account,
+  transaction: Transaction
+): Promise<AlgoTransactionPayload> => {
+  const { amount, recipient, mode, memo, assetId, subAccountId } = transaction;
+  const subAccount = subAccountId
+    ? account.subAccounts &&
+      account.subAccounts.find((t) => t.id === subAccountId)
+    : null;
+
+  const note = memo ? new TextEncoder().encode(memo) : undefined;
+
+  // Minor hack: cast the result as a algosdk.SuggestedParams, while it's actually a TransactionParametersResponse
+  const params = (await getTransactionParams()) as AlgoSuggestedParams;
+
+  let algoTxn: AlgoTransaction;
+  if (subAccount || (assetId && mode === "optIn")) {
+    const targetAssetId =
+      subAccount && subAccount.type === "TokenAccount"
+        ? extractTokenId(subAccount.token.id)
+        : assetId
+        ? extractTokenId(assetId)
+        : "";
+
+    if (!targetAssetId) {
+      throw new Error("Token Asset Id not found");
+    }
+
+    algoTxn = makeAssetTransferTxnWithSuggestedParams(
+      account.freshAddress,
+      recipient,
+      undefined,
+      undefined,
+      amount.toNumber(),
+      note,
+      Number(targetAssetId),
+      params,
+      undefined
+    );
+  } else {
+    algoTxn = makePaymentTxnWithSuggestedParams(
+      account.freshAddress,
+      recipient,
+      amount.toNumber(),
+      undefined,
+      note,
+      params
+    );
+  }
+
+  // Bit of safety: set tx validity to the next 1000 blocks
+  algoTxn.firstRound = params.lastRound;
+  algoTxn.lastRound = params.lastRound + 1000;
+
+  // Flaw in the SDK: payload isn't sorted, but it needs to be for msgPack encoding
+  const sorted = Object.fromEntries(
+    Object.entries(algoTxn.get_obj_for_encoding()).sort()
+  ) as AlgoTransactionPayload;
+
+  return sorted;
+};
+
+export const encodeToSign = async (
+  payload: AlgoTransactionPayload
+): Promise<string> => {
+  const msgPackEncoded = msgpackEncode(payload);
+
+  return Buffer.from(msgPackEncoded).toString("hex");
+};
+
+export const encodeToBroadcast = async (
+  payload: AlgoTransactionPayload,
+  signature: Buffer
+): Promise<Buffer> => {
+  const signedPayload: AlgoSignedTransactionPayload = {
+    sig: signature,
+    txn: payload,
+  };
+  const msgPackEncoded = msgpackEncode(signedPayload);
+
+  return Buffer.from(msgPackEncoded);
+};

package/src/families/algorand/cli-transaction.ts

@@ -102,7 +102,7 @@ function inferTransactions(
       memo: opts.memo,
       mode: opts.mode || "send",
       subAccountId: account.type === "TokenAccount" ? account.id : null,
-      assetId: "algorand/asa/" + opts.token,
+      assetId: opts.token ? "algorand/asa/" + opts.token : null,
     };
   });
 }

package/src/families/algorand/deviceTransactionConfig.ts

@@ -3,7 +3,7 @@ import type {
   TransactionStatus,
   TokenCurrency,
 } from "../../types";
-import type { Transaction } from "./types";
+import type { AlgorandTransaction } from "./types";
 import type { DeviceTransactionField } from "../../transaction";
 import { getAccountUnit } from "../../account";
 import { formatCurrencyUnit, findTokenById } from "../../currencies";
@@ -68,7 +68,7 @@ function getDeviceTransactionConfig({
   status,
 }: {
   account: AccountLike;
-  transaction: Transaction;
+  transaction: AlgorandTransaction;
   status: TransactionStatus;
 }): Array<DeviceTransactionField> {
   const { mode, assetId } = transaction;
@@ -121,20 +121,6 @@ function getDeviceTransactionConfig({
       });
       break;
 
-    case "optOut":
-      fields.push({
-        type: "text",
-        label: "Type",
-        value: "Opt out",
-      });
-      if (assetId)
-        fields.push({
-          type: "text",
-          label: "Asset id",
-          value: assetId,
-        });
-      break;
-
     default:
       break;
   }

package/src/families/algorand/hw-getAddress.ts

@@ -1,20 +1,11 @@
 import Algorand from "@ledgerhq/hw-app-algorand";
 import type { Resolver } from "../../hw/getAddress/types";
-import { withLibcore } from "../../libcore/access";
-
-const convertPubkeyToAddress = async (pubkey) => {
-  return await withLibcore(async (core) => {
-    const address = await core.AlgorandAddress.fromPublicKey(pubkey);
-    return address;
-  });
-};
 
 const resolver: Resolver = async (transport, { path, verify }) => {
   const algorand = new Algorand(transport);
   const r = await algorand.getAddress(path, verify || false);
-  const address = await convertPubkeyToAddress(r.publicKey);
   return {
-    address: address,
+    address: r.address,
     publicKey: r.publicKey,
     path,
   };

package/src/families/algorand/js-broadcast.ts

@@ -0,0 +1,17 @@
+import { patchOperationWithHash } from "../../operation";
+import type { Operation, SignedOperation } from "../../types";
+import { broadcastTransaction as apiBroadcast } from "./api";
+
+/**
+ * Broadcast a signed transaction
+ * @param {signature: string, operation: string} signedOperation
+ */
+export const broadcast = async ({
+  signedOperation,
+}: {
+  signedOperation: SignedOperation;
+}): Promise<Operation> => {
+  const { signature, operation } = signedOperation;
+  const hash = await apiBroadcast(signature);
+  return patchOperationWithHash(operation, hash);
+};

package/src/families/algorand/js-estimateMaxSpendable.ts

@@ -0,0 +1,51 @@
+import { BigNumber } from "bignumber.js";
+import type { Account, AccountLike } from "../../types";
+import { getMainAccount } from "../../account";
+import type { AlgorandTransaction } from "./types";
+import { computeAlgoMaxSpendable } from "./logic";
+import { createTransaction } from "./js-prepareTransaction";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+
+export const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount?: Account | null | undefined;
+  transaction?: AlgorandTransaction | null | undefined;
+}): Promise<BigNumber> => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const { algorandResources } = mainAccount;
+  if (!algorandResources) {
+    throw new Error("Algorand account expected");
+  }
+
+  const tx = {
+    ...createTransaction(),
+    subAccountId: account.type === "Account" ? null : account.id,
+    ...transaction,
+    recipient:
+      transaction?.recipient || getAbandonSeedAddress(mainAccount.currency.id),
+    useAllAmount: true,
+  };
+
+  const tokenAccount =
+    tx.subAccountId &&
+    mainAccount.subAccounts &&
+    mainAccount.subAccounts.find((ta) => ta.id === tx.subAccountId);
+
+  if (tokenAccount) {
+    return tokenAccount.balance;
+  } else {
+    let maxSpendable = computeAlgoMaxSpendable({
+      accountBalance: mainAccount.balance,
+      nbAccountAssets: algorandResources.nbAssets,
+      mode: tx.mode,
+    });
+    if (tx.fees) {
+      maxSpendable = maxSpendable.minus(tx.fees);
+    }
+    return maxSpendable.gte(0) ? maxSpendable : new BigNumber(0);
+  }
+};