@ledgerhq/coin-sui 0.17.0-nightly.2 → 0.17.0-nightly.20251031023756

package/src/bridge/synchronisation.ts

@@ -10,13 +10,13 @@ import {
   type GetAccountShape,
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { type Operation } from "@ledgerhq/types-live";
-import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets/tokens";
 import { getAccountBalances, getOperations, getStakesRaw } from "../network";
-import { DEFAULT_COIN_TYPE } from "../network/sdk";
+import { AccountBalance, DEFAULT_COIN_TYPE } from "../network/sdk";
 import { SuiOperationExtra, SuiAccount } from "../types";
 import type { SyncConfig, TokenAccount } from "@ledgerhq/types-live";
 import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { promiseAllBatched } from "@ledgerhq/live-promise";
+import { getCryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/index";
 
 /**
  * Get the shape of the account including its operations and balance.
@@ -53,28 +53,28 @@ export const getAccountShape: GetAccountShape<SuiAccount> = async (info, syncCon
   );
 
   const accountBalances = await getAccountBalances(address);
-  const tokensCurrencies = listTokensForCryptoCurrency(currency);
-  const tokensCurrenciesMap = tokensCurrencies.reduce(
-    (acc, token) => {
-      acc[token.contractAddress] = token;
-      return acc;
-    },
-    {} as Record<string, (typeof tokensCurrencies)[0]>,
-  );
   const balance =
     accountBalances.find(({ coinType }) => coinType === DEFAULT_COIN_TYPE)?.balance ?? BigNumber(0);
-  const subAccountsBalances = accountBalances.filter(
-    ({ coinType }) => tokensCurrenciesMap[coinType],
-  );
+
+  const subAccountsBalances: AccountBalance[] = [];
+  for (const accountBalance of accountBalances) {
+    const token = await getCryptoAssetsStore().findTokenByAddressInCurrency(
+      accountBalance.coinType,
+      currency.id,
+    );
+    if (token) {
+      subAccountsBalances.push(accountBalance);
+    }
+  }
 
   const subAccounts =
     (await buildSubAccounts({
       accountId,
-      initialAccount,
       operations,
       subAccountsBalances,
       syncConfig,
-      tokensCurrenciesMap,
+      currencyId: currency.id,
+      subAccounts: initialAccount?.subAccounts ?? [],
     })) || [];
 
   return {
@@ -102,39 +102,41 @@ export const sync = makeSync({ getAccountShape, shouldMergeOps: false });
 
 async function buildSubAccounts({
   accountId,
-  initialAccount,
   operations,
   subAccountsBalances,
   syncConfig,
-  tokensCurrenciesMap,
+  currencyId,
+  subAccounts,
 }: {
   accountId: string;
-  initialAccount?: SuiAccount | null | undefined;
   operations: Operation[];
   subAccountsBalances: { coinType: string; blockHeight: number; balance: BigNumber }[];
   syncConfig: SyncConfig;
-  tokensCurrenciesMap: Record<string, TokenCurrency>;
+  currencyId: string;
+  subAccounts: TokenAccount[];
 }) {
-  if (Object.keys(tokensCurrenciesMap).length === 0) return undefined;
+  if (subAccountsBalances.length === 0) return undefined;
   const { blacklistedTokenIds = [] } = syncConfig;
   const tokenAccounts: TokenAccount[] = [];
   const existingAccountByTicker: { [ticker: string]: TokenAccount } = {}; // used for fast lookup
   const existingAccountTickers: string[] = []; // used to keep track of ordering
 
-  if (initialAccount?.subAccounts) {
-    for (const existingSubAccount of initialAccount.subAccounts) {
-      if (existingSubAccount.type === "TokenAccount") {
-        const { ticker, id } = existingSubAccount.token;
-        if (!blacklistedTokenIds.includes(id)) {
-          existingAccountTickers.push(ticker);
-          existingAccountByTicker[ticker] = existingSubAccount;
-        }
+  for (const existingSubAccount of subAccounts) {
+    if (existingSubAccount.type === "TokenAccount") {
+      const { ticker, id } = existingSubAccount.token;
+      if (!blacklistedTokenIds.includes(id)) {
+        existingAccountTickers.push(ticker);
+        existingAccountByTicker[ticker] = existingSubAccount;
       }
     }
   }
 
   await promiseAllBatched(3, subAccountsBalances, async accountBalance => {
-    const token = tokensCurrenciesMap[accountBalance.coinType];
+    const token = await getCryptoAssetsStore().findTokenByAddressInCurrency(
+      accountBalance.coinType,
+      currencyId,
+    );
+
     if (token && !blacklistedTokenIds.includes(token.id)) {
       const initialTokenAccount = existingAccountByTicker[token.ticker];
       const tokenAccount = await buildSubAccount({

package/src/logic/estimateFees.integration.test.ts

@@ -3,7 +3,7 @@ import { getFullnodeUrl } from "@mysten/sui/client";
 import coinConfig from "../config";
 import { estimateFees } from "./estimateFees";
 
-const SENDER = "0xad79719ac7edb44f6e253f1f771e8291e281a6aaf1e4789b52bf85336f525e8e";
+const SENDER = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
 const RECIPIENT = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
 
 describe("estimateFees", () => {

package/src/network/sdk.test.ts

@@ -7,6 +7,7 @@ import type {
   TransactionBlockData,
   SuiTransactionBlockResponse,
   SuiTransactionBlockKind,
+  PaginatedTransactionResponse,
 } from "@mysten/sui/client";
 import assert, { fail } from "assert";
 
@@ -2121,6 +2122,27 @@ describe("getCoinsForAmount", () => {
     });
   });
 
+  describe.only("dedup", () => {
+    const outs: PaginatedTransactionResponse = {
+      data: [],
+      hasNextPage: false,
+    };
+    const ins: PaginatedTransactionResponse = {
+      data: [],
+      hasNextPage: true,
+    };
+
+    test("handles no data in asc mode", async () => {
+      const r = sdk.dedupOperations(outs, ins, "asc");
+      expect(r.operations.length).toBe(0);
+    });
+
+    test("handles no data in desc mode", async () => {
+      const r = sdk.dedupOperations(outs, ins, "desc");
+      expect(r.operations.length).toBe(0);
+    });
+  });
+
   describe("pagination", () => {
     test("handles single page scenarios", async () => {
       const mockCoins = createMockCoins(["800", "400", "300"]);

package/src/network/sdk.ts

@@ -137,10 +137,16 @@ function isUnstaking(block?: SuiTransactionBlockKind): block is ProgrammableTran
   return hasMoveCallWithFunction("request_withdraw_stake", block);
 }
 
+export type AccountBalance = {
+  coinType: string;
+  blockHeight: number;
+  balance: BigNumber;
+};
+
 /**
  * Get account balance (native and tokens)
  */
-export const getAccountBalances = async (addr: string) => {
+export const getAccountBalances = async (addr: string): Promise<AccountBalance[]> => {
   const balances = await getAllBalancesCached(addr);
   return balances.map(({ coinType, totalBalance }) => ({
     coinType,
@@ -196,7 +202,18 @@ export const getOperationRecipients = (transaction?: TransactionBlockData): stri
         recipients.push(String(input.value));
       }
     });
-    if (isUnstaking(transaction.transaction) || isStaking(transaction.transaction)) return [];
+    if (isStaking(transaction.transaction)) {
+      const address = transaction.transaction.inputs.find(
+        (input: SuiCallArg) => "valueType" in input && input.valueType === "address",
+      );
+      if (address && address.type === "pure" && address.valueType === "address") {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        recipients.push(address.value as string);
+      }
+    }
+    if (isUnstaking(transaction.transaction)) {
+      return [];
+    }
     return recipients;
   }
   return [];
@@ -680,8 +697,8 @@ export const getListOperations = async (
   });
 
 const oldestOpTime = (ops: PaginatedTransactionResponse) =>
-  Number(ops.data[ops.data.length - 1].timestampMs ?? 0);
-const newestOpTime = (ops: PaginatedTransactionResponse) => Number(ops.data[0].timestampMs ?? 0);
+  Number(ops.data[ops.data.length - 1]?.timestampMs ?? 0);
+const newestOpTime = (ops: PaginatedTransactionResponse) => Number(ops.data[0]?.timestampMs ?? 0);
 
 /**
  * Some IN operations are also OUT operations because the sender receive a new version of the coin objects,

package/src/test/bridge.dataset.ts

@@ -31,6 +31,7 @@ const suiAccount1: AccountRaw = {
 };
 
 const sui: CurrenciesData<Transaction> = {
+  FIXME_ignorePreloadFields: ["tokens"],
   scanAccounts: [
     {
       name: "sui seed 1",

package/src/types/bridge.ts

@@ -15,6 +15,7 @@ export type MappedStake = StakeObject & {
   validator: SuiValidator;
   stakedSuiId: string;
   formattedAmount: string;
+  formattedEstimatedReward: string;
 };
 
 /**