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

package/src/bridge/synchronisation.test.ts

@@ -4,6 +4,9 @@ import { faker } from "@faker-js/faker";
 import { createFixtureAccount, createFixtureOperation } from "../types/bridge.fixture";
 import { DEFAULT_COIN_TYPE } from "../network/sdk";
 import { getAccountShape } from "./synchronisation";
+import coinConfig from "../config";
+import { getFullnodeUrl } from "@mysten/sui/client";
+import * as networkModule from "../network";
 
 // Mock getTokenById and listTokensForCryptoCurrency
 jest.mock("@ledgerhq/cryptoassets/tokens", () => ({
@@ -20,17 +23,34 @@ jest.mock("@ledgerhq/cryptoassets/tokens", () => ({
   listTokensForCryptoCurrency: () => [{ id: "0x123::sui::TEST" }],
 }));
 
-const mockGetAccountBalances = jest.fn();
-const mockGetOperations = jest.fn();
-jest.mock("../network", () => ({
-  getAccountBalances: () => mockGetAccountBalances(),
-  getOperations: () => mockGetOperations(),
-}));
+jest.mock("../network", () => {
+  const mockGetAccountBalances = jest.fn();
+  const mockGetOperations = jest.fn();
+  const mockGetStakesRaw = jest.fn();
+  return {
+    getAccountBalances: mockGetAccountBalances,
+    getOperations: mockGetOperations,
+    getStakesRaw: mockGetStakesRaw,
+    createTransaction: jest.fn(),
+  };
+});
 
 describe("getAccountShape", () => {
+  const mockGetAccountBalances = networkModule.getAccountBalances as jest.Mock;
+  const mockGetOperations = networkModule.getOperations as jest.Mock;
+  const mockGetStakesRaw = networkModule.getStakesRaw as jest.Mock;
+
   beforeEach(() => {
     mockGetAccountBalances.mockClear();
     mockGetOperations.mockClear();
+    mockGetStakesRaw.mockClear();
+  });
+
+  beforeAll(() => {
+    coinConfig.setCoinConfig(() => ({
+      status: { type: "active" },
+      node: { url: getFullnodeUrl("mainnet") },
+    }));
   });
 
   it("calls getAccountBalances and getOperations", async () => {
@@ -38,6 +58,7 @@ describe("getAccountShape", () => {
     const initialAccount = undefined;
     mockGetAccountBalances.mockResolvedValue([createAccountBalance()]);
     mockGetOperations.mockResolvedValue([]);
+    mockGetStakesRaw.mockResolvedValue([]);
 
     // WHEN
     await getAccountShape(
@@ -63,6 +84,7 @@ describe("getAccountShape", () => {
     const accountBalance = createAccountBalance();
     mockGetAccountBalances.mockResolvedValue([accountBalance]);
     mockGetOperations.mockResolvedValue([]);
+    mockGetStakesRaw.mockResolvedValue([]);
 
     // WHEN
     const shape = await getAccountShape(
@@ -85,8 +107,11 @@ describe("getAccountShape", () => {
       blockHeight: 5,
       operations: [],
       operationsCount: 0,
-      suiResources: {},
+      suiResources: {
+        stakes: [],
+      },
       subAccounts: [],
+      syncHash: undefined,
     });
   });
 
@@ -98,6 +123,7 @@ describe("getAccountShape", () => {
     const accountBalance = createAccountBalance();
     mockGetAccountBalances.mockResolvedValue([accountBalance]);
     mockGetOperations.mockResolvedValue([]);
+    mockGetStakesRaw.mockResolvedValue([]);
 
     // WHEN
     const shape = await getAccountShape(
@@ -128,6 +154,7 @@ describe("getAccountShape", () => {
       createFixtureOperation({ id: faker.string.uuid(), extra }),
     ];
     mockGetOperations.mockResolvedValue(apiOperations);
+    mockGetStakesRaw.mockResolvedValue([]);
 
     // WHEN
     const shape = await getAccountShape(
@@ -154,6 +181,7 @@ describe("getAccountShape", () => {
     const tokenBalance = createAccountBalance({ coinType: "0x123::sui::TEST" });
     mockGetAccountBalances.mockResolvedValue([mainBalance, tokenBalance]);
     mockGetOperations.mockResolvedValue([]);
+    mockGetStakesRaw.mockResolvedValue([]);
 
     // WHEN
     const shape = await getAccountShape(
@@ -173,6 +201,360 @@ describe("getAccountShape", () => {
     expect(shape.subAccounts).toBeDefined();
     expect(Array.isArray(shape.subAccounts)).toBe(true);
   });
+
+  describe("stakes functionality", () => {
+    it("calls getStakesRaw with the correct address", async () => {
+      // GIVEN
+      const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
+      const initialAccount = undefined;
+      mockGetAccountBalances.mockResolvedValue([createAccountBalance()]);
+      mockGetOperations.mockResolvedValue([]);
+      mockGetStakesRaw.mockResolvedValue([]);
+
+      // WHEN
+      await getAccountShape(
+        {
+          index: 0,
+          derivationPath: "44'/784'/0'/0'/0'",
+          currency: getCryptoCurrencyById("sui"),
+          address,
+          initialAccount,
+          derivationMode: "sui",
+        },
+        { blacklistedTokenIds: [], paginationConfig: {} },
+      );
+
+      // THEN
+      expect(mockGetStakesRaw).toHaveBeenCalledTimes(1);
+      expect(mockGetStakesRaw).toHaveBeenCalledWith(address);
+    });
+
+    it("includes empty stakes in suiResources when no stakes are returned", async () => {
+      // GIVEN
+      const initialAccount = undefined;
+      mockGetAccountBalances.mockResolvedValue([createAccountBalance()]);
+      mockGetOperations.mockResolvedValue([]);
+      mockGetStakesRaw.mockResolvedValue([]);
+
+      // WHEN
+      const shape = await getAccountShape(
+        {
+          index: 0,
+          derivationPath: "44'/784'/0'/0'/0'",
+          currency: getCryptoCurrencyById("sui"),
+          address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+          initialAccount,
+          derivationMode: "sui",
+        },
+        { blacklistedTokenIds: [], paginationConfig: {} },
+      );
+
+      // THEN
+      expect(shape.suiResources).toBeDefined();
+      expect(shape.suiResources?.stakes).toEqual([]);
+    });
+
+    it("includes stakes in suiResources when stakes are returned", async () => {
+      // GIVEN
+      const initialAccount = undefined;
+      const mockStakes = [
+        {
+          validatorAddress: "0xvalidator1",
+          stakes: [
+            {
+              stakedSuiId: "0xstake1",
+              status: "Active" as const,
+              principal: "1000000000",
+              stakeActiveEpoch: "100",
+              stakeRequestEpoch: "95",
+            },
+          ],
+        },
+        {
+          validatorAddress: "0xvalidator2",
+          stakes: [
+            {
+              stakedSuiId: "0xstake2",
+              status: "Pending" as const,
+              principal: "2000000000",
+              stakeActiveEpoch: "0",
+              stakeRequestEpoch: "100",
+            },
+          ],
+        },
+      ];
+      mockGetAccountBalances.mockResolvedValue([createAccountBalance()]);
+      mockGetOperations.mockResolvedValue([]);
+      mockGetStakesRaw.mockResolvedValue(mockStakes);
+
+      // WHEN
+      const shape = await getAccountShape(
+        {
+          index: 0,
+          derivationPath: "44'/784'/0'/0'/0'",
+          currency: getCryptoCurrencyById("sui"),
+          address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+          initialAccount,
+          derivationMode: "sui",
+        },
+        { blacklistedTokenIds: [], paginationConfig: {} },
+      );
+
+      // THEN
+      expect(shape.suiResources).toBeDefined();
+      expect(shape.suiResources?.stakes).toEqual(mockStakes);
+    });
+
+    it("handles multiple stakes per validator", async () => {
+      // GIVEN
+      const initialAccount = undefined;
+      const mockStakes = [
+        {
+          validatorAddress: "0xvalidator1",
+          stakes: [
+            {
+              stakedSuiId: "0xstake1",
+              status: "Active" as const,
+              principal: "1000000000",
+              stakeActiveEpoch: "100",
+              stakeRequestEpoch: "95",
+            },
+            {
+              stakedSuiId: "0xstake2",
+              status: "Active" as const,
+              principal: "1500000000",
+              stakeActiveEpoch: "100",
+              stakeRequestEpoch: "95",
+            },
+          ],
+        },
+      ];
+      mockGetAccountBalances.mockResolvedValue([createAccountBalance()]);
+      mockGetOperations.mockResolvedValue([]);
+      mockGetStakesRaw.mockResolvedValue(mockStakes);
+
+      // WHEN
+      const shape = await getAccountShape(
+        {
+          index: 0,
+          derivationPath: "44'/784'/0'/0'/0'",
+          currency: getCryptoCurrencyById("sui"),
+          address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+          initialAccount,
+          derivationMode: "sui",
+        },
+        { blacklistedTokenIds: [], paginationConfig: {} },
+      );
+
+      // THEN
+      expect(shape.suiResources?.stakes).toEqual(mockStakes);
+      expect(shape.suiResources?.stakes?.[0].stakes).toHaveLength(2);
+    });
+
+    it("handles different stake statuses correctly", async () => {
+      // GIVEN
+      const initialAccount = undefined;
+      const mockStakes = [
+        {
+          validatorAddress: "0xvalidator1",
+          stakes: [
+            {
+              stakedSuiId: "0xactive",
+              status: "Active" as const,
+              principal: "1000000000",
+              stakeActiveEpoch: "100",
+              stakeRequestEpoch: "95",
+            },
+            {
+              stakedSuiId: "0xpending",
+              status: "Pending" as const,
+              principal: "2000000000",
+              stakeActiveEpoch: "0",
+              stakeRequestEpoch: "100",
+            },
+            {
+              stakedSuiId: "0xunstaked",
+              status: "Unstaked" as const,
+              principal: "3000000000",
+              stakeActiveEpoch: "0",
+              stakeRequestEpoch: "0",
+            },
+          ],
+        },
+      ];
+      mockGetAccountBalances.mockResolvedValue([createAccountBalance()]);
+      mockGetOperations.mockResolvedValue([]);
+      mockGetStakesRaw.mockResolvedValue(mockStakes);
+
+      // WHEN
+      const shape = await getAccountShape(
+        {
+          index: 0,
+          derivationPath: "44'/784'/0'/0'/0'",
+          currency: getCryptoCurrencyById("sui"),
+          address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+          initialAccount,
+          derivationMode: "sui",
+        },
+        { blacklistedTokenIds: [], paginationConfig: {} },
+      );
+
+      // THEN
+      expect(shape.suiResources?.stakes).toEqual(mockStakes);
+      const stakes = shape.suiResources?.stakes?.[0].stakes || [];
+      expect(stakes).toHaveLength(3);
+      expect(stakes.find(s => s.stakedSuiId === "0xactive")?.status).toBe("Active");
+      expect(stakes.find(s => s.stakedSuiId === "0xpending")?.status).toBe("Pending");
+      expect(stakes.find(s => s.stakedSuiId === "0xunstaked")?.status).toBe("Unstaked");
+    });
+
+    it("handles getStakesRaw throwing an error gracefully", async () => {
+      // GIVEN
+      const initialAccount = undefined;
+      const error = new Error("Network error");
+      mockGetAccountBalances.mockResolvedValue([createAccountBalance()]);
+      mockGetOperations.mockResolvedValue([]);
+      mockGetStakesRaw.mockRejectedValue(error);
+
+      // WHEN & THEN
+      await expect(
+        getAccountShape(
+          {
+            index: 0,
+            derivationPath: "44'/784'/0'/0'/0'",
+            currency: getCryptoCurrencyById("sui"),
+            address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+            initialAccount,
+            derivationMode: "sui",
+          },
+          { blacklistedTokenIds: [], paginationConfig: {} },
+        ),
+      ).rejects.toThrow("Network error");
+    });
+
+    it("preserves existing suiResources when initialAccount has stakes", async () => {
+      // GIVEN
+      const existingStakes = [
+        {
+          validatorAddress: "0xexistingValidator",
+          stakes: [
+            {
+              stakedSuiId: "0xexistingStake",
+              status: "Active" as const,
+              principal: "500000000",
+              stakeActiveEpoch: "90",
+              stakeRequestEpoch: "85",
+            },
+          ],
+        },
+      ];
+      const initialAccount = createFixtureAccount({
+        suiResources: { stakes: existingStakes },
+      });
+      const newStakes = [
+        {
+          validatorAddress: "0xnewValidator",
+          stakes: [
+            {
+              stakedSuiId: "0xnewStake",
+              status: "Active" as const,
+              principal: "1000000000",
+              stakeActiveEpoch: "100",
+              stakeRequestEpoch: "95",
+            },
+          ],
+        },
+      ];
+      mockGetAccountBalances.mockResolvedValue([createAccountBalance()]);
+      mockGetOperations.mockResolvedValue([]);
+      mockGetStakesRaw.mockResolvedValue(newStakes);
+
+      // WHEN
+      const shape = await getAccountShape(
+        {
+          index: 0,
+          derivationPath: "44'/784'/0'/0'/0'",
+          currency: getCryptoCurrencyById("sui"),
+          address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+          initialAccount,
+          derivationMode: "sui",
+        },
+        { blacklistedTokenIds: [], paginationConfig: {} },
+      );
+
+      // THEN
+      expect(shape.suiResources?.stakes).toEqual(newStakes);
+      // The new stakes should replace the old ones, not merge
+      expect(shape.suiResources?.stakes).not.toEqual(existingStakes);
+    });
+
+    it("handles large stake amounts correctly", async () => {
+      // GIVEN
+      const initialAccount = undefined;
+      const mockStakes = [
+        {
+          validatorAddress: "0xvalidator1",
+          stakes: [
+            {
+              stakedSuiId: "0xlargeStake",
+              status: "Active" as const,
+              principal: "999999999999999999999999999999",
+              stakeActiveEpoch: "1000",
+              stakeRequestEpoch: "995",
+            },
+          ],
+        },
+      ];
+      mockGetAccountBalances.mockResolvedValue([createAccountBalance()]);
+      mockGetOperations.mockResolvedValue([]);
+      mockGetStakesRaw.mockResolvedValue(mockStakes);
+
+      // WHEN
+      const shape = await getAccountShape(
+        {
+          index: 0,
+          derivationPath: "44'/784'/0'/0'/0'",
+          currency: getCryptoCurrencyById("sui"),
+          address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+          initialAccount,
+          derivationMode: "sui",
+        },
+        { blacklistedTokenIds: [], paginationConfig: {} },
+      );
+
+      // THEN
+      expect(shape.suiResources?.stakes).toEqual(mockStakes);
+      const stake = shape.suiResources?.stakes?.[0].stakes?.[0];
+      expect(stake?.principal).toBe("999999999999999999999999999999");
+      expect(stake?.stakeActiveEpoch).toBe("1000");
+      expect(stake?.stakeRequestEpoch).toBe("995");
+    });
+
+    it("handles getStakesRaw returning null or undefined", async () => {
+      // GIVEN
+      const initialAccount = undefined;
+      mockGetAccountBalances.mockResolvedValue([createAccountBalance()]);
+      mockGetOperations.mockResolvedValue([]);
+      mockGetStakesRaw.mockResolvedValue(null);
+
+      // WHEN
+      const shape = await getAccountShape(
+        {
+          index: 0,
+          derivationPath: "44'/784'/0'/0'/0'",
+          currency: getCryptoCurrencyById("sui"),
+          address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+          initialAccount,
+          derivationMode: "sui",
+        },
+        { blacklistedTokenIds: [], paginationConfig: {} },
+      );
+
+      // THEN
+      expect(shape.suiResources).toBeDefined();
+      expect(shape.suiResources?.stakes).toBeNull();
+    });
+  });
 });
 
 function createAccountBalance(overrides = {}) {

package/src/bridge/synchronisation.ts

@@ -11,7 +11,7 @@ import {
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { type Operation } from "@ledgerhq/types-live";
 import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets/tokens";
-import { getAccountBalances, getOperations } from "../network";
+import { getAccountBalances, getOperations, getStakesRaw } from "../network";
 import { DEFAULT_COIN_TYPE } from "../network/sdk";
 import { SuiOperationExtra, SuiAccount } from "../types";
 import type { SyncConfig, TokenAccount } from "@ledgerhq/types-live";
@@ -41,6 +41,7 @@ export const getAccountShape: GetAccountShape<SuiAccount> = async (info, syncCon
   });
 
   let operations: Operation[] = [];
+  const stakes = await getStakesRaw(address);
 
   let syncHash = initialAccount?.syncHash ?? latestHash(oldOperations);
   const newOperations = await getOperations(accountId, address, syncHash);
@@ -84,7 +85,9 @@ export const getAccountShape: GetAccountShape<SuiAccount> = async (info, syncCon
     operationsCount: mainAccountOperations.length,
     blockHeight: 5,
     subAccounts,
-    suiResources: {},
+    suiResources: {
+      stakes,
+    },
     operations: mainAccountOperations,
   };
 };
@@ -118,7 +121,7 @@ async function buildSubAccounts({
   const existingAccountByTicker: { [ticker: string]: TokenAccount } = {}; // used for fast lookup
   const existingAccountTickers: string[] = []; // used to keep track of ordering
 
-  if (initialAccount && initialAccount.subAccounts) {
+  if (initialAccount?.subAccounts) {
     for (const existingSubAccount of initialAccount.subAccounts) {
       if (existingSubAccount.type === "TokenAccount") {
         const { ticker, id } = existingSubAccount.token;

package/src/bridge/utils.ts

@@ -35,6 +35,22 @@ const calculateMaxSend = (account: SuiAccount, transaction: Transaction): BigNum
   return amount.lt(0) ? new BigNumber(0) : amount;
 };
 
+/**
+ * Calculate the maximum amount that can be delegated after deducting fees and reserving gas.
+ *
+ * @param {SuiAccount} account - The account from which the amount is being delegated.
+ * @param {Transaction} transaction - The transaction details including fees.
+ * @returns {BigNumber} - The maximum amount that can be delegated, or 0 if insufficient balance.
+ */
+const calculateMaxDelegate = (account: SuiAccount, transaction: Transaction): BigNumber => {
+  // Reserve 0.1 SUI for future gas fees as recommended for delegation
+  const ONE_SUI = new BigNumber("1000000000"); // 1 SUI in MIST
+  const gasReserve = ONE_SUI.div(10); // 0.1 SUI
+
+  const amount = account.spendableBalance.minus(transaction.fees || 0).minus(gasReserve);
+  return amount.lt(0) ? new BigNumber(0) : amount;
+};
+
 /**
  * Calculates the amount to be sent in a transaction based on the account's balance and transaction details.
  *
@@ -61,6 +77,14 @@ export const calculateAmount = ({
         amount =
           findSubAccountById(account, transaction.subAccountId!)?.spendableBalance ??
           new BigNumber(0);
+        break;
+      case "delegate":
+        amount = calculateMaxDelegate(account, transaction);
+        break;
+      case "undelegate":
+        // For undelegate, use the full staked amount (handled elsewhere)
+        amount = transaction.amount;
+        break;
     }
   } else if (transaction.amount.gt(MAX_AMOUNT_INPUT)) {
     return new BigNumber(MAX_AMOUNT_INPUT);
@@ -69,6 +93,6 @@ export const calculateAmount = ({
   return amount.lt(0) ? new BigNumber(0) : amount;
 };
 
-export const assertUnreachable = (_: never): never => {
+export const assertUnreachable = (_: unknown): never => {
   throw new Error("unreachable assertion failed");
 };

package/src/constants.ts

@@ -0,0 +1,4 @@
+export const STAKING_GAS_BASE = "25000000000000";
+export const FIGMENT_SUI_VALIDATOR_ADDRESS =
+  "0x3d9fb148e35ef4d74fcfc36995da14fc504b885d5f2bfeca37d6ea2cc044a32d";
+export const ONE_SUI = 1000000000;

package/src/errors.ts

@@ -0,0 +1,21 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+/*
+ * One SUI is minimal to stake.
+ */
+export const OneSuiMinForStake = createCustomErrorClass("OneSuiMinForStake");
+
+/*
+ * One SUI is minimal for partial unstake.
+ */
+export const OneSuiMinForUnstake = createCustomErrorClass("OneSuiMinForUnstake");
+
+/*
+ * One SUI is minimal to be left when partial unstake.
+ */
+export const OneSuiMinForUnstakeToBeLeft = createCustomErrorClass("OneSuiMinForUnstakeToBeLeft");
+
+/*
+ * At least 0.1 SUI to unstake
+ */
+export const SomeSuiForUnstake = createCustomErrorClass("SomeSuiForUnstake");

package/src/logic/craftTransaction.ts

@@ -4,21 +4,17 @@ import type { SuiTransactionMode, CoreTransaction } from "../types";
 import suiAPI from "../network";
 import { DEFAULT_COIN_TYPE } from "../network/sdk";
 
-export type CreateExtrinsicArg = {
-  amount: BigNumber;
-  coinType: string;
-  mode: SuiTransactionMode;
-  recipient: string;
-  useAllAmount?: boolean | undefined;
-};
-
 export async function craftTransaction({
   amount,
   asset,
   recipient,
   sender,
   type,
-}: TransactionIntent): Promise<CoreTransaction> {
+  ...extra
+}: TransactionIntent & {
+  useAllAmount?: boolean;
+  stakedSuiId?: string;
+}): Promise<CoreTransaction> {
   let coinType = DEFAULT_COIN_TYPE;
   if (asset.type === "token" && asset.assetReference) {
     coinType = asset.assetReference;
@@ -28,6 +24,7 @@ export async function craftTransaction({
     coinType,
     mode: type as SuiTransactionMode,
     recipient,
+    ...extra,
   });
 
   return { unsigned };

package/src/logic/estimateFees.ts

@@ -8,13 +8,28 @@ export async function estimateFees({
   amount,
   sender,
   asset,
+  type,
 }: TransactionIntent): Promise<bigint> {
   let coinType = DEFAULT_COIN_TYPE;
   if (asset.type === "token" && asset.assetReference) {
     coinType = asset.assetReference;
   }
+
+  let mode: "send" | "delegate" | "undelegate";
+  switch (type) {
+    case "delegate":
+      mode = "delegate";
+      break;
+    case "undelegate":
+      mode = "undelegate";
+      break;
+    default:
+      mode = "send";
+      break;
+  }
+
   const { gasBudget } = await suiAPI.paymentInfo(sender, {
-    mode: "send",
+    mode,
     family: "sui",
     recipient,
     amount: BigNumber(amount.toString()),

package/src/logic/index.ts

@@ -1,4 +1,4 @@
-export { craftTransaction, type CreateExtrinsicArg } from "./craftTransaction";
+export { craftTransaction } from "./craftTransaction";
 export { estimateFees } from "./estimateFees";
 export { broadcast } from "./broadcast";
 export { combine } from "./combine";
@@ -7,3 +7,4 @@ export { lastBlock } from "./lastBlock";
 export { getBlock, getBlockInfo } from "./getBlock";
 export { listOperations } from "./listOperations";
 export { getStakes, getRewards } from "./staking";
+export { canStake } from "./stake";

package/src/logic/stake.ts

@@ -0,0 +1,9 @@
+import { SuiAccount } from "../types";
+import { ONE_SUI } from "../constants";
+
+/*
+ * Make sure that an account has enough funds to stake, unstake, AND withdraw before staking.
+ */
+export const canStake = (account: SuiAccount): boolean => {
+  return account.balance.gte(ONE_SUI);
+};

package/src/network/index.ts

@@ -4,10 +4,11 @@ import {
   getOperations,
   getBlock,
   getBlockInfo,
-  getStakes,
+  getStakesRaw,
   paymentInfo,
   createTransaction,
   executeTransactionBlock,
+  getStakes,
 } from "./sdk";
 
 export {
@@ -16,10 +17,11 @@ export {
   getOperations,
   getBlock,
   getBlockInfo,
-  getStakes,
+  getStakesRaw,
   paymentInfo,
   createTransaction,
   executeTransactionBlock,
+  getStakes,
 };
 
 export default {
@@ -28,8 +30,9 @@ export default {
   getOperations,
   getBlock,
   getBlockInfo,
-  getStakes,
+  getStakesRaw,
   paymentInfo,
   createTransaction,
   executeTransactionBlock,
+  getStakes,
 };