@ledgerhq/coin-aptos 1.9.6-next.0 → 1.10.0-nightly.0

package/src/__tests__/bridge/logic.test.ts

@@ -6,25 +6,35 @@ import {
 } from "@aptos-labs/ts-sdk";
 import type { Operation, OperationType } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
-import { APTOS_ASSET_ID, APTOS_COIN_CHANGE, DIRECTION } from "../../constants";
+import {
+  APTOS_ASSET_ID,
+  APTOS_COIN_CHANGE,
+  APTOS_FUNGIBLE_STORE,
+  APTOS_OBJECT_CORE,
+  DIRECTION,
+} from "../../constants";
 import {
   calculateAmount,
   compareAddress,
-  getAptosAmounts,
+  getCoinAndAmounts,
   getFunctionAddress,
-  isChangeOfAptos,
+  getResourceAddress,
   isTestnet,
   processRecipients,
   getMaxSendBalance,
   normalizeTransactionOptions,
   getBlankOperation,
   txsToOps,
+  getEventCoinAddress,
+  getEventFAAddress,
 } from "../../bridge/logic";
 import type { AptosTransaction, TransactionOptions } from "../../types";
+import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
+import { decodeTokenAccountId, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
 
-jest.mock("@ledgerhq/cryptoassets", () => ({
-  getCryptoCurrencyById: jest.fn(),
-}));
+jest.mock("@ledgerhq/cryptoassets");
+jest.mock("@ledgerhq/coin-framework/account/index");
 
 describe("Aptos logic ", () => {
   describe("isTestnet", () => {
@@ -40,41 +50,48 @@ describe("Aptos logic ", () => {
   describe("getMaxSendBalance", () => {
     it("should return the correct max send balance when amount is greater than total gas", () => {
       const amount = new BigNumber(1000000);
+      const account = createFixtureAccount({ balance: amount, spendableBalance: amount });
+      const transaction = createFixtureTransaction();
       const gas = new BigNumber(200);
       const gasPrice = new BigNumber(100);
-      const result = getMaxSendBalance(amount, gas, gasPrice);
+      const result = getMaxSendBalance(gas, gasPrice, account, transaction);
       expect(result.isEqualTo(amount.minus(gas.multipliedBy(gasPrice)))).toBe(true);
     });
 
     it("should return zero when amount is less than total gas", () => {
-      const amount = new BigNumber(1000);
+      const account = createFixtureAccount();
+      const transaction = createFixtureTransaction();
       const gas = new BigNumber(200);
       const gasPrice = new BigNumber(100);
-      const result = getMaxSendBalance(amount, gas, gasPrice);
+      const result = getMaxSendBalance(gas, gasPrice, account, transaction);
       expect(result.isEqualTo(new BigNumber(0))).toBe(true);
     });
 
     it("should return zero when amount is equal to total gas", () => {
-      const amount = new BigNumber(20000);
+      const account = createFixtureAccount();
+      const transaction = createFixtureTransaction();
       const gas = new BigNumber(200);
       const gasPrice = new BigNumber(100);
-      const result = getMaxSendBalance(amount, gas, gasPrice);
+      const result = getMaxSendBalance(gas, gasPrice, account, transaction);
       expect(result.isEqualTo(new BigNumber(0))).toBe(true);
     });
 
     it("should handle zero amount", () => {
-      const amount = new BigNumber(0);
+      const account = createFixtureAccount();
+      const transaction = createFixtureTransaction();
       const gas = new BigNumber(200);
       const gasPrice = new BigNumber(100);
-      const result = getMaxSendBalance(amount, gas, gasPrice);
+      const result = getMaxSendBalance(gas, gasPrice, account, transaction);
       expect(result.isEqualTo(new BigNumber(0))).toBe(true);
     });
 
     it("should handle zero gas and gas price", () => {
       const amount = new BigNumber(1000000);
+      const account = createFixtureAccount({ balance: amount, spendableBalance: amount });
+      const transaction = createFixtureTransaction();
       const gas = new BigNumber(0);
       const gasPrice = new BigNumber(0);
-      const result = getMaxSendBalance(amount, gas, gasPrice);
+      const result = getMaxSendBalance(gas, gasPrice, account, transaction);
       expect(result.isEqualTo(amount)).toBe(true);
     });
   });
@@ -114,7 +131,7 @@ describe("Aptos logic ", () => {
         version: "1",
       } as unknown as AptosTransaction;
 
-      const id = "test-id";
+      const id = "test_id";
       const result = getBlankOperation(tx, id);
 
       expect(result).toEqual({
@@ -142,7 +159,7 @@ describe("Aptos logic ", () => {
         sequence_number: "1",
       } as unknown as AptosTransaction;
 
-      const id = "test-id";
+      const id = "test_id";
       const result = getBlankOperation(tx, id);
 
       expect(result).toEqual({
@@ -292,10 +309,21 @@ describe("Aptos sync logic ", () => {
       processRecipients(payload, "0x11", op, "0x2");
       expect(op.recipients).toContain("0x2");
     });
+
+    it("should add recipient for fungible assets transfer-like functions", () => {
+      const payload: InputEntryFunctionData = {
+        function: "0x1::primary_fungible_store::transfer",
+        typeArguments: [],
+        functionArguments: [["0xfff"], "0x13"],
+      };
+
+      processRecipients(payload, "0x13", op, "0x1");
+      expect(op.recipients).toContain("0x13");
+    });
   });
 
-  describe("isChangeOfAptos", () => {
-    it("should return true for a valid change of Aptos", () => {
+  describe("getResourceAddress", () => {
+    it("should return coin name from the change", () => {
       const change = {
         type: "write_resource",
         data: {
@@ -313,6 +341,15 @@ describe("Aptos sync logic ", () => {
         },
       } as unknown as WriteSetChange;
 
+      const tx: AptosTransaction = {
+        hash: "0x123",
+        block: { hash: "0xabc", height: 1 },
+        timestamp: "1000000",
+        sequence_number: "1",
+        version: "1",
+        changes: [change],
+      } as unknown as AptosTransaction;
+
       const event = {
         guid: {
           account_address: "0x11",
@@ -321,11 +358,11 @@ describe("Aptos sync logic ", () => {
         type: "0x1::coin::WithdrawEvent",
       } as Event;
 
-      const result = isChangeOfAptos(change, event, "withdraw_events");
-      expect(result).toBe(true);
+      const result = getResourceAddress(tx, event, "withdraw_events", getEventCoinAddress);
+      expect(result).toEqual(APTOS_ASSET_ID);
     });
 
-    it("should return false for an invalid change of Aptos", () => {
+    it("should return null for not finding the valid coin in change", () => {
       const change = {
         type: "write_resource",
         data: {
@@ -343,6 +380,15 @@ describe("Aptos sync logic ", () => {
         },
       } as unknown as WriteSetChange;
 
+      const tx: AptosTransaction = {
+        hash: "0x123",
+        block: { hash: "0xabc", height: 1 },
+        timestamp: "1000000",
+        sequence_number: "1",
+        version: "1",
+        changes: [change],
+      } as unknown as AptosTransaction;
+
       const event = {
         guid: {
           account_address: "0x11",
@@ -351,107 +397,169 @@ describe("Aptos sync logic ", () => {
         type: "0x1::coin::WithdrawEvent",
       } as Event;
 
-      const result = isChangeOfAptos(change, event, "withdraw_events");
-      expect(result).toBe(false);
+      const result = getResourceAddress(tx, event, "withdraw_events", getEventCoinAddress);
+      expect(result).toBe(null);
     });
 
-    it("should return false for a change with a different WriteSet type", () => {
+    it("should return null for not finding the event name in change", () => {
       const change = {
-        type: "write_module",
-        data: {},
+        type: "write_resource",
+        data: {
+          type: APTOS_COIN_CHANGE,
+          data: {
+            other_events: {
+              guid: {
+                id: {
+                  addr: "0x12",
+                  creation_num: "2",
+                },
+              },
+            },
+          },
+        },
       } as unknown as WriteSetChange;
 
+      const tx: AptosTransaction = {
+        hash: "0x123",
+        block: { hash: "0xabc", height: 1 },
+        timestamp: "1000000",
+        sequence_number: "1",
+        version: "1",
+        changes: [change],
+      } as unknown as AptosTransaction;
+
       const event = {
         guid: {
-          account_address: "0x1",
+          account_address: "0x11",
           creation_number: "1",
         },
         type: "0x1::coin::WithdrawEvent",
       } as Event;
 
-      const result = isChangeOfAptos(change, event, "withdraw_events");
-      expect(result).toBe(false);
+      const result = getResourceAddress(tx, event, "withdraw_events", getEventCoinAddress);
+      expect(result).toBe(null);
     });
 
-    it("should return false if no data in WriteSet Change", () => {
+    it("should return fungible asset address", () => {
       const change = {
         type: "write_resource",
+        address: "0xsomeaddress",
+        data: {
+          type: APTOS_FUNGIBLE_STORE,
+          data: {
+            metadata: {
+              inner: "0xassetaddress",
+            },
+          },
+        },
       } as unknown as WriteSetChange;
 
+      const tx: AptosTransaction = {
+        hash: "0x123",
+        block: { hash: "0xabc", height: 1 },
+        timestamp: "1000000",
+        sequence_number: "1",
+        version: "1",
+        changes: [change],
+      } as unknown as AptosTransaction;
+
       const event = {
         guid: {
-          account_address: "0x11",
-          creation_number: "2",
+          account_address: "0x0",
+          creation_number: "0",
+        },
+        type: "0x1::fungible_asset::Deposit",
+        data: {
+          amount: "100",
+          store: "0xsomeaddress",
         },
-        type: "0x1::coin::WithdrawEvent",
       } as Event;
 
-      const result = isChangeOfAptos(change, event, "withdraw_events");
-      expect(result).toBe(false);
+      const result = getResourceAddress(tx, event, "withdraw_events", getEventFAAddress);
+      expect(result).toEqual("0xassetaddress");
     });
 
-    it("should return false if no type in change data", () => {
+    it("should return null address instead of fungible asset when wrong type", () => {
       const change = {
         type: "write_resource",
+        address: "0xsomeaddress",
         data: {
+          type: APTOS_COIN_CHANGE,
           data: {
-            withdraw_events: {
-              guid: {
-                id: {
-                  addr: "0x11",
-                  creation_num: "2",
-                },
-              },
+            metadata: {
+              inner: "0xassetaddress",
             },
           },
         },
       } as unknown as WriteSetChange;
 
+      const tx: AptosTransaction = {
+        hash: "0x123",
+        block: { hash: "0xabc", height: 1 },
+        timestamp: "1000000",
+        sequence_number: "1",
+        version: "1",
+        changes: [change],
+      } as unknown as AptosTransaction;
+
       const event = {
         guid: {
-          account_address: "0x11",
-          creation_number: "2",
+          account_address: "0x0",
+          creation_number: "0",
+        },
+        type: "0x1::fungible_asset::Deposit",
+        data: {
+          amount: "100",
+          store: "0xsomeaddress",
         },
-        type: "0x1::coin::WithdrawEvent",
       } as Event;
 
-      const result = isChangeOfAptos(change, event, "withdraw_events");
-      expect(result).toBe(false);
+      const result = getResourceAddress(tx, event, "withdraw_events", getEventFAAddress);
+      expect(result).toEqual(null);
     });
 
-    it("should return false for a change with a different WriteSet Change type", () => {
+    it("should return null address instead of fungible asset when wrong event address", () => {
       const change = {
         type: "write_resource",
+        address: "0xsomeaddress",
         data: {
-          type: "0x1::coin::CoinStore<0x1::aptos_coin::ANY_OTHER_COIN>",
+          type: APTOS_FUNGIBLE_STORE,
           data: {
-            withdraw_events: {
-              guid: {
-                id: {
-                  addr: "0x11",
-                  creation_num: "2",
-                },
-              },
+            metadata: {
+              inner: "0xassetaddress",
             },
           },
         },
       } as unknown as WriteSetChange;
 
+      const tx: AptosTransaction = {
+        hash: "0x123",
+        block: { hash: "0xabc", height: 1 },
+        timestamp: "1000000",
+        sequence_number: "1",
+        version: "1",
+        changes: [change],
+      } as unknown as AptosTransaction;
+
       const event = {
         guid: {
-          account_address: "0x11",
-          creation_number: "2",
+          account_address: "0x0",
+          creation_number: "0",
+        },
+        type: "0x1::fungible_asset::Deposit",
+        data: {
+          amount: "100",
+          store: "0xwrongaddress",
         },
-        type: "0x1::coin::WithdrawEvent",
       } as Event;
 
-      const result = isChangeOfAptos(change, event, "withdraw_events");
-      expect(result).toBe(false);
+      const result = getResourceAddress(tx, event, "withdraw_events", getEventFAAddress);
+      expect(result).toEqual(null);
     });
   });
 
-  describe("getAptosAmounts", () => {
-    it("should calculate the correct amounts for withdraw and deposit events", () => {
+  describe("getCoinAndAmounts", () => {
+    it("should calculate the correct legacy coins amounts for withdraw and deposit events", () => {
       const tx = {
         events: [
           {
@@ -504,37 +612,78 @@ describe("Aptos sync logic ", () => {
       } as unknown as AptosTransaction;
 
       const address = "0x11";
-      const result = getAptosAmounts(tx, address);
+      const result = getCoinAndAmounts(tx, address);
 
       expect(result.amount_in).toEqual(new BigNumber(50));
       expect(result.amount_out).toEqual(new BigNumber(100));
+      expect(result.coin_id).toEqual(APTOS_ASSET_ID);
     });
 
-    it("should return zero amounts if no matching events are found", () => {
+    it("should calculate the correct fungible asset amounts for withdraw and deposit events", () => {
       const tx = {
         events: [
           {
-            type: "0x1::coin::WithdrawEvent",
+            type: "0x1::fungible_asset::Withdraw",
             guid: {
               account_address: "0x11",
               creation_number: "1",
             },
             data: {
               amount: "100",
+              store: "0x22",
             },
           },
           {
-            type: "0x1::coin::DepositEvent",
+            type: "0x1::fungible_asset::Deposit",
             guid: {
               account_address: "0x11",
               creation_number: "2",
             },
             data: {
               amount: "50",
+              store: "0x33",
             },
           },
         ],
         changes: [
+          {
+            type: "write_resource",
+            address: "0x22",
+            data: {
+              type: APTOS_FUNGIBLE_STORE,
+              data: {
+                metadata: {
+                  inner: "0x44",
+                },
+                transfer_events: {
+                  guid: {
+                    id: {
+                      addr: "0x11",
+                      creation_num: "2",
+                    },
+                  },
+                },
+              },
+            },
+          },
+          {
+            type: "write_resource",
+            address: "0x22",
+            data: {
+              type: APTOS_OBJECT_CORE,
+              data: {
+                owner: "0x11",
+                transfer_events: {
+                  guid: {
+                    id: {
+                      addr: "0x22",
+                      creation_num: "2",
+                    },
+                  },
+                },
+              },
+            },
+          },
           {
             type: "write_resource",
             data: {
@@ -543,7 +692,7 @@ describe("Aptos sync logic ", () => {
                 withdraw_events: {
                   guid: {
                     id: {
-                      addr: "0x12", // should fail by address check
+                      addr: "0x11",
                       creation_num: "1",
                     },
                   },
@@ -552,7 +701,7 @@ describe("Aptos sync logic ", () => {
                   guid: {
                     id: {
                       addr: "0x11",
-                      creation_num: "3", // should fail by number check
+                      creation_num: "2",
                     },
                   },
                 },
@@ -563,10 +712,11 @@ describe("Aptos sync logic ", () => {
       } as unknown as AptosTransaction;
 
       const address = "0x11";
-      const result = getAptosAmounts(tx, address);
+      const result = getCoinAndAmounts(tx, address);
 
       expect(result.amount_in).toEqual(new BigNumber(0));
-      expect(result.amount_out).toEqual(new BigNumber(0));
+      expect(result.amount_out).toEqual(new BigNumber(100));
+      expect(result.coin_id).toEqual("0x44");
     });
 
     it("should handle transactions with other events", () => {
@@ -586,10 +736,11 @@ describe("Aptos sync logic ", () => {
       } as unknown as AptosTransaction;
 
       const address = "0x1";
-      const result = getAptosAmounts(tx, address);
+      const result = getCoinAndAmounts(tx, address);
 
       expect(result.amount_in).toEqual(new BigNumber(0));
       expect(result.amount_out).toEqual(new BigNumber(0));
+      expect(result.coin_id).toEqual(null);
     });
   });
 
@@ -597,24 +748,22 @@ describe("Aptos sync logic ", () => {
     it("should calculate the correct amount when the address is the sender", () => {
       const address = "0x11";
       const sender = "0x11";
-      const fee = new BigNumber(10); // account pays fees
       const amount_in = new BigNumber(50);
       const amount_out = new BigNumber(100);
 
-      const result = calculateAmount(sender, address, fee, amount_in, amount_out);
+      const result = calculateAmount(sender, address, amount_in, amount_out);
 
       // LL negates the amount for SEND transactions during output
-      expect(result).toEqual(new BigNumber(60)); // -(50 - 100 - 10)
+      expect(result).toEqual(new BigNumber(50)); // -(50 - 100 - 10)
     });
 
     it("should calculate the correct amount when the address is not the sender", () => {
       const address = "0x11";
       const sender = "0x12";
-      const fee = new BigNumber(10); // sender pays fees
       const amount_in = new BigNumber(100);
       const amount_out = new BigNumber(50);
 
-      const result = calculateAmount(sender, address, fee, amount_in, amount_out);
+      const result = calculateAmount(sender, address, amount_in, amount_out);
 
       expect(result).toEqual(new BigNumber(50)); // 100 - 50
     });
@@ -622,34 +771,32 @@ describe("Aptos sync logic ", () => {
     it("should handle transactions with zero amounts", () => {
       const address = "0x11";
       const sender = "0x11";
-      const fee = new BigNumber(10);
       const amount_in = new BigNumber(0);
       const amount_out = new BigNumber(0);
 
-      const result = calculateAmount(sender, address, fee, amount_in, amount_out);
+      const result = calculateAmount(sender, address, amount_in, amount_out);
 
       // LL negates the amount for SEND transactions during output
-      expect(result).toEqual(new BigNumber(10)); // -(0 - 0 - 10)
+      expect(result).toEqual(new BigNumber(0)); // -(0 - 0 - 10)
     });
 
     it("should get negative numbers (for send tx with deposit to account)", () => {
       const address = "0x11";
       const sender = "0x11";
-      const fee = new BigNumber(10);
       const amount_in = new BigNumber(100);
       const amount_out = new BigNumber(0);
 
-      const result = calculateAmount(sender, address, fee, amount_in, amount_out);
+      const result = calculateAmount(sender, address, amount_in, amount_out);
 
       // LL negates the amount for SEND transactions during output
-      expect(result).toEqual(new BigNumber(90).negated()); // 100 - 10
+      expect(result).toEqual(new BigNumber(100).negated()); // 100 - 10
     });
   });
 
   describe("txsToOps", () => {
-    it("should convert transactions to operations correctly", () => {
+    it("should convert Aptos transactions to operations correctly", () => {
       const address = "0x11";
-      const id = "test-id";
+      const id = "test_id";
       const txs: AptosTransaction[] = [
         {
           hash: "0x123",
@@ -717,14 +864,14 @@ describe("Aptos sync logic ", () => {
         } as unknown as AptosTransaction,
       ];
 
-      const result = txsToOps({ address }, id, txs);
+      const [result] = txsToOps({ address }, id, txs);
 
       expect(result).toHaveLength(1);
       expect(result[0]).toEqual({
         id: expect.any(String),
         hash: "0x123",
         type: DIRECTION.OUT,
-        value: new BigNumber(20100),
+        value: new BigNumber(100),
         fee: new BigNumber(20000),
         blockHash: "0xabc",
         blockHeight: 1,
@@ -740,7 +887,7 @@ describe("Aptos sync logic ", () => {
 
     it("should skip transactions without functions in payload", () => {
       const address = "0x11";
-      const id = "test-id";
+      const id = "test_id";
       const txs: AptosTransaction[] = [
         {
           hash: "0x123",
@@ -749,12 +896,6 @@ describe("Aptos sync logic ", () => {
           gas_unit_price: "100",
           success: true,
           payload: {} as EntryFunctionPayloadResponse,
-          // payload: {
-          //   type: "entry_function_payload",
-          //   function: "0x1::coin::transfer",
-          //   type_arguments: [],
-          //   arguments: ["0x12", 100],
-          // } as EntryFunctionPayloadResponse,
           events: [],
           changes: [],
           block: { hash: "0xabc", height: 1 },
@@ -763,14 +904,14 @@ describe("Aptos sync logic ", () => {
         } as unknown as AptosTransaction,
       ];
 
-      const result = txsToOps({ address }, id, txs);
+      const [result] = txsToOps({ address }, id, txs);
 
       expect(result).toHaveLength(0);
     });
 
     it("should skip transactions that result in no Aptos change", () => {
       const address = "0x11";
-      const id = "test-id";
+      const id = "test_id";
       const txs: AptosTransaction[] = [
         {
           hash: "0x123",
@@ -792,73 +933,719 @@ describe("Aptos sync logic ", () => {
         } as unknown as AptosTransaction,
       ];
 
-      const result = txsToOps({ address }, id, txs);
+      const [result] = txsToOps({ address }, id, txs);
 
       expect(result).toHaveLength(0);
     });
 
     it("should handle failed transactions", () => {
-      const address = "0x11";
-      const id = "test-id";
+      const address = "0xa0d8";
+      const id = "test_id";
       const txs: AptosTransaction[] = [
         {
-          hash: "0x123",
-          sender: "0x11",
+          hash: "0x0189",
+          sender: "0xa0d8",
           gas_used: "200",
           gas_unit_price: "100",
           success: false,
           payload: {
-            type: "entry_function_payload",
             function: "0x1::coin::transfer",
-            type_arguments: [],
-            arguments: ["0x12", 100],
+            type_arguments: ["0xd111::staked_coin::StakedAptos"],
+            arguments: ["0x4e5e", "50000000"],
+            type: "entry_function_payload",
           } as EntryFunctionPayloadResponse,
           events: [
             {
-              type: "0x1::coin::WithdrawEvent",
               guid: {
-                account_address: "0x11",
-                creation_number: "1",
+                creation_number: "0",
+                account_address: "0x0",
               },
+              sequence_number: "0",
+              type: "0x1::transaction_fee::FeeStatement",
               data: {
-                amount: "100",
+                execution_gas_units: "5",
+                io_gas_units: "4",
+                storage_fee_octas: "0",
+                storage_fee_refund_octas: "0",
+                total_charge_gas_units: "8",
               },
             },
+          ],
+          changes: [
             {
+              address: "0xa0d8",
+              state_key_hash: "0x1709",
+              data: {
+                type: "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>",
+                data: {
+                  coin: {
+                    value: "573163341",
+                  },
+                  deposit_events: {
+                    counter: "45",
+                    guid: {
+                      id: {
+                        addr: "0xa0d8",
+                        creation_num: "2",
+                      },
+                    },
+                  },
+                  frozen: false,
+                  withdraw_events: {
+                    counter: "82",
+                    guid: {
+                      id: {
+                        addr: "0xa0d8",
+                        creation_num: "3",
+                      },
+                    },
+                  },
+                },
+              },
+              type: "write_resource",
+            },
+            {
+              address: "0xa0d8",
+              state_key_hash: "0x6f1e",
+              data: {
+                type: "0x1::account::Account",
+                data: {
+                  authentication_key: "0xa0d8",
+                  coin_register_events: {
+                    counter: "5",
+                    guid: {
+                      id: {
+                        addr: "0xa0d8",
+                        creation_num: "0",
+                      },
+                    },
+                  },
+                  guid_creation_num: "12",
+                  key_rotation_events: {
+                    counter: "0",
+                    guid: {
+                      id: {
+                        addr: "0xa0d8",
+                        creation_num: "1",
+                      },
+                    },
+                  },
+                  rotation_capability_offer: {
+                    for: {
+                      vec: [],
+                    },
+                  },
+                  sequence_number: "83",
+                  signer_capability_offer: {
+                    for: {
+                      vec: [],
+                    },
+                  },
+                },
+              },
+              type: "write_resource",
+            },
+            {
+              state_key_hash: "0x6e4b",
+              handle: "0x1b85",
+              key: "0x0619",
+              value: "0x72c5e483c25c96010000000000000000",
+              data: null,
+              type: "write_table_item",
+            },
+          ],
+          block: {
+            hash: "0xc496",
+            height: 1,
+          },
+          timestamp: "1000000",
+          sequence_number: "1",
+        } as unknown as AptosTransaction,
+      ];
+
+      const [result] = txsToOps({ address }, id, txs);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        id: expect.any(String),
+        hash: "0x0189",
+        type: DIRECTION.OUT,
+        value: new BigNumber(20000),
+        fee: new BigNumber(20000),
+        blockHash: "0xc496",
+        blockHeight: 1,
+        senders: ["0xa0d8"],
+        recipients: ["0x4e5e"],
+        accountId: id,
+        date: new Date(1000),
+        extra: { version: undefined },
+        transactionSequenceNumber: 1,
+        hasFailed: true,
+      });
+    });
+
+    it("should convert Aptos token transactions to operations correctly", () => {
+      (findTokenByAddressInCurrency as jest.Mock).mockReturnValue({
+        type: "TokenCurrency",
+        id: "aptos/coin/dstapt::staked_coin::stakedaptos",
+        contractAddress: "0xd111::staked_coin::StakedAptos",
+        parentCurrency: {
+          type: "CryptoCurrency",
+          id: "aptos",
+          coinType: 637,
+          name: "Aptos",
+          managerAppName: "Aptos",
+          ticker: "APT",
+          scheme: "aptos",
+          color: "#231F20",
+          family: "aptos",
+          units: [
+            {
+              name: "APT",
+              code: "APT",
+              magnitude: 8,
+            },
+          ],
+          explorerViews: [
+            {
+              address: "https://explorer.aptoslabs.com/account/$address?network=mainnet",
+              tx: "https://explorer.aptoslabs.com/txn/$hash?network=mainnet",
+            },
+          ],
+        },
+        name: "dstAPT",
+        tokenType: "coin",
+        ticker: "dstAPT",
+        disableCountervalue: false,
+        delisted: false,
+        units: [
+          {
+            name: "dstAPT",
+            code: "dstAPT",
+            magnitude: 8,
+          },
+        ],
+      });
+
+      jest.mock("../../bridge/logic", () => ({
+        ...jest.requireActual("../../bridge/logic"),
+        getResourceAddress: jest.fn().mockReturnValue("0xd111::staked_coin::StakedAptos"),
+      }));
+
+      (decodeTokenAccountId as jest.Mock).mockReturnValue({
+        accountId: "token_account_id",
+      });
+
+      const address = "0xa0d";
+      const id = "test_id";
+      const txs: AptosTransaction[] = [
+        {
+          hash: "0x123",
+          sender: address,
+          gas_used: "200",
+          gas_unit_price: "100",
+          success: true,
+          payload: {
+            function: "0x1::aptos_account::transfer_coins",
+            type_arguments: ["0xd111::staked_coin::StakedAptos"],
+            arguments: ["0x4e5", "1500000"],
+            type: "entry_function_payload",
+          } as EntryFunctionPayloadResponse,
+          events: [
+            {
+              guid: {
+                creation_number: "11",
+                account_address: "0xa0d",
+              },
+              sequence_number: "12",
+              type: "0x1::coin::WithdrawEvent",
+              data: {
+                amount: "1500000",
+              },
+            },
+            {
+              guid: {
+                creation_number: "4",
+                account_address: "0x4e5",
+              },
+              sequence_number: "8",
               type: "0x1::coin::DepositEvent",
+              data: {
+                amount: "1500000",
+              },
+            },
+            {
               guid: {
-                account_address: "0x12",
-                creation_number: "2",
+                creation_number: "0",
+                account_address: "0x0",
               },
+              sequence_number: "0",
+              type: "0x1::transaction_fee::FeeStatement",
               data: {
-                amount: "100",
+                execution_gas_units: "6",
+                io_gas_units: "6",
+                storage_fee_octas: "0",
+                storage_fee_refund_octas: "0",
+                total_charge_gas_units: "12",
               },
             },
           ],
           changes: [
             {
+              address: "0x4e5",
+              state_key_hash: "0x3c0",
+              data: {
+                type: "0x1::coin::CoinStore<0xd111::staked_coin::StakedAptos>",
+                data: {
+                  coin: {
+                    value: "4000000",
+                  },
+                  deposit_events: {
+                    counter: "9",
+                    guid: {
+                      id: {
+                        addr: "0x4e5",
+                        creation_num: "4",
+                      },
+                    },
+                  },
+                  frozen: false,
+                  withdraw_events: {
+                    counter: "6",
+                    guid: {
+                      id: {
+                        addr: "0x4e5",
+                        creation_num: "5",
+                      },
+                    },
+                  },
+                },
+              },
               type: "write_resource",
+            },
+            {
+              address: "0xa0d",
+              state_key_hash: "0x1709",
               data: {
-                type: APTOS_COIN_CHANGE,
+                type: "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>",
                 data: {
+                  coin: {
+                    value: "68254118",
+                  },
+                  deposit_events: {
+                    counter: "46",
+                    guid: {
+                      id: {
+                        addr: "0xa0d",
+                        creation_num: "2",
+                      },
+                    },
+                  },
+                  frozen: false,
                   withdraw_events: {
+                    counter: "89",
                     guid: {
                       id: {
-                        addr: "0x11",
+                        addr: "0xa0d",
+                        creation_num: "3",
+                      },
+                    },
+                  },
+                },
+              },
+              type: "write_resource",
+            },
+            {
+              address: "0xa0d",
+              state_key_hash: "0x5520",
+              data: {
+                type: "0x1::coin::CoinStore<0xd111::staked_coin::StakedAptos>",
+                data: {
+                  coin: {
+                    value: "1000000",
+                  },
+                  deposit_events: {
+                    counter: "7",
+                    guid: {
+                      id: {
+                        addr: "0xa0d",
+                        creation_num: "10",
+                      },
+                    },
+                  },
+                  frozen: false,
+                  withdraw_events: {
+                    counter: "13",
+                    guid: {
+                      id: {
+                        addr: "0xa0d",
+                        creation_num: "11",
+                      },
+                    },
+                  },
+                },
+              },
+              type: "write_resource",
+            },
+            {
+              address: "0xa0d",
+              state_key_hash: "0x6f1e",
+              data: {
+                type: "0x1::account::Account",
+                data: {
+                  authentication_key: "0xa0d",
+                  coin_register_events: {
+                    counter: "5",
+                    guid: {
+                      id: {
+                        addr: "0xa0d",
+                        creation_num: "0",
+                      },
+                    },
+                  },
+                  guid_creation_num: "12",
+                  key_rotation_events: {
+                    counter: "0",
+                    guid: {
+                      id: {
+                        addr: "0xa0d",
                         creation_num: "1",
                       },
                     },
                   },
+                  rotation_capability_offer: {
+                    for: {
+                      vec: [],
+                    },
+                  },
+                  sequence_number: "122",
+                  signer_capability_offer: {
+                    for: {
+                      vec: [],
+                    },
+                  },
+                },
+              },
+              type: "write_resource",
+            },
+            {
+              state_key_hash: "0x6e4b",
+              handle: "0x1b85",
+              key: "0x0619",
+              value: "0x1ddaf8da3b1497010000000000000000",
+              data: null,
+              type: "write_table_item",
+            },
+          ],
+          block: { hash: "0xabc", height: 1 },
+          timestamp: "1000000",
+          sequence_number: "1",
+        } as unknown as AptosTransaction,
+      ];
+
+      const [ops, tokenOps] = txsToOps({ address }, id, txs);
+
+      expect(ops).toHaveLength(1);
+      expect(ops[0]).toEqual({
+        id: expect.any(String),
+        hash: "0x123",
+        type: "FEES",
+        value: new BigNumber(20000),
+        fee: new BigNumber(20000),
+        blockHash: "0xabc",
+        blockHeight: 1,
+        senders: ["0xa0d"],
+        recipients: ["0x4e5"],
+        accountId: "token_account_id",
+        date: new Date(1000),
+        extra: { version: undefined },
+        transactionSequenceNumber: 1,
+        hasFailed: false,
+      });
+
+      expect(tokenOps).toHaveLength(1);
+      expect(tokenOps[0]).toEqual({
+        id: expect.any(String),
+        hash: "0x123",
+        type: DIRECTION.OUT,
+        value: new BigNumber(1500000),
+        fee: new BigNumber(20000),
+        blockHash: "0xabc",
+        blockHeight: 1,
+        senders: ["0xa0d"],
+        recipients: ["0x4e5"],
+        date: new Date(1000),
+        extra: { version: undefined },
+        transactionSequenceNumber: 1,
+        hasFailed: false,
+      });
+    });
+
+    it("should convert Aptos token transactions to operations correctly", () => {
+      (findTokenByAddressInCurrency as jest.Mock).mockReturnValue({
+        type: "TokenCurrency",
+        id: "aptos/fungible_asset/cellana_0x2ebb2ccac5e027a87fa0e2e5f656a3a4238d6a48d93ec9b610d570fc0aa0df12",
+        contractAddress: "0x2ebb",
+        parentCurrency: {
+          type: "CryptoCurrency",
+          id: "aptos",
+          coinType: 637,
+          name: "Aptos",
+          managerAppName: "Aptos",
+          ticker: "APT",
+          scheme: "aptos",
+          color: "#231F20",
+          family: "aptos",
+          units: [
+            {
+              name: "APT",
+              code: "APT",
+              magnitude: 8,
+            },
+          ],
+          explorerViews: [
+            {
+              address: "https://explorer.aptoslabs.com/account/$address?network=mainnet",
+              tx: "https://explorer.aptoslabs.com/txn/$hash?network=mainnet",
+            },
+          ],
+        },
+        name: "CELLANA",
+        tokenType: "fungible_asset",
+        ticker: "CELL",
+        disableCountervalue: false,
+        delisted: false,
+        units: [
+          {
+            name: "CELLANA",
+            code: "CELL",
+            magnitude: 8,
+          },
+        ],
+      });
+
+      jest.mock("../../bridge/logic", () => ({
+        ...jest.requireActual("../../bridge/logic"),
+        getResourceAddress: jest.fn().mockReturnValue("0x2ebb"),
+      }));
+
+      (encodeTokenAccountId as jest.Mock).mockReturnValue("token_account_id");
+
+      const txs: AptosTransaction[] = [
+        {
+          hash: "0x10c9",
+          sender: "0xa0d8",
+          gas_used: "200",
+          gas_unit_price: "100",
+          success: true,
+          payload: {
+            function: "0x1::primary_fungible_store::transfer",
+            type_arguments: ["0x1::fungible_asset::Metadata"],
+            arguments: [
+              {
+                inner: "0x2ebb",
+              },
+              "0x6b8c",
+              "193",
+            ],
+            type: "entry_function_payload",
+          } as EntryFunctionPayloadResponse,
+          events: [
+            {
+              guid: {
+                creation_number: "0",
+                account_address: "0x0",
+              },
+              sequence_number: "0",
+              type: "0x1::fungible_asset::Withdraw",
+              data: {
+                amount: "193",
+                store: "0xd475",
+              },
+            },
+            {
+              guid: {
+                creation_number: "0",
+                account_address: "0x0",
+              },
+              sequence_number: "0",
+              type: "0x1::fungible_asset::Deposit",
+              data: {
+                amount: "193",
+                store: "0xaaa9",
+              },
+            },
+            {
+              guid: {
+                creation_number: "0",
+                account_address: "0x0",
+              },
+              sequence_number: "0",
+              type: "0x1::transaction_fee::FeeStatement",
+              data: {
+                execution_gas_units: "4",
+                io_gas_units: "6",
+                storage_fee_octas: "0",
+                storage_fee_refund_octas: "0",
+                total_charge_gas_units: "10",
+              },
+            },
+          ],
+          changes: [
+            {
+              address: "0xaaa9",
+              state_key_hash: "0x9a17",
+              data: {
+                type: "0x1::fungible_asset::FungibleStore",
+                data: {
+                  balance: "10044959",
+                  frozen: false,
+                  metadata: {
+                    inner: "0x2ebb",
+                  },
+                },
+              },
+              type: "write_resource",
+            },
+            {
+              address: "0xaaa9",
+              state_key_hash: "0x9a17",
+              data: {
+                type: "0x1::object::ObjectCore",
+                data: {
+                  allow_ungated_transfer: false,
+                  guid_creation_num: "1125899906842625",
+                  owner: "0x6b8c",
+                  transfer_events: {
+                    counter: "0",
+                    guid: {
+                      id: {
+                        addr: "0xaaa9",
+                        creation_num: "1125899906842624",
+                      },
+                    },
+                  },
+                },
+              },
+              type: "write_resource",
+            },
+            {
+              address: "0xa0d8",
+              state_key_hash: "0x1709",
+              data: {
+                type: "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>",
+                data: {
+                  coin: {
+                    value: "98423118",
+                  },
                   deposit_events: {
+                    counter: "46",
                     guid: {
                       id: {
-                        addr: "0x12",
+                        addr: "0xa0d8",
                         creation_num: "2",
                       },
                     },
                   },
+                  frozen: false,
+                  withdraw_events: {
+                    counter: "88",
+                    guid: {
+                      id: {
+                        addr: "0xa0d8",
+                        creation_num: "3",
+                      },
+                    },
+                  },
+                },
+              },
+              type: "write_resource",
+            },
+            {
+              address: "0xa0d8",
+              state_key_hash: "0x6f1e",
+              data: {
+                type: "0x1::account::Account",
+                data: {
+                  authentication_key: "0xa0d8",
+                  coin_register_events: {
+                    counter: "5",
+                    guid: {
+                      id: {
+                        addr: "0xa0d8",
+                        creation_num: "0",
+                      },
+                    },
+                  },
+                  guid_creation_num: "12",
+                  key_rotation_events: {
+                    counter: "0",
+                    guid: {
+                      id: {
+                        addr: "0xa0d8",
+                        creation_num: "1",
+                      },
+                    },
+                  },
+                  rotation_capability_offer: {
+                    for: {
+                      vec: [],
+                    },
+                  },
+                  sequence_number: "108",
+                  signer_capability_offer: {
+                    for: {
+                      vec: [],
+                    },
+                  },
+                },
+              },
+              type: "write_resource",
+            },
+            {
+              address: "0xd475",
+              state_key_hash: "0x7567",
+              data: {
+                type: "0x1::fungible_asset::FungibleStore",
+                data: {
+                  balance: "14000",
+                  frozen: false,
+                  metadata: {
+                    inner: "0x2ebb",
+                  },
                 },
               },
+              type: "write_resource",
+            },
+            {
+              address: "0xd475",
+              state_key_hash: "0x7567",
+              data: {
+                type: "0x1::object::ObjectCore",
+                data: {
+                  allow_ungated_transfer: false,
+                  guid_creation_num: "1125899906842625",
+                  owner: "0xa0d8",
+                  transfer_events: {
+                    counter: "0",
+                    guid: {
+                      id: {
+                        addr: "0xd475",
+                        creation_num: "1125899906842624",
+                      },
+                    },
+                  },
+                },
+              },
+              type: "write_resource",
+            },
+            {
+              state_key_hash: "0x6e4b",
+              handle: "0x1b85",
+              key: "0x0619",
+              value: "0xad4388dc7daf96010000000000000000",
+              data: null,
+              type: "write_table_item",
             },
           ],
           block: { hash: "0xabc", height: 1 },
@@ -867,10 +1654,27 @@ describe("Aptos sync logic ", () => {
         } as unknown as AptosTransaction,
       ];
 
-      const result = txsToOps({ address }, id, txs);
+      const [ops, tokenOps] = txsToOps({ address: "0x6b8c" }, "test_id", txs);
 
-      expect(result).toHaveLength(1);
-      expect(result[0].hasFailed).toBe(true);
+      expect(ops).toHaveLength(0);
+
+      expect(tokenOps).toHaveLength(1);
+      expect(tokenOps[0]).toEqual({
+        id: expect.any(String),
+        accountId: "token_account_id",
+        hash: "0x10c9",
+        type: DIRECTION.IN,
+        value: new BigNumber(193),
+        fee: new BigNumber(20000),
+        blockHash: "0xabc",
+        blockHeight: 1,
+        senders: ["0xa0d8"],
+        recipients: ["0x6b8c"],
+        date: new Date(1000),
+        extra: { version: undefined },
+        transactionSequenceNumber: 1,
+        hasFailed: false,
+      });
     });
   });
 });