@ledgerhq/coin-sui 0.15.0-nightly.2 → 0.15.0

package/src/api/index.test.ts

@@ -62,7 +62,7 @@ describe("api/index", () => {
     const txIntent = { foo: "bar" } as any;
     const { transaction: result } = await api.craftTransaction(txIntent);
     expect(result).toBe(unsigned.toString("hex"));
-    expect(logic.craftTransaction).toHaveBeenCalledWith(txIntent, true);
+    expect(logic.craftTransaction).toHaveBeenCalledWith(txIntent);
   });
 
   it("should call estimateFees via estimate wrapper and return FeeEstimation", async () => {

package/src/api/index.ts

@@ -38,14 +38,9 @@ export function createApi(config: SuiConfig): AlpacaApi {
 }
 
 async function craft(transactionIntent: TransactionIntent): Promise<CraftedTransaction> {
-  const { unsigned, objects } = await craftTransaction(transactionIntent, true);
+  const { unsigned } = await craftTransaction(transactionIntent);
 
-  return {
-    transaction: Buffer.from(unsigned).toString("hex"),
-    details: {
-      objects: objects?.map(obj => Buffer.from(obj).toString("hex")),
-    },
-  };
+  return { transaction: Buffer.from(unsigned).toString("hex") };
 }
 
 async function estimate(transactionIntent: TransactionIntent): Promise<FeeEstimation> {

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

@@ -32,7 +32,6 @@ 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")]));
@@ -57,53 +56,6 @@ 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({ unsigned: mockUnsignedTx });
+    mockCreateTransaction.mockResolvedValue(mockUnsignedTx);
   });
 
   it("should create a transaction with correct parameters", async () => {
@@ -27,16 +27,12 @@ describe("craftTransaction", () => {
       asset: { type: "native" },
     });
 
-    expect(mockCreateTransaction).toHaveBeenCalledWith(
-      sender,
-      {
-        amount: new BigNumber(amount.toString()),
-        recipient,
-        mode: type,
-        coinType: "0x2::sui::SUI",
-      },
-      false,
-    );
+    expect(mockCreateTransaction).toHaveBeenCalledWith(sender, {
+      amount: new BigNumber(amount.toString()),
+      recipient,
+      mode: type,
+      coinType: "0x2::sui::SUI",
+    });
     expect(result).toEqual({ unsigned: mockUnsignedTx });
   });
 
@@ -54,16 +50,12 @@ describe("craftTransaction", () => {
       asset: { type: "native" },
     });
 
-    expect(mockCreateTransaction).toHaveBeenCalledWith(
-      sender,
-      {
-        amount: new BigNumber(amount.toString()),
-        recipient,
-        mode: type,
-        coinType: "0x2::sui::SUI",
-      },
-      false,
-    );
+    expect(mockCreateTransaction).toHaveBeenCalledWith(sender, {
+      amount: new BigNumber(amount.toString()),
+      recipient,
+      mode: type,
+      coinType: "0x2::sui::SUI",
+    });
     expect(result).toEqual({ unsigned: mockUnsignedTx });
   });
 
@@ -81,16 +73,12 @@ describe("craftTransaction", () => {
       asset: { type: "native" },
     });
 
-    expect(mockCreateTransaction).toHaveBeenCalledWith(
-      sender,
-      {
-        amount: new BigNumber(amount.toString()),
-        recipient,
-        mode: type,
-        coinType: "0x2::sui::SUI",
-      },
-      false,
-    );
+    expect(mockCreateTransaction).toHaveBeenCalledWith(sender, {
+      amount: new BigNumber(amount.toString()),
+      recipient,
+      mode: type,
+      coinType: "0x2::sui::SUI",
+    });
     expect(result).toEqual({ unsigned: mockUnsignedTx });
   });
 
@@ -108,16 +96,12 @@ describe("craftTransaction", () => {
       asset: { type: "native" },
     });
 
-    expect(mockCreateTransaction).toHaveBeenCalledWith(
-      sender,
-      {
-        amount: new BigNumber(amount.toString()),
-        recipient,
-        mode: type,
-        coinType: "0x2::sui::SUI",
-      },
-      false,
-    );
+    expect(mockCreateTransaction).toHaveBeenCalledWith(sender, {
+      amount: new BigNumber(amount.toString()),
+      recipient,
+      mode: type,
+      coinType: "0x2::sui::SUI",
+    });
     expect(result).toEqual({ unsigned: mockUnsignedTx });
   });
 

package/src/logic/craftTransaction.ts

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

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 = "0xad79719ac7edb44f6e253f1f771e8291e281a6aaf1e4789b52bf85336f525e8e";
+const SENDER = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
 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 { unsigned: tx } = await createTransaction(address, transaction);
+      const tx = await createTransaction(address, transaction);
       expect(tx).toBeInstanceOf(Uint8Array);
     });
   });
 
   describe("paymentInfo", () => {
     test("paymentInfo should return gas budget and fees", async () => {
-      const sender = "0xad79719ac7edb44f6e253f1f771e8291e281a6aaf1e4789b52bf85336f525e8e";
+      const sender = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
       const fakeTransaction = {
         mode: "send" as const,
         family: "sui" as const,

package/src/network/sdk.ts

@@ -34,19 +34,13 @@ 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,
-  CoreTransaction,
-} from "../types";
+import type { Transaction as TransactionType, SuiValidator, CreateExtrinsicArg } 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>;
@@ -738,15 +732,10 @@ 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,
-  withObjects: boolean = false,
-): Promise<CoreTransaction> =>
+export const createTransaction = async (address: string, transaction: CreateExtrinsicArg) =>
   withApi(async api => {
     const tx = new Transaction();
     tx.setSender(ensureAddressFormat(address));
@@ -811,14 +800,7 @@ export const createTransaction = async (
       }
     }
 
-    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 };
+    return tx.build({ client: api });
   });
 
 /**
@@ -826,7 +808,7 @@ export const createTransaction = async (
  */
 export const paymentInfo = async (sender: string, fakeTransaction: TransactionType) =>
   withApi(async api => {
-    const { unsigned: txb } = await createTransaction(sender, fakeTransaction);
+    const txb = await createTransaction(sender, fakeTransaction);
     const dryRunTxResponse = await api.dryRunTransactionBlock({ transactionBlock: txb });
     const fees = getTotalGasUsed(dryRunTxResponse.effects);
 

package/src/types/model.ts

@@ -3,9 +3,5 @@ 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[];
 };