@ledgerhq/coin-aptos 1.10.0-nightly.0 → 1.10.0-nightly.2

package/src/api/index.ts

@@ -1,252 +1,30 @@
-import { ApolloClient, InMemoryCache } from "@apollo/client";
-
-import {
-  AccountData,
-  Aptos,
-  AptosApiType,
-  AptosConfig,
-  Ed25519PublicKey,
-  GasEstimation,
-  InputEntryFunctionData,
-  InputGenerateTransactionOptions,
-  MimeType,
-  post,
-  RawTransaction,
-  SimpleTransaction,
-  TransactionResponse,
-  UserTransactionResponse,
-  PostRequestOptions,
-  Block,
-} from "@aptos-labs/ts-sdk";
-import { getEnv } from "@ledgerhq/live-env";
-import network from "@ledgerhq/live-network";
-import BigNumber from "bignumber.js";
-import isUndefined from "lodash/isUndefined";
-import { APTOS_ASSET_ID } from "../constants";
-import { isTestnet } from "../bridge/logic";
-import type { AptosTransaction, TransactionOptions } from "../types";
-import { GetAccountTransactionsData, GetAccountTransactionsDataGt } from "./graphql/queries";
-import {
-  GetAccountTransactionsDataQuery,
-  GetAccountTransactionsDataGtQueryVariables,
-} from "./graphql/types";
-import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-
-const getApiEndpoint = (currencyId: string) =>
-  isTestnet(currencyId) ? getEnv("APTOS_TESTNET_API_ENDPOINT") : getEnv("APTOS_API_ENDPOINT");
-const getIndexerEndpoint = (currencyId: string) =>
-  isTestnet(currencyId)
-    ? getEnv("APTOS_TESTNET_INDEXER_ENDPOINT")
-    : getEnv("APTOS_INDEXER_ENDPOINT");
-
-export class AptosAPI {
-  private apiUrl: string;
-  private indexerUrl: string;
-  private aptosConfig: AptosConfig;
-  private aptosClient: Aptos;
-  private apolloClient: ApolloClient<object>;
-
-  constructor(currencyId: string) {
-    this.apiUrl = getApiEndpoint(currencyId);
-    this.indexerUrl = getIndexerEndpoint(currencyId);
-    this.aptosConfig = new AptosConfig({
-      fullnode: this.apiUrl,
-      indexer: this.indexerUrl,
-    });
-    this.aptosClient = new Aptos(this.aptosConfig);
-    this.apolloClient = new ApolloClient({
-      uri: this.indexerUrl,
-      cache: new InMemoryCache(),
-      headers: {
-        "x-client": "ledger-live",
-      },
-    });
-  }
-
-  async getAccount(address: string): Promise<AccountData> {
-    return this.aptosClient.getAccountInfo({ accountAddress: address });
-  }
-
-  async getAccountInfo(address: string, startAt?: string) {
-    const [balance, transactions, blockHeight] = await Promise.all([
-      this.getCoinBalance(address, APTOS_ASSET_ID),
-      this.fetchTransactions(address, startAt),
-      this.getHeight(),
-    ]);
-
-    return {
-      balance,
-      transactions,
-      blockHeight,
-    };
-  }
-
-  async estimateGasPrice(): Promise<GasEstimation> {
-    return this.aptosClient.getGasPriceEstimation();
-  }
-
-  async generateTransaction(
-    address: string,
-    payload: InputEntryFunctionData,
-    options: TransactionOptions,
-  ): Promise<RawTransaction> {
-    const opts: Partial<InputGenerateTransactionOptions> = {};
-    if (!isUndefined(options.maxGasAmount)) {
-      opts.maxGasAmount = Number(options.maxGasAmount);
-    }
-
-    if (!isUndefined(options.gasUnitPrice)) {
-      opts.gasUnitPrice = Number(options.gasUnitPrice);
-    }
-
-    try {
-      const { ledger_timestamp } = await this.aptosClient.getLedgerInfo();
-      opts.expireTimestamp = Number(Math.ceil(+ledger_timestamp / 1_000_000 + 2 * 60)); // in milliseconds
-    } catch {
-      // skip
-    }
-
-    return this.aptosClient.transaction.build
-      .simple({
-        sender: address,
-        data: payload,
-        options: opts,
-      })
-      .then(t => t.rawTransaction)
-      .catch(error => {
-        throw error;
-      });
-  }
-
-  async simulateTransaction(
-    address: Ed25519PublicKey,
-    tx: RawTransaction,
-    options = {
-      estimateGasUnitPrice: true,
-      estimateMaxGasAmount: true,
-      estimatePrioritizedGasUnitPrice: false,
-    },
-  ): Promise<UserTransactionResponse[]> {
-    return this.aptosClient.transaction.simulate.simple({
-      signerPublicKey: address,
-      transaction: { rawTransaction: tx } as SimpleTransaction,
-      options,
-    });
-  }
-
-  async broadcast(signature: string): Promise<string> {
-    const txBytes = Uint8Array.from(Buffer.from(signature, "hex"));
-    const pendingTx = await post<PostRequestOptions, TransactionResponse>({
-      contentType: MimeType.BCS_SIGNED_TRANSACTION,
-      aptosConfig: this.aptosClient.config,
-      body: txBytes,
-      path: "transactions",
-      type: AptosApiType.FULLNODE,
-      originMethod: "",
-    });
-    return pendingTx.data.hash;
-  }
-
-  async getBalance(address: string, token: TokenCurrency): Promise<BigNumber> {
-    let balance = new BigNumber(0);
-    if (token.tokenType === "coin") {
-      balance = await this.getCoinBalance(address, token.contractAddress);
-    } else {
-      balance = await this.getFABalance(address, token.contractAddress);
-    }
-    return balance;
-  }
-
-  async getCoinBalance(address: string, contract_address: string): Promise<BigNumber> {
-    try {
-      const [balanceStr] = await this.aptosClient.view<[string]>({
-        payload: {
-          function: "0x1::coin::balance",
-          typeArguments: [contract_address],
-          functionArguments: [address],
-        },
-      });
-      const balance = parseInt(balanceStr, 10);
-      return new BigNumber(balance);
-    } catch (_) {
-      return new BigNumber(0);
-    }
-  }
-
-  async getFABalance(address: string, contract_address: string): Promise<BigNumber> {
-    try {
-      const [balanceStr] = await this.aptosClient.view<[string]>({
-        payload: {
-          function: "0x1::primary_fungible_store::balance",
-          typeArguments: ["0x1::object::ObjectCore"],
-          functionArguments: [address, contract_address],
-        },
-      });
-      const balance = parseInt(balanceStr, 10);
-      return new BigNumber(balance);
-    } catch (_) {
-      return new BigNumber(0);
-    }
-  }
-
-  private async fetchTransactions(address: string, gt?: string) {
-    if (!address) {
-      return [];
-    }
-
-    let query = GetAccountTransactionsData;
-    if (gt) {
-      query = GetAccountTransactionsDataGt;
-    }
-
-    const queryResponse = await this.apolloClient.query<
-      GetAccountTransactionsDataQuery,
-      GetAccountTransactionsDataGtQueryVariables
-    >({
-      query,
-      variables: {
-        address,
-        limit: 1000,
-        gt,
-      },
-      fetchPolicy: "network-only",
-    });
-
-    return Promise.all(
-      queryResponse.data.account_transactions.map(({ transaction_version }) => {
-        return this.richItemByVersion(transaction_version);
-      }),
-    );
-  }
-
-  private async richItemByVersion(version: number): Promise<AptosTransaction | null> {
-    try {
-      const tx: TransactionResponse = await this.aptosClient.getTransactionByVersion({
-        ledgerVersion: version,
-      });
-      const block = await this.getBlock(version);
-      return {
-        ...tx,
-        block,
-      } as AptosTransaction;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  private async getHeight(): Promise<number> {
-    const { data } = await network<Block>({
-      method: "GET",
-      url: this.apiUrl,
-    });
-    return parseInt(data.block_height);
-  }
-
-  private async getBlock(version: number) {
-    const block = await this.aptosClient.getBlockByVersion({ ledgerVersion: version });
-    return {
-      height: parseInt(block.block_height),
-      hash: block.block_hash,
-    };
-  }
+import type { Api } from "@ledgerhq/coin-framework/api/index";
+import type { AptosConfig as AptosConfigApi } from "../config";
+import type { Balance, Pagination, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import coinConfig from "../config";
+import type { AptosAsset, AptosExtra, AptosFeeParameters, AptosSender } from "../types/assets";
+import { AptosAPI } from "../network";
+import { combine } from "../logic/combine";
+import { craftTransaction } from "../logic/craftTransaction";
+import { getBalance } from "../logic/getBalance";
+
+export function createApi(
+  config: AptosConfigApi,
+): Api<AptosAsset, AptosExtra, AptosSender, AptosFeeParameters> {
+  coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
+
+  const client = new AptosAPI(config.aptosSettings);
+
+  return {
+    broadcast: (tx: string) => client.broadcast(tx),
+    combine: (tx, signature, pubkey): string => combine(tx, signature, pubkey),
+    craftTransaction: (transactionIntent, _customFees): Promise<string> =>
+      craftTransaction(client, transactionIntent),
+    estimateFees: (transactionIntent: TransactionIntent<AptosAsset, AptosExtra, AptosSender>) =>
+      client.estimateFees(transactionIntent),
+    getBalance: (address): Promise<Balance<AptosAsset>[]> => getBalance(client, address),
+    lastBlock: () => client.getLastBlock(),
+    listOperations: (address: string, pagination: Pagination) =>
+      client.listOperations(address, pagination),
+  };
 }

package/src/bridge/broadcast.ts

@@ -1,16 +1,16 @@
 import type { Account, Operation, SignedOperation } from "@ledgerhq/types-live";
 import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
-import { AptosAPI } from "../api";
+import { AptosAPI } from "../network";
 
-const broadcast = async ({
-  signedOperation,
-  account,
-}: {
+type broadcastFunc = {
   signedOperation: SignedOperation;
   account: Account;
-}): Promise<Operation> => {
+};
+
+const broadcast = async ({ signedOperation, account }: broadcastFunc): Promise<Operation> => {
   const { signature, operation } = signedOperation;
-  const hash = await new AptosAPI(account.currency.id).broadcast(signature);
+  const client = new AptosAPI(account.currency.id);
+  const hash = await client.broadcast(signature);
   return patchOperationWithHash(operation, hash);
 };
 

package/src/bridge/estimateMaxSpendable.ts

@@ -1,10 +1,11 @@
 import type { Account, AccountLike } from "@ledgerhq/types-live";
 import { BigNumber } from "bignumber.js";
 import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
-import { AptosAPI } from "../api";
+import { AptosAPI } from "../network";
 import { getEstimatedGas } from "./getFeesForTransaction";
-import { DEFAULT_GAS, DEFAULT_GAS_PRICE, getMaxSendBalance } from "./logic";
+import { getMaxSendBalance } from "./logic";
 import type { Transaction } from "../types";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "../constants";
 
 const estimateMaxSpendable = async ({
   account,

package/src/bridge/getFeesForTransaction.ts

@@ -3,10 +3,11 @@ import { log } from "@ledgerhq/logs";
 import type { Account } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { makeLRUCache, seconds } from "@ledgerhq/live-network/cache";
-import { AptosAPI } from "../api";
-import buildTransaction from "./buildTransaction";
-import { DEFAULT_GAS, DEFAULT_GAS_PRICE, ESTIMATE_GAS_MUL, getTokenAccount } from "./logic";
+import { AptosAPI } from "../network";
+import { getTokenAccount } from "./logic";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE, ESTIMATE_GAS_MUL } from "../constants";
 import type { Transaction, TransactionErrors } from "../types";
+import buildTransaction from "../logic/buildTransaction";
 
 type IGetEstimatedGasReturnType = {
   fees: BigNumber;

package/src/bridge/index.ts

@@ -6,17 +6,17 @@ import {
   updateTransaction,
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { SignerContext } from "@ledgerhq/coin-framework/signer";
 import type { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
 import resolver from "../signer";
 import type { Transaction, TransactionStatus, AptosSigner } from "../types";
 import getTransactionStatus from "./getTransactionStatus";
 import estimateMaxSpendable from "./estimateMaxSpendable";
 import prepareTransaction from "./prepareTransaction";
-import createTransaction from "./createTransaction";
 import { getAccountShape } from "./synchronisation";
 import buildSignOperation from "./signOperation";
 import broadcast from "./broadcast";
+import createTransaction from "../logic/createTransaction";
 
 function buildCurrencyBridge(signerContext: SignerContext<AptosSigner>): CurrencyBridge {
   const getAddress = resolver(signerContext);

package/src/bridge/logic.ts

@@ -1,12 +1,4 @@
-import {
-  EntryFunctionPayloadResponse,
-  Event,
-  InputEntryFunctionData,
-  MoveResource,
-  WriteSetChange,
-  WriteSetChangeWriteResource,
-} from "@aptos-labs/ts-sdk";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { EntryFunctionPayloadResponse } from "@aptos-labs/ts-sdk";
 import type { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
 import {
   decodeTokenAccountId,
@@ -16,35 +8,14 @@ import {
 } from "@ledgerhq/coin-framework/account/index";
 import BigNumber from "bignumber.js";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import {
-  APTOS_ASSET_ID,
-  APTOS_FUNGIBLE_STORE,
-  BATCH_TRANSFER_TYPES,
-  DELEGATION_POOL_TYPES,
-  DIRECTION,
-  COIN_TRANSFER_TYPES,
-  FA_TRANSFER_TYPES,
-  APTOS_OBJECT_CORE,
-} from "../constants";
-import type {
-  AptosFungibleoObjectCoreResourceData,
-  AptosFungibleStoreResourceData,
-  AptosMoveResource,
-  AptosTransaction,
-  Transaction,
-  TransactionOptions,
-} from "../types";
+import { APTOS_ASSET_ID, DIRECTION } from "../constants";
+import type { AptosTransaction, Transaction } from "../types";
 import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
-
-export const DEFAULT_GAS = new BigNumber(200);
-export const DEFAULT_GAS_PRICE = new BigNumber(100);
-export const ESTIMATE_GAS_MUL = new BigNumber(1.0); // define buffer for gas estimation change here, if needed
-
-const CLEAN_HEX_REGEXP = /^0x0*|^0+/;
-
-export function isTestnet(currencyId: string): boolean {
-  return getCryptoCurrencyById(currencyId).isTestnetFor ? true : false;
-}
+import { convertFunctionPayloadResponseToInputEntryFunctionData } from "../logic/transactionsToOperations";
+import { compareAddress, getCoinAndAmounts } from "../logic/getCoinAndAmounts";
+import { calculateAmount } from "../logic/calculateAmount";
+import { processRecipients } from "../logic/processRecipients";
+import { getFunctionAddress } from "../logic/getFunctionAddress";
 
 export const getMaxSendBalance = (
   gas: BigNumber,
@@ -64,23 +35,6 @@ export const getMaxSendBalance = (
       : new BigNumber(0);
 };
 
-export function normalizeTransactionOptions(options: TransactionOptions): TransactionOptions {
-  // FIXME: this is wrong. TransactionOptions is
-  // {
-  //     maxGasAmount: string;
-  //     gasUnitPrice: string;
-  //     sequenceNumber?: string;
-  //     expirationTimestampSecs?: string;
-  // }
-  // meaning we can't return undefined in check method.
-  // This method is useless, not deleting as it breaks code and this iteration is coin modularisation.
-  const check = (v: any) => ((v ?? "").toString().trim() ? v : undefined);
-  return {
-    maxGasAmount: check(options.maxGasAmount),
-    gasUnitPrice: check(options.gasUnitPrice),
-  };
-}
-
 export const getBlankOperation = (
   tx: AptosTransaction,
   id: string,
@@ -101,14 +55,6 @@ export const getBlankOperation = (
   hasFailed: false,
 });
 
-const convertFunctionPayloadResponseToInputEntryFunctionData = (
-  payload: EntryFunctionPayloadResponse,
-): InputEntryFunctionData => ({
-  function: payload.function,
-  typeArguments: payload.type_arguments,
-  functionArguments: payload.arguments,
-});
-
 export const txsToOps = (
   info: { address: string },
   id: string,
@@ -173,227 +119,6 @@ export const txsToOps = (
   return [ops, opsTokens];
 };
 
-export function compareAddress(addressA: string, addressB: string) {
-  return (
-    addressA.replace(CLEAN_HEX_REGEXP, "").toLowerCase() ===
-    addressB.replace(CLEAN_HEX_REGEXP, "").toLowerCase()
-  );
-}
-
-export function getFunctionAddress(payload: InputEntryFunctionData): string | undefined {
-  if (payload.function) {
-    const parts = payload.function.split("::");
-    return parts.length === 3 && parts[0].length ? parts[0] : undefined;
-  }
-  return undefined;
-}
-
-export function processRecipients(
-  payload: InputEntryFunctionData,
-  address: string,
-  op: Operation,
-  function_address: string,
-): void {
-  // get recipients buy 3 groups
-  if (
-    (COIN_TRANSFER_TYPES.includes(payload.function) ||
-      DELEGATION_POOL_TYPES.includes(payload.function)) &&
-    payload.functionArguments &&
-    payload.functionArguments.length > 0 &&
-    typeof payload.functionArguments[0] === "string"
-  ) {
-    // 1. Transfer like functions (includes some delegation pool functions)
-    op.recipients.push(payload.functionArguments[0].toString());
-  } else if (
-    FA_TRANSFER_TYPES.includes(payload.function) &&
-    payload.functionArguments &&
-    payload.functionArguments.length > 1 &&
-    typeof payload.functionArguments[0] === "object" &&
-    typeof payload.functionArguments[1] === "string"
-  ) {
-    // 1. Transfer like functions (includes some delegation pool functions)
-    op.recipients.push(payload.functionArguments[1].toString());
-  } else if (
-    BATCH_TRANSFER_TYPES.includes(payload.function) &&
-    payload.functionArguments &&
-    payload.functionArguments.length > 0 &&
-    Array.isArray(payload.functionArguments[0])
-  ) {
-    // 2. Batch function, to validate we are in the recipients list
-    if (!compareAddress(op.senders[0], address)) {
-      for (const recipient of payload.functionArguments[0]) {
-        if (recipient && compareAddress(recipient.toString(), address)) {
-          op.recipients.push(recipient.toString());
-        }
-      }
-    }
-  } else {
-    // 3. other smart contracts, in this case smart contract will be treated as a recipient
-    op.recipients.push(function_address);
-  }
-}
-
-export function getEventCoinAddress(
-  change: WriteSetChangeWriteResource,
-  event: Event,
-  event_name: string,
-): string | null {
-  const change_data = change.data;
-
-  const mr = change_data as MoveResource<AptosMoveResource>; // -> this is data that we want to parse
-
-  if (!(event_name in mr.data)) {
-    return null;
-  }
-
-  const change_event_data = mr.data[event_name];
-  if (
-    change_event_data.guid.id.addr !== event.guid.account_address ||
-    change_event_data.guid.id.creation_num !== event.guid.creation_number
-  ) {
-    return null;
-  }
-
-  const address = extractAddress(mr.type);
-
-  return address;
-}
-
-export function getEventFAAddress(
-  change: WriteSetChangeWriteResource,
-  event: Event,
-  _event_name: string,
-): string | null {
-  const change_data = change.data;
-
-  if (change_data.type !== APTOS_FUNGIBLE_STORE) {
-    return null;
-  }
-
-  const mr = change_data as MoveResource<AptosFungibleStoreResourceData>;
-
-  if (change.address !== event.data.store) {
-    return null;
-  }
-
-  return mr.data.metadata.inner;
-}
-
-export function getResourceAddress(
-  tx: AptosTransaction,
-  event: Event,
-  event_name: string,
-  getAddressProcessor: (
-    change: WriteSetChangeWriteResource,
-    event: Event,
-    event_name: string,
-  ) => string | null,
-): string | null {
-  for (const change of tx.changes) {
-    if (isWriteSetChangeWriteResource(change)) {
-      const address = getAddressProcessor(change, event, event_name);
-      if (address !== null) {
-        return address;
-      }
-    }
-  }
-  return null;
-}
-
-function isWriteSetChangeWriteResource(
-  change: WriteSetChange,
-): change is WriteSetChangeWriteResource {
-  return (change as WriteSetChangeWriteResource).data !== undefined;
-}
-
-export function checkFAOwner(tx: AptosTransaction, event: Event, user_address: string): boolean {
-  for (const change of tx.changes) {
-    if (isWriteSetChangeWriteResource(change)) {
-      const storeData = change.data as MoveResource<AptosFungibleoObjectCoreResourceData>;
-      if (
-        change.address == event.data.store &&
-        storeData.type == APTOS_OBJECT_CORE &&
-        storeData.data.owner == user_address
-      ) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-export function getCoinAndAmounts(
-  tx: AptosTransaction,
-  address: string,
-): { coin_id: string | null; amount_in: BigNumber; amount_out: BigNumber } {
-  let coin_id: string | null = null;
-  let amount_in = BigNumber(0);
-  let amount_out = BigNumber(0);
-
-  // collect all events related to the address and calculate the overall amounts
-  tx.events.forEach(event => {
-    switch (event.type) {
-      case "0x1::coin::WithdrawEvent":
-        if (compareAddress(event.guid.account_address, address)) {
-          coin_id = getResourceAddress(tx, event, "withdraw_events", getEventCoinAddress);
-          amount_out = amount_out.plus(event.data.amount);
-        }
-        break;
-      case "0x1::coin::DepositEvent":
-        if (compareAddress(event.guid.account_address, address)) {
-          coin_id = getResourceAddress(tx, event, "deposit_events", getEventCoinAddress);
-          amount_in = amount_in.plus(event.data.amount);
-        }
-        break;
-      case "0x1::fungible_asset::Withdraw":
-        if (checkFAOwner(tx, event, address)) {
-          coin_id = getResourceAddress(tx, event, "withdraw_events", getEventFAAddress);
-          amount_out = amount_out.plus(event.data.amount);
-        }
-        break;
-      case "0x1::fungible_asset::Deposit":
-        if (checkFAOwner(tx, event, address)) {
-          coin_id = getResourceAddress(tx, event, "deposit_events", getEventFAAddress);
-          amount_in = amount_in.plus(event.data.amount);
-        }
-        break;
-      case "0x1::transaction_fee::FeeStatement":
-        if (tx.sender === address) {
-          if (coin_id === null) coin_id = APTOS_ASSET_ID;
-          if (coin_id === APTOS_ASSET_ID) {
-            const fees = BigNumber(tx.gas_unit_price).times(BigNumber(tx.gas_used));
-            amount_out = amount_out.plus(fees);
-          }
-        }
-        break;
-    }
-  });
-  return { coin_id, amount_in, amount_out }; // TODO: manage situation when there are several coinID from the events parsing
-}
-
-export function calculateAmount(
-  sender: string,
-  address: string,
-  amount_in: BigNumber,
-  amount_out: BigNumber,
-): BigNumber {
-  const is_sender: boolean = compareAddress(sender, address);
-  // LL negates the amount for SEND transactions
-  // to show positive amount on the send transaction (ex: in "cancel" tx, when amount will be returned to our account)
-  // we need to make it negative
-  return is_sender ? amount_out.minus(amount_in) : amount_in.minus(amount_out);
-}
-
-/**
- * Extracts the address from a string like "0x1::coin::CoinStore<address::module::type>"
- * @param {string} str - The input string containing the address.
- * @returns {string | null} - The extracted address or null if not found.
- */
-function extractAddress(str: string): string | null {
-  const match = str.match(/<([^<>]+)>{1}$/);
-  return match ? match[1] : null;
-}
-
 export function getTokenAccount(
   account: Account,
   transaction: Transaction,

package/src/bridge/prepareTransaction.ts

@@ -1,9 +1,11 @@
 import type { Account } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
-import { AptosAPI } from "../api";
+
+import { AptosAPI } from "../network";
 import { getEstimatedGas } from "./getFeesForTransaction";
 import type { Transaction } from "../types";
-import { DEFAULT_GAS, DEFAULT_GAS_PRICE, getMaxSendBalance } from "./logic";
+import { getMaxSendBalance } from "./logic";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "../constants";
 
 const prepareTransaction = async (
   account: Account,