@ledgerhq/coin-sui 0.2.0-nightly.0

package/src/bridge/preload.ts

@@ -0,0 +1,46 @@
+import { Observable, Subject } from "rxjs";
+import { log } from "@ledgerhq/logs";
+
+import type { SuiPreloadData } from "../types";
+
+const PRELOAD_MAX_AGE = 30 * 60 * 1000; // 30 minutes
+
+let currentPreloadedData: SuiPreloadData = {};
+
+function fromHydratePreloadData(_data: SuiPreloadData): SuiPreloadData {
+  return {};
+}
+
+const updates = new Subject<SuiPreloadData>();
+
+export function getCurrentSuiPreloadData(): SuiPreloadData {
+  return currentPreloadedData;
+}
+
+export function setSuiPreloadData(data: SuiPreloadData) {
+  if (data === currentPreloadedData) return;
+
+  currentPreloadedData = data;
+
+  updates.next(data);
+}
+
+export function getSuiPreloadDataUpdates(): Observable<SuiPreloadData> {
+  return updates.asObservable();
+}
+
+export const getPreloadStrategy = () => ({
+  preloadMaxAge: PRELOAD_MAX_AGE,
+});
+
+export const preload = async (): Promise<SuiPreloadData> => {
+  log("sui/preload", "preloading sui data...");
+
+  return {};
+};
+
+export const hydrate = (data: SuiPreloadData) => {
+  const hydrated = fromHydratePreloadData(data);
+
+  setSuiPreloadData(hydrated);
+};

package/src/bridge/prepareTransaction.test.ts

