@ledgerhq/coin-aptos 1.9.0-next.0 → 2.0.0-nightly.3

package/src/bridge/logic.ts

@@ -4,20 +4,37 @@ import {
   InputEntryFunctionData,
   MoveResource,
   WriteSetChange,
+  WriteSetChangeWriteResource,
 } from "@aptos-labs/ts-sdk";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
-import type { Operation, OperationType } from "@ledgerhq/types-live";
+import type { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
+import {
+  decodeTokenAccountId,
+  encodeTokenAccountId,
+  findSubAccountById,
+  isTokenAccount,
+} from "@ledgerhq/coin-framework/account/index";
 import BigNumber from "bignumber.js";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import {
-  APTOS_COIN_CHANGE,
+  APTOS_ASSET_ID,
+  APTOS_FUNGIBLE_STORE,
   BATCH_TRANSFER_TYPES,
   DELEGATION_POOL_TYPES,
   DIRECTION,
-  TRANSFER_TYPES,
-  WRITE_RESOURCE,
+  COIN_TRANSFER_TYPES,
+  FA_TRANSFER_TYPES,
+  APTOS_OBJECT_CORE,
 } from "../constants";
-import type { AptosMoveResource, AptosTransaction, TransactionOptions } from "../types";
+import type {
+  AptosFungibleoObjectCoreResourceData,
+  AptosFungibleStoreResourceData,
+  AptosMoveResource,
+  AptosTransaction,
+  Transaction,
+  TransactionOptions,
+} from "../types";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
 
 export const DEFAULT_GAS = new BigNumber(200);
 export const DEFAULT_GAS_PRICE = new BigNumber(100);
@@ -30,13 +47,21 @@ 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 amount.gt(totalGas) ? amount.minus(totalGas) : new BigNumber(0);
+  return fromTokenAccount
+    ? tokenAccount.spendableBalance
+    : account.spendableBalance.gt(totalGas)
+      ? account.spendableBalance.minus(totalGas)
+      : new BigNumber(0);
 };
 
 export function normalizeTransactionOptions(options: TransactionOptions): TransactionOptions {
@@ -88,9 +113,10 @@ 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) {
@@ -107,10 +133,12 @@ export const txsToOps = (
         return; // skip transaction without functions in payload
       }
 
-      const { amount_in, amount_out } = getAptosAmounts(tx, address);
-      op.value = calculateAmount(tx.sender, address, op.fee, amount_in, amount_out);
+      const { coin_id, amount_in, amount_out } = getCoinAndAmounts(tx, address);
+      op.value = calculateAmount(tx.sender, address, 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);
 
@@ -119,13 +147,30 @@ export const txsToOps = (
         op.type = DIRECTION.UNKNOWN;
       }
 
-      op.hasFailed = !tx.success;
-      op.id = encodeOperationId(id, tx.hash, op.type);
-      if (op.type !== DIRECTION.UNKNOWN) ops.push(op);
+      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",
+              });
+            }
+          }
+        }
+      }
     }
   });
 
-  return ops;
+  return [ops, opsTokens];
 };
 
 export function compareAddress(addressA: string, addressB: string) {
@@ -151,7 +196,7 @@ export function processRecipients(
 ): void {
   // get recipients buy 3 groups
   if (
-    (TRANSFER_TYPES.includes(payload.function) ||
+    (COIN_TRANSFER_TYPES.includes(payload.function) ||
       DELEGATION_POOL_TYPES.includes(payload.function)) &&
     payload.functionArguments &&
     payload.functionArguments.length > 0 &&
@@ -159,6 +204,15 @@ 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 &&
@@ -179,87 +233,172 @@ export function processRecipients(
   }
 }
 
-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,
+export function getEventCoinAddress(
+  change: WriteSetChangeWriteResource,
   event: Event,
   event_name: string,
-): 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;
+): 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;
   }
 
-  if (!("data" in writeSetChange)) {
-    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;
   }
 
-  const change_data = writeSetChange.data;
+  const address = extractAddress(mr.type);
+
+  return address;
+}
 
-  if (!("type" in change_data)) {
-    return false;
+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<AptosMoveResource>;
+  const mr = change_data as MoveResource<AptosFungibleStoreResourceData>;
 
-  if (mr.type !== APTOS_COIN_CHANGE) {
-    return false;
+  if (change.address !== event.data.store) {
+    return null;
   }
 
-  const change_event_data = mr.data[event_name];
+  return mr.data.metadata.inner;
+}
 
-  return (
-    change_event_data.guid.id.addr === event.guid.account_address &&
-    change_event_data.guid.id.creation_num === event.guid.creation_number
-  );
+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 getAptosAmounts(
+export function getCoinAndAmounts(
   tx: AptosTransaction,
   address: string,
-): { amount_in: BigNumber; amount_out: BigNumber } {
-  let amount_in = new BigNumber(0);
-  let amount_out = new BigNumber(0);
+): { 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 => {
-    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;
-        case "0x1::coin::DepositEvent":
-          if (checkWriteSets(tx, event, "deposit_events")) {
-            amount_in = amount_in.plus(event.data.amount);
+    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;
-      }
+        }
+        break;
     }
   });
-  return { amount_in, amount_out };
+  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,
-  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,6 +1,5 @@
 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";
@@ -28,9 +27,10 @@ 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,9 +39,10 @@ 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,6 +9,7 @@ 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,
@@ -45,14 +46,15 @@ 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: transaction.useAllAmount
-            ? account.balance.minus(fee)
-            : transaction.amount.plus(fee),
+          value: subAccount ? fee : transaction.amount.plus(fee),
           fee,
           extra,
           blockHash: null,
@@ -62,6 +64,20 @@ 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,9 +1,160 @@
+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;
@@ -26,14 +177,29 @@ 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, startAt);
+  const { balance, transactions, blockHeight } = await aptosClient.getAccountInfo(address);
 
-  const newOperations = txsToOps(info, accountId, transactions);
+  const [newOperations, tokenOperations]: [Operation[], Operation[]] = 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,
@@ -44,6 +210,7 @@ export const getAccountShape: GetAccountShape = async info => {
     operationsCount: operations.length,
     blockHeight,
     lastSyncDate: new Date(),
+    subAccounts,
   };
 
   return shape;

package/src/constants.ts

@@ -10,25 +10,36 @@ export enum TX_STATUS {
 
 export const WRITE_RESOURCE = "write_resource";
 
-export const TRANSFER_TYPES: MoveStructId[] = [
+export const COIN_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"];