@ledgerhq/coin-sui 0.8.1-nightly.1 → 0.9.0-nightly.3

package/src/logic/craftTransaction.ts

@@ -5,18 +5,18 @@ import suiAPI from "../network";
 import { DEFAULT_COIN_TYPE } from "../network/sdk";
 
 export type CreateExtrinsicArg = {
-  mode: SuiTransactionMode;
   amount: BigNumber;
   coinType: string;
+  mode: SuiTransactionMode;
   recipient: string;
   useAllAmount?: boolean | undefined;
 };
 
 export async function craftTransaction({
-  sender,
   amount,
-  recipient,
   asset,
+  recipient,
+  sender,
   type,
 }: TransactionIntent): Promise<CoreTransaction> {
   let coinType = DEFAULT_COIN_TYPE;

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

@@ -0,0 +1,89 @@
+import type { TransactionIntent } from "@ledgerhq/coin-framework/api/index";
+import { getFullnodeUrl } from "@mysten/sui/client";
+import coinConfig from "../config";
+import { estimateFees } from "./estimateFees";
+
+const SENDER = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
+const RECIPIENT = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
+
+describe("estimateFees", () => {
+  beforeAll(() => {
+    coinConfig.setCoinConfig(() => ({
+      status: {
+        type: "active",
+      },
+      node: {
+        url: getFullnodeUrl("mainnet"),
+      },
+    }));
+  });
+
+  it("should estimate fees for native SUI transaction", async () => {
+    const transactionIntent: TransactionIntent = {
+      sender: SENDER,
+      recipient: RECIPIENT,
+      amount: BigInt(1000),
+      type: "send",
+      asset: { type: "native" },
+    };
+
+    const estimatedFees = await estimateFees(transactionIntent);
+
+    expect(typeof estimatedFees).toBe("bigint");
+    expect(estimatedFees).toBeGreaterThan(1000n);
+    expect(estimatedFees).toBeLessThan(10000000n);
+  }, 25000);
+
+  it("should estimate fees for token transaction", async () => {
+    const coinType =
+      "0x375f70cf2ae4c00bf37117d0c85a2c71545e6ee05c4a5c7d282cd66a4504b068::usdt::USDT";
+
+    const transactionIntent: TransactionIntent = {
+      sender: SENDER,
+      recipient: RECIPIENT,
+      amount: BigInt(1000),
+      type: "send",
+      asset: {
+        type: "token",
+        assetReference: coinType,
+      },
+    };
+
+    const estimatedFees = await estimateFees(transactionIntent);
+
+    expect(typeof estimatedFees).toBe("bigint");
+    expect(estimatedFees).toBeGreaterThan(1000n);
+    expect(estimatedFees).toBeLessThan(10000000n);
+  }, 25000);
+
+  it("should handle concurrent fee estimations", async () => {
+    const transactionIntent: TransactionIntent = {
+      sender: SENDER,
+      recipient: RECIPIENT,
+      amount: BigInt(1000),
+      type: "send",
+      asset: { type: "native" },
+    };
+
+    // Run multiple concurrent estimations
+    const promises = Array(5)
+      .fill(0)
+      .map(() => estimateFees(transactionIntent));
+    const results = await Promise.all(promises);
+
+    // All results should be valid
+    results.forEach(fees => {
+      expect(typeof fees).toBe("bigint");
+      expect(fees).toBeGreaterThan(1000n);
+      expect(fees).toBeLessThan(10000000n);
+    });
+
+    // Results should be similar (may have slight variations)
+    const values = results.map(r => Number(r));
+    const minValue = Math.min(...values);
+    const maxValue = Math.max(...values);
+
+    // Should not vary by more than 50% under concurrent load
+    expect((maxValue - minValue) / minValue).toBeLessThan(0.5);
+  }, 25000);
+});

package/src/logic/estimateFees.ts

@@ -1,19 +1,25 @@
 import suiAPI from "../network";
 import { BigNumber } from "bignumber.js";
 import type { TransactionIntent } from "@ledgerhq/coin-framework/api/index";
+import { DEFAULT_COIN_TYPE } from "../network/sdk";
 
 export async function estimateFees({
   recipient,
   amount,
   sender,
+  asset,
 }: TransactionIntent): Promise<bigint> {
+  let coinType = DEFAULT_COIN_TYPE;
+  if (asset.type === "token" && asset.assetReference) {
+    coinType = asset.assetReference;
+  }
   const { gasBudget } = await suiAPI.paymentInfo(sender, {
     mode: "send",
     family: "sui",
     recipient,
     amount: BigNumber(amount.toString()),
     errors: {},
-    coinType: "0x2::sui::SUI",
+    coinType,
   });
   return BigInt(gasBudget);
 }

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

@@ -0,0 +1,66 @@
+import { getFullnodeUrl } from "@mysten/sui/client";
+import coinConfig from "../config";
+import { getBalance } from "./getBalance";
+
+const SENDER = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
+
+describe("getBalance", () => {
+  beforeAll(() => {
+    coinConfig.setCoinConfig(() => ({
+      status: {
+        type: "active",
+      },
+      node: {
+        url: getFullnodeUrl("testnet"),
+      },
+    }));
+  });
+
+  it("should fetch native SUI balance", async () => {
+    const balances = await getBalance(SENDER);
+
+    expect(balances.length).toBeGreaterThanOrEqual(1);
+    expect(balances[0]).toMatchObject({
+      asset: { type: "native" },
+    });
+
+    expect(typeof balances[0].value).toBe("bigint");
+    expect(balances[0].value).toBeGreaterThanOrEqual(0n);
+  }, 10000);
+
+  it("should fetch token balances", async () => {
+    const balances = await getBalance(SENDER);
+
+    expect(balances.length).toBeGreaterThanOrEqual(1);
+
+    const tokenBalances = balances.filter(balance => balance.asset.type === "token");
+    tokenBalances.forEach(balance => {
+      expect(balance.asset.type).toBe("token");
+      if (balance.asset.type === "token") {
+        expect(balance.asset.assetReference).toMatch(
+          /^0x[a-fA-F0-9]+::[a-zA-Z0-9_]+::[a-zA-Z0-9_]+$/,
+        );
+      }
+      expect(typeof balance.value).toBe("bigint");
+      expect(balance.value).toBeGreaterThanOrEqual(0n);
+    });
+  }, 15000);
+
+  it("should properly parse token asset reference", async () => {
+    const balances = await getBalance(SENDER);
+
+    const usdTokens = balances.filter(
+      balance =>
+        balance.asset.type === "token" &&
+        balance.asset.assetReference?.toLowerCase().includes("usd"),
+    );
+
+    usdTokens.forEach(balance => {
+      expect(balance.asset.type).toBe("token");
+      if (balance.asset.type === "token") {
+        expect(balance.asset.assetReference).toBeTruthy();
+      }
+      expect(typeof balance.value).toBe("bigint");
+    });
+  }, 15000);
+});

package/src/logic/getBalance.test.ts

@@ -1,24 +1,74 @@
 import { getBalance } from "./getBalance";
-import { getAccount } from "../network";
+import { getAllBalancesCached, getStakes } from "../network";
+import type { Stake } from "@ledgerhq/coin-framework/api/types";
 
-// Mock the getAccount function
 jest.mock("../network", () => ({
-  getAccount: jest.fn().mockResolvedValue({ balance: 1000000000 }),
+  getAllBalancesCached: jest.fn().mockResolvedValue([
+    { coinType: "0x2::sui::SUI", totalBalance: 1000000000 },
+    { coinType: "0x3::usdt::USDT", totalBalance: 500000000 },
+  ]),
+  getStakes: jest.fn().mockResolvedValue([]),
 }));
 
+const mockedGetStakes = jest.mocked(getStakes);
+
 describe("getBalance", () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
-  it("should return the correct balance as bigint", async () => {
-    // Mock the getAccount response
-    const mockBalance = { balance: 1000000000 };
+  it("should return the correct native SUI balance", async () => {
+    const address = "0x123";
+    const result = await getBalance(address);
 
+    expect(result[0]).toMatchObject({
+      value: BigInt(1000000000),
+      asset: { type: "native" },
+    });
+  });
+
+  it("should return the correct USDT token balance", async () => {
     const address = "0x123";
     const result = await getBalance(address);
 
-    expect(getAccount).toHaveBeenCalledWith(address);
-    expect(result[0].value).toBe(BigInt(mockBalance.balance.toString()));
+    expect(result[1]).toMatchObject({
+      value: BigInt(500000000),
+      asset: { type: "token", assetReference: "0x3::usdt::USDT" },
+    });
+  });
+
+  it("should return staking balances when stakes are available", async () => {
+    const mockStakes: Stake[] = [
+      {
+        uid: "stake_1",
+        address: "0x123",
+        delegate: "0xvalidator1",
+        state: "active",
+        asset: { type: "native" },
+        amount: BigInt(2000000000),
+      },
+    ];
+
+    mockedGetStakes.mockResolvedValueOnce(mockStakes);
+
+    const address = "0x123";
+    const result = await getBalance(address);
+
+    expect(getAllBalancesCached).toHaveBeenCalledWith(address);
+    expect(getStakes).toHaveBeenCalledWith(address);
+    expect(result).toHaveLength(3);
+
+    expect(result[2]).toMatchObject({
+      value: BigInt(2000000000),
+      asset: { type: "native" },
+      stake: {
+        uid: "stake_1",
+        address: "0x123",
+        delegate: "0xvalidator1",
+        state: "active",
+        asset: { type: "native" },
+        amount: BigInt(2000000000),
+      },
+    });
   });
 });

package/src/logic/getBalance.ts

@@ -1,12 +1,28 @@
-import { getAccount } from "../network";
+import { getStakes, getAllBalancesCached } from "../network";
 import { Balance } from "@ledgerhq/coin-framework/api/types";
+import { toSuiAsset } from "../network/sdk";
 
 export async function getBalance(address: string): Promise<Balance[]> {
-  const { balance } = await getAccount(address);
-  return [
-    {
-      value: BigInt(balance.toString()),
-      asset: { type: "native" },
-    },
-  ];
+  const [native, staking] = await Promise.all([
+    getNativeBalance(address),
+    getStakingBalances(address),
+  ]);
+  return [...native, ...staking];
 }
+
+const getNativeBalance = async (address: string): Promise<Balance[]> => {
+  const balances = await getAllBalancesCached(address);
+  return balances.map(({ coinType, totalBalance }) => ({
+    value: BigInt(totalBalance),
+    asset: toSuiAsset(coinType),
+  }));
+};
+
+const getStakingBalances = (address: string): Promise<Balance[]> =>
+  getStakes(address).then(stakes =>
+    stakes.map(stake => ({
+      value: stake.amount,
+      asset: stake.asset,
+      stake: stake,
+    })),
+  );

package/src/logic/index.ts

@@ -6,3 +6,4 @@ export { getBalance } from "./getBalance";
 export { lastBlock } from "./lastBlock";
 export { getBlock, getBlockInfo } from "./getBlock";
 export { listOperations } from "./listOperations";
+export { getStakes, getRewards } from "./staking";

package/src/logic/staking.ts

@@ -0,0 +1,10 @@
+import { Cursor, Page, Stake, Reward } from "@ledgerhq/coin-framework/api/types";
+import * as sdk from "../network";
+
+export const getStakes = (address: string, _cursor?: Cursor): Promise<Page<Stake>> => {
+  return sdk.getStakes(address).then(stakes => ({ items: stakes }));
+};
+
+export const getRewards = (_address: string, _cursor?: Cursor): Promise<Page<Reward>> => {
+  throw new Error("getRewards is not supported");
+};

package/src/network/index.ts

@@ -1,25 +1,34 @@
 import {
-  getAccount,
   getAccountBalances,
+  getAllBalancesCached,
   getOperations,
+  getBlock,
+  getBlockInfo,
+  getStakes,
   paymentInfo,
   createTransaction,
   executeTransactionBlock,
 } from "./sdk";
 
 export {
-  getAccount,
   getAccountBalances,
+  getAllBalancesCached,
   getOperations,
+  getBlock,
+  getBlockInfo,
+  getStakes,
   paymentInfo,
   createTransaction,
   executeTransactionBlock,
 };
 
 export default {
-  getAccount,
   getAccountBalances,
+  getAllBalancesCached,
   getOperations,
+  getBlock,
+  getBlockInfo,
+  getStakes,
   paymentInfo,
   createTransaction,
   executeTransactionBlock,

package/src/network/sdk.integration.test.ts

@@ -10,6 +10,7 @@ import {
   paymentInfo,
   getBlock,
   getBlockInfo,
+  getStakes,
 } from "./sdk";
 import { getFullnodeUrl } from "@mysten/sui/client";
 
@@ -189,26 +190,6 @@ describe("SUI SDK Integration tests", () => {
       expect(checkpointById.transactions.length).toEqual(19);
       expect(checkpointById.digest).toEqual(checkpointBySequenceNumber.digest);
     });
-    /*
-    test("getCheckpointWithTransactions", async () => {
-      const { checkpoint: checkpointById, transactions: checkpointByIdTransactions } =
-        await getCheckpointWithTransactions("3Q4zW4ieWnNgKLEq6kvVfP35PX2tBDUJERTWYyyz4eyS");
-      const {
-        checkpoint: checkpointBySequenceNumber,
-        transactions: checkpointBySequenceNumberTransactions,
-      } = await getCheckpointWithTransactions("164167623");
-      expect(checkpointById.epoch).toEqual("814");
-      expect(checkpointById.sequenceNumber).toEqual("164167623");
-      expect(checkpointById.timestampMs).toEqual("1751696298663");
-      expect(checkpointById.digest).toEqual("3Q4zW4ieWnNgKLEq6kvVfP35PX2tBDUJERTWYyyz4eyS");
-      expect(checkpointById.previousDigest).toEqual("6VKtVnpxstb968SzSrgYJ7zy5LXgFB6PnNHSJsT8Wr4E");
-      expect(checkpointById.transactions.length).toEqual(19);
-      expect(checkpointById).toEqual(checkpointBySequenceNumber);
-      expect(checkpointByIdTransactions.length).toEqual(19);
-      expect(checkpointBySequenceNumberTransactions.length).toEqual(19);
-      expect(checkpointByIdTransactions).toEqual(checkpointBySequenceNumberTransactions);
-    });
-    */
   });
 
   describe("getBlockInfo", () => {
@@ -219,7 +200,7 @@ describe("SUI SDK Integration tests", () => {
       expect(blockById.hash).toEqual("3Q4zW4ieWnNgKLEq6kvVfP35PX2tBDUJERTWYyyz4eyS");
       expect(blockById.time).toEqual(new Date(1751696298663));
       expect(blockById.parent?.height).toEqual(164167622);
-      // expect(blockById.parent?.hash).toEqual("TODO");
+      expect(blockById.parent?.hash).toEqual("6VKtVnpxstb968SzSrgYJ7zy5LXgFB6PnNHSJsT8Wr4E");
       expect(blockById).toEqual(blockBySequenceNumber);
     });
   });
@@ -232,9 +213,31 @@ describe("SUI SDK Integration tests", () => {
       expect(blockById.info.hash).toEqual("3Q4zW4ieWnNgKLEq6kvVfP35PX2tBDUJERTWYyyz4eyS");
       expect(blockById.info.time).toEqual(new Date(1751696298663));
       expect(blockById.info.parent?.height).toEqual(164167622);
-      // expect(blockById.info.parent?.hash).toEqual("TODO");
+      expect(blockById.info.parent?.hash).toEqual("6VKtVnpxstb968SzSrgYJ7zy5LXgFB6PnNHSJsT8Wr4E");
       expect(blockById.transactions.length).toEqual(19);
       expect(blockById).toEqual(blockBySequenceNumber);
     });
   });
