@ledgerhq/coin-sui 0.16.1-nightly.0 → 0.17.0-nightly.1

package/src/network/sdk.test.ts

@@ -236,7 +236,6 @@ function mockStakingTx(address: string, amount: string) {
 
 // amount must be a positive number
 function mockUnstakingTx(address: string, amount: string) {
-  assert(new BigNumber(amount).gte(0), "amount must be a positive number");
   return {
     digest: "undelegate_tx_digest_456",
     transaction: {
@@ -696,17 +695,20 @@ describe("Staking Operations", () => {
     }
 
     test("alpaca getOperationAmount should calculate staking amount", () =>
-      expect(alpacaOperationAmount(mockStakingTx(address, "-1000000000"))).toEqual(
+      expect(alpacaOperationAmount(mockStakingTx(address, "-1001050000"))).toEqual(
         new BigNumber("1000000000"),
       ));
 
+    // 1000 unstaked & 1050000 gas fees = -1049000 balance change
     test("alpaca getOperationAmount should calculate unstaking amount of 1000", () =>
-      expect(alpacaOperationAmount(mockUnstakingTx(address, "1000"))).toEqual(
+      expect(alpacaOperationAmount(mockUnstakingTx(address, "-1049000"))).toEqual(
         new BigNumber("1000"),
       ));
 
     test("alpaca getOperationAmount should calculate unstaking amount of 0", () =>
-      expect(alpacaOperationAmount(mockUnstakingTx(address, "0"))).toEqual(new BigNumber("0")));
+      expect(alpacaOperationAmount(mockUnstakingTx(address, "-1050000"))).toEqual(
+        new BigNumber("0"),
+      ));
 
     test("alpaca getOperationAmount should calculate amount correctly for SUI", () =>
       expect(alpacaOperationAmount(mockTransaction)).toEqual(new BigNumber("9998990120")));
@@ -859,7 +861,7 @@ describe("Staking Operations", () => {
     test("transactionToOp should map staking transaction correctly", () => {
       const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
 
-      const operation = sdk.alpacaTransactionToOp(address, mockStakingTx(address, "-1000000000"));
+      const operation = sdk.alpacaTransactionToOp(address, mockStakingTx(address, "-1001050000"));
 
       expect(operation.id).toEqual("delegate_tx_digest_123");
       expect(operation.type).toEqual("DELEGATE");
@@ -873,7 +875,7 @@ describe("Staking Operations", () => {
     test("transactionToOp should map unstaking transaction correctly", () => {
       const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
 
-      const operation = sdk.alpacaTransactionToOp(address, mockUnstakingTx(address, "1000000000"));
+      const operation = sdk.alpacaTransactionToOp(address, mockUnstakingTx(address, "998950000"));
 
       expect(operation.id).toEqual("undelegate_tx_digest_456");
       expect(operation.type).toEqual("UNDELEGATE");
@@ -1772,13 +1774,17 @@ describe("filterOperations", () => {
   describe("conversion methods", () => {
     test("toBlockOperation should map native transfers correctly", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: {
-            AddressOwner: "0x65449f57946938c84c5127",
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: {
+              AddressOwner: "0x65449f57946938c84c5127",
+            },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
           },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+          BigNumber(0),
+        ),
       ).toEqual([
         {
           type: "transfer",
@@ -1792,64 +1798,84 @@ describe("filterOperations", () => {
 
     test("toBlockOperation should ignore transfers from shared owner", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: {
-            Shared: {
-              initial_shared_version: "0",
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: {
+              Shared: {
+                initial_shared_version: "0",
+              },
             },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
           },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+          BigNumber(0),
+        ),
       ).toEqual([]);
     });
 
     test("toBlockOperation should ignore transfers from object owner", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: {
-            ObjectOwner: "test",
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: {
+              ObjectOwner: "test",
+            },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
           },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+          BigNumber(0),
+        ),
       ).toEqual([]);
     });
 
     test("toBlockOperation should ignore transfers from immutable owner", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: "Immutable",
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: "Immutable",
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
+          },
+          BigNumber(0),
+        ),
       ).toEqual([]);
     });
 
     test("toBlockOperation should ignore transfers from consensus owner", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: {
-            ConsensusAddressOwner: {
-              owner: "test",
-              start_version: "1",
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: {
+              ConsensusAddressOwner: {
+                owner: "test",
+                start_version: "1",
+              },
             },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
           },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+          BigNumber(0),
+        ),
       ).toEqual([]);
     });
 
     test("toBlockOperation should map token transfers correctly", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: {
-            AddressOwner: "0x65449f57946938c84c5127",
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: {
+              AddressOwner: "0x65449f57946938c84c5127",
+            },
+            coinType: "0x168da5bf1f48dafc111b0a488fa454aca95e0b5e::usdc::USDC",
+            amount: "8824",
           },
-          coinType: "0x168da5bf1f48dafc111b0a488fa454aca95e0b5e::usdc::USDC",
-          amount: "8824",
-        }),
+          BigNumber(0),
+        ),
       ).toEqual([
         {
           type: "transfer",
@@ -1867,18 +1893,22 @@ describe("filterOperations", () => {
     test("toBlockOperation should map staking operations correctly", () => {
       const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
       expect(
-        sdk.toBlockOperation(mockStakingTx(address, "-1000000000"), {
-          owner: { AddressOwner: address },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+        sdk.toBlockOperation(
+          mockStakingTx(address, "-1000000000"),
+          {
+            owner: { AddressOwner: address },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
+          },
+          BigNumber(0),
+        ),
       ).toEqual([
         {
           type: "other",
           operationType: "DELEGATE",
           address: address,
           asset: { type: "native" },
-          amount: 10000000000n,
+          amount: -10000000000n,
         },
       ]);
     });
@@ -1886,11 +1916,15 @@ describe("filterOperations", () => {
     test("toBlockOperation should map unstaking operations correctly", () => {
       const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
       expect(
-        sdk.toBlockOperation(mockUnstakingTx(address, "1000000000"), {
-          owner: { AddressOwner: address },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "10000000000",
-        }),
+        sdk.toBlockOperation(
+          mockUnstakingTx(address, "1000000000"),
+          {
+            owner: { AddressOwner: address },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "10000000000",
+          },
+          BigNumber(0),
+        ),
       ).toEqual([
         {
           type: "other",
@@ -1947,7 +1981,7 @@ describe("filterOperations", () => {
           {
             address: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
             peer: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-            amount: -10000000000n,
+            amount: -9998990120n,
             asset: { type: "native" },
             type: "transfer",
           },

package/src/network/sdk.ts

@@ -343,10 +343,6 @@ export function transactionToOperation(
   };
 }
 
-function absoluteAmount(balanceChange: BalanceChange | undefined): BigNumber {
-  return new BigNumber(balanceChange?.amount || 0).abs();
-}
-
 // 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
@@ -358,9 +354,11 @@ export const alpacaGetOperationAmount = (
   const zero = BigNumber(0);
 
   const tx = transaction.transaction?.data.transaction;
-
-  if (isStaking(tx) || isUnstaking(tx)) return absoluteAmount(transaction.balanceChanges?.[0]);
-  else {
+  const change = transaction.balanceChanges;
+  if (isStaking(tx) || isUnstaking(tx)) {
+    if (change) return removeFeesFromAmountForNative(change[0], getOperationFee(transaction)).abs();
+    return BigNumber(0);
+  } else {
     return (
       transaction.balanceChanges
         ?.filter(
@@ -370,7 +368,11 @@ export const alpacaGetOperationAmount = (
             balanceChange.owner.AddressOwner === address &&
             balanceChange.coinType === coinType,
         )
-        .map(absoluteAmount)
+        .map(change => {
+          if (isSender(address, transaction.transaction?.data))
+            return removeFeesFromAmountForNative(change, getOperationFee(transaction)).abs();
+          else return BigNumber(change.amount).abs();
+        })
         .reduce((acc, curr) => acc.plus(curr), zero) || zero
     );
   }
@@ -443,35 +445,46 @@ export function toBlockInfo(checkpoint: Checkpoint): BlockInfo {
  * @param transaction SUI RPC transaction block response
  */
 export function toBlockTransaction(transaction: SuiTransactionBlockResponse): BlockTransaction {
+  const operationFee = getOperationFee(transaction);
   return {
     hash: transaction.digest,
     failed: transaction.effects?.status.status !== "success",
     operations:
-      transaction.balanceChanges?.flatMap(change => toBlockOperation(transaction, change)) || [],
-    fees: BigInt(getOperationFee(transaction).toString()),
+      transaction.balanceChanges?.flatMap(change =>
+        toBlockOperation(transaction, change, operationFee),
+      ) || [],
+    fees: BigInt(operationFee.toString()),
     feesPayer: transaction.transaction?.data.sender || "",
   };
 }
 
+export function removeFeesFromAmountForNative(change: BalanceChange, fees: BigNumber): BigNumber {
+  if (change.coinType === DEFAULT_COIN_TYPE) return BigNumber(change.amount).plus(fees);
+  return BigNumber(change.amount);
+}
+
 /**
  * Convert a SUI RPC transaction balance change to a {@link BlockOperation}.
  *
+ * @param transaction
  * @param change balance change
+ * @param fees transaction fees to be deducted from the amount if applicable
  */
 export function toBlockOperation(
   transaction: SuiTransactionBlockResponse,
   change: BalanceChange,
+  fees: BigNumber,
 ): BlockOperation[] {
   if (typeof change.owner === "string" || !("AddressOwner" in change.owner)) return [];
   const address = change.owner.AddressOwner;
   const operationType = getOperationType(address, transaction);
 
-  function transferOp(peer: string | undefined): BlockOperation {
+  function transferOp(peer: string | undefined, amount: bigint): BlockOperation {
     const op: BlockOperation = {
       type: "transfer",
       address: address,
       asset: toSuiAsset(change.coinType),
-      amount: BigInt(change.amount),
+      amount: amount,
     };
     if (peer) op.peer = peer;
     return op;
@@ -479,9 +492,16 @@ export function toBlockOperation(
 
   switch (operationType) {
     case "IN":
-      return [transferOp(getOperationSenders(transaction.transaction?.data).at(0))];
+      return [
+        transferOp(getOperationSenders(transaction.transaction?.data).at(0), BigInt(change.amount)),
+      ];
     case "OUT":
-      return [transferOp(getOperationRecipients(transaction.transaction?.data).at(0))];
+      return [
+        transferOp(
+          getOperationRecipients(transaction.transaction?.data).at(0),
+          BigInt(removeFeesFromAmountForNative(change, fees).toString()),
+        ),
+      ];
     case "DELEGATE":
     case "UNDELEGATE":
       return [
@@ -490,11 +510,18 @@ export function toBlockOperation(
           operationType: operationType,
           address: change.owner.AddressOwner,
           asset: toSuiAsset(change.coinType),
-          amount: BigInt(absoluteAmount(change).toString()),
+          amount: BigInt(removeFeesFromAmountForNative(change, fees).toString()),
         },
       ];
     default:
-      return [];
+      return [
+        {
+          type: "transfer",
+          address: address,
+          asset: toSuiAsset(change.coinType),
+          amount: BigInt(change.amount),
+        },
+      ];
   }
 }