@ledgerhq/coin-sui 0.14.1-nightly.0 → 0.15.0-nightly.1

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

@@ -32,6 +32,7 @@ describe("craftTransaction", () => {
 
     expect(result).toBeDefined();
     expect(result.unsigned).toBeInstanceOf(Uint8Array);
+    expect(result.objects).toBeUndefined();
 
     const resultCoinTypes = await extractCoinTypeFromUnsignedTx(result.unsigned);
     expect(resultCoinTypes).toEqual(expect.arrayContaining([expect.stringContaining("sui")]));
@@ -56,6 +57,53 @@ describe("craftTransaction", () => {
 
     expect(result).toBeDefined();
     expect(result.unsigned).toBeInstanceOf(Uint8Array);
+    expect(result.objects).toBeUndefined();
+
+    const resultCoinTypes = await extractCoinTypeFromUnsignedTx(result.unsigned);
+    expect(resultCoinTypes).toEqual(expect.arrayContaining([expect.stringContaining("usdt")]));
+  }, 15000);
+
+  it("should craft a native SUI send transaction, returning serialized objects when requested", async () => {
+    const transactionIntent: TransactionIntent = {
+      sender: SENDER,
+      recipient: RECIPIENT,
+      amount: BigInt(1000),
+      type: "send",
+      asset: { type: "native" },
+    };
+
+    const result = await craftTransaction(transactionIntent, true);
+
+    expect(result).toBeDefined();
+    expect(result.unsigned).toBeInstanceOf(Uint8Array);
+    expect(result.objects).toBeDefined();
+    expect(result.objects?.length).toBeGreaterThan(0);
+
+    const resultCoinTypes = await extractCoinTypeFromUnsignedTx(result.unsigned);
+    expect(resultCoinTypes).toEqual(expect.arrayContaining([expect.stringContaining("sui")]));
+  }, 15000);
+
+  it("should craft a token send transaction, returning serialized objects when requested", 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, true);
+
+    expect(result).toBeDefined();
+    expect(result.unsigned).toBeInstanceOf(Uint8Array);
+    expect(result.objects).toBeDefined();
+    expect(result.objects?.length).toBeGreaterThan(0);
 
     const resultCoinTypes = await extractCoinTypeFromUnsignedTx(result.unsigned);
     expect(resultCoinTypes).toEqual(expect.arrayContaining([expect.stringContaining("usdt")]));

package/src/logic/craftTransaction.test.ts

@@ -10,7 +10,7 @@ describe("craftTransaction", () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
-    mockCreateTransaction.mockResolvedValue(mockUnsignedTx);
+    mockCreateTransaction.mockResolvedValue({ unsigned: mockUnsignedTx });
   });
 
   it("should create a transaction with correct parameters", async () => {
@@ -27,12 +27,16 @@ describe("craftTransaction", () => {
       asset: { type: "native" },
     });
 
-    expect(mockCreateTransaction).toHaveBeenCalledWith(sender, {
-      amount: new BigNumber(amount.toString()),
-      recipient,
-      mode: type,
-      coinType: "0x2::sui::SUI",
-    });
+    expect(mockCreateTransaction).toHaveBeenCalledWith(
+      sender,
+      {
+        amount: new BigNumber(amount.toString()),
+        recipient,
+        mode: type,
+        coinType: "0x2::sui::SUI",
+      },
+      false,
+    );
     expect(result).toEqual({ unsigned: mockUnsignedTx });
   });
 
@@ -50,12 +54,16 @@ describe("craftTransaction", () => {
       asset: { type: "native" },
     });
 
-    expect(mockCreateTransaction).toHaveBeenCalledWith(sender, {
-      amount: new BigNumber(amount.toString()),
-      recipient,
-      mode: type,
-      coinType: "0x2::sui::SUI",
-    });
+    expect(mockCreateTransaction).toHaveBeenCalledWith(
+      sender,
+      {
+        amount: new BigNumber(amount.toString()),
+        recipient,
+        mode: type,
+        coinType: "0x2::sui::SUI",
+      },
+      false,
+    );
     expect(result).toEqual({ unsigned: mockUnsignedTx });
   });
 
@@ -73,12 +81,16 @@ describe("craftTransaction", () => {
       asset: { type: "native" },
     });
 
-    expect(mockCreateTransaction).toHaveBeenCalledWith(sender, {
-      amount: new BigNumber(amount.toString()),
-      recipient,
-      mode: type,
-      coinType: "0x2::sui::SUI",
-    });
+    expect(mockCreateTransaction).toHaveBeenCalledWith(
+      sender,
+      {
+        amount: new BigNumber(amount.toString()),
+        recipient,
+        mode: type,
+        coinType: "0x2::sui::SUI",
+      },
+      false,
+    );
     expect(result).toEqual({ unsigned: mockUnsignedTx });
   });
 
@@ -96,12 +108,16 @@ describe("craftTransaction", () => {
       asset: { type: "native" },
     });
 
-    expect(mockCreateTransaction).toHaveBeenCalledWith(sender, {
-      amount: new BigNumber(amount.toString()),
-      recipient,
-      mode: type,
-      coinType: "0x2::sui::SUI",
-    });
+    expect(mockCreateTransaction).toHaveBeenCalledWith(
+      sender,
+      {
+        amount: new BigNumber(amount.toString()),
+        recipient,
+        mode: type,
+        coinType: "0x2::sui::SUI",
+      },
+      false,
+    );
     expect(result).toEqual({ unsigned: mockUnsignedTx });
   });
 

package/src/logic/craftTransaction.ts