+
+  describe("getStakes", () => {
+    test("Account 0xea438b6ce07762ea61e04af4d405dfcf197d5f77d30765f365f75460380f3cce", async () => {
+      const stakes = await getStakes(
+        "0xea438b6ce07762ea61e04af4d405dfcf197d5f77d30765f365f75460380f3cce",
+      );
+      expect(stakes.length).toBeGreaterThan(0);
+      stakes.forEach(stake => {
+        expect(stake.uid).toMatch(/0x[0-9a-z]+/);
+        expect(stake.address).toMatch(/0x[0-9a-z]+/);
+        expect(stake.delegate).toMatch(/0x[0-9a-z]+/);
+        expect(stake.state).toMatch(/(activating|active|inactive)/);
+        expect(stake.asset).toEqual({ type: "native" });
+        expect(stake.amount).toBeGreaterThan(0);
+        expect(stake.amountDeposited).toBeGreaterThan(0);
+        expect(stake.amountRewarded).toBeGreaterThanOrEqual(0);
+        // @ts-expect-error properties are defined
+        expect(stake.amount).toEqual(stake.amountDeposited + stake.amountRewarded);
+        expect(stake.details).toBeDefined();
+      });
+    });
+  });
 });

package/src/network/sdk.ts

@@ -11,6 +11,8 @@ import {
   QueryTransactionBlocksParams,
   BalanceChange,
   SuiTransactionBlockResponseOptions,
+  DelegatedStake,
+  StakeObject,
 } from "@mysten/sui/client";
 import { Transaction } from "@mysten/sui/transactions";
 import { BigNumber } from "bignumber.js";
