@ledgerhq/coin-sui 0.15.0 → 0.16.0-nightly.1

package/lib-es/network/sdk.test.js

@@ -2,6 +2,7 @@ import * as sdk from "./sdk";
 import coinConfig from "../config";
 import { BigNumber } from "bignumber.js";
 import { SuiClient } from "@mysten/sui/client";
+import assert from "assert";
 // Mock SUI client for tests
 jest.mock("@mysten/sui/client", () => {
     return {
@@ -180,6 +181,87 @@ const mockTransaction = {
     timestampMs: "1742294454878",
     checkpoint: "313024",
 };
+// Create a mock staking transaction
+// amount must be a negative number
+function mockStakingTx(address, amount) {
+    assert(new BigNumber(amount).lte(0), "amount must be a negative number");
+    return {
+        digest: "delegate_tx_digest_123",
+        transaction: {
+            data: {
+                sender: address,
+                transaction: {
+                    kind: "ProgrammableTransaction",
+                    inputs: [],
+                    transactions: [
+                        {
+                            MoveCall: {
+                                function: "request_add_stake",
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+        effects: {
+            status: { status: "success" },
+            gasUsed: {
+                computationCost: "1000000",
+                storageCost: "500000",
+                storageRebate: "450000",
+            },
+        },
+        balanceChanges: [
+            {
+                owner: { AddressOwner: address },
+                coinType: "0x2::sui::SUI",
+                amount: amount.startsWith("-") ? amount : `-${amount}`,
+            },
+        ],
+        timestampMs: "1742294454878",
+        checkpoint: "313024",
+    };
+}
+// amount must be a positive number
+function mockUnstakingTx(address, amount) {
+    assert(new BigNumber(amount).gte(0), "amount must be a positive number");
+    return {
+        digest: "undelegate_tx_digest_456",
+        transaction: {
+            data: {
+                sender: address,
+                transaction: {
+                    kind: "ProgrammableTransaction",
+                    inputs: [],
+                    transactions: [
+                        {
+                            MoveCall: {
+                                function: "request_withdraw_stake",
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+        effects: {
+            status: { status: "success" },
+            gasUsed: {
+                computationCost: "1000000",
+                storageCost: "500000",
+                storageRebate: "450000",
+            },
+        },
+        balanceChanges: [
+            {
+                owner: { AddressOwner: address },
+                coinType: "0x2::sui::SUI",
+                amount: amount,
+            },
+        ],
+        timestampMs: "1742294454878",
+        checkpoint: "313024",
+    };
+}
 const mockApi = new SuiClient({ url: "mock" });
 // Add getTransactionBlock method to mockApi
 mockApi.getTransactionBlock = jest.fn();
@@ -250,14 +332,6 @@ describe("SDK Functions", () => {
     test("getOperationRecipients should return recipient addresses", () => {
         expect(sdk.getOperationRecipients(mockTransaction.transaction?.data)).toEqual(["0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0"]);
     });
-    test("getOperationAmount should calculate amount correctly for SUI", () => {
-        const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
-        expect(sdk.getOperationAmount(address, mockTransaction, sdk.DEFAULT_COIN_TYPE)).toEqual(new BigNumber("9998990120"));
-    });
-    test("getOperationAmount should calculate amount correctly for tokens", () => {
-        const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
-        expect(sdk.getOperationAmount(address, mockTransaction, "0x123::test::TOKEN")).toEqual(new BigNumber("500000"));
-    });
     test("getOperationFee should calculate fee correctly", () => {
         expect(sdk.getOperationFee(mockTransaction)).toEqual(new BigNumber(1009880));
     });
@@ -402,7 +476,7 @@ describe("SDK Functions", () => {
                 },
             ],
         };
-        const operation = sdk.transactionToOp(address, tokenTx);
+        const operation = sdk.alpacaTransactionToOp(address, tokenTx);
         expect(operation.id).toEqual("DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt");
         expect(operation.type).toEqual("IN");
         expect(operation.senders).toEqual([
@@ -473,186 +547,39 @@ describe("Staking Operations", () => {
     describe("Operation Type Detection", () => {
         test("getOperationType should return DELEGATE for staking transaction", () => {
             const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            // Create a mock staking transaction
-            const mockStakingTx = {
-                digest: "delegate_tx_digest_123",
-                transaction: {
-                    data: {
-                        sender: address,
-                        transaction: {
-                            kind: "ProgrammableTransaction",
-                            inputs: [],
-                            transactions: [
-                                {
-                                    MoveCall: {
-                                        function: "request_add_stake",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-                effects: {
-                    status: { status: "success" },
-                    gasUsed: {
-                        computationCost: "1000000",
-                        storageCost: "500000",
-                        storageRebate: "450000",
-                    },
-                },
-                balanceChanges: [
-                    {
-                        owner: { AddressOwner: address },
-                        coinType: "0x2::sui::SUI",
-                        amount: "-1000000000",
-                    },
-                ],
-                timestampMs: "1742294454878",
-                checkpoint: "313024",
-            };
-            expect(sdk.getOperationType(address, mockStakingTx)).toBe("DELEGATE");
+            expect(sdk.getOperationType(address, mockStakingTx(address, "-1000000000"))).toBe("DELEGATE");
         });
         test("getOperationType should return UNDELEGATE for unstaking transaction", () => {
             const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            // Create a mock unstaking transaction
-            const mockUnstakingTx = {
-                digest: "undelegate_tx_digest_456",
-                transaction: {
-                    data: {
-                        sender: address,
-                        transaction: {
-                            kind: "ProgrammableTransaction",
-                            inputs: [],
-                            transactions: [
-                                {
-                                    MoveCall: {
-                                        function: "request_withdraw_stake",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-                effects: {
-                    status: { status: "success" },
-                    gasUsed: {
-                        computationCost: "1000000",
-                        storageCost: "500000",
-                        storageRebate: "450000",
-                    },
-                },
-                balanceChanges: [
-                    {
-                        owner: { AddressOwner: address },
-                        coinType: "0x2::sui::SUI",
-                        amount: "0",
-                    },
-                ],
-                timestampMs: "1742294454878",
-                checkpoint: "313024",
-            };
-            expect(sdk.getOperationType(address, mockUnstakingTx)).toBe("UNDELEGATE");
+            expect(sdk.getOperationType(address, mockUnstakingTx(address, "1000000000"))).toBe("UNDELEGATE");
         });
     });
     describe("Operation Amount Calculation", () => {
-        test("getOperationAmount should calculate staking amount correctly", () => {
-            const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const mockStakingTx = {
-                transaction: {
-                    data: {
-                        transaction: {
-                            kind: "ProgrammableTransaction",
-                            transactions: [
-                                {
-                                    MoveCall: {
-                                        function: "request_add_stake",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-                balanceChanges: [
-                    {
-                        owner: { AddressOwner: address },
-                        coinType: "0x2::sui::SUI",
-                        amount: "-1000000000",
-                    },
-                ],
-            };
-            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: {
-                            kind: "ProgrammableTransaction",
-                            transactions: [
-                                {
-                                    MoveCall: {
-                                        function: "request_withdraw_stake",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-                balanceChanges: [
-                    {
-                        owner: { AddressOwner: address },
-                        coinType: "0x2::sui::SUI",
-                        amount: "0",
-                    },
-                ],
-            };
-            const amount = sdk.getOperationAmount(address, mockUnstakingTx, sdk.DEFAULT_COIN_TYPE);
-            expect(amount).toEqual(new BigNumber("0"));
-        });
+        const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
+        function bridgeOperationAmount(mock, coinType = sdk.DEFAULT_COIN_TYPE) {
+            return sdk.getOperationAmount(address, mock, coinType);
+        }
+        test("getOperationAmount should calculate staking amount", () => expect(bridgeOperationAmount(mockStakingTx(address, "-1000000000"))).toEqual(new BigNumber("1000000000")));
+        test("getOperationAmount should calculate unstaking amount of 1000", () => expect(bridgeOperationAmount(mockUnstakingTx(address, "1000"))).toEqual(new BigNumber("-1000")));
+        test("getOperationAmount should calculate unstaking amount of 0", () => expect(bridgeOperationAmount(mockUnstakingTx(address, "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, coinType = sdk.DEFAULT_COIN_TYPE) {
+            return sdk.alpacaGetOperationAmount(address, mock, coinType);
+        }
+        test("alpaca getOperationAmount should calculate staking amount", () => expect(alpacaOperationAmount(mockStakingTx(address, "-1000000000"))).toEqual(new BigNumber("1000000000")));
+        test("alpaca getOperationAmount should calculate unstaking amount of 1000", () => expect(alpacaOperationAmount(mockUnstakingTx(address, "1000"))).toEqual(new BigNumber("1000")));
+        test("alpaca getOperationAmount should calculate unstaking amount of 0", () => expect(alpacaOperationAmount(mockUnstakingTx(address, "0"))).toEqual(new BigNumber("0")));
+        test("alpaca getOperationAmount should calculate amount correctly for SUI", () => expect(alpacaOperationAmount(mockTransaction)).toEqual(new BigNumber("9998990120")));
+        test("alpaca getOperationAmount should calculate amount correctly for tokens", () => expect(alpacaOperationAmount(mockTransaction, "0x123::test::TOKEN")).toEqual(new BigNumber("500000")));
     });
     describe("Operation Recipients", () => {
         test("getOperationRecipients should return empty array for staking transaction", () => {
-            const mockStakingTx = {
-                transaction: {
-                    data: {
-                        transaction: {
-                            kind: "ProgrammableTransaction",
-                            inputs: [],
-                            transactions: [
-                                {
-                                    MoveCall: {
-                                        function: "request_add_stake",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-            };
-            const recipients = sdk.getOperationRecipients(mockStakingTx.transaction?.data);
+            const recipients = sdk.getOperationRecipients(mockStakingTx("0xdeadbeef", "-1000000000").transaction?.data);
             expect(recipients).toEqual([]);
         });
         test("getOperationRecipients should return empty array for unstaking transaction", () => {
-            const mockUnstakingTx = {
-                transaction: {
-                    data: {
-                        transaction: {
-                            kind: "ProgrammableTransaction",
-                            inputs: [],
-                            transactions: [
-                                {
-                                    MoveCall: {
-                                        function: "request_withdraw_stake",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-            };
-            const recipients = sdk.getOperationRecipients(mockUnstakingTx.transaction?.data);
+            const recipients = sdk.getOperationRecipients(mockUnstakingTx("0xdeadbeef", "1000000000").transaction?.data);
             expect(recipients).toEqual([]);
         });
     });
@@ -733,43 +660,7 @@ describe("Staking Operations", () => {
         test("transactionToOperation should map staking transaction correctly", () => {
             const accountId = "mockAccountId";
             const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const mockStakingTx = {
-                digest: "delegate_tx_digest_123",
-                transaction: {
-                    data: {
-                        sender: address,
-                        transaction: {
-                            kind: "ProgrammableTransaction",
-                            inputs: [],
-                            transactions: [
-                                {
-                                    MoveCall: {
-                                        function: "request_add_stake",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-                effects: {
-                    status: { status: "success" },
-                    gasUsed: {
-                        computationCost: "1000000",
-                        storageCost: "500000",
-                        storageRebate: "450000",
-                    },
-                },
-                balanceChanges: [
-                    {
-                        owner: { AddressOwner: address },
-                        coinType: "0x2::sui::SUI",
-                        amount: "-1000000000",
-                    },
-                ],
-                timestampMs: "1742294454878",
-                checkpoint: "313024",
-            };
-            const operation = sdk.transactionToOperation(accountId, address, mockStakingTx);
+            const operation = sdk.transactionToOperation(accountId, address, mockStakingTx(address, "-1000000000"));
             expect(operation).toHaveProperty("id");
             expect(operation).toHaveProperty("accountId", accountId);
             expect(operation).toHaveProperty("type", "DELEGATE");
@@ -783,92 +674,20 @@ describe("Staking Operations", () => {
         test("transactionToOperation should map unstaking transaction correctly", () => {
             const accountId = "mockAccountId";
             const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const mockUnstakingTx = {
-                digest: "undelegate_tx_digest_456",
-                transaction: {
-                    data: {
-                        sender: address,
-                        transaction: {
-                            kind: "ProgrammableTransaction",
-                            inputs: [],
-                            transactions: [
-                                {
-                                    MoveCall: {
-                                        function: "request_withdraw_stake",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-                effects: {
-                    status: { status: "success" },
-                    gasUsed: {
-                        computationCost: "1000000",
-                        storageCost: "500000",
-                        storageRebate: "450000",
-                    },
-                },
-                balanceChanges: [
-                    {
-                        owner: { AddressOwner: address },
-                        coinType: "0x2::sui::SUI",
-                        amount: "0",
-                    },
-                ],
-                timestampMs: "1742294454878",
-                checkpoint: "313024",
-            };
-            const operation = sdk.transactionToOperation(accountId, address, mockUnstakingTx);
+            const operation = sdk.transactionToOperation(accountId, address, mockUnstakingTx(address, "1000000000"));
             expect(operation).toHaveProperty("id");
             expect(operation).toHaveProperty("accountId", accountId);
             expect(operation).toHaveProperty("type", "UNDELEGATE");
             expect(operation).toHaveProperty("hash", "undelegate_tx_digest_456");
             expect(operation).toHaveProperty("extra");
             expect(operation.extra.coinType).toBe(sdk.DEFAULT_COIN_TYPE);
-            expect(operation.value).toEqual(new BigNumber("0"));
+            expect(operation.value).toEqual(new BigNumber("-1000000000"));
             expect(operation.recipients).toEqual([]);
             expect(operation.senders).toEqual([address]);
         });
         test("transactionToOp should map staking transaction correctly", () => {
             const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const mockStakingTx = {
-                digest: "delegate_tx_digest_123",
-                transaction: {
-                    data: {
-                        sender: address,
-                        transaction: {
-                            kind: "ProgrammableTransaction",
-                            inputs: [],
-                            transactions: [
-                                {
-                                    MoveCall: {
-                                        function: "request_add_stake",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-                effects: {
-                    status: { status: "success" },
-                    gasUsed: {
-                        computationCost: "1000000",
-                        storageCost: "500000",
-                        storageRebate: "450000",
-                    },
-                },
-                balanceChanges: [
-                    {
-                        owner: { AddressOwner: address },
-                        coinType: "0x2::sui::SUI",
-                        amount: "-1000000000",
-                    },
-                ],
-                timestampMs: "1742294454878",
-                checkpoint: "313024",
-            };
-            const operation = sdk.transactionToOp(address, mockStakingTx);
+            const operation = sdk.alpacaTransactionToOp(address, mockStakingTx(address, "-1000000000"));
             expect(operation.id).toEqual("delegate_tx_digest_123");
             expect(operation.type).toEqual("DELEGATE");
             expect(operation.senders).toEqual([address]);
@@ -879,48 +698,12 @@ describe("Staking Operations", () => {
         });
         test("transactionToOp should map unstaking transaction correctly", () => {
             const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const mockUnstakingTx = {
-                digest: "undelegate_tx_digest_456",
-                transaction: {
-                    data: {
-                        sender: address,
-                        transaction: {
-                            kind: "ProgrammableTransaction",
-                            inputs: [],
-                            transactions: [
-                                {
-                                    MoveCall: {
-                                        function: "request_withdraw_stake",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-                effects: {
-                    status: { status: "success" },
-                    gasUsed: {
-                        computationCost: "1000000",
-                        storageCost: "500000",
-                        storageRebate: "450000",
-                    },
-                },
-                balanceChanges: [
-                    {
-                        owner: { AddressOwner: address },
-                        coinType: "0x2::sui::SUI",
-                        amount: "0",
-                    },
-                ],
-                timestampMs: "1742294454878",
-                checkpoint: "313024",
-            };
-            const operation = sdk.transactionToOp(address, mockUnstakingTx);
+            const operation = sdk.alpacaTransactionToOp(address, mockUnstakingTx(address, "1000000000"));
             expect(operation.id).toEqual("undelegate_tx_digest_456");
             expect(operation.type).toEqual("UNDELEGATE");
             expect(operation.senders).toEqual([address]);
             expect(operation.recipients).toEqual([]);
-            expect(operation.value).toEqual(0n);
+            expect(operation.value).toEqual(1000000000n);
             expect(operation.asset).toEqual({ type: "native" });
             expect(operation.tx.block.hash).toBeUndefined();
         });
@@ -1661,7 +1444,7 @@ describe("filterOperations", () => {
     });
     describe("conversion methods", () => {
         test("toBlockOperation should map native transfers correctly", () => {
-            expect(sdk.toBlockOperation({
+            expect(sdk.toBlockOperation(mockTransaction, {
                 owner: {
                     AddressOwner: "0x65449f57946938c84c5127",
                 },
@@ -1677,7 +1460,7 @@ describe("filterOperations", () => {
             ]);
         });
         test("toBlockOperation should ignore transfers from shared owner", () => {
-            expect(sdk.toBlockOperation({
+            expect(sdk.toBlockOperation(mockTransaction, {
                 owner: {
                     Shared: {
                         initial_shared_version: "0",
@@ -1688,7 +1471,7 @@ describe("filterOperations", () => {
             })).toEqual([]);
         });
         test("toBlockOperation should ignore transfers from object owner", () => {
-            expect(sdk.toBlockOperation({
+            expect(sdk.toBlockOperation(mockTransaction, {
                 owner: {
                     ObjectOwner: "test",
                 },
@@ -1697,14 +1480,14 @@ describe("filterOperations", () => {
             })).toEqual([]);
         });
         test("toBlockOperation should ignore transfers from immutable owner", () => {
-            expect(sdk.toBlockOperation({
+            expect(sdk.toBlockOperation(mockTransaction, {
                 owner: "Immutable",
                 coinType: sdk.DEFAULT_COIN_TYPE,
                 amount: "-10000000000",
             })).toEqual([]);
         });
         test("toBlockOperation should ignore transfers from consensus owner", () => {
-            expect(sdk.toBlockOperation({
+            expect(sdk.toBlockOperation(mockTransaction, {
                 owner: {
                     ConsensusAddressOwner: {
                         owner: "test",
@@ -1716,7 +1499,7 @@ describe("filterOperations", () => {
             })).toEqual([]);
         });
         test("toBlockOperation should map token transfers correctly", () => {
-            expect(sdk.toBlockOperation({
+            expect(sdk.toBlockOperation(mockTransaction, {
                 owner: {
                     AddressOwner: "0x65449f57946938c84c5127",
                 },
@@ -1734,6 +1517,38 @@ 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",
+            })).toEqual([
+                {
+                    type: "other",
+                    operationType: "DELEGATE",
+                    address: address,
+                    asset: { type: "native" },
+                    amount: 10000000000n,
+                },
+            ]);
+        });
+        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",
+            })).toEqual([
+                {
+                    type: "other",
+                    operationType: "UNDELEGATE",
+                    address: address,
+                    asset: { type: "native" },
+                    amount: 10000000000n,
+                },
+            ]);
+        });
         test("toBlockInfo should map checkpoints correctly", () => {
             expect(sdk.toBlockInfo({
                 checkpointCommitments: [],