@@ -4,28 +4,33 @@ import type { SuiTransactionMode, CoreTransaction } from "../types";
 import suiAPI from "../network";
 import { DEFAULT_COIN_TYPE } from "../network/sdk";
 
-export async function craftTransaction({
-  amount,
-  asset,
-  recipient,
-  sender,
-  type,
-  ...extra
-}: TransactionIntent & {
-  useAllAmount?: boolean;
-  stakedSuiId?: string;
-}): Promise<CoreTransaction> {
+export async function craftTransaction(
+  {
+    amount,
+    asset,
+    recipient,
+    sender,
+    type,
+    ...extra
+  }: TransactionIntent & {
+    useAllAmount?: boolean;
+    stakedSuiId?: string;
+  },
+  withObjects: boolean = false,
+): Promise<CoreTransaction> {
   let coinType = DEFAULT_COIN_TYPE;
   if (asset.type === "token" && asset.assetReference) {
     coinType = asset.assetReference;
   }
-  const unsigned = await suiAPI.createTransaction(sender, {
-    amount: BigNumber(amount.toString()),
-    coinType,
-    mode: type as SuiTransactionMode,
-    recipient,
-    ...extra,
-  });
-
-  return { unsigned };
+  return suiAPI.createTransaction(
+    sender,
+    {
+      amount: BigNumber(amount.toString()),
+      coinType,
+      mode: type as SuiTransactionMode,
+      recipient,
+      ...extra,
+    },
+    withObjects,
+  );
 }

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

@@ -3,7 +3,7 @@ import { getFullnodeUrl } from "@mysten/sui/client";
 import coinConfig from "../config";
 import { estimateFees } from "./estimateFees";
 
-const SENDER = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
+const SENDER = "0xad79719ac7edb44f6e253f1f771e8291e281a6aaf1e4789b52bf85336f525e8e";
 const RECIPIENT = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
 
 describe("estimateFees", () => {

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

@@ -155,14 +155,14 @@ describe("SUI SDK Integration tests", () => {
         recipient: "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164",
         errors: {},
       };
-      const tx = await createTransaction(address, transaction);
+      const { unsigned: tx } = await createTransaction(address, transaction);
       expect(tx).toBeInstanceOf(Uint8Array);
     });
   });
 
   describe("paymentInfo", () => {
     test("paymentInfo should return gas budget and fees", async () => {
-      const sender = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
+      const sender = "0xad79719ac7edb44f6e253f1f771e8291e281a6aaf1e4789b52bf85336f525e8e";
       const fakeTransaction = {
         mode: "send" as const,
         family: "sui" as const,

package/src/network/sdk.ts

@@ -34,13 +34,19 @@ import uniqBy from "lodash/unionBy";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { log } from "@ledgerhq/logs";
 import { makeLRUCache, minutes } from "@ledgerhq/live-network/cache";
-import type { Transaction as TransactionType, SuiValidator, CreateExtrinsicArg } from "../types";
+import type {
+  Transaction as TransactionType,
+  SuiValidator,
+  CreateExtrinsicArg,
+  CoreTransaction,
+} from "../types";
 import { ensureAddressFormat } from "../utils";
 import coinConfig from "../config";
 import { getEnv } from "@ledgerhq/live-env";
 import { SUI_SYSTEM_STATE_OBJECT_ID } from "@mysten/sui/utils";
 import { getCurrentSuiPreloadData } from "../bridge/preload";
 import { ONE_SUI } from "../constants";
+import { getInputObjects } from "@mysten/signers/ledger";
 
 const apiMap: Record<string, SuiClient> = {};
 type AsyncApiFunction<T> = (api: SuiClient) => Promise<T>;
@@ -732,10 +738,15 @@ export const getCoinsForAmount = async (
  *
  * @param address - The sender's address
  * @param transaction - The transaction details including recipient, amount, and coin type
+ * @param withObjects - Return serialized input objects used in the transaction
  * @returns Promise<TransactionBlock> - A built transaction block ready for execution
  *
  */
-export const createTransaction = async (address: string, transaction: CreateExtrinsicArg) =>
+export const createTransaction = async (
+  address: string,
+  transaction: CreateExtrinsicArg,
+  withObjects: boolean = false,
+): Promise<CoreTransaction> =>
   withApi(async api => {
     const tx = new Transaction();
     tx.setSender(ensureAddressFormat(address));
@@ -800,7 +811,14 @@ export const createTransaction = async (address: string, transaction: CreateExtr
       }
     }
 
-    return tx.build({ client: api });
+    const serialized = await tx.build({ client: api });
+
+    if (withObjects) {
+      const { bcsObjects } = await getInputObjects(tx, api);
+      return { unsigned: serialized, objects: bcsObjects as Uint8Array[] };
+    }
+
+    return { unsigned: serialized };
   });
 
 /**
@@ -808,7 +826,7 @@ export const createTransaction = async (address: string, transaction: CreateExtr
  */
 export const paymentInfo = async (sender: string, fakeTransaction: TransactionType) =>
   withApi(async api => {
-    const txb = await createTransaction(sender, fakeTransaction);
+    const { unsigned: txb } = await createTransaction(sender, fakeTransaction);
     const dryRunTxResponse = await api.dryRunTransactionBlock({ transactionBlock: txb });
     const fees = getTotalGasUsed(dryRunTxResponse.effects);
 

package/src/types/model.ts

@@ -3,5 +3,9 @@ export type SuiOperationMode = "send";
 export type AccountInfoResponse = Record<string, string>;
 
 export type CoreTransaction = {
+  /** The transaction in a serialized format, ready to be signed. */
   unsigned: Uint8Array;
+
+  /** The input objects referenced in the transaction, in serialized form.. */
+  objects?: Uint8Array[];
 };