@@ -20,6 +22,8 @@ import type {
   BlockTransaction,
   BlockOperation,
   Operation as Op,
+  Stake,
+  StakeState,
   AssetInfo,
 } from "@ledgerhq/coin-framework/api/index";
 import type { Operation, OperationType } from "@ledgerhq/types-live";
@@ -81,45 +85,29 @@ export async function withApi<T>(execute: AsyncApiFunction<T>) {
   return result;
 }
 
-export const getBalanceCached = makeLRUCache(
-  ({ api, owner }: { api: SuiClient; owner: string }) => api.getBalance({ owner }),
-  (params: { api: SuiClient; owner: string }) => params.owner,
-  minutes(1),
-);
-
 export const getAllBalancesCached = makeLRUCache(
-  ({ api, owner }: { api: SuiClient; owner: string }) =>
-    api.getAllBalances({
-      owner,
-    }),
-  (params: { api: SuiClient; owner: string }) => params.owner,
+  async (owner: string) =>
+    withApi(
+      async api =>
+        await api.getAllBalances({
+          owner,
+        }),
+    ),
+  (owner: string) => owner,
   minutes(1),
 );
 
-/**
- * Get account balance
- */
-export const getAccount = async (addr: string) =>
-  withApi(async api => {
-    const balance = await getBalanceCached({ api, owner: addr });
-    return {
-      blockHeight: BLOCK_HEIGHT * 2,
-      balance: BigNumber(balance.totalBalance),
-    };
-  });
-
 /**
  * Get account balance (native and tokens)
  */
