@ledgerhq/coin-aptos 2.0.0-nightly.4 → 2.0.0-nightly.5

package/src/bridge/logic.ts

@@ -4,37 +4,20 @@ import {
   InputEntryFunctionData,
   MoveResource,
   WriteSetChange,
-  WriteSetChangeWriteResource,
 } from "@aptos-labs/ts-sdk";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
-import type { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
-import {
-  decodeTokenAccountId,
-  encodeTokenAccountId,
-  findSubAccountById,
-  isTokenAccount,
-} from "@ledgerhq/coin-framework/account/index";
+import type { Operation, OperationType } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import {
-  APTOS_ASSET_ID,
-  APTOS_FUNGIBLE_STORE,
+  APTOS_COIN_CHANGE,
   BATCH_TRANSFER_TYPES,
   DELEGATION_POOL_TYPES,
   DIRECTION,
-  COIN_TRANSFER_TYPES,
-  FA_TRANSFER_TYPES,
-  APTOS_OBJECT_CORE,
+  TRANSFER_TYPES,
+  WRITE_RESOURCE,
 } from "../constants";
-import type {
-  AptosFungibleoObjectCoreResourceData,
-  AptosFungibleStoreResourceData,
-  AptosMoveResource,
-  AptosTransaction,
-  Transaction,
-  TransactionOptions,
-} from "../types";
-import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
+import type { AptosMoveResource, AptosTransaction, TransactionOptions } from "../types";
 
 export const DEFAULT_GAS = new BigNumber(200);
 export const DEFAULT_GAS_PRICE = new BigNumber(100);
@@ -47,21 +30,13 @@ export function isTestnet(currencyId: string): boolean {
 }
 
 export const getMaxSendBalance = (
+  amount: BigNumber,
   gas: BigNumber,
   gasPrice: BigNumber,
-  account: Account,
-  transaction?: Transaction,
 ): BigNumber => {
-  const tokenAccount = findSubAccountById(account, transaction?.subAccountId ?? "");
-  const fromTokenAccount = tokenAccount && isTokenAccount(tokenAccount);
-
   const totalGas = gas.multipliedBy(gasPrice);
 
-  return fromTokenAccount
-    ? tokenAccount.spendableBalance
-    : account.spendableBalance.gt(totalGas)
-      ? account.spendableBalance.minus(totalGas)
-      : new BigNumber(0);
+  return amount.gt(totalGas) ? amount.minus(totalGas) : new BigNumber(0);
 };
 
 export function normalizeTransactionOptions(options: TransactionOptions): TransactionOptions {
@@ -113,10 +88,9 @@ export const txsToOps = (
   info: { address: string },
   id: string,
   txs: (AptosTransaction | null)[],
-): [Operation[], Operation[]] => {
+): Operation[] => {
   const { address } = info;
   const ops: Operation[] = [];
-  const opsTokens: Operation[] = [];
 
   txs.forEach(tx => {
     if (tx !== null) {
@@ -133,12 +107,10 @@ export const txsToOps = (
         return; // skip transaction without functions in payload
       }
 
-      const { coin_id, amount_in, amount_out } = getCoinAndAmounts(tx, address);
-      op.value = calculateAmount(tx.sender, address, amount_in, amount_out);
+      const { amount_in, amount_out } = getAptosAmounts(tx, address);
+      op.value = calculateAmount(tx.sender, address, op.fee, amount_in, amount_out);
       op.type = compareAddress(tx.sender, address) ? DIRECTION.OUT : DIRECTION.IN;
       op.senders.push(tx.sender);
-      op.hasFailed = !tx.success;
-      op.id = encodeOperationId(op.accountId, tx.hash, op.type);
 
       processRecipients(payload, address, op, function_address);
 
@@ -147,30 +119,13 @@ export const txsToOps = (
         op.type = DIRECTION.UNKNOWN;
       }
 
-      if (op.type !== DIRECTION.UNKNOWN && coin_id !== null) {
-        if (coin_id === APTOS_ASSET_ID) {
-          ops.push(op);
-        } else {
-          const token = findTokenByAddressInCurrency(coin_id.toLowerCase(), "aptos");
-          if (token !== undefined) {
-            op.accountId = encodeTokenAccountId(id, token);
-            opsTokens.push(op);
-
-            if (op.type === DIRECTION.OUT) {
-              ops.push({
-                ...op,
-                accountId: decodeTokenAccountId(op.accountId).accountId,
-                value: op.fee,
-                type: "FEES",
-              });
-            }
-          }
-        }
-      }
+      op.hasFailed = !tx.success;
+      op.id = encodeOperationId(id, tx.hash, op.type);
+      if (op.type !== DIRECTION.UNKNOWN) ops.push(op);
     }
   });
 
-  return [ops, opsTokens];
+  return ops;
 };
 
 export function compareAddress(addressA: string, addressB: string) {
@@ -196,7 +151,7 @@ export function processRecipients(
 ): void {
   // get recipients buy 3 groups
   if (
-    (COIN_TRANSFER_TYPES.includes(payload.function) ||
+    (TRANSFER_TYPES.includes(payload.function) ||
       DELEGATION_POOL_TYPES.includes(payload.function)) &&
     payload.functionArguments &&
     payload.functionArguments.length > 0 &&
@@ -204,15 +159,6 @@ export function processRecipients(
   ) {
     // 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 &&
@@ -233,172 +179,87 @@ export function processRecipients(
   }
 }
 
-export function getEventCoinAddress(
-  change: WriteSetChangeWriteResource,
+function checkWriteSets(tx: AptosTransaction, event: Event, event_name: string): boolean {
+  return tx.changes.some(change => {
+    return isChangeOfAptos(change, event, event_name);
+  });
+}
+
+export function isChangeOfAptos(
+  writeSetChange: WriteSetChange,
   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;
+): boolean {
+  // to validate the event is related to Aptos Tokens we need to find change of type "write_resource"
+  // with the same guid as event
+  if (writeSetChange.type !== WRITE_RESOURCE) {
+    return false;
   }
 
-  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;
+  if (!("data" in writeSetChange)) {
+    return false;
   }
 
-  const address = extractAddress(mr.type);
-
-  return address;
-}
+  const change_data = writeSetChange.data;
 
-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;
+  if (!("type" in change_data)) {
+    return false;
   }
 
-  const mr = change_data as MoveResource<AptosFungibleStoreResourceData>;
+  const mr = change_data as MoveResource<AptosMoveResource>;
 
-  if (change.address !== event.data.store) {
-    return null;
+  if (mr.type !== APTOS_COIN_CHANGE) {
+    return false;
   }
 
-  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;
-}
+  const change_event_data = mr.data[event_name];
 
-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;
+  return (
+    change_event_data.guid.id.addr === event.guid.account_address &&
+    change_event_data.guid.id.creation_num === event.guid.creation_number
+  );
 }
 
-export function getCoinAndAmounts(
+export function getAptosAmounts(
   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);
-
+): { amount_in: BigNumber; amount_out: BigNumber } {
+  let amount_in = new BigNumber(0);
+  let amount_out = new 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);
+    if (compareAddress(event.guid.account_address, address)) {
+      switch (event.type) {
+        case "0x1::coin::WithdrawEvent":
+          if (checkWriteSets(tx, event, "withdraw_events")) {
+            amount_out = amount_out.plus(event.data.amount);
           }
-        }
-        break;
+          break;
+        case "0x1::coin::DepositEvent":
+          if (checkWriteSets(tx, event, "deposit_events")) {
+            amount_in = amount_in.plus(event.data.amount);
+          }
+          break;
+      }
     }
   });
-  return { coin_id, amount_in, amount_out }; // TODO: manage situation when there are several coinID from the events parsing
+  return { amount_in, amount_out };
 }
 
 export function calculateAmount(
   sender: string,
   address: string,
+  fee: BigNumber,
   amount_in: BigNumber,
   amount_out: BigNumber,
 ): BigNumber {
   const is_sender: boolean = compareAddress(sender, address);
+  // Include fees if our address is the sender
+  if (is_sender) {
+    amount_out = amount_out.plus(fee);
+  }
   // 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,
-): TokenAccount | undefined {
-  const tokenAccount = findSubAccountById(account, transaction.subAccountId ?? "");
-  const fromTokenAccount = tokenAccount && isTokenAccount(tokenAccount);
-  return fromTokenAccount ? tokenAccount : undefined;
-}

package/src/bridge/prepareTransaction.ts

@@ -1,5 +1,6 @@
 import type { Account } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
+
 import { AptosAPI } from "../api";
 import { getEstimatedGas } from "./getFeesForTransaction";
 import type { Transaction } from "../types";
@@ -27,10 +28,9 @@ const prepareTransaction = async (
   if (transaction.useAllAmount) {
     // we will use this amount in simulation, to estimate gas
     transaction.amount = getMaxSendBalance(
+      account.spendableBalance,
       new BigNumber(DEFAULT_GAS),
       new BigNumber(DEFAULT_GAS_PRICE),
-      account,
-      transaction,
     );
   }
 
@@ -39,10 +39,9 @@ const prepareTransaction = async (
   if (transaction.useAllAmount) {
     // correct the transaction amount according to estimated fees
     transaction.amount = getMaxSendBalance(
+      account.spendableBalance,
       BigNumber(estimate.maxGasAmount),
       BigNumber(estimate.gasUnitPrice),
-      account,
-      transaction,
     );
   }
 

package/src/bridge/signOperation.ts

@@ -9,7 +9,6 @@ import { AptosAPI } from "../api";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { AptosSigner } from "../types";
 import { signTransaction } from "../network";
-import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
 
 export const getAddress = (a: Account) => ({
   address: a.freshAddress,
@@ -46,15 +45,14 @@ const buildSignOperation =
           recipients.push(transaction.recipient);
         }
 
-        const subAccount =
-          !!transaction.subAccountId && findSubAccountById(account, transaction.subAccountId);
-
         // build optimistic operation
         const operation: Operation = {
           id: encodeOperationId(accountId, hash, type),
           hash,
           type,
-          value: subAccount ? fee : transaction.amount.plus(fee),
+          value: transaction.useAllAmount
+            ? account.balance.minus(fee)
+            : transaction.amount.plus(fee),
           fee,
           extra,
           blockHash: null,
@@ -64,20 +62,6 @@ const buildSignOperation =
           accountId,
           date: new Date(),
           transactionSequenceNumber: Number(rawTx.sequence_number),
-          subOperations: subAccount
-            ? [
-                {
-                  id: encodeOperationId(subAccount.id, "", "OUT"),
-                  type: "OUT",
-                  accountId: transaction.subAccountId,
-                  senders: [account.freshAddress],
-                  recipients: [transaction.recipient],
-                  value: transaction.amount,
-                  fee,
-                  date: new Date(),
-                } as Operation,
-              ]
-            : [],
         };
 
         o.next({

package/src/bridge/synchronisation.ts

@@ -1,160 +1,9 @@
-import { inferSubOperations } from "@ledgerhq/coin-framework/serialization/index";
 import { decodeAccountId, encodeAccountId } from "@ledgerhq/coin-framework/account";
 import type { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { AptosAPI } from "../api";
 import { txsToOps } from "./logic";
 import type { AptosAccount } from "../types";
-import { Account, Operation, TokenAccount } from "@ledgerhq/types-live";
-import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import {
-  decodeTokenAccountId,
-  emptyHistoryCache,
-  encodeTokenAccountId,
-} from "@ledgerhq/coin-framework/account/index";
-import { AccountShapeInfo } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-
-/**
- * List of properties of a sub account that can be updated when 2 "identical" accounts are found
- */
-const updatableSubAccountProperties: { name: string; isOps: boolean }[] = [
-  { name: "balance", isOps: false },
-  { name: "spendableBalance", isOps: false },
-  { name: "balanceHistoryCache", isOps: false },
-  { name: "operations", isOps: true },
-  { name: "pendingOperations", isOps: true },
-];
-/**
- * In charge of smartly merging sub accounts while maintaining references as much as possible
- */
-export const mergeSubAccounts = (
-  initialAccount: Account | undefined,
-  newSubAccounts: TokenAccount[],
-): Array<TokenAccount> => {
-  const oldSubAccounts: Array<TokenAccount> | undefined = initialAccount?.subAccounts;
-  if (!oldSubAccounts) {
-    return newSubAccounts;
-  }
-
-  // Creating a map of already existing sub accounts by id
-  const oldSubAccountsById: { [key: string]: TokenAccount } = {};
-  for (const oldSubAccount of oldSubAccounts) {
-    oldSubAccountsById[oldSubAccount.id!] = oldSubAccount;
-  }
-
-  // Looping on new sub accounts to compare them with already existing ones
-  // Already existing will be updated if necessary (see `updatableSubAccountProperties`)
-  // Fresh new sub accounts will be added/pushed after already existing
-  const newSubAccountsToAdd: TokenAccount[] = [];
-  for (const newSubAccount of newSubAccounts) {
-    const duplicatedAccount: TokenAccount | undefined = oldSubAccountsById[newSubAccount.id!];
-
-    // If this sub account was not already in the initialAccount
-    if (!duplicatedAccount) {
-      // We'll add it later
-      newSubAccountsToAdd.push(newSubAccount);
-      continue;
-    }
-
-    const updates: Partial<TokenAccount> & { [key: string]: any } = {};
-    for (const { name, isOps } of updatableSubAccountProperties) {
-      if (!isOps) {
-        if (
-          newSubAccount[name as keyof TokenAccount] !==
-          duplicatedAccount[name as keyof TokenAccount]
-        ) {
-          updates[name] = newSubAccount[name as keyof TokenAccount];
-        }
-      } else {
-        updates[name] =
-          mergeOps(
-            duplicatedAccount[name as keyof TokenAccount] as Operation[],
-            newSubAccount[name as keyof TokenAccount] as Operation[],
-          ) || [];
-      }
-    }
-
-    // Updating the operationsCount in case the mergeOps changed it
-    updates.operationsCount =
-      updates.operations?.length || duplicatedAccount?.operations?.length || 0;
-
-    // Modifying the Map with the updated sub account with a new ref
-    oldSubAccountsById[newSubAccount.id!] = {
-      ...duplicatedAccount,
-      ...updates,
-    };
-  }
-  const updatedSubAccounts = Object.values(oldSubAccountsById);
-  return [...updatedSubAccounts, ...newSubAccountsToAdd];
-};
-
-/**
- * Fetch the balance for a token and creates a TokenAccount based on this and the provided operations
- */
-export const getSubAccountShape = async (
-  currency: CryptoCurrency,
-  address: string,
-  parentId: string,
-  token: TokenCurrency,
-  operations: Operation[],
-): Promise<TokenAccount> => {
-  const aptosClient = new AptosAPI(currency.id);
-  const tokenAccountId = encodeTokenAccountId(parentId, token);
-  const balance = await aptosClient.getBalance(address, token);
-  const firstOperation = operations
-    .sort((a, b) => b.date.getTime() - a.date.getTime())
-    .at(operations.length - 1);
-
-  return {
-    type: "TokenAccount",
-    id: tokenAccountId,
-    parentId,
-    token,
-    balance,
-    spendableBalance: balance,
-    creationDate: firstOperation?.date || new Date(0),
-    operations,
-    operationsCount: operations.length,
-    pendingOperations: [],
-    balanceHistoryCache: emptyHistoryCache,
-    swapHistory: [],
-  };
-};
-
-/**
- * Getting all token related operations in order to provide TokenAccounts
- */
-export const getSubAccounts = async (
-  infos: AccountShapeInfo<Account>,
-  address: string,
-  accountId: string,
-  lastTokenOperations: Operation[],
-): Promise<TokenAccount[]> => {
-  const { currency } = infos;
-
-  // Creating a Map of Operations by TokenCurrencies in order to know which TokenAccounts should be synced as well
-  const operationsByToken = lastTokenOperations.reduce<Map<TokenCurrency, Operation[]>>(
-    (acc, operation) => {
-      const { token } = decodeTokenAccountId(operation.accountId);
-      if (!token) return acc; // TODO: do we need to check blacklistedTokenIds
-
-      if (!acc.has(token)) {
-        acc.set(token, []);
-      }
-      acc.get(token)?.push(operation);
-      return acc;
-    },
-    new Map<TokenCurrency, Operation[]>(),
-  );
-
-  // Fetching all TokenAccounts possible and providing already filtered operations
-  const subAccountsPromises: Promise<TokenAccount>[] = [];
-  for (const [token, ops] of operationsByToken.entries()) {
-    subAccountsPromises.push(getSubAccountShape(currency, address, accountId, token, ops));
-  }
-
-  return Promise.all(subAccountsPromises);
-};
 
 export const getAccountShape: GetAccountShape = async info => {
   const { address, initialAccount, currency, derivationMode, rest } = info;
@@ -177,29 +26,14 @@ export const getAccountShape: GetAccountShape = async info => {
   const xpub = initialAccount?.xpub || publicKey || "";
 
   const oldOperations = initialAccount?.operations || [];
+  const startAt = (oldOperations[0]?.extra as any)?.version;
 
   const aptosClient = new AptosAPI(currency.id);
-  const { balance, transactions, blockHeight } = await aptosClient.getAccountInfo(address);
+  const { balance, transactions, blockHeight } = await aptosClient.getAccountInfo(address, startAt);
 
-  const [newOperations, tokenOperations]: [Operation[], Operation[]] = txsToOps(
-    info,
-    accountId,
-    transactions,
-  );
+  const newOperations = txsToOps(info, accountId, transactions);
   const operations = mergeOps(oldOperations, newOperations);
 
-  const newSubAccounts = await getSubAccounts(info, address, accountId, tokenOperations);
-  const shouldSyncFromScratch = initialAccount === undefined;
-  const subAccounts = shouldSyncFromScratch
-    ? newSubAccounts
-    : mergeSubAccounts(initialAccount, newSubAccounts);
-
-  operations.forEach(op => {
-    const subOperations = inferSubOperations(op.hash, subAccounts);
-    op.subOperations =
-      subOperations.length === 1 ? subOperations : subOperations.filter(op => !!op.blockHash);
-  });
-
   const shape: Partial<AptosAccount> = {
     type: "Account",
     id: accountId,
@@ -210,7 +44,6 @@ export const getAccountShape: GetAccountShape = async info => {
     operationsCount: operations.length,
     blockHeight,
     lastSyncDate: new Date(),
-    subAccounts,
   };
 
   return shape;

package/src/constants.ts

@@ -10,36 +10,25 @@ export enum TX_STATUS {
 
 export const WRITE_RESOURCE = "write_resource";
 
-export const COIN_TRANSFER_TYPES: MoveStructId[] = [
+export const TRANSFER_TYPES: MoveStructId[] = [
   "0x1::aptos_account::transfer",
   "0x1::aptos_account::transfer_coins",
   "0x1::coin::transfer",
 ];
-
-export const FA_TRANSFER_TYPES: MoveStructId[] = ["0x1::primary_fungible_store::transfer"];
-
 export const BATCH_TRANSFER_TYPES: MoveStructId[] = [
   "0x1::aptos_account::batch_transfer",
   "0x1::aptos_account::batch_transfer_coins",
 ];
-
 export const DELEGATION_POOL_TYPES: MoveStructId[] = [
   "0x1::delegation_pool::add_stake",
   "0x1::delegation_pool::withdraw",
 ];
 
 export const APTOS_ASSET_ID: MoveStructId = "0x1::aptos_coin::AptosCoin";
-
 export const APTOS_COIN_CHANGE: MoveStructId = `0x1::coin::CoinStore<${APTOS_ASSET_ID}>`;
 
-export const APTOS_FUNGIBLE_STORE: MoveStructId = "0x1::fungible_asset::FungibleStore";
-
-export const APTOS_OBJECT_CORE: MoveStructId = "0x1::object::ObjectCore";
-
 export enum DIRECTION {
   IN = "IN",
   OUT = "OUT",
   UNKNOWN = "UNKNOWN",
 }
-
-export const SUPPORTED_TOKEN_TYPES = ["coin", "fungible_asset"];