@ledgerhq/coin-aptos 2.5.1 → 2.5.2-nightly.1

package/src/bridge/synchronisation.ts

@@ -4,8 +4,8 @@ import type { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers"
 import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { AptosAPI } from "../network";
 import { txsToOps } from "./logic";
-import type { AptosAccount } from "../types";
-import { Account, Operation, TokenAccount } from "@ledgerhq/types-live";
+import type { AptosAccount, AptosStakingPosition } from "../types";
+import { Operation, TokenAccount } from "@ledgerhq/types-live";
 import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import {
   decodeTokenAccountId,
@@ -14,6 +14,7 @@ import {
 } from "@ledgerhq/coin-framework/account/index";
 import { AccountShapeInfo } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import BigNumber from "bignumber.js";
+import { getEnv } from "@ledgerhq/live-env";
 
 /**
  * List of properties of a sub account that can be updated when 2 "identical" accounts are found
@@ -29,7 +30,7 @@ const updatableSubAccountProperties: { name: string; isOps: boolean }[] = [
  * In charge of smartly merging sub accounts while maintaining references as much as possible
  */
 export const mergeSubAccounts = (
-  initialAccount: Account | undefined,
+  initialAccount: AptosAccount | undefined,
   newSubAccounts: TokenAccount[],
 ): Array<TokenAccount> => {
   const oldSubAccounts: Array<TokenAccount> | undefined = initialAccount?.subAccounts;
@@ -127,7 +128,7 @@ export const getSubAccountShape = async (
  * Getting all token related operations in order to provide TokenAccounts
  */
 export const getSubAccounts = async (
-  infos: AccountShapeInfo<Account>,
+  infos: AccountShapeInfo<AptosAccount>,
   address: string,
   accountId: string,
   lastTokenOperations: Operation[],
@@ -158,7 +159,9 @@ export const getSubAccounts = async (
   return Promise.all(subAccountsPromises);
 };
 
-export const getAccountShape: GetAccountShape = async info => {
+export const getAccountShape: GetAccountShape<AptosAccount> = async (
+  info: AccountShapeInfo<AptosAccount>,
+) => {
   const { address, initialAccount, currency, derivationMode, rest } = info;
 
   const publicKey =
@@ -183,11 +186,11 @@ export const getAccountShape: GetAccountShape = async info => {
   const aptosClient = new AptosAPI(currency.id);
   const { balance, transactions, blockHeight } = await aptosClient.getAccountInfo(address);
 
-  const [newOperations, tokenOperations]: [Operation[], Operation[]] = txsToOps(
-    info,
-    accountId,
-    transactions,
-  );
+  const [newOperations, tokenOperations, stakingOperations]: [
+    Operation[],
+    Operation[],
+    Operation[],
+  ] = txsToOps(info, accountId, transactions);
   const operations = mergeOps(oldOperations, newOperations);
 
   const newSubAccounts = await getSubAccounts(info, address, accountId, tokenOperations);
@@ -196,24 +199,78 @@ export const getAccountShape: GetAccountShape = async info => {
     ? newSubAccounts
     : mergeSubAccounts(initialAccount, newSubAccounts);
 
-  operations.forEach(op => {
+  operations?.forEach(op => {
     const subOperations = inferSubOperations(op.hash, subAccounts);
     op.subOperations =
       subOperations.length === 1 ? subOperations : subOperations.filter(op => !!op.blockHash);
   });
 
+  const stakingPositions: AptosStakingPosition[] = [];
+  let activeBalance = BigNumber(0);
+  let inactiveBalance = BigNumber(0);
+  let pendingInactiveBalance = BigNumber(0);
+
+  if (getEnv("APTOS_ENABLE_STAKING") === true) {
+    const stakingPoolAddresses = getStakingPoolAddresses(stakingOperations);
+    for (const stakingPoolAddress of stakingPoolAddresses) {
+      const [active_string, inactive_string, pending_inactive_string] =
+        await aptosClient.getDelegatorBalanceInPool(stakingPoolAddress, address);
+
+      const active = BigNumber(active_string);
+      const inactive = BigNumber(inactive_string);
+      const pendingInactive = BigNumber(pending_inactive_string);
+
+      stakingPositions.push({
+        active,
+        inactive,
+        pendingInactive,
+        validatorId: stakingPoolAddress,
+      });
+
+      activeBalance = activeBalance.plus(active);
+      inactiveBalance = inactiveBalance.plus(inactive);
+      pendingInactiveBalance = pendingInactiveBalance.plus(pendingInactive);
+    }
+  }
+
+  const aptosResources = {
+    activeBalance,
+    inactiveBalance,
+    pendingInactiveBalance,
+    stakingPositions,
+  };
+
   const shape: Partial<AptosAccount> = {
     type: "Account",
     id: accountId,
     xpub,
-    balance: balance,
+    balance: balance
+      .plus(aptosResources.activeBalance)
+      .plus(aptosResources.pendingInactiveBalance)
+      .plus(aptosResources.inactiveBalance),
     spendableBalance: balance,
     operations,
     operationsCount: operations.length,
     blockHeight,
     lastSyncDate: new Date(),
     subAccounts,
+    aptosResources,
   };
 
   return shape;
 };
+
+export const getStakingPoolAddresses = (stakingOperations: Operation[]): string[] => {
+  const stakingPoolsAddrs: string[] = [];
+
+  for (const op of stakingOperations) {
+    if (!op.recipients.length) continue;
+
+    const poolAddress = op.recipients[0];
+    if (poolAddress === "0x1") continue;
+
+    if (!stakingPoolsAddrs.includes(poolAddress)) stakingPoolsAddrs.push(poolAddress);
+  }
+
+  return stakingPoolsAddrs;
+};

package/src/constants.ts

@@ -1,7 +1,8 @@
 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 ESTIMATE_GAS_MUL = new BigNumber(1.1); // define buffer for gas estimation change here, if needed
+export const ESTIMATE_GAS_MUL_FOR_STAKING = new BigNumber(3); // gas multiplier for staking operations
 
 export const LOAD_LIMIT = 10;
 
@@ -13,6 +14,10 @@ export enum TX_STATUS {
 
 export const WRITE_RESOURCE = "write_resource";
 
+export const APTOS_NON_HARDENED_DERIVATION_PATH_REGEX = /^44'\/637'\/[0-9]+'\/[0-9]+\/[0-9]+$/;
+export const APTOS_NON_HARDENED_DERIVATION_PATH = "44'/637'/0'/0/0";
+export const APTOS_HARDENED_DERIVATION_PATH = "44'/637'/0'/0'/0'";
+
 export const COIN_TRANSFER_TYPES: MoveStructId[] = [
   "0x1::aptos_account::transfer",
   "0x1::aptos_account::transfer_coins",
@@ -28,9 +33,45 @@ export const BATCH_TRANSFER_TYPES: MoveStructId[] = [
 
 export const DELEGATION_POOL_TYPES: MoveStructId[] = [
   "0x1::delegation_pool::add_stake",
+  "0x1::delegation_pool::reactivate_stake",
+  "0x1::delegation_pool::unlock",
   "0x1::delegation_pool::withdraw",
 ];
 
+export const ADD_STAKE_EVENTS = [
+  "0x1::stake::AddStake",
+  "0x1::stake::AddStakeEvent",
+  "0x1::delegation_pool::AddStake",
+  "0x1::delegation_pool::AddStakeEvent",
+];
+
+export const REACTIVATE_STAKE_EVENTS = [
+  "0x1::stake::ReactivateStake",
+  "0x1::stake::ReactivateStakeEvent",
+  "0x1::delegation_pool::ReactivateStake",
+  "0x1::delegation_pool::ReactivateStakeEvent",
+];
+
+export const UNLOCK_STAKE_EVENTS = [
+  "0x1::stake::UnlockStake",
+  "0x1::stake::UnlockStakeEvent",
+  "0x1::delegation_pool::UnlockStake",
+  "0x1::delegation_pool::UnlockStakeEvent",
+];
+
+export const WITHDRAW_STAKE_EVENTS = [
+  "0x1::stake::WithdrawStake",
+  "0x1::stake::WithdrawStakeEvent",
+  "0x1::delegation_pool::WithdrawStake",
+  "0x1::delegation_pool::WithdrawStakeEvent",
+];
+
+export const STAKING_EVENTS = ADD_STAKE_EVENTS.concat(
+  REACTIVATE_STAKE_EVENTS,
+  UNLOCK_STAKE_EVENTS,
+  WITHDRAW_STAKE_EVENTS,
+);
+
 export const APTOS_ASSET_ID: MoveStructId = "0x1::aptos_coin::AptosCoin";
 
 export const APTOS_COIN_CHANGE: MoveStructId = `0x1::coin::CoinStore<${APTOS_ASSET_ID}>`;
@@ -39,12 +80,33 @@ export const APTOS_FUNGIBLE_STORE: MoveStructId = "0x1::fungible_asset::Fungible
 
 export const APTOS_OBJECT_CORE: MoveStructId = "0x1::object::ObjectCore";
 
-export enum DIRECTION {
+export enum OP_TYPE {
   IN = "IN",
   OUT = "OUT",
+  STAKE = "STAKE",
+  UNSTAKE = "UNSTAKE",
+  WITHDRAW = "WITHDRAW",
   UNKNOWN = "UNKNOWN",
 }
 
+export const SUPPORTED_TOKEN_TYPES = ["coin", "fungible_asset"];
+
+export const STAKING_TX_MODES = ["stake", "unstake", "restake", "withdraw"];
+
+export const APTOS_PRECISION = 8;
+export const APTOS_MINIMUM_RESTAKE = BigNumber(1);
+export const APTOS_MINIMUM_RESTAKE_IN_OCTAS = APTOS_MINIMUM_RESTAKE.shiftedBy(APTOS_PRECISION);
+export const APTOS_DELEGATION_RESERVE = BigNumber(0.05);
+export const APTOS_DELEGATION_RESERVE_IN_OCTAS =
+  APTOS_DELEGATION_RESERVE.shiftedBy(APTOS_PRECISION);
+export const MIN_COINS_ON_SHARES_POOL = BigNumber(11);
+export const MIN_COINS_ON_SHARES_POOL_IN_OCTAS =
+  MIN_COINS_ON_SHARES_POOL.shiftedBy(APTOS_PRECISION);
+export const MIN_AMOUNT_TO_UNSTAKE = BigNumber(10);
+export const MIN_AMOUNT_TO_UNSTAKE_IN_OCTAS = MIN_AMOUNT_TO_UNSTAKE.shiftedBy(APTOS_PRECISION);
+
+export const APTOS_EXPLORER_ACCOUNT_URL = "https://explorer.aptoslabs.com/account";
+
 export enum TOKEN_TYPE {
   COIN = "coin",
   FUNGIBLE_ASSET = "fungible_asset",

package/src/index.ts

@@ -1,3 +1 @@
-export * from "./types";
-
 export { createBridges } from "./bridge/index";

package/src/logic/buildTransaction.ts

@@ -5,7 +5,6 @@ import { APTOS_ASSET_ID, TOKEN_TYPE } from "../constants";
 import type { AptosAPI } from "../network";
 import { normalizeTransactionOptions } from "./normalizeTransactionOptions";
 import type { Transaction } from "../types";
-import type BigNumber from "bignumber.js";
 
 const buildTransaction = async (
   account: Account,
@@ -20,10 +19,9 @@ const buildTransaction = async (
   const payloadTokenType = (subAccount?.token?.tokenType as TOKEN_TYPE) ?? tokenType;
 
   const txPayload = getPayload({
-    amount: transaction.amount,
-    recipient: transaction.recipient,
-    contractAddress: payloadContracAddress,
+    transaction,
     tokenType: payloadTokenType,
+    contractAddress: payloadContracAddress,
   });
 
   const txOptions = normalizeTransactionOptions(transaction.options);
@@ -33,33 +31,60 @@ const buildTransaction = async (
   return tx;
 };
 
-const getPayload = (args: {
-  amount: BigNumber;
-  recipient: string;
-  contractAddress?: string | undefined;
-  tokenType?: string;
+const getPayload = ({
+  transaction,
+  tokenType,
+  contractAddress,
+}: {
+  transaction: Transaction;
+  tokenType: TOKEN_TYPE;
+  contractAddress: string | undefined;
 }): InputEntryFunctionData => {
-  if (args.tokenType !== undefined && !isTokenType(args.tokenType)) {
-    throw new Error(`Token type ${args.tokenType} not supported`);
-  }
+  const { amount, recipient, mode } = transaction;
 
-  if (args.tokenType === TOKEN_TYPE.FUNGIBLE_ASSET) {
-    return {
-      function: "0x1::primary_fungible_store::transfer",
-      typeArguments: ["0x1::fungible_asset::Metadata"],
-      functionArguments: [args.contractAddress, args.recipient, args.amount.toString()],
-    };
-  }
+  switch (mode) {
+    case "stake":
+      return {
+        function: "0x1::delegation_pool::add_stake",
+        typeArguments: [],
+        functionArguments: [recipient, amount.toString()],
+      };
+    case "unstake":
+      return {
+        function: "0x1::delegation_pool::unlock",
+        typeArguments: [],
+        functionArguments: [recipient, amount.toString()],
+      };
+    case "restake":
+      return {
+        function: "0x1::delegation_pool::reactivate_stake",
+        typeArguments: [],
+        functionArguments: [recipient, amount.toString()],
+      };
+    case "withdraw":
+      return {
+        function: "0x1::delegation_pool::withdraw",
+        typeArguments: [],
+        functionArguments: [recipient, amount.toString()],
+      };
+    case "send":
+      if (tokenType !== undefined && !isTokenType(tokenType)) {
+        throw new Error(`Token type ${tokenType} not supported`);
+      }
 
-  let address = args.contractAddress ?? "";
-  if (address === "") {
-    address = APTOS_ASSET_ID;
+      if (tokenType === TOKEN_TYPE.FUNGIBLE_ASSET) {
+        return {
+          function: "0x1::primary_fungible_store::transfer",
+          typeArguments: ["0x1::fungible_asset::Metadata"],
+          functionArguments: [contractAddress, recipient, amount.toString()],
+        };
+      }
   }
 
   return {
     function: "0x1::aptos_account::transfer_coins",
-    typeArguments: [address],
-    functionArguments: [args.recipient, args.amount.toString()],
+    typeArguments: [contractAddress ?? APTOS_ASSET_ID],
+    functionArguments: [recipient, amount.toString()],
   };
 };
 

package/src/logic/getCoinAndAmounts.ts

@@ -1,5 +1,15 @@
 import BigNumber from "bignumber.js";
-import { APTOS_ASSET_ID, APTOS_FUNGIBLE_STORE, APTOS_OBJECT_CORE } from "../constants";
+import {
+  ADD_STAKE_EVENTS,
+  APTOS_ASSET_ID,
+  APTOS_FUNGIBLE_STORE,
+  APTOS_OBJECT_CORE,
+  OP_TYPE,
+  REACTIVATE_STAKE_EVENTS,
+  STAKING_EVENTS,
+  UNLOCK_STAKE_EVENTS,
+  WITHDRAW_STAKE_EVENTS,
+} from "../constants";
 import {
   AptosFungibleoObjectCoreResourceData,
   AptosFungibleStoreResourceData,
@@ -94,48 +104,88 @@ export function getEventFAAddress(
 export function getCoinAndAmounts(
   tx: AptosTransaction,
   address: string,
-): { coin_id: string | null; amount_in: BigNumber; amount_out: BigNumber } {
+): {
+  coin_id: string | null;
+  amount_in: BigNumber;
+  amount_out: BigNumber;
+  type: OP_TYPE;
+} {
   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) {
-          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);
-          }
+  let type = OP_TYPE.UNKNOWN;
+
+  // Check if it is a staking transaction
+  const stakingTx = !!tx.events.find(event => STAKING_EVENTS.includes(event.type));
+
+  // Collect all events related to the address and calculate the overall amounts
+  if (stakingTx) {
+    tx.events.forEach(event => {
+      if (ADD_STAKE_EVENTS.includes(event.type) && tx.sender === address && amount_out.isZero()) {
+        coin_id = APTOS_ASSET_ID;
+        type = OP_TYPE.STAKE;
+        amount_out = amount_out.plus(event.data.amount_added || event.data.amount);
+      } else if (
+        REACTIVATE_STAKE_EVENTS.includes(event.type) &&
+        tx.sender === address &&
+        amount_out.isZero()
+      ) {
+        coin_id = APTOS_ASSET_ID;
+        type = OP_TYPE.STAKE;
+        amount_out = amount_out.plus(event.data.amount_reactivated || event.data.amount);
+      } else if (
+        UNLOCK_STAKE_EVENTS.includes(event.type) &&
+        tx.sender === address &&
+        amount_in.isZero()
+      ) {
+        coin_id = APTOS_ASSET_ID;
+        type = OP_TYPE.UNSTAKE;
+        amount_in = amount_in.plus(event.data.amount_unlocked || event.data.amount);
+      } else if (
+        WITHDRAW_STAKE_EVENTS.includes(event.type) &&
+        tx.sender === address &&
+        amount_in.isZero()
+      ) {
+        coin_id = APTOS_ASSET_ID;
+        type = OP_TYPE.WITHDRAW;
+        amount_in = amount_in.plus(event.data.amount_withdrawn || event.data.amount);
+      }
+    });
+  } else {
+    tx.events.forEach(event => {
+      if (
+        event.type === "0x1::coin::WithdrawEvent" &&
+        compareAddress(event.guid.account_address, address)
+      ) {
+        coin_id = getResourceAddress(tx, event, "withdraw_events", getEventCoinAddress);
+        amount_out = amount_out.plus(event.data.amount);
+      } else if (
+        event.type === "0x1::coin::DepositEvent" &&
+        compareAddress(event.guid.account_address, address)
+      ) {
+        coin_id = getResourceAddress(tx, event, "deposit_events", getEventCoinAddress);
+        amount_in = amount_in.plus(event.data.amount);
+      } else if (
+        event.type === "0x1::fungible_asset::Withdraw" &&
+        checkFAOwner(tx, event, address)
+      ) {
+        coin_id = getResourceAddress(tx, event, "withdraw_events", getEventFAAddress);
+        amount_out = amount_out.plus(event.data.amount);
+      } else if (
+        event.type === "0x1::fungible_asset::Deposit" &&
+        checkFAOwner(tx, event, address)
+      ) {
+        coin_id = getResourceAddress(tx, event, "deposit_events", getEventFAAddress);
+        amount_in = amount_in.plus(event.data.amount);
+      } else if (event.type === "0x1::transaction_fee::FeeStatement" && tx.sender === address) {
+        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 };
+      }
+    });
+  }
+
+  return { coin_id, amount_in, amount_out, type };
 }

package/src/logic/staking.ts

@@ -0,0 +1,105 @@
+import BigNumber from "bignumber.js";
+import { Unit } from "@ledgerhq/types-cryptoassets";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
+import {
+  AptosAccount,
+  AptosMappedStakingPosition,
+  AptosStakingPosition,
+  AptosValidator,
+} from "../types";
+import { MIN_COINS_ON_SHARES_POOL_IN_OCTAS } from "../constants";
+import { getMaxSendBalance } from "../bridge/logic";
+
+export const mapStakingPositions = (
+  stakingPositions: AptosStakingPosition[],
+  validators: AptosValidator[],
+  unit: Unit,
+): AptosMappedStakingPosition[] => {
+  return stakingPositions.map(sp => {
+    const rank = validators.findIndex(v => v.address === sp.validatorId);
+    const validator = validators[rank] ?? sp;
+    const formatConfig = {
+      disableRounding: false,
+      alwaysShowSign: false,
+      showCode: true,
+    };
+
+    return {
+      ...sp,
+      formattedAmount: formatCurrencyUnit(unit, sp.active, formatConfig),
+      formattedPending: formatCurrencyUnit(unit, sp.pendingInactive, formatConfig),
+      formattedAvailable: formatCurrencyUnit(unit, sp.inactive, formatConfig),
+      rank,
+      validator,
+    };
+  });
+};
+
+export const canStake = (account: AptosAccount): boolean => {
+  return getMaxSendBalance(account) > MIN_COINS_ON_SHARES_POOL_IN_OCTAS;
+};
+
+export const canUnstake = (
+  stakingPosition: AptosMappedStakingPosition | AptosStakingPosition,
+): boolean => {
+  return stakingPosition.active.gt(0);
+};
+
+export const canWithdraw = (
+  stakingPosition: AptosMappedStakingPosition | AptosStakingPosition,
+): boolean => {
+  return stakingPosition.inactive.gt(0);
+};
+
+export const canRestake = (
+  stakingPosition: AptosMappedStakingPosition | AptosStakingPosition,
+): boolean => {
+  return stakingPosition.pendingInactive.gt(0);
+};
+
+export const getStakingPosition = (account: AptosAccount, validatorAddress: string) =>
+  (account.aptosResources?.stakingPositions ?? []).find(
+    stakingPosition => stakingPosition.validatorId === validatorAddress,
+  );
+
+export const getDelegationOpMaxAmount = (
+  account: AptosAccount,
+  validatorAddress: string,
+  mode: string,
+): BigNumber => {
+  let maxAmount: BigNumber | undefined;
+
+  const stakingPosition = getStakingPosition(account, validatorAddress);
+
+  switch (mode) {
+    case "unstake":
+      maxAmount = stakingPosition?.active;
+      break;
+    case "withdraw":
+      maxAmount = stakingPosition?.inactive;
+      break;
+    case "restake":
+      maxAmount = stakingPosition?.pendingInactive;
+  }
+
+  if (maxAmount === undefined || maxAmount.lt(0)) {
+    return new BigNumber(0);
+  }
+
+  return maxAmount;
+};
+
+export const formatUnlockTime = (epochSecs: string): string => {
+  const unlockTime = parseInt(epochSecs, 10) * 1000; // Convert to ms
+  const now = Date.now();
+  const diffMs = unlockTime - now;
+
+  if (diffMs <= 0) return "Unlocked";
+
+  const totalMinutes = Math.floor(diffMs / (1000 * 60));
+  const days = Math.floor(totalMinutes / (60 * 24));
+  const hours = Math.floor((totalMinutes % (60 * 24)) / 60);
+  const minutes = totalMinutes % 60;
+
+  return `${days}d ${hours}h ${minutes}m`;
+};

package/src/logic/transactionsToOperations.ts

@@ -3,7 +3,7 @@ import { Operation } from "@ledgerhq/coin-framework/api/types";
 import { AptosAsset } from "../types/assets";
 import BigNumber from "bignumber.js";
 import { EntryFunctionPayloadResponse, InputEntryFunctionData } from "@aptos-labs/ts-sdk";
-import { APTOS_ASSET_ID, DIRECTION } from "../constants";
+import { APTOS_ASSET_ID, OP_TYPE } from "../constants";
 import { compareAddress, getCoinAndAmounts } from "./getCoinAndAmounts";
 import { calculateAmount } from "./calculateAmount";
 import { processRecipients } from "./processRecipients";
@@ -18,12 +18,12 @@ export const convertFunctionPayloadResponseToInputEntryFunctionData = (
   functionArguments: payload.arguments,
 });
 
-const detectType = (address: string, tx: AptosTransaction, value: BigNumber): DIRECTION => {
-  let type = compareAddress(tx.sender, address) ? DIRECTION.OUT : DIRECTION.IN;
+const detectType = (address: string, tx: AptosTransaction, value: BigNumber): OP_TYPE => {
+  let type = compareAddress(tx.sender, address) ? OP_TYPE.OUT : OP_TYPE.IN;
 
   if (!value) {
     // skip transaction that result no Aptos change
-    type = DIRECTION.UNKNOWN;
+    type = OP_TYPE.UNKNOWN;
   }
 
   return type;
@@ -88,7 +88,7 @@ export function transactionsToOperations(
 
     processRecipients(payload, address, op, function_address);
 
-    if (op.type !== DIRECTION.UNKNOWN && coin_id !== null) {
+    if (op.type !== OP_TYPE.UNKNOWN && coin_id !== null) {
       if (coin_id === APTOS_ASSET_ID) {
         acc.push(op);
         return acc;