@ledgerhq/coin-sui 0.14.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,14 +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 bs58 from "bs58";
+import { getInputObjects } from "@mysten/signers/ledger";
 
 const apiMap: Record<string, SuiClient> = {};
 type AsyncApiFunction<T> = (api: SuiClient) => Promise<T>;
@@ -528,21 +533,6 @@ function convertApiOrderToSdkOrder(order: "asc" | "desc"): "ascending" | "descen
   return order === "asc" ? "ascending" : "descending";
 }
 
-type Cursor = {
-  out?: string;
-  in?: string;
-};
-
-function serializeCursor(cursor: Cursor): string | undefined {
-  return cursor.in || cursor.out ? bs58.encode(Buffer.from(JSON.stringify(cursor))) : undefined;
-}
-
-function deserializeCursor(b58cursor: string | undefined): Cursor {
-  return b58cursor
-    ? (JSON.parse(Buffer.from(bs58.decode(b58cursor)).toString()) as Cursor)
-    : ({} as Cursor);
-}
-
 function toSdkCursor(cursor: string | undefined): QueryTransactionBlocksParams["cursor"] {
   const ret: QueryTransactionBlocksParams["cursor"] = cursor;
   return ret;
@@ -553,20 +543,6 @@ function toSdkCursor(cursor: string | undefined): QueryTransactionBlocksParams["
  * It fetches separately the "OUT" and "IN" operations and then merge them.
  * The cursor is composed of the last "OUT" and "IN" operation cursors.
  *
- * Warning:
- * Some IN operations are also OUT operations because the sender receive a new version of the coin objects,
- * and the complexity of this function don't go that far to detect it.
- * IN calls and OUT calls are not disjoint
- * Consequence: 2 successive calls of this function when passing cursor may return an operation we already saw in previous calls,
- * fetched as an OUT operation.
- *
- * Note: I think it's possible to detect duplicated IN oprations:
- * - if the address is the sender of the tx
- * - and there is some transfer to other address
- * - and the address is the single only owner of mutated or deleted object
- * when all that conditions are met, the transaction will be fetched as an OUT operation,
- * and it can be filtered out from the IN operations results.
- *
  * @returns the operations.
  *
  */
@@ -578,43 +554,95 @@ export const getListOperations = async (
 ): Promise<Page<Op>> =>
   withApiImpl(async api => {
     const rpcOrder = convertApiOrderToSdkOrder(order);
-    const { out: outCursor, in: inCursor } = deserializeCursor(cursor);
 
     const [opsOut, opsIn] = await Promise.all([
       queryTransactions({
         api,
         addr,
         type: "OUT",
-        cursor: toSdkCursor(outCursor),
+        cursor: toSdkCursor(cursor),
         order: rpcOrder,
       }),
       queryTransactions({
         api,
         addr,
         type: "IN",
-        cursor: toSdkCursor(inCursor),
+        cursor: toSdkCursor(cursor),
         order: rpcOrder,
       }),
     ]);
 
-    const ops = [...opsOut.data, ...opsIn.data]
+    const ops = dedupOperations(opsOut, opsIn, order);
+
+    const operations = ops.operations
       .sort((a, b) => Number(b.timestampMs) - Number(a.timestampMs))
       .map(t => transactionToOp(addr, t));
 
-    const nextCursor: Cursor = {};
-    if (opsOut.hasNextPage && opsOut.nextCursor) {
-      nextCursor.out = opsOut.nextCursor;
-    }
-    if (opsIn.hasNextPage && opsIn.nextCursor) {
-      nextCursor.in = opsIn.nextCursor;
-    }
-
     return {
-      items: ops,
-      next: serializeCursor(nextCursor),
+      items: operations,
+      next: ops.cursor ?? "",
     };
   });
 
+const oldestOpTime = (ops: PaginatedTransactionResponse) =>
+  Number(ops.data[ops.data.length - 1].timestampMs ?? 0);
+const newestOpTime = (ops: PaginatedTransactionResponse) => Number(ops.data[0].timestampMs ?? 0);
+
+/**
+ * Some IN operations are also OUT operations because the sender receive a new version of the coin objects,
+ * So IN operations and OUT operations are not disjoint
+ * This function will takes the logical lowest operation of the two lists (according so sort order)
+ * and remove any higher operation of the other list.
+ *
+ * Most of the logic have been duplicated from filterOperations (used by bridge).
+ *
+ * Warning:
+ * This function removes some results, so it's not very efficient
+ * What we want is the FromOrToAddress filter from SUI RPC, but it's not supported yet
+ *
+ * Note: I think it's possible to detect duplicated IN oprations:
+ * - if the address is the sender of the tx
+ * - and there is some transfer to other address
+ * - and the address is the single only owner of mutated or deleted object
+ * when all that conditions are met, the transaction will be fetched as an OUT operation,
+ * and it can be filtered out from the IN operations results.
+ *
+ * @returns a chronologically sorted list of operations without duplicates and
+ *          a cursor that guarantee to not return any operation that was already returned in previous calls
+ *
+ */
+export const dedupOperations = (
+  outOps: PaginatedTransactionResponse,
+  inOps: PaginatedTransactionResponse,
+  order: "asc" | "desc",
+): LoadOperationResponse => {
+  // in asc order, the operations are sorted by timestamp in ascending order
+  // in desc order, the operations are sorted by timestamp in descending order
+
+  let lastOpTime: number = 0;
+  let nextCursor: string | null | undefined = undefined;
+  const findLastOpTime = order === "asc" ? newestOpTime : oldestOpTime;
+
+  // When we've reached the limit for either sent or received operations,
+  // we filter out extra operations to maintain correct chronological order
+  if (outOps.hasNextPage || inOps.hasNextPage) {
+    const lastOut = findLastOpTime(outOps);
+    const lastIn = findLastOpTime(inOps);
+    if (lastOut >= lastIn) {
+      nextCursor = outOps.nextCursor;
+      lastOpTime = lastOut;
+    } else {
+      nextCursor = inOps.nextCursor;
+      lastOpTime = lastIn;
+    }
+  }
+  const operations = [...outOps.data, ...inOps.data]
+    .sort((a, b) => Number(b.timestampMs) - Number(a.timestampMs))
+    .filter(op => Number(op.timestampMs) >= lastOpTime);
+
+  return { operations: uniqBy(operations, tx => tx.digest), cursor: nextCursor };
+};
+
 /**
  * Get a checkpoint (a.k.a, a block) metadata.
  *
@@ -710,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));
@@ -778,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 };
   });
 
 /**
@@ -786,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);
 
@@ -865,6 +905,8 @@ export const queryTransactions = async (params: {
   cursor?: QueryTransactionBlocksParams["cursor"];
 }): Promise<PaginatedTransactionResponse> => {
   const { api, addr, type, cursor, order } = params;
+  // what we really want is te  FromOrToAddress filter, but it's not supported yet
+  // it would relieve a lot of complexity (see dedupOperations)
   const filter: QueryTransactionBlocksParams["filter"] =
     type === "IN" ? { ToAddress: addr } : { FromAddress: addr };
 

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[];
 };