@ledgerhq/coin-aptos 2.0.0-nightly.5 → 2.1.0-next.0

package/src/bridge/logic.ts

@@ -1,61 +1,40 @@
+import { EntryFunctionPayloadResponse } from "@aptos-labs/ts-sdk";
+import type { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
 import {
-  EntryFunctionPayloadResponse,
-  Event,
-  InputEntryFunctionData,
-  MoveResource,
-  WriteSetChange,
-} from "@aptos-labs/ts-sdk";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
-import type { Operation, OperationType } from "@ledgerhq/types-live";
+  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,
-  BATCH_TRANSFER_TYPES,
-  DELEGATION_POOL_TYPES,
-  DIRECTION,
-  TRANSFER_TYPES,
-  WRITE_RESOURCE,
-} from "../constants";
-import type { AptosMoveResource, AptosTransaction, TransactionOptions } from "../types";
-
-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 { APTOS_ASSET_ID, DIRECTION } from "../constants";
+import type { AptosTransaction, Transaction } from "../types";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
+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 = (
-  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 {
-  // 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,
@@ -76,21 +55,14 @@ 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,
   txs: (AptosTransaction | null)[],
-): Operation[] => {
+): [Operation[], Operation[]] => {
   const { address } = info;
   const ops: Operation[] = [];
+  const opsTokens: Operation[] = [];
 
   txs.forEach(tx => {
     if (tx !== null) {
@@ -107,10 +79,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,147 +93,37 @@ 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);
-    }
-  });
-
-  return ops;
-};
-
-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 (
-    (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 (
-    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());
+      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",
+              });
+            }
+          }
         }
       }
     }
-  } else {
-    // 3. other smart contracts, in this case smart contract will be treated as a recipient
-    op.recipients.push(function_address);
-  }
-}
-
-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,
-): 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;
-  }
-
-  if (!("data" in writeSetChange)) {
-    return false;
-  }
-
-  const change_data = writeSetChange.data;
-
-  if (!("type" in change_data)) {
-    return false;
-  }
-
-  const mr = change_data as MoveResource<AptosMoveResource>;
-
-  if (mr.type !== APTOS_COIN_CHANGE) {
-    return false;
-  }
-
-  const change_event_data = mr.data[event_name];
 
-  return (
-    change_event_data.guid.id.addr === event.guid.account_address &&
-    change_event_data.guid.id.creation_num === event.guid.creation_number
-  );
-}
-
-export function getAptosAmounts(
-  tx: AptosTransaction,
-  address: string,
-): { 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 => {
-    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);
-          }
-          break;
-      }
-    }
-  });
-  return { amount_in, amount_out };
-}
+  return [ops, opsTokens];
+};
 
-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);
+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,10 +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,
@@ -28,9 +29,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 +41,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

@@ -1,14 +1,15 @@
 import type { AptosAccount, Transaction } from "../types";
 import { Observable } from "rxjs";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import buildTransaction from "./buildTransaction";
 import BigNumber from "bignumber.js";
 import type { Account, AccountBridge, Operation, OperationType } from "@ledgerhq/types-live";
-import { AptosAPI } from "../api";
+import { AptosAPI } from "../network";
 
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { AptosSigner } from "../types";
 import { signTransaction } from "../network";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
+import buildTransaction from "../logic/buildTransaction";
 
 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 { AptosAPI } from "../network";
 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/config.ts

@@ -0,0 +1,19 @@
+import type { AptosSettings } from "@aptos-labs/ts-sdk";
+import buildCoinConfig, {
+  type CoinConfig,
+  type CurrencyConfig,
+} from "@ledgerhq/coin-framework/config";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+export type AptosConfig = {
+  aptosSettings: AptosSettings;
+};
+
+export type AptosCoinConfig = CurrencyConfig & AptosConfig;
+
+const coinConfig: {
+  setCoinConfig: (config: CoinConfig<AptosCoinConfig>) => void;
+  getCoinConfig: (currency?: CryptoCurrency) => AptosCoinConfig;
+} = buildCoinConfig<AptosCoinConfig>();
+
+export default coinConfig;

package/src/constants.ts

@@ -1,4 +1,7 @@
-import { MoveStructId } from "@aptos-labs/ts-sdk";
+import type { MoveStructId } from "@aptos-labs/ts-sdk";
+import BigNumber from "bignumber.js";
+
+export const ESTIMATE_GAS_MUL = new BigNumber(1.0); // define buffer for gas estimation change here, if needed
 
 export const LOAD_LIMIT = 10;
 
@@ -10,25 +13,42 @@ 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 enum TOKEN_TYPE {
+  COIN = "coin",
+  FUNGIBLE_ASSET = "fungible_asset",
+}
+
+export const DEFAULT_GAS = new BigNumber(200);
+export const DEFAULT_GAS_PRICE = new BigNumber(100);