@@ -0,0 +1,47 @@
+import BigNumber from "bignumber.js";
+import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
+import prepareTransaction from "./prepareTransaction";
+import { faker } from "@faker-js/faker";
+
+const mockEstimateFees = jest.fn();
+jest.mock("../logic", () => ({
+  estimateFees: () => mockEstimateFees(),
+}));
+
+describe("prepareTransaction", () => {
+  afterEach(() => {
+    mockEstimateFees.mockClear();
+  });
+
+  it("returns a new Transaction with new fees", async () => {
+    // GIVEN
+    const fees = new BigNumber(faker.number.int(50));
+    mockEstimateFees.mockResolvedValue(fees);
+    const tx = createFixtureTransaction();
+
+    // WHEN
+    const newTx = await prepareTransaction(createFixtureAccount(), tx);
+
+    // THEN
+    expect(newTx.fees).toEqual(fees);
+    expect(newTx).not.toBe(tx);
+    expect(newTx).toMatchObject({
+      amount: tx.amount,
+      recipient: tx.recipient,
+      mode: tx.mode,
+    });
+  });
+
+  it("returns the passed transaction if fees are the same", async () => {
+    // GIVEN
+    const fees = new BigNumber(faker.number.int(50));
+    mockEstimateFees.mockResolvedValue(fees);
+    const tx = createFixtureTransaction({ fees });
+
+    // WHEN
+    const newTx = await prepareTransaction(createFixtureAccount(), tx);
+
+    // THEN
+    expect(newTx).toBe(tx);
+  });
+});

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,44 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { updateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import type { SuiAccount, Transaction } from "../types";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import getFeesForTransaction from "./getFeesForTransaction";
+import BigNumber from "bignumber.js";
+
+/**
+ * Calculate fees for the current transaction
+ * @function prepareTransaction
+ * @description Prepares a transaction by calculating the amount, fees, and validating the recipient address.
+ * @param {SuiAccount} account - The account from which the transaction is being prepared.
+ * @param {Transaction} transaction - The transaction object containing details such as amount, fees, and recipient.
+ * @returns {Promise<Transaction>} A promise that resolves to the updated transaction object.
+ */
+export const prepareTransaction: AccountBridge<
+  Transaction,
+  SuiAccount
+>["prepareTransaction"] = async (account, transaction) => {
+  let amount = transaction.amount;
+  const spendable = await estimateMaxSpendable({ account, transaction });
+  if (transaction.useAllAmount) {
+    amount = spendable;
+  }
+
+  let fees: BigNumber;
+  try {
+    fees = await getFeesForTransaction({
+      account,
+      transaction,
+    });
+  } catch (e) {
+    fees = BigNumber(0);
+  }
+
+  const patch: Partial<Transaction> = {
+    amount,
+    fees,
+  };
+
+  return updateTransaction(transaction, patch);
+};
+
+export default prepareTransaction;

package/src/bridge/serialization.test.ts

@@ -0,0 +1,135 @@
+import BigNumber from "bignumber.js";
+import {
+  toSuiResourcesRaw,
+  fromSuiResourcesRaw,
+  assignToAccountRaw,
+  assignFromAccountRaw,
+} from "./serialization";
+
+const account = {
+  type: "Account" as const,
+  id: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui",
+  used: true,
+  seedIdentifier: "99807c4b6e1b8b25120f633f5f7816a393e4d3e7f84bdf24bd8afe725911be91",
+  derivationMode: "sui" as const,
+  index: 0,
+  freshAddress: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+  freshAddressPath: "44'/784'/0'/0'/0'",
+  blockHeight: 10,
+  creationDate: new Date(),
+  balance: BigNumber(9998990120),
+  spendableBalance: BigNumber(9998990120),
+  operations: [
+    {
+      id: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui-DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt-IN",
+      hash: "DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt",
+      type: "IN" as const,
+      senders: ["0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24"],
+      recipients: ["0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0"],
+      accountId: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui",
+      blockHash: "DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt",
+      blockHeight: 5,
+      date: new Date(),
+      value: BigNumber(9998990120),
+      fee: BigNumber(1009880),
+      extra: {},
+      hasFailed: false,
+    },
+  ],
+  operationsCount: 1,
+  pendingOperations: [],
+  currency: {
+    type: "CryptoCurrency" as const,
+    id: "sui" as const,
+    coinType: 784,
+    name: "Sui",
+    managerAppName: "Sui",
+    ticker: "SUI",
+    scheme: "sui",
+    color: "#000",
+    family: "sui",
+    units: [{ name: "Sui", code: "SUI", magnitude: 9 }],
+    explorerViews: [
+      {
+        tx: "https://suiscan.xyz/mainnet/tx/$hash",
+        address: "https://suiscan.xyz/mainnet/account/$address",
+      },
+      {
+        tx: "https://suivision.xyz/txblock/$hash",
+        address: "https://suivision.xyz/account/$address",
+      },
+    ],
+  },
+  lastSyncDate: new Date(),
+  swapHistory: [],
+  balanceHistoryCache: {
+    HOUR: { balances: [0, 9998990120, 9998990120, 9998990120], latestDate: 1742302800000 },
+    DAY: { balances: [0], latestDate: 1742245200000 },
+    WEEK: { balances: [0], latestDate: 1742072400000 },
+  },
+  suiResources: {},
+};
+const accountRaw = {
+  id: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui",
+  seedIdentifier: "99807c4b6e1b8b25120f633f5f7816a393e4d3e7f84bdf24bd8afe725911be91",
+  used: true,
+  derivationMode: "sui" as const,
+  index: 0,
+  freshAddress: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+  freshAddressPath: "44'/784'/0'/0'/0'",
+  blockHeight: 10,
+  creationDate: "2025-03-18T10:40:54.878Z",
+  operationsCount: 1,
+  operations: [
+    {
+      id: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui-DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt-IN",
+      hash: "DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt",
+      type: "IN" as const,
+      senders: ["0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24"],
+      recipients: ["0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0"],
+      accountId: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui",
+      blockHash: "DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt",
+      blockHeight: 5,
+      extra: {},
+      date: "2025-03-18T10:40:54.878Z",
+      value: "9998990120",
+      fee: "1009880",
+      hasFailed: false,
+    },
+  ],
+  pendingOperations: [],
+  currencyId: "sui",
+  lastSyncDate: "2025-03-18T10:40:54.878Z",
+  balance: "9998990120",
+  spendableBalance: "9998990120",
+  balanceHistoryCache: {
+    HOUR: { balances: [0, 9998990120, 9998990120, 9998990120], latestDate: 1742302800000 },
+    DAY: { balances: [0], latestDate: 1742245200000 },
+    WEEK: { balances: [0], latestDate: 1742072400000 },
+  },
+  suiResources: {},
+};
+
+describe("serialization", () => {
+  test("toSuiResourcesRaw should convert SuiResources to SuiResourcesRaw", () => {
+    const resources = {};
+    const result = toSuiResourcesRaw(resources);
+    expect(result).toEqual({});
+  });
+
+  test("fromSuiResourcesRaw should convert SuiResourcesRaw to SuiResources", () => {
+    const resourcesRaw = {};
+    const result = fromSuiResourcesRaw(resourcesRaw);
+    expect(result).toEqual({});
+  });
+
+  test("assignToAccountRaw should assign SuiResources to AccountRaw", () => {
+    assignToAccountRaw(account, accountRaw);
+    expect(accountRaw.suiResources).toBeDefined();
+  });
+
+  test("assignFromAccountRaw should assign SuiResourcesRaw to Account", () => {
+    assignFromAccountRaw(accountRaw, account);
+    expect(account.suiResources).toBeDefined();
+  });
+});

package/src/bridge/serialization.ts

@@ -0,0 +1,24 @@
+import { Account, AccountRaw } from "@ledgerhq/types-live";
+import type { SuiAccount, SuiAccountRaw, SuiResourcesRaw, SuiResources } from "../types";
+
+export function toSuiResourcesRaw(_resources: SuiResources): SuiResourcesRaw {
+  return {};
+}
+
+export function fromSuiResourcesRaw(_resources: SuiResourcesRaw): SuiResources {
+  return {};
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw) {
+  const suiAccount = account as SuiAccount;
+  const suiAccountRaw = accountRaw as SuiAccountRaw;
+  if (suiAccount.suiResources) {
+    suiAccountRaw.suiResources = toSuiResourcesRaw(suiAccount.suiResources);
+  }
+}
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const suiResourcesRaw = (accountRaw as SuiAccountRaw).suiResources;
+  if (suiResourcesRaw) {
+    (account as SuiAccount).suiResources = fromSuiResourcesRaw(suiResourcesRaw);
+  }
+}

package/src/bridge/signOperation.test.ts

@@ -0,0 +1,80 @@
+import buildSignOperation from "./signOperation";
+import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
+import { SuiSigner } from "../types";
+import coinConfig from "../config";
+
+jest.mock("../config");
+const mockGetConfig = jest.mocked(coinConfig.getCoinConfig);
+
+describe("signOperation", () => {
+  const fakeSignature = new Uint8Array(64).fill(0x42);
+  const fakeSigner = {
+    getPublicKey: jest.fn().mockResolvedValue({
+      publicKey: new Uint8Array(32).fill(0x01),
+      address: "0x1234567890abcdef",
+    }),
+    signTransaction: jest.fn().mockResolvedValue({
+      signature: fakeSignature,
+    }),
+    getVersion: jest.fn().mockResolvedValue({ major: 0, minor: 1, patch: 0 }),
+    transport: {} as any,
+  } as unknown as SuiSigner;
+  const signerContext = <T>(_deviceId: string, fn: (signer: SuiSigner) => Promise<T>) =>
+    fn(fakeSigner);
+  const signOperation = buildSignOperation(signerContext);
+  const deviceId = "dummyDeviceId";
+
+  beforeAll(() => {
+    mockGetConfig.mockImplementation((): any => {
+      return {};
+    });
+  });
+
+  it("returns events in the right order", done => {
+    // GIVEN
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+
+    // WHEN & THEN
+    const expectedEvent = [
+      {
+        type: "device-signature-requested",
+      },
+      {
+        type: "device-signature-granted",
+      },
+      {
+        type: "signed",
+      },
+    ];
+    let eventIdx = 0;
+
+    signOperation({ account, deviceId, transaction }).forEach((e: { type: string }) => {
+      try {
+        expect(e.type).toEqual(expectedEvent[eventIdx].type);
+        eventIdx++;
+
+        if (eventIdx === expectedEvent.length) {
+          done();
+        }
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("throws an error of transaction has no fees", done => {
+    // GIVEN
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction({ fees: undefined });
+
+    // WHEN & THEN
+    const observer = {
+      error: (e: Error) => {
+        expect(e.name).toMatch("FeeNotLoaded");
+        done();
+      },
+    };
+    signOperation({ account, deviceId, transaction }).subscribe(observer);
+  });
+});

package/src/bridge/signOperation.ts

@@ -0,0 +1,101 @@
+import { BigNumber } from "bignumber.js";
+import { Observable } from "rxjs";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { messageWithIntent, toSerializedSignature } from "@mysten/sui/cryptography";
+import { Ed25519PublicKey } from "@mysten/sui/keypairs/ed25519";
+import { verifyTransactionSignature } from "@mysten/sui/verify";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { buildTransaction } from "./buildTransaction";
+import { calculateAmount } from "./utils";
+import type { SuiSignedOperation, SuiAccount, SuiSigner, Transaction } from "../types";
+import { ensureAddressFormat } from "../utils";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const buildSignOperation =
+  (
+    signerContext: SignerContext<SuiSigner>,
+  ): AccountBridge<Transaction, SuiAccount>["signOperation"] =>
+  ({ account, deviceId, transaction }) =>
+    new Observable(subscriber => {
+      async function main() {
+        subscriber.next({
+          type: "device-signature-requested",
+        });
+
+        if (!transaction.fees) {
+          throw new FeeNotLoaded();
+        }
+
+        // Ensure amount is filled when useAllAmount
+        const transactionToSign = {
+          ...transaction,
+          amount: calculateAmount({
+            account,
+            transaction,
+          }),
+        };
+
+        const { unsigned } = await buildTransaction(account, transactionToSign);
+
+        const signData = messageWithIntent("TransactionData", unsigned);
+
+        const { signature } = await signerContext(deviceId, signer =>
+          signer.signTransaction(account.freshAddressPath, signData),
+        );
+
+        const publicKeyResult = await signerContext(deviceId, signer =>
+          signer.getPublicKey(account.freshAddressPath),
+        );
+        const publicKey = new Ed25519PublicKey(publicKeyResult.publicKey);
+
+        const serializedSignature = toSerializedSignature({
+          signature,
+          signatureScheme: "ED25519",
+          publicKey,
+        });
+
+        if (!transaction.skipVerify) {
+          const verify = await verifyTransactionSignature(unsigned, serializedSignature, {
+            address: ensureAddressFormat(account.freshAddress),
+          });
+          if (!verify) {
+            throw new Error("verifyTransactionSignature failed");
+          }
+        }
+
+        subscriber.next({
+          type: "device-signature-granted",
+        });
+
+        const operation = buildOptimisticOperation(
+          account,
+          transactionToSign,
+          transactionToSign.fees ?? new BigNumber(0),
+        );
+
+        const signedOperation: SuiSignedOperation = {
+          operation,
+          signature: Buffer.from(signature).toString("base64"),
+          rawData: {
+            serializedSignature,
+            unsigned: Buffer.from(unsigned).toString("base64"),
+          },
+        };
+
+        subscriber.next({
+          type: "signed",
+          signedOperation,
+        });
+      }
+
+      main().then(
+        () => subscriber.complete(),
+        e => subscriber.error(e),
+      );
+    });
+
+export default buildSignOperation;

package/src/bridge/synchronisation.test.ts

@@ -0,0 +1,140 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import BigNumber from "bignumber.js";
+import { faker } from "@faker-js/faker";
+import { createFixtureAccount, createFixtureOperation } from "../types/bridge.fixture";
+
+import { getAccountShape } from "./synchronisation";
+
+const mockGetAccount = jest.fn();
+const mockGetOperations = jest.fn();
+jest.mock("../network", () => ({
+  getAccount: () => mockGetAccount(),
+  getOperations: () => mockGetOperations(),
+}));
+
+describe("getAccountShape", () => {
+  beforeEach(() => {
+    mockGetAccount.mockClear();
+    mockGetOperations.mockClear();
+  });
+
+  it("calls getAccount and getOperations", async () => {
+    // GIVEN
+    const initialAccount = undefined;
+    const accountInfo = createAccountInfo();
+    mockGetAccount.mockResolvedValue(accountInfo);
+    mockGetOperations.mockResolvedValue([]);
+
+    // WHEN
+    await getAccountShape(
+      {
+        index: -1, // not used but mandatory
+        derivationPath: "not used",
+        currency: getCryptoCurrencyById("sui"),
+        address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+        initialAccount,
+        derivationMode: "sui",
+      },
+      { paginationConfig: {} },
+    );
+
+    // THEN
+    expect(mockGetAccount).toHaveBeenCalledTimes(1);
+    expect(mockGetOperations).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns an AccountShapeInfo based on getAccount API", async () => {
+    // GIVEN
+    const initialAccount = undefined;
+    const accountInfo = createAccountInfo();
+    mockGetAccount.mockResolvedValue(accountInfo);
+    mockGetOperations.mockResolvedValue([]);
+
+    // WHEN
+    const shape = await getAccountShape(
+      {
+        index: -1, // not used but mandatory
+        derivationPath: "not used",
+        currency: getCryptoCurrencyById("sui"),
+        address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+        initialAccount,
+        derivationMode: "sui",
+      },
+      { paginationConfig: {} },
+    );
+
+    // THEN
+    expect(shape).toEqual({
+      id: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui",
+      balance: accountInfo.balance,
+      spendableBalance: accountInfo.balance,
+      blockHeight: accountInfo.blockHeight,
+      operations: [],
+      operationsCount: 0,
+      suiResources: {},
+    });
+  });
+
+  it("returns an AccountShapeInfo with operations from initialAccount", async () => {
+    // GIVEN
+    const initialOperations = [createFixtureOperation({ id: faker.string.uuid() })];
+    const initialAccount = createFixtureAccount({ operations: initialOperations });
+    const accountInfo = createAccountInfo();
+    mockGetAccount.mockResolvedValue(accountInfo);
+    mockGetOperations.mockResolvedValue([]);
+
+    // WHEN
+    const shape = await getAccountShape(
+      {
+        index: -1, // not used but mandatory
+        derivationPath: "not used",
+        currency: getCryptoCurrencyById("sui"),
+        address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+        initialAccount,
+        derivationMode: "sui",
+      },
+      { paginationConfig: {} },
+    );
+
+    // THEN
+    expect(shape.operationsCount).toEqual(1);
+    expect(shape.operations).toEqual(expect.arrayContaining(initialOperations));
+  });
+
+  it("returns an AccountShapeInfo with operations from getOperations API", async () => {
+    // GIVEN
+    const initialAccount = createFixtureAccount();
+    const accountInfo = createAccountInfo();
+    mockGetAccount.mockResolvedValue(accountInfo);
+    const apiOperations = [
+      createFixtureOperation({ id: faker.string.uuid() }),
+      createFixtureOperation({ id: faker.string.uuid() }),
+    ];
+    mockGetOperations.mockResolvedValue(apiOperations);
+
+    // WHEN
+    const shape = await getAccountShape(
+      {
+        index: -1, // not used but mandatory
+        derivationPath: "not used",
+        currency: getCryptoCurrencyById("sui"),
+        address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+        initialAccount,
+        derivationMode: "sui",
+      },
+      { paginationConfig: {} },
+    );
+
+    // THEN
+    expect(shape.operationsCount).toEqual(initialAccount.operations.length + apiOperations.length);
+    expect(shape.operations).toEqual(expect.arrayContaining(apiOperations));
+  });
+});
+
+function createAccountInfo() {
+  return {
+    blockHeight: 10,
+    balance: new BigNumber(faker.string.numeric()),
+    spendableBalance: new BigNumber(faker.string.numeric()),
+  };
+}

package/src/bridge/synchronisation.ts

@@ -0,0 +1,75 @@
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { log } from "@ledgerhq/logs";
+import {
+  makeSync,
+  mergeOps,
+  type GetAccountShape,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getAccount, getOperations } from "../network";
+import { SuiAccount } from "../types";
+import { OperationType, type Operation } from "@ledgerhq/types-live";
+
+/**
+ * Get the shape of the account including its operations and balance.
+ * @function getAccountShape
+ * @param {Object} info - The information needed to retrieve the account shape.
+ * @param {string} info.address - The address of the account.
+ * @param {SuiAccount} info.initialAccount - The initial account data.
+ * @param {Object} info.currency - The currency information.
+ * @param {string} info.derivationMode - The derivation mode for the account.
+ * @returns {Promise<Object>} A promise that resolves to the account shape including balance and operations.
+ */
+export const getAccountShape: GetAccountShape<SuiAccount> = async info => {
+  const { address, initialAccount, currency, derivationMode } = info;
+  const oldOperations = initialAccount?.operations || [];
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+
+  const { blockHeight, balance } = await getAccount(address);
+
+  // Merge new operations with the previously synced ones
+  let operations: Operation[] = [];
+  try {
+    // Needed for incremental synchronisation
+    const startAtIn = latestHash(oldOperations, "IN");
+    const startAtOut = latestHash(oldOperations, "OUT");
+    const newOperations = await getOperations(accountId, address, startAtIn, startAtOut);
+    operations = mergeOps(oldOperations, newOperations);
+  } catch (e) {
+    log(
+      "sui/getAccountShape",
+      "failed to sync with incremental strategy, falling back to full resync",
+      { error: e },
+    );
+    // if we could NOT sync with existing transaction - we start from the beggining, rewritting transaction history
+    operations = await getOperations(accountId, address);
+  }
+
+  operations.sort((a, b) => b.date.valueOf() - a.date.valueOf());
+  const shape = {
+    id: accountId,
+    balance,
+    spendableBalance: balance,
+    operationsCount: operations.length,
+    blockHeight,
+    suiResources: {},
+  };
+  return { ...shape, operations };
+};
+
+/**
+ * Synchronise the account with the latest operations and balance.
+ * @function sync
+ * @param {Object} params - The parameters for synchronisation.
+ * @returns {Promise<void>} A promise that resolves when synchronisation is complete.
+ */
+export const sync = makeSync({ getAccountShape });
+
+function latestHash(operations: Operation[], type: OperationType) {
+  return operations.find(el => type === el.type)?.blockHash ?? null;
+}