@ledgerhq/coin-sui 0.11.0 → 0.12.0-nightly.1

package/src/bridge/estimateMaxSpendable.ts

@@ -4,6 +4,7 @@ import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
 import type { SuiAccount, Transaction } from "../types";
 import getFeesForTransaction from "./getFeesForTransaction";
 import createTransaction from "./createTransaction";
+import { ONE_SUI } from "../constants";
 
 /**
  * Returns the maximum possible amount for transaction
@@ -30,17 +31,30 @@ export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpenda
 
     let spendableBalance = account.spendableBalance;
 
-    if (account.type == "Account") {
+    if (account.type === "Account") {
       const fees = await getFeesForTransaction({
         account: mainAccount,
         transaction: estimatedTransaction,
       });
       if (fees) {
-        spendableBalance = BigNumber.max(spendableBalance.minus(fees), 0);
+        spendableBalance = spendableBalance.minus(fees);
       }
     }
 
-    return spendableBalance;
+    // Apply delegation-specific constraints
+    if (transaction?.mode === "delegate") {
+      // Reserve 0.1 SUI for future gas fees as recommended
+      const gasReserve = new BigNumber(ONE_SUI).div(10);
+      spendableBalance = spendableBalance.minus(gasReserve);
+
+      // Ensure we don't go below 1 SUI minimum for delegation
+      const oneSui = new BigNumber(ONE_SUI);
+      if (spendableBalance.lt(oneSui)) {
+        return new BigNumber(0);
+      }
+    }
+
+    return BigNumber.max(spendableBalance, 0);
   } catch (e) {
     return new BigNumber(0);
   }

package/src/bridge/getFeesForTransaction.ts

@@ -37,11 +37,24 @@ export default async function getEstimatedFees({
   const subAccount = findSubAccountById(account, transaction.subAccountId ?? "");
   const asset = toSuiAsset(subAccount?.token.contractAddress ?? DEFAULT_COIN_TYPE);
 
+  let transactionType: "send" | "delegate" | "undelegate";
+  switch (transaction.mode) {
+    case "delegate":
+      transactionType = "delegate";
+      break;
+    case "undelegate":
+      transactionType = "undelegate";
+      break;
+    default:
+      transactionType = "send";
+      break;
+  }
+
   const fees = await estimateFees({
     recipient: getAbandonSeedAddress(account.currency.id),
     sender: account.freshAddress,
     amount: BigInt(t.amount.toString()),
-    type: "send",
+    type: transactionType,
     asset,
   });
   return new BigNumber(fees.toString());

package/src/bridge/getOperationExtra.ts

@@ -0,0 +1 @@
+export { getOperationExtra } from "../network/sdk";

package/src/bridge/getTransactionStatus.ts

@@ -3,17 +3,24 @@ import {
   NotEnoughBalance,
   NotEnoughBalanceInParentAccount,
   RecipientRequired,
-  InvalidAddress,
   InvalidAddressBecauseDestinationIsAlsoSource,
   AmountRequired,
   FeeNotLoaded,
   FeeTooHigh,
+  InvalidAddress,
 } from "@ledgerhq/errors";
 import { AccountBridge } from "@ledgerhq/types-live";
 import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
 import { isValidSuiAddress } from "@mysten/sui/utils";
 import type { SuiAccount, Transaction, TransactionStatus } from "../types";
 import { ensureAddressFormat } from "../utils";
+import {
+  OneSuiMinForStake,
+  OneSuiMinForUnstake,
+  OneSuiMinForUnstakeToBeLeft,
+  SomeSuiForUnstake,
+} from "../errors";
+import { ONE_SUI } from "../constants";
 
 /**
  * Get the status of a transaction.
@@ -39,36 +46,61 @@ export const getTransactionStatus: AccountBridge<
     accountBalance = subAccount?.balance ?? new BigNumber(0);
   }
 
-  if (amount.lte(0)) {
+  if (amount.lte(0) && !transaction.useAllAmount) {
     errors.amount = new AmountRequired();
   } else if (estimatedFees.times(10).gt(amount) && !transaction.subAccountId) {
     warnings.feeTooHigh = new FeeTooHigh();
   }
 
-  if (!transaction.recipient) {
-    errors.recipient = new RecipientRequired();
-  } else if (!isValidSuiAddress(transaction.recipient)) {
-    errors.recipient = new InvalidAddress(undefined, {
-      currencyName: account.currency.name,
-    });
+  if (!transaction.fees) {
+    errors.fees = new FeeNotLoaded();
   }
 
-  if (ensureAddressFormat(account.freshAddress) === ensureAddressFormat(transaction.recipient)) {
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-  }
+  if (transaction.mode === "undelegate") {
+    const stakes = account.suiResources?.stakes?.flatMap(({ stakes }) => stakes) ?? [];
+    const stake = stakes.find(s => s.stakedSuiId === transaction.stakedSuiId);
+    if (stake) {
+      if (!transaction.useAllAmount && amount.lt(ONE_SUI)) {
+        errors.amount = new OneSuiMinForUnstake();
+      }
+      const stakeLeft = BigNumber(stake?.principal).minus(amount);
+      if (!transaction.useAllAmount && stakeLeft.lt(ONE_SUI) && stakeLeft.gt(0)) {
+        errors.amount = new OneSuiMinForUnstakeToBeLeft();
+      }
+    }
+  } else {
+    if (!transaction.recipient) {
+      errors.recipient = new RecipientRequired();
+    } else if (!isValidSuiAddress(transaction.recipient)) {
+      errors.recipient = new InvalidAddress(undefined, {
+        currencyName: account.currency.name,
+      });
+    }
 
-  if (transaction.subAccountId && estimatedFees.gt(account.balance)) {
-    errors.amount = new NotEnoughBalanceInParentAccount();
-  }
+    if (ensureAddressFormat(account.freshAddress) === ensureAddressFormat(transaction.recipient)) {
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+    }
 
-  if (totalSpent.eq(0) && transaction.useAllAmount) {
-    errors.amount = new NotEnoughBalance();
-  }
-  if (totalSpent.gt(accountBalance)) {
-    errors.amount = new NotEnoughBalance();
+    if (totalSpent.eq(0) && transaction.useAllAmount) {
+      errors.amount = new NotEnoughBalance();
+    }
+
+    if (transaction.subAccountId && estimatedFees.gt(account.balance)) {
+      errors.amount = new NotEnoughBalanceInParentAccount();
+    }
+
+    if (totalSpent.gt(accountBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
   }
-  if (!transaction.fees) {
-    errors.fees = new FeeNotLoaded();
+  if (transaction.mode === "delegate") {
+    if (amount.lt(new BigNumber(ONE_SUI))) {
+      errors.amount = new OneSuiMinForStake();
+    }
+
+    // 0.1 SUI
+    if (account.balance.minus(transaction.amount).lt(ONE_SUI / 10))
+      warnings.amount = new SomeSuiForUnstake();
   }
 
   return {

package/src/bridge/preload.test.ts

@@ -5,8 +5,6 @@ import {
   setSuiPreloadData,
   getSuiPreloadDataUpdates,
   getPreloadStrategy,
-  preload,
-  hydrate,
 } from "./preload";
 import type { SuiPreloadData } from "../types";
 
@@ -18,17 +16,12 @@ jest.mock("@ledgerhq/logs", () => ({
 describe("Sui Preload Functions", () => {
   beforeEach(() => {
     // Reset the preload data before each test
-    setSuiPreloadData({});
+    setSuiPreloadData({ validators: [] });
   });
 
   describe("getCurrentSuiPreloadData", () => {
-    it("should return empty object by default", () => {
-      const data = getCurrentSuiPreloadData();
-      expect(data).toEqual({});
-    });
-
     it("should return the current preloaded data", () => {
-      const testData: SuiPreloadData = { testKey: "testValue" };
+      const testData: SuiPreloadData = { validators: [] };
       setSuiPreloadData(testData);
 
       const data = getCurrentSuiPreloadData();
@@ -36,46 +29,6 @@ describe("Sui Preload Functions", () => {
     });
   });
 
-  describe("setSuiPreloadData", () => {
-    it("should set the preload data", () => {
-      const testData: SuiPreloadData = { key1: "value1", key2: "value2" };
-
-      setSuiPreloadData(testData);
-
-      const currentData = getCurrentSuiPreloadData();
-      expect(currentData).toEqual(testData);
-    });
-
-    it("should not update if data is the same reference", () => {
-      const testData: SuiPreloadData = { test: "data" };
-
-      // Set data first time
-      setSuiPreloadData(testData);
-      const firstCall = getCurrentSuiPreloadData();
-
-      // Set the same data reference
-      setSuiPreloadData(testData);
-      const secondCall = getCurrentSuiPreloadData();
-
-      expect(firstCall).toBe(secondCall);
-      expect(firstCall).toEqual(testData);
-    });
-
-    it("should update if data has different content", () => {
-      const firstData: SuiPreloadData = { test: "first" };
-      const secondData: SuiPreloadData = { test: "second" };
-
-      setSuiPreloadData(firstData);
-      const firstCall = getCurrentSuiPreloadData();
-
-      setSuiPreloadData(secondData);
-      const secondCall = getCurrentSuiPreloadData();
-
-      expect(firstCall).not.toBe(secondCall);
-      expect(secondCall).toEqual(secondData);
-    });
-  });
-
   describe("getSuiPreloadDataUpdates", () => {
     it("should return an Observable", () => {
       const updates = getSuiPreloadDataUpdates();
@@ -83,7 +36,7 @@ describe("Sui Preload Functions", () => {
     });
 
     it("should emit updates when data is set", done => {
-      const testData: SuiPreloadData = { update: "test" };
+      const testData: SuiPreloadData = { validators: [] };
       const updates = getSuiPreloadDataUpdates();
 
       updates.pipe(take(1)).subscribe(data => {
@@ -94,240 +47,21 @@ describe("Sui Preload Functions", () => {
       setSuiPreloadData(testData);
     });
 
-    it("should emit multiple updates", done => {
-      const firstData: SuiPreloadData = { first: "data" };
-      const secondData: SuiPreloadData = { second: "data" };
-      const updates = getSuiPreloadDataUpdates();
-
-      let callCount = 0;
-      updates.pipe(take(2)).subscribe(data => {
-        callCount++;
-        if (callCount === 1) {
-          expect(data).toEqual(firstData);
-        } else if (callCount === 2) {
-          expect(data).toEqual(secondData);
-          done();
-        }
-      });
-
-      setSuiPreloadData(firstData);
-      setSuiPreloadData(secondData);
-    });
-
-    it("should not emit when same data reference is set", done => {
-      const testData: SuiPreloadData = { test: "data" };
-      const updates = getSuiPreloadDataUpdates();
-
-      let callCount = 0;
-      updates.pipe(take(1)).subscribe(data => {
-        callCount++;
-        expect(data).toEqual(testData);
-        // Wait a bit to ensure no additional emissions
-        setTimeout(() => {
-          expect(callCount).toBe(1);
-          done();
-        }, 10);
-      });
-
-      setSuiPreloadData(testData);
-      setSuiPreloadData(testData); // Same reference, should not emit
-    });
-  });
-
-  describe("getPreloadStrategy", () => {
-    it("should return preload strategy with correct max age", () => {
-      const strategy = getPreloadStrategy();
-
-      expect(strategy).toHaveProperty("preloadMaxAge");
-      expect(strategy.preloadMaxAge).toBe(30 * 60 * 1000); // 30 minutes in milliseconds
-    });
-
-    it("should return consistent strategy object", () => {
-      const strategy1 = getPreloadStrategy();
-      const strategy2 = getPreloadStrategy();
-
-      expect(strategy1).toEqual(strategy2);
-      expect(strategy1.preloadMaxAge).toBe(30 * 60 * 1000);
-    });
-  });
-
-  describe("preload", () => {
-    it("should return empty object", async () => {
-      const result = await preload();
-      expect(result).toEqual({});
-    });
-
-    it("should log preload message", async () => {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const { log } = require("@ledgerhq/logs");
-
-      await preload();
-
-      expect(log).toHaveBeenCalledWith("sui/preload", "preloading sui data...");
-    });
-
-    it("should always return the same result", async () => {
-      const result1 = await preload();
-      const result2 = await preload();
-
-      expect(result1).toEqual(result2);
-      expect(result1).toEqual({});
-    });
-  });
-
-  describe("hydrate", () => {
-    it("should set preload data with hydrated data", () => {
-      const testData: SuiPreloadData = { hydrate: "test" };
-
-      hydrate(testData);
-
-      const currentData = getCurrentSuiPreloadData();
-      expect(currentData).toEqual({}); // fromHydratePreloadData returns empty object
-    });
-
-    it("should emit update when hydrated", done => {
-      const testData: SuiPreloadData = { hydrate: "test" };
-      const updates = getSuiPreloadDataUpdates();
-
-      updates.pipe(take(1)).subscribe(data => {
-        expect(data).toEqual({}); // fromHydratePreloadData returns empty object
-        done();
-      });
-
-      hydrate(testData);
-    });
-
-    it("should handle empty data", () => {
-      const emptyData: SuiPreloadData = {};
-
-      hydrate(emptyData);
-
-      const currentData = getCurrentSuiPreloadData();
-      expect(currentData).toEqual({});
-    });
-
-    it("should handle complex data structures", () => {
-      const complexData: SuiPreloadData = {
-        nested: { key: "value" },
-        array: [1, 2, 3],
-        boolean: true,
-        number: 42,
-      };
-
-      hydrate(complexData);
-
-      const currentData = getCurrentSuiPreloadData();
-      expect(currentData).toEqual({}); // fromHydratePreloadData returns empty object
-    });
-  });
-
-  describe("Integration Tests", () => {
-    it("should maintain data consistency across multiple operations", () => {
-      const testData: SuiPreloadData = { integration: "test" };
-
-      // Set data
-      setSuiPreloadData(testData);
-      expect(getCurrentSuiPreloadData()).toEqual(testData);
-
-      // Hydrate should override
-      hydrate({ different: "data" });
-      expect(getCurrentSuiPreloadData()).toEqual({});
-
-      // Set again
-      setSuiPreloadData(testData);
-      expect(getCurrentSuiPreloadData()).toEqual(testData);
-    });
-
-    it("should handle rapid successive updates", done => {
-      const updates = getSuiPreloadDataUpdates();
-      const results: SuiPreloadData[] = [];
+    describe("getPreloadStrategy", () => {
+      it("should return preload strategy with correct max age", () => {
+        const strategy = getPreloadStrategy();
 
-      updates.pipe(take(3)).subscribe(data => {
-        results.push(data);
-        if (results.length === 3) {
-          expect(results).toEqual([{ first: "update" }, { second: "update" }, { third: "update" }]);
-          done();
-        }
+        expect(strategy).toHaveProperty("preloadMaxAge");
+        expect(strategy.preloadMaxAge).toBe(30 * 60 * 1000); // 30 minutes in milliseconds
       });
 
-      setSuiPreloadData({ first: "update" });
-      setSuiPreloadData({ second: "update" });
-      setSuiPreloadData({ third: "update" });
-    });
-
-    it("should work with preload strategy", async () => {
-      const strategy = getPreloadStrategy();
-      const preloadResult = await preload();
-
-      expect(strategy.preloadMaxAge).toBe(30 * 60 * 1000);
-      expect(preloadResult).toEqual({});
-
-      // Preload should not affect current data
-      expect(getCurrentSuiPreloadData()).toEqual({});
-    });
-  });
-
-  describe("Edge Cases", () => {
-    it("should handle null data gracefully", () => {
-      // TypeScript would prevent this, but testing runtime behavior
-      const nullData = null as any;
-
-      expect(() => {
-        setSuiPreloadData(nullData);
-      }).not.toThrow();
-    });
-
-    it("should handle undefined data gracefully", () => {
-      // TypeScript would prevent this, but testing runtime behavior
-      const undefinedData = undefined as any;
-
-      expect(() => {
-        setSuiPreloadData(undefinedData);
-      }).not.toThrow();
-    });
-
-    it("should handle multiple subscribers", done => {
-      const updates1 = getSuiPreloadDataUpdates();
-      const updates2 = getSuiPreloadDataUpdates();
-
-      let subscriber1Called = false;
-      let subscriber2Called = false;
+      it("should return consistent strategy object", () => {
+        const strategy1 = getPreloadStrategy();
+        const strategy2 = getPreloadStrategy();
 
-      updates1.pipe(take(1)).subscribe(() => {
-        subscriber1Called = true;
-        if (subscriber1Called && subscriber2Called) {
-          done();
-        }
+        expect(strategy1).toEqual(strategy2);
+        expect(strategy1.preloadMaxAge).toBe(30 * 60 * 1000);
       });
-
-      updates2.pipe(take(1)).subscribe(() => {
-        subscriber2Called = true;
-        if (subscriber1Called && subscriber2Called) {
-          done();
-        }
-      });
-
-      setSuiPreloadData({ multi: "subscriber" });
-    });
-
-    it("should handle unsubscribe scenarios", done => {
-      const updates = getSuiPreloadDataUpdates();
-      let callCount = 0;
-
-      const subscription = updates.subscribe(() => {
-        callCount++;
-      });
-
-      setSuiPreloadData({ first: "update" });
-
-      subscription.unsubscribe();
-
-      setSuiPreloadData({ second: "update" });
-
-      setTimeout(() => {
-        expect(callCount).toBe(1); // Should only receive first update
-        done();
-      }, 10);
     });
   });
 });

package/src/bridge/preload.ts

@@ -2,13 +2,14 @@ import { Observable, Subject } from "rxjs";
 import { log } from "@ledgerhq/logs";
 
 import type { SuiPreloadData } from "../types";
+import { getValidators } from "../network/sdk";
 
 const PRELOAD_MAX_AGE = 30 * 60 * 1000; // 30 minutes
 
-let currentPreloadedData: SuiPreloadData = {};
+let currentPreloadedData: SuiPreloadData = { validators: [] };
 
 function fromHydratePreloadData(_data: SuiPreloadData): SuiPreloadData {
-  return {};
+  return { validators: _data.validators };
 }
 
 const updates = new Subject<SuiPreloadData>();
@@ -34,9 +35,10 @@ export const getPreloadStrategy = () => ({
 });
 
 export const preload = async (): Promise<SuiPreloadData> => {
+  const validators = await getValidators();
   log("sui/preload", "preloading sui data...");
 
-  return {};
+  return { validators };
 };
 
 export const hydrate = (data: SuiPreloadData) => {

package/src/bridge/prepareTransaction.ts

@@ -35,7 +35,7 @@ export const prepareTransaction: AccountBridge<
     fees = BigNumber(0);
   }
 
-  let mode: SuiTransactionMode = "send";
+  let mode: SuiTransactionMode = transaction.mode ?? "send";
   let coinType = DEFAULT_COIN_TYPE;
   if (transaction?.subAccountId) {
     mode = "token.send";