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

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.test.ts

@@ -185,7 +185,7 @@ const mockTransaction = {
   ],
   timestampMs: "1742294454878",
   checkpoint: "313024",
-} as SuiTransactionBlockResponse;
+};
 
 const mockApi = new SuiClient({ url: "mock" }) as jest.Mocked<SuiClient>;
 
@@ -254,12 +254,16 @@ describe("SDK Functions", () => {
 
   test("getOperationType should return IN for incoming tx", () => {
     const address = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
-    expect(sdk.getOperationType(address, mockTransaction)).toBe("IN");
+    expect(sdk.getOperationType(address, mockTransaction as SuiTransactionBlockResponse)).toBe(
+      "IN",
+    );
   });
 
   test("getOperationType should return OUT for outgoing tx", () => {
     const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-    expect(sdk.getOperationType(address, mockTransaction)).toBe("OUT");
+    expect(sdk.getOperationType(address, mockTransaction as SuiTransactionBlockResponse)).toBe(
+      "OUT",
+    );
   });
 
   test("getOperationSenders should return sender address", () => {
@@ -274,12 +278,36 @@ describe("SDK Functions", () => {
     ).toEqual(["0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0"]);
   });
 
+  test("getOperationAmount should calculate amount correctly for SUI", () => {
+    const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
+    expect(
+      sdk.getOperationAmount(
+        address,
+        mockTransaction as SuiTransactionBlockResponse,
+        sdk.DEFAULT_COIN_TYPE,
+      ),
+    ).toEqual(new BigNumber("9998990120"));
+  });
+
+  test("getOperationAmount should calculate amount correctly for tokens", () => {
+    const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
+    expect(
+      sdk.getOperationAmount(
+        address,
+        mockTransaction as SuiTransactionBlockResponse,
+        "0x123::test::TOKEN",
+      ),
+    ).toEqual(new BigNumber("500000"));
+  });
+
   test("getOperationFee should calculate fee correctly", () => {
-    expect(sdk.getOperationFee(mockTransaction)).toEqual(new BigNumber(1009880));
+    expect(sdk.getOperationFee(mockTransaction as SuiTransactionBlockResponse)).toEqual(
+      new BigNumber(1009880),
+    );
   });
 
   test("getOperationDate should return correct date", () => {
-    const date = sdk.getOperationDate(mockTransaction);
+    const date = sdk.getOperationDate(mockTransaction as SuiTransactionBlockResponse);
     expect(date).toBeDefined();
     expect(date).toBeInstanceOf(Date);
   });
@@ -449,7 +477,7 @@ describe("SDK Functions", () => {
       ],
     };
 
-    const operation = sdk.alpacaTransactionToOp(address, tokenTx as SuiTransactionBlockResponse);
+    const operation = sdk.transactionToOp(address, tokenTx as SuiTransactionBlockResponse);
     expect(operation.id).toEqual("DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt");
     expect(operation.type).toEqual("IN");
     expect(operation.senders).toEqual([
@@ -615,34 +643,41 @@ describe("Staking Operations", () => {
   });
 
   describe("Operation Amount Calculation", () => {
-    const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
+    test("getOperationAmount should calculate staking amount correctly", () => {
+      const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
 
-    const mockStakingTx = {
-      transaction: {
-        data: {
-          transaction: {
-            kind: "ProgrammableTransaction",
-            transactions: [
-              {
-                MoveCall: {
-                  function: "request_add_stake",
+      const mockStakingTx = {
+        transaction: {
+          data: {
+            transaction: {
+              kind: "ProgrammableTransaction",
+              transactions: [
+                {
+                  MoveCall: {
+                    function: "request_add_stake",
+                  },
                 },
-              },
-            ],
+              ],
+            },
           },
         },
-      },
-      balanceChanges: [
-        {
-          owner: { AddressOwner: address },
-          coinType: "0x2::sui::SUI",
-          amount: "-1000000000",
-        },
-      ],
-    } as SuiTransactionBlockResponse;
+        balanceChanges: [
+          {
+            owner: { AddressOwner: address },
+            coinType: "0x2::sui::SUI",
+            amount: "-1000000000",
+          },
+        ],
+      } as unknown as SuiTransactionBlockResponse;
 
-    function mockUnstakingTx(amount: string) {
-      return {
+      const amount = sdk.getOperationAmount(address, mockStakingTx, sdk.DEFAULT_COIN_TYPE);
+      expect(amount).toEqual(new BigNumber("1000000000")); // The function returns minus of the balance change
+    });
+
+    test("getOperationAmount should calculate unstaking amount correctly", () => {
+      const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
+
+      const mockUnstakingTx = {
         transaction: {
           data: {
             transaction: {
@@ -661,59 +696,14 @@ describe("Staking Operations", () => {
           {
             owner: { AddressOwner: address },
             coinType: "0x2::sui::SUI",
-            amount: amount,
+            amount: "0",
           },
         ],
-      } as SuiTransactionBlockResponse;
-    }
-
-    function bridgeOperationAmount(
-      mock: SuiTransactionBlockResponse,
-      coinType: string = sdk.DEFAULT_COIN_TYPE,
-    ) {
-      return sdk.getOperationAmount(address, mock, coinType);
-    }
-
-    test("getOperationAmount should calculate staking amount", () =>
-      expect(bridgeOperationAmount(mockStakingTx)).toEqual(new BigNumber("1000000000")));
-
-    test("getOperationAmount should calculate unstaking amount of 1000", () =>
-      expect(bridgeOperationAmount(mockUnstakingTx("1000"))).toEqual(new BigNumber("-1000")));
-
-    test("getOperationAmount should calculate unstaking amount of 0", () =>
-      expect(bridgeOperationAmount(mockUnstakingTx("0"))).toEqual(new BigNumber("0")));
-
-    test("getOperationAmount should calculate amount correctly for SUI", () =>
-      expect(bridgeOperationAmount(mockTransaction)).toEqual(new BigNumber("9998990120")));
-
-    test("getOperationAmount should calculate amount correctly for tokens", () =>
-      expect(bridgeOperationAmount(mockTransaction, "0x123::test::TOKEN")).toEqual(
-        new BigNumber("500000"),
-      ));
-
-    function alpacaOperationAmount(
-      mock: SuiTransactionBlockResponse,
-      coinType: string = sdk.DEFAULT_COIN_TYPE,
-    ) {
-      return sdk.alpacaGetOperationAmount(address, mock, coinType);
-    }
-
-    test("alpaca getOperationAmount should calculate staking amount", () =>
-      expect(alpacaOperationAmount(mockStakingTx)).toEqual(new BigNumber("1000000000")));
-
-    test("alpaca getOperationAmount should calculate unstaking amount of 1000", () =>
-      expect(alpacaOperationAmount(mockUnstakingTx("1000"))).toEqual(new BigNumber("1000")));
-
-    test("alpaca getOperationAmount should calculate unstaking amount of 0", () =>
-      expect(alpacaOperationAmount(mockUnstakingTx("0"))).toEqual(new BigNumber("0")));
-
-    test("alpaca getOperationAmount should calculate amount correctly for SUI", () =>
-      expect(alpacaOperationAmount(mockTransaction)).toEqual(new BigNumber("9998990120")));
+      } as unknown as SuiTransactionBlockResponse;
 
-    test("alpaca getOperationAmount should calculate amount correctly for tokens", () =>
-      expect(alpacaOperationAmount(mockTransaction, "0x123::test::TOKEN")).toEqual(
-        new BigNumber("500000"),
-      ));
+      const amount = sdk.getOperationAmount(address, mockUnstakingTx, sdk.DEFAULT_COIN_TYPE);
+      expect(amount).toEqual(new BigNumber("0"));
+    });
   });
 
   describe("Operation Recipients", () => {
@@ -994,7 +984,7 @@ describe("Staking Operations", () => {
         checkpoint: "313024",
       } as unknown as SuiTransactionBlockResponse;
 
-      const operation = sdk.alpacaTransactionToOp(address, mockStakingTx);
+      const operation = sdk.transactionToOp(address, mockStakingTx);
 
       expect(operation.id).toEqual("delegate_tx_digest_123");
       expect(operation.type).toEqual("DELEGATE");
@@ -1045,7 +1035,7 @@ describe("Staking Operations", () => {
         checkpoint: "313024",
       } as unknown as SuiTransactionBlockResponse;
 
-      const operation = sdk.alpacaTransactionToOp(address, mockUnstakingTx);
+      const operation = sdk.transactionToOp(address, mockUnstakingTx);
 
       expect(operation.id).toEqual("undelegate_tx_digest_456");
       expect(operation.type).toEqual("UNDELEGATE");

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>;
@@ -108,31 +102,32 @@ export const getAllBalancesCached = makeLRUCache(
   (owner: string) => owner,
   minutes(1),
 );
-
-type ProgrammableTransaction = {
+function isStaking(block?: SuiTransactionBlockKind): block is {
   inputs: SuiCallArg[];
   kind: "ProgrammableTransaction";
   transactions: SuiTransaction[];
-};
-
-function isMoveCallWithFunction(
-  functionName: string,
-  block?: SuiTransactionBlockKind,
-): block is ProgrammableTransaction {
-  if (block?.kind === "ProgrammableTransaction") {
+} {
+  if (!block) return false;
+  if (block.kind === "ProgrammableTransaction") {
     const move = block.transactions.find(item => "MoveCall" in item) as any;
-    return move?.MoveCall.function === functionName;
-  } else {
-    return false;
+    return move?.MoveCall.function === "request_add_stake";
   }
+  return false;
 }
 
-function isStaking(block?: SuiTransactionBlockKind): block is ProgrammableTransaction {
-  return isMoveCallWithFunction("request_add_stake", block);
-}
-
-function isUnstaking(block?: SuiTransactionBlockKind): block is ProgrammableTransaction {
-  return isMoveCallWithFunction("request_withdraw_stake", block);
+function isUnstaking(block?: SuiTransactionBlockKind): block is {
+  inputs: SuiCallArg[];
+  kind: "ProgrammableTransaction";
+  transactions: SuiTransaction[];
+} {
+  if (!block) return false;
+  if (block.kind === "ProgrammableTransaction") {
+    const move = block.transactions.find(
+      item => "MoveCall" in item && item["MoveCall"].function === "request_withdraw_stake",
+    ) as any;
+    return Boolean(move);
+  }
+  return false;
 }
 
 /**
@@ -341,48 +336,11 @@ export function transactionToOperation(
   };
 }
 
-// This function is only used by alpaca code path
-// Logic is similar to getOperationAmount, but we guarantee to return a positive amount in any case
-// If there is need to display negative amount for staking or unstaking, the view can handle it based on the type of the operation
-export const alpacaGetOperationAmount = (
-  address: string,
-  transaction: SuiTransactionBlockResponse,
-  coinType: string,
-): BigNumber => {
-  const absoluteAmount = (balanceChange: BalanceChange | undefined) =>
-    new BigNumber(balanceChange?.amount || 0).abs();
-
-  const zero = BigNumber(0);
-
-  const tx = transaction.transaction?.data.transaction;
-
-  if (isStaking(tx) || isUnstaking(tx)) return absoluteAmount(transaction.balanceChanges?.[0]);
-  else {
-    return (
-      transaction.balanceChanges
-        ?.filter(
-          balanceChange =>
-            typeof balanceChange.owner !== "string" &&
-            "AddressOwner" in balanceChange.owner &&
-            balanceChange.owner.AddressOwner === address &&
-            balanceChange.coinType === coinType,
-        )
-        .map(absoluteAmount)
-        .reduce((acc, curr) => acc.plus(curr), zero) || zero
-    );
-  }
-};
-
 /**
- * This function is only used by alpaca code path
- *
  * @returns the operation converted. Note that if param `transaction` was retrieved as an "IN" operations, the type may be converted to "OUT".
  *    It happens for most "OUT" operations because the sender receive a new version of the coin objects.
  */
-export function alpacaTransactionToOp(
-  address: string,
-  transaction: SuiTransactionBlockResponse,
-): Op {
+export function transactionToOp(address: string, transaction: SuiTransactionBlockResponse): Op {
   const type = getOperationType(address, transaction);
   const coinType = getOperationCoinType(transaction);
   const hash = transaction.digest;
@@ -401,7 +359,7 @@ export function alpacaTransactionToOp(
     recipients: getOperationRecipients(transaction.transaction?.data),
     senders: getOperationSenders(transaction.transaction?.data),
     type,
-    value: BigInt(alpacaGetOperationAmount(address, transaction, coinType).toString()),
+    value: BigInt(getOperationAmount(address, transaction, coinType).toString()),
   };
 }
 
@@ -612,7 +570,7 @@ export const getListOperations = async (
 
     const operations = ops.operations
       .sort((a, b) => Number(b.timestampMs) - Number(a.timestampMs))
-      .map(t => alpacaTransactionToOp(addr, t));
+      .map(t => transactionToOp(addr, t));
 
     return {
       items: operations,
@@ -774,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));
@@ -847,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 });
   });
 
 /**
@@ -862,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[];
 };