@ledgerhq/coin-sui 0.9.0 → 0.10.0-nightly.1

package/src/bridge/buildTransaction.test.ts

@@ -1,6 +1,7 @@
 import { BigNumber } from "bignumber.js";
-import { buildTransaction, extractExtrinsicArg } from "./buildTransaction";
+import { buildTransaction } from "./buildTransaction";
 import type { SuiAccount, Transaction } from "../types";
+import { createFixtureAccount } from "../types/bridge.fixture";
 
 // Mock the craftTransaction function
 jest.mock("../logic", () => ({
@@ -64,7 +65,7 @@ describe("buildTransaction", () => {
   });
 
   describe("buildTransaction", () => {
-    it("should call craftTransaction with correct parameters", async () => {
+    it("should call craftTransaction with correct parameters for native asset", async () => {
       // WHEN
       await buildTransaction(mockAccount, mockTransaction);
 
@@ -78,6 +79,40 @@ describe("buildTransaction", () => {
       });
     });
 
+    it("should call craftTransaction with correct parameters for token asset", async () => {
+      const account = createFixtureAccount({
+        id: "parentAccountId",
+        balance: BigNumber(0),
+        spendableBalance: BigNumber(0),
+        subAccounts: [
+          createFixtureAccount({
+            id: "subAccountId",
+            parentId: "parentAccountId",
+            type: "TokenAccount",
+            token: {
+              contractAddress: "0x3::usdt::USDT",
+            },
+          }),
+        ],
+      });
+
+      // WHEN
+      await buildTransaction(account, {
+        ...mockTransaction,
+        subAccountId: "subAccountId",
+        coinType: "0x3::usdt::USDT",
+      });
+
+      // THEN
+      expect(craftTransaction).toHaveBeenCalledWith({
+        sender: account.freshAddress,
+        recipient: mockTransaction.recipient,
+        type: mockTransaction.mode,
+        amount: BigInt(mockTransaction.amount!.toString()),
+        asset: { type: "token", assetReference: "0x3::usdt::USDT" },
+      });
+    });
+
     it("should return the result from craftTransaction", async () => {
       const expectedResult = {
         unsigned: new Uint8Array([1, 2, 3, 4, 5]),
@@ -207,164 +242,6 @@ describe("buildTransaction", () => {
     });
   });
 
-  describe("extractExtrinsicArg", () => {
-    it("should extract correct fields from transaction", () => {
-      const transaction: Transaction = {
-        ...mockTransaction,
-        useAllAmount: true,
-      };
-
-      // WHEN
-      const result = extractExtrinsicArg(transaction);
-
-      // THEN
-      expect(result).toEqual({
-        mode: "send",
-        coinType: "0x2::sui::SUI",
-        amount: new BigNumber("100000000"),
-        recipient: "0xabcdef1234567890",
-        useAllAmount: true,
-      });
-    });
-
-    it("should handle transaction without useAllAmount", () => {
-      const transaction: Transaction = {
-        ...mockTransaction,
-        useAllAmount: false,
-      };
-
-      // WHEN
-      const result = extractExtrinsicArg(transaction);
-
-      // THEN
-      expect(result).toEqual({
-        mode: "send",
-        coinType: "0x2::sui::SUI",
-        amount: new BigNumber("100000000"),
-        recipient: "0xabcdef1234567890",
-        useAllAmount: false,
-      });
-    });
-
-    it("should handle transaction with undefined useAllAmount", () => {
-      const transaction = {
-        ...mockTransaction,
-        useAllAmount: undefined,
-      } as any;
-
-      // WHEN
-      const result = extractExtrinsicArg(transaction);
-
-      // THEN
-      expect(result).toEqual({
-        mode: "send",
-        coinType: "0x2::sui::SUI",
-        amount: new BigNumber("100000000"),
-        recipient: "0xabcdef1234567890",
-        useAllAmount: undefined,
-      });
-    });
-
-    it("should handle different transaction modes", () => {
-      const transaction: Transaction = {
-        ...mockTransaction,
-        mode: "send",
-      };
-
-      // WHEN
-      const result = extractExtrinsicArg(transaction);
-
-      // THEN
-      expect(result.mode).toBe("send");
-    });
-
-    it("should handle different amounts", () => {
-      const transaction: Transaction = {
-        ...mockTransaction,
-        amount: new BigNumber("500000000"),
-      };
-
-      // WHEN
-      const result = extractExtrinsicArg(transaction);
-
-      // THEN
-      expect(result.amount).toEqual(new BigNumber("500000000"));
-    });
-
-    it("should handle different recipients", () => {
-      const transaction: Transaction = {
-        ...mockTransaction,
-        recipient: "0x9876543210fedcba",
-      };
-
-      // WHEN
-      const result = extractExtrinsicArg(transaction);
-
-      // THEN
-      expect(result.recipient).toBe("0x9876543210fedcba");
-    });
-
-    it("should not include other transaction fields", () => {
-      const transaction: Transaction = {
-        ...mockTransaction,
-        fees: new BigNumber("1000000"),
-        errors: { someError: new Error("test") },
-      };
-
-      // WHEN
-      const result = extractExtrinsicArg(transaction);
-
-      // THEN
-      expect(result).not.toHaveProperty("fees");
-      expect(result).not.toHaveProperty("errors");
-      expect(result).not.toHaveProperty("family");
-      expect(result).not.toHaveProperty("id");
-    });
-
-    it("should handle zero amount", () => {
-      const transaction: Transaction = {
-        ...mockTransaction,
-        amount: new BigNumber("0"),
-      };
-
-      // WHEN
-      const result = extractExtrinsicArg(transaction);
-
-      // THEN
-      expect(result.amount).toEqual(new BigNumber("0"));
-    });
-  });
-
-  describe("Integration between extractExtrinsicArg and buildTransaction", () => {
-    it("should work together correctly", async () => {
-      const transaction: Transaction = {
-        ...mockTransaction,
-        useAllAmount: true,
-      };
-
-      // Extract extrinsic arg
-      const extrinsicArg = extractExtrinsicArg(transaction);
-
-      // Build transaction
-      await buildTransaction(mockAccount, transaction);
-
-      // Verify that the extracted arg contains the expected fields
-      expect(extrinsicArg).toHaveProperty("mode", "send");
-      expect(extrinsicArg).toHaveProperty("amount");
-      expect(extrinsicArg).toHaveProperty("recipient");
-      expect(extrinsicArg).toHaveProperty("useAllAmount", true);
-
-      // Verify that buildTransaction was called with correct parameters
-      expect(craftTransaction).toHaveBeenCalledWith({
-        sender: mockAccount.freshAddress,
-        recipient: transaction.recipient,
-        type: transaction.mode,
-        amount: BigInt(transaction.amount!.toString()),
-        asset: { type: "native" },
-      });
-    });
-  });
-
   describe("Edge Cases", () => {
     it("should handle empty recipient string", async () => {
       const transactionWithEmptyRecipient: Transaction = {

package/src/bridge/buildTransaction.ts

@@ -1,34 +1,25 @@
-import pick from "lodash/pick";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
 import type { SuiAccount, Transaction } from "../types";
-import { craftTransaction, type CreateExtrinsicArg } from "../logic";
-import { AssetInfo } from "@ledgerhq/coin-framework/api/types";
-
-export const extractExtrinsicArg = (transaction: Transaction): CreateExtrinsicArg =>
-  pick(transaction, ["mode", "amount", "recipient", "useAllAmount", "coinType"]);
+import { craftTransaction } from "../logic";
+import { DEFAULT_COIN_TYPE, toSuiAsset } from "../network/sdk";
 
 /**
  * @param {Account} account
  * @param {Transaction} transaction
  */
 export const buildTransaction = async (
-  { freshAddress }: SuiAccount,
-  { recipient, mode, amount, coinType }: Transaction,
+  account: SuiAccount,
+  { amount, mode, recipient, subAccountId }: Transaction,
 ) => {
-  const NATIVE_COIN_TYPE = "0x2::sui::SUI"; // <-- NOTE: unusure, double check
-  let asset: AssetInfo = {
-    type: "native",
-  };
-  if (coinType !== NATIVE_COIN_TYPE) {
-    asset = {
-      type: "token",
-      assetReference: coinType,
-    };
-  }
+  const { freshAddress } = account;
+  const subAccount = findSubAccountById(account, subAccountId ?? "");
+  const asset = toSuiAsset(subAccount?.token.contractAddress ?? DEFAULT_COIN_TYPE);
+
   return craftTransaction({
-    sender: freshAddress,
-    recipient,
-    type: mode,
     amount: BigInt(amount.toString()),
     asset,
+    recipient,
+    sender: freshAddress,
+    type: mode,
   });
 };

package/src/bridge/getFeesForTransaction.ts

@@ -1,8 +1,10 @@
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
 import { BigNumber } from "bignumber.js";
 import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
 import type { SuiAccount, Transaction } from "../types";
 import { calculateAmount } from "./utils";
 import { estimateFees } from "../logic";
+import { DEFAULT_COIN_TYPE, toSuiAsset } from "../network/sdk";
 
 /**
  * Fetch the transaction fees for a transaction
@@ -32,12 +34,15 @@ export default async function getEstimatedFees({
     }), // Remove fees if present since we are fetching fees
   };
 
+  const subAccount = findSubAccountById(account, transaction.subAccountId ?? "");
+  const asset = toSuiAsset(subAccount?.token.contractAddress ?? DEFAULT_COIN_TYPE);
+
   const fees = await estimateFees({
     recipient: getAbandonSeedAddress(account.currency.id),
     sender: account.freshAddress,
     amount: BigInt(t.amount.toString()),
     type: "send",
-    asset: { type: "native" },
+    asset,
   });
   return new BigNumber(fees.toString());
 }

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

@@ -0,0 +1,63 @@
+import type { TransactionIntent } from "@ledgerhq/coin-framework/api/index";
+import { getFullnodeUrl } from "@mysten/sui/client";
+import coinConfig from "../config";
+import { extractCoinTypeFromUnsignedTx } from "../test/testUtils";
+import { craftTransaction } from "./craftTransaction";
+
+const SENDER = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
+const RECIPIENT = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
+
+describe("craftTransaction", () => {
+  beforeAll(() => {
+    coinConfig.setCoinConfig(() => ({
+      status: {
+        type: "active",
+      },
+      node: {
+        url: getFullnodeUrl("mainnet"),
+      },
+    }));
+  });
+
+  it("should craft a native SUI send transaction", async () => {
+    const transactionIntent: TransactionIntent = {
+      sender: SENDER,
+      recipient: RECIPIENT,
+      amount: BigInt(1000),
+      type: "send",
+      asset: { type: "native" },
+    };
+
+    const result = await craftTransaction(transactionIntent);
+
+    expect(result).toBeDefined();
+    expect(result.unsigned).toBeInstanceOf(Uint8Array);
+
+    const resultCoinTypes = await extractCoinTypeFromUnsignedTx(result.unsigned);
+    expect(resultCoinTypes).toEqual(expect.arrayContaining([expect.stringContaining("sui")]));
+  }, 15000);
+
+  it("should craft a token send 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 result = await craftTransaction(transactionIntent);
+
+    expect(result).toBeDefined();
+    expect(result.unsigned).toBeInstanceOf(Uint8Array);
+
+    const resultCoinTypes = await extractCoinTypeFromUnsignedTx(result.unsigned);
+    expect(resultCoinTypes).toEqual(expect.arrayContaining([expect.stringContaining("usdt")]));
+  }, 15000);
+});

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;
@@ -25,9 +25,9 @@ export async function craftTransaction({
   }
   const unsigned = await suiAPI.createTransaction(sender, {
     amount: BigNumber(amount.toString()),
-    recipient,
     coinType,
     mode: type as SuiTransactionMode,
+    recipient,
   });
 
   return { unsigned };

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),
+      },
+    });
   });
 });