-export const getAccountBalances = async (addr: string) =>
-  withApi(async api => {
-    const balances = await getAllBalancesCached({ api, owner: addr });
-    return balances.map(({ coinType, totalBalance }) => ({
-      coinType,
-      blockHeight: BLOCK_HEIGHT * 2,
-      balance: BigNumber(totalBalance),
-    }));
-  });
+export const getAccountBalances = async (addr: string) => {
+  const balances = await getAllBalancesCached(addr);
+  return balances.map(({ coinType, totalBalance }) => ({
+    coinType,
+    blockHeight: BLOCK_HEIGHT * 2,
+    balance: BigNumber(totalBalance),
+  }));
+};
 
 /**
  * Returns true if account is the signer
@@ -670,3 +658,51 @@ export const queryTransactionsByDigest = async (params: {
 
   return responses;
 };
+
+export const getStakes = (address: string): Promise<Stake[]> =>
+  withApi(async api =>
+    api
+      .getStakes({ owner: address })
+      .then(delegations => delegations.flatMap(delegation => toStakes(address, delegation))),
+  );
+
+export const toStakes = (address: string, delegation: DelegatedStake): Stake[] =>
+  delegation.stakes.map(stake => {
+    const { deposited, rewarded } = toStakeAmounts(stake);
+    return {
+      uid: stake.stakedSuiId,
+      address: address,
+      delegate: delegation.validatorAddress,
+      state: toStakeState(stake.status),
+      asset: { type: "native" },
+      amount: deposited + rewarded,
+      amountDeposited: deposited,
+      amountRewarded: rewarded,
+      details: {
+        activeEpoch: Number(stake.stakeActiveEpoch),
+        requestEpoch: Number(stake.stakeRequestEpoch),
+      },
+    };
+  });
+
+export const toStakeState = (status: "Pending" | "Active" | "Unstaked"): StakeState => {
+  switch (status) {
+    case "Pending":
+      return "activating";
+    case "Active":
+      return "active";
+    case "Unstaked":
+      return "inactive";
+  }
+};
+
+export const toStakeAmounts = (stake: StakeObject): { deposited: bigint; rewarded: bigint } => {
+  switch (stake.status) {
+    case "Pending":
+      return { deposited: BigInt(stake.principal), rewarded: 0n };
+    case "Active":
+      return { deposited: BigInt(stake.principal), rewarded: BigInt(stake.estimatedReward) };
+    case "Unstaked":
+      return { deposited: BigInt(stake.principal), rewarded: 0n }; // note: we lose reward information in unstaked state here
+  }
+};

package/src/test/testUtils.ts

@@ -0,0 +1,38 @@
+import { Transaction } from "@mysten/sui/transactions";
+import { SuiClient, getFullnodeUrl } from "@mysten/sui/client";
+
+export async function extractCoinTypeFromUnsignedTx(
+  unsignedTxBytes: Uint8Array,
+): Promise<string[] | null> {
+  const tx = Transaction.from(unsignedTxBytes);
+  const data = tx.getData();
+
+  const gasObjectIds = data.gasData.payment?.map(object => object.objectId) ?? [];
+  const inputObjectIds = data.inputs
+    .map(input => {
+      return input.$kind === "Object" && input.Object.$kind === "ImmOrOwnedObject"
+        ? input.Object.ImmOrOwnedObject.objectId
+        : null;
+    })
+    .filter((objectId): objectId is string => !!objectId);
+
+  const suiClient = new SuiClient({ url: getFullnodeUrl("mainnet") });
+  const objects = await suiClient.multiGetObjects({
+    ids: [...gasObjectIds, ...inputObjectIds],
+    options: {
+      showBcs: true,
+      showPreviousTransaction: true,
+      showStorageRebate: true,
+      showOwner: true,
+    },
+  });
+
+  const coinObjects = objects.filter(obj => {
+    const bcsData = obj.data?.bcs as any;
+    return bcsData.type.includes("coin");
+  });
+
+  const coinTypes: string[] = coinObjects.map(obj => (obj.data?.bcs as any).type);
+
+  return coinTypes;
+}