@ledgerhq/coin-sui 0.16.0-nightly.7 → 0.16.0-nightly.8

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

@@ -1,1786 +0,0 @@
-import * as sdk from "./sdk";
-import coinConfig from "../config";
-import { BigNumber } from "bignumber.js";
-import { SuiClient } from "@mysten/sui/client";
-import assert, { fail } from "assert";
-// Mock SUI client for tests
-jest.mock("@mysten/sui/client", () => {
-    return {
-        ...jest.requireActual("@mysten/sui/client"),
-        SuiClient: jest.fn().mockImplementation(() => ({
-            getAllBalances: jest.fn().mockResolvedValue([
-                { coinType: "0x2::sui::SUI", totalBalance: "1000000000" },
-                { coinType: "0x123::test::TOKEN", totalBalance: "500000" },
-            ]),
-            queryTransactionBlocks: jest.fn().mockResolvedValue({
-                data: [],
-                hasNextPage: false,
-            }),
-            dryRunTransactionBlock: jest.fn().mockResolvedValue({
-                effects: {
-                    gasUsed: {
-                        computationCost: "1000000",
-                        storageCost: "500000",
-                        storageRebate: "450000",
-                    },
-                },
-                input: {
-                    gasData: {
-                        budget: "4000000",
-                    },
-                },
-            }),
-            getCoins: jest.fn().mockResolvedValue({
-                data: [{ coinObjectId: "0xtest_coin_object_id" }],
-            }),
-            executeTransactionBlock: jest.fn().mockResolvedValue({
-                digest: "transaction_digest_123",
-                effects: {
-                    status: { status: "success" },
-                },
-            }),
-            getReferenceGasPrice: jest.fn().mockResolvedValue("1000"),
-            getTransactionBlock: jest.fn().mockResolvedValue({
-                transaction: {
-                    data: {
-                        transaction: {
-                            kind: "ProgrammableTransaction",
-                            inputs: [],
-                            transactions: [],
-                        },
-                    },
-                },
-                effects: {
-                    status: { status: "success" },
-                },
-            }),
-        })),
-        getFullnodeUrl: jest.fn().mockReturnValue("https://mockapi.sui.io"),
-    };
-});
-// Mock the Transaction class
-jest.mock("@mysten/sui/transactions", () => {
-    const mockTxb = {
-        // This will be the built transaction block
-        transactionBlock: new Uint8Array(),
-    };
-    return {
-        ...jest.requireActual("@mysten/sui/transactions"),
-        Transaction: jest.fn().mockImplementation(() => {
-            return {
-                gas: "0xmock_gas_object_id",
-                setSender: jest.fn(),
-                splitCoins: jest.fn().mockReturnValue(["0xmock_coin"]),
-                transferObjects: jest.fn(),
-                moveCall: jest.fn(),
-                object: jest.fn(),
-                pure: {
-                    address: jest.fn(),
-                    u64: jest.fn(),
-                },
-                build: jest.fn().mockResolvedValue(mockTxb),
-                setGasBudgetIfNotSet: jest.fn(),
-            };
-        }),
-    };
-});
-const mockTransaction = {
-    digest: "DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt",
-    transaction: {
-        data: {
-            messageVersion: "v1",
-            transaction: {
-                kind: "ProgrammableTransaction",
-                inputs: [
-                    {
-                        type: "pure",
-                        valueType: "address",
-                        value: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                    },
-                ],
-                transactions: [
-                    {
-                        TransferObjects: [["GasCoin"], { Input: 0 }],
-                    },
-                ],
-            },
-            sender: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
-            gasData: {
-                payment: [
-                    {
-                        objectId: "0x9d49c70b621b618c7918468a7ac286e71cffe6e30c4e4175a4385516b121cb0e",
-                        version: "57",
-                        digest: "2rPEonJQQUXmAmAegn3fVqBjpKrC5NadAZBetb5wJQm6",
-                    },
-                ],
-                owner: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
-                price: "1000",
-                budget: "2988000",
-            },
-        },
-        txSignatures: [
-            "AJKFd5y+1y/ggTAKTZlrrQlvSWXoYCSU7ksxyBG6BI9FDjN/R8db5PNbw19Bs+Lp4VE0cu9BBzAc/gYDFwgYrQVgR+QnZSFg3qWm+IjLX2dEep/wlLje2lziXO+HmZApcQ==",
-        ],
-    },
-    effects: {
-        messageVersion: "v1",
-        status: { status: "success" },
-        executedEpoch: "18",
-        gasUsed: {
-            computationCost: "1000000",
-            storageCost: "988000",
-            storageRebate: "978120",
-            nonRefundableStorageFee: "9880",
-        },
-        modifiedAtVersions: [
-            {
-                objectId: "0x9d49c70b621b618c7918468a7ac286e71cffe6e30c4e4175a4385516b121cb0e",
-                sequenceNumber: "57",
-            },
-        ],
-        transactionDigest: "DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt",
-        mutated: [
-            {
-                owner: {
-                    AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                },
-                reference: {
-                    objectId: "0x9d49c70b621b618c7918468a7ac286e71cffe6e30c4e4175a4385516b121cb0e",
-                    version: "58",
-                    digest: "82pvkMbymnBFQjhuDDaaW88BeATbNgWWcWH67DcLaPBi",
-                },
-            },
-        ],
-        gasObject: {
-            owner: { AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0" },
-            reference: {
-                objectId: "0x9d49c70b621b618c7918468a7ac286e71cffe6e30c4e4175a4385516b121cb0e",
-                version: "58",
-                digest: "82pvkMbymnBFQjhuDDaaW88BeATbNgWWcWH67DcLaPBi",
-            },
-        },
-        dependencies: ["D8tHbu9JwGuoaH67PFXCoswqDUy2M4S6KVLWhCodt1a7"],
-    },
-    balanceChanges: [
-        {
-            owner: { AddressOwner: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24" },
-            coinType: "0x2::sui::SUI",
-            amount: "-10000000000",
-        },
-        {
-            owner: { AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0" },
-            coinType: "0x2::sui::SUI",
-            amount: "9998990120",
-        },
-        {
-            owner: { AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0" },
-            coinType: "0x123::test::TOKEN",
-            amount: "500000",
-        },
-    ],
-    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();
-// Helper function to generate mock coins from an array of balances
-const createMockCoins = (balances) => {
-    return balances.map((balance, index) => ({
-        coinObjectId: `0xcoin${index + 1}`,
-        balance,
-        digest: `0xdigest${index + 1}`,
-        version: "1",
-    }));
-};
-beforeAll(() => {
-    coinConfig.setCoinConfig(() => ({
-        status: {
-            type: "active",
-        },
-        node: {
-            url: "https://mockapi.sui.io",
-        },
-    }));
-});
-beforeEach(() => {
-    mockApi.queryTransactionBlocks.mockReset();
-});
-describe("SDK Functions", () => {
-    test("getAccountBalances should return array of account balances", async () => {
-        // Patch getAllBalancesCached to return a valid array for this test
-        jest.spyOn(sdk, "getAllBalancesCached").mockResolvedValue([
-            {
-                coinType: "0x2::sui::SUI",
-                totalBalance: "1000000000",
-                coinObjectCount: 1,
-                lockedBalance: {},
-            },
-            {
-                coinType: "0x123::test::TOKEN",
-                totalBalance: "500000",
-                coinObjectCount: 1,
-                lockedBalance: {},
-            },
-        ]);
-        const address = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
-        const balances = await sdk.getAccountBalances(address);
-        expect(Array.isArray(balances)).toBe(true);
-        expect(balances.length).toBeGreaterThan(0);
-        // Check structure of the first balance
-        const firstBalance = balances[0];
-        expect(firstBalance).toHaveProperty("coinType");
-        expect(firstBalance).toHaveProperty("blockHeight");
-        expect(firstBalance).toHaveProperty("balance");
-        expect(firstBalance.balance).toBeInstanceOf(BigNumber);
-        // Should include SUI and token balances
-        const coinTypes = balances.map(b => b.coinType);
-        expect(coinTypes).toContain(sdk.DEFAULT_COIN_TYPE);
-    });
-    test("getOperationType should return IN for incoming tx", () => {
-        const address = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
-        expect(sdk.getOperationType(address, mockTransaction)).toBe("IN");
-    });
-    test("getOperationType should return OUT for outgoing tx", () => {
-        const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-        expect(sdk.getOperationType(address, mockTransaction)).toBe("OUT");
-    });
-    test("getOperationSenders should return sender address", () => {
-        expect(sdk.getOperationSenders(mockTransaction.transaction?.data)).toEqual(["0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24"]);
-    });
-    test("getOperationRecipients should return recipient addresses", () => {
-        expect(sdk.getOperationRecipients(mockTransaction.transaction?.data)).toEqual(["0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0"]);
-    });
-    test("getOperationFee should calculate fee correctly", () => {
-        expect(sdk.getOperationFee(mockTransaction)).toEqual(new BigNumber(1009880));
-    });
-    test("getOperationDate should return correct date", () => {
-        const date = sdk.getOperationDate(mockTransaction);
-        expect(date).toBeDefined();
-        expect(date).toBeInstanceOf(Date);
-    });
-    test("getOperationCoinType should extract token coin type", () => {
-        // For a token transaction
-        const tokenTx = {
-            ...mockTransaction,
-            balanceChanges: [
-                {
-                    owner: {
-                        AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                    },
-                    coinType: "0x123::test::TOKEN",
-                    amount: "500000",
-                },
-                {
-                    owner: {
-                        AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                    },
-                    coinType: sdk.DEFAULT_COIN_TYPE,
-                    amount: "-1009880",
-                },
-            ],
-        };
-        expect(sdk.getOperationCoinType(tokenTx)).toBe("0x123::test::TOKEN");
-        // For a SUI-only transaction
-        const suiTx = {
-            ...mockTransaction,
-            balanceChanges: [
-                {
-                    owner: {
-                        AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                    },
-                    coinType: sdk.DEFAULT_COIN_TYPE,
-                    amount: "9998990120",
-                },
-            ],
-        };
-        expect(sdk.getOperationCoinType(suiTx)).toBe(sdk.DEFAULT_COIN_TYPE);
-    });
-    test("transactionToOperation should map transaction to operation", () => {
-        const accountId = "mockAccountId";
-        const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
-        // Create a SUI-only transaction for this test to avoid token detection
-        const suiTx = {
-            ...mockTransaction,
-            balanceChanges: [
-                {
-                    owner: {
-                        AddressOwner: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
-                    },
-                    coinType: sdk.DEFAULT_COIN_TYPE,
-                    amount: "-10000000000",
-                },
-                {
-                    owner: {
-                        AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                    },
-                    coinType: sdk.DEFAULT_COIN_TYPE,
-                    amount: "9998990120",
-                },
-            ],
-        };
-        // Instead of mocking, just directly verify the amount
-        const operation = sdk.transactionToOperation(accountId, address, suiTx);
-        expect(operation).toHaveProperty("id");
-        expect(operation).toHaveProperty("accountId", accountId);
-        expect(operation).toHaveProperty("extra");
-        expect(operation.extra.coinType).toBe(sdk.DEFAULT_COIN_TYPE);
-        // Directly calculate expected amount for SUI coin type
-        const expectedAmount = sdk.getOperationAmount(address, suiTx, sdk.DEFAULT_COIN_TYPE);
-        expect(expectedAmount.toString()).toBe("9998990120");
-    });
-    test("transactionToOperation should map token transaction to operation", () => {
-        const accountId = "mockAccountId";
-        const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
-        // Create a token transaction
-        const tokenTx = {
-            ...mockTransaction,
-            balanceChanges: [
-                {
-                    owner: {
-                        AddressOwner: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
-                    },
-                    coinType: "0x123::test::TOKEN",
-                    amount: "-500000",
-                },
-                {
-                    owner: {
-                        AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                    },
-                    coinType: "0x123::test::TOKEN",
-                    amount: "500000",
-                },
-                {
-                    owner: {
-                        AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                    },
-                    coinType: sdk.DEFAULT_COIN_TYPE,
-                    amount: "-1000000",
-                },
-            ],
-        };
-        const operation = sdk.transactionToOperation(accountId, address, tokenTx);
-        expect(operation).toHaveProperty("id");
-        expect(operation).toHaveProperty("accountId", accountId);
-        expect(operation).toHaveProperty("extra");
-        expect(operation.extra.coinType).toBe("0x123::test::TOKEN");
-        expect(operation.value).toEqual(new BigNumber("500000"));
-    });
-    test("transactionToOp should map token transaction to operation", () => {
-        const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
-        // Create a token transaction
-        const tokenTx = {
-            ...mockTransaction,
-            balanceChanges: [
-                {
-                    owner: {
-                        AddressOwner: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
-                    },
-                    coinType: "0x123::test::TOKEN",
-                    amount: "-500000",
-                },
-                {
-                    owner: {
-                        AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                    },
-                    coinType: "0x123::test::TOKEN",
-                    amount: "500000",
-                },
-                {
-                    owner: {
-                        AddressOwner: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                    },
-                    coinType: sdk.DEFAULT_COIN_TYPE,
-                    amount: "-1000000",
-                },
-            ],
-        };
-        const operation = sdk.alpacaTransactionToOp(address, tokenTx);
-        expect(operation.id).toEqual("DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt");
-        expect(operation.type).toEqual("IN");
-        expect(operation.senders).toEqual([
-            "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
-        ]);
-        expect(operation.recipients).toEqual([
-            "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-        ]);
-        expect(operation.value).toEqual(500000n);
-        expect(operation.asset).toEqual({ type: "token", assetReference: "0x123::test::TOKEN" });
-        expect(operation.memo).toBeUndefined();
-        expect(operation.details).toBeUndefined();
-        expect(operation.tx.block.hash).toBeUndefined();
-        expect(operation.tx).toMatchObject({
-            hash: "DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt",
-            block: {},
-            fees: 1009880n,
-            date: new Date("2025-03-18T10:40:54.878Z"),
-        });
-    });
-    test("getOperations should fetch operations", async () => {
-        const accountId = "mockAccountId";
-        const addr = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
-        const operations = await sdk.getOperations(accountId, addr);
-        expect(Array.isArray(operations)).toBe(true);
-    });
-    test("paymentInfo should return gas budget and fees", async () => {
-        const sender = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
-        const fakeTransaction = {
-            mode: "send",
-            coinType: sdk.DEFAULT_COIN_TYPE,
-            family: "sui",
-            amount: new BigNumber(100),
-            recipient: "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164",
-            errors: {},
-        };
-        const info = await sdk.paymentInfo(sender, fakeTransaction);
-        expect(info).toHaveProperty("gasBudget");
-        expect(info).toHaveProperty("totalGasUsed");
-        expect(info).toHaveProperty("fees");
-    });
-    test("createTransaction should build a transaction", async () => {
-        const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
-        const transaction = {
-            mode: "send",
-            coinType: sdk.DEFAULT_COIN_TYPE,
-            amount: new BigNumber(100),
-            recipient: "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164",
-        };
-        const tx = await sdk.createTransaction(address, transaction);
-        expect(tx).toBeDefined();
-    });
-    test("executeTransactionBlock should execute a transaction", async () => {
-        const result = await sdk.executeTransactionBlock({
-            transactionBlock: new Uint8Array(),
-            signature: "mockSignature",
-            options: { showEffects: true },
-        });
-        expect(result).toHaveProperty("digest", "transaction_digest_123");
-        expect(result?.effects).toBeDefined();
-        if (result?.effects) {
-            expect(result.effects).toHaveProperty("status");
-            expect(result.effects.status).toHaveProperty("status", "success");
-        }
-    });
-});
-describe("Staking Operations", () => {
-    describe("Operation Type Detection", () => {
-        const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-        test("getOperationType should return DELEGATE for staking transaction", () => {
-            expect(sdk.getOperationType(address, mockStakingTx(address, "-1000000000"))).toBe("DELEGATE");
-        });
-        test("getOperationType should return UNDELEGATE for unstaking transaction", () => {
-            expect(sdk.getOperationType(address, mockUnstakingTx(address, "1000000000"))).toBe("UNDELEGATE");
-        });
-        function prependOtherMoveCall(block) {
-            if (block?.kind === "ProgrammableTransaction") {
-                block.transactions.unshift({
-                    MoveCall: {
-                        function: "other_function",
-                        module: "module",
-                        package: "package",
-                    },
-                });
-            }
-        }
-        test("getOperationType should return UNDELEGATE when it's not the first MoveCall ", () => {
-            const tx = mockUnstakingTx(address, "1000");
-            if (tx.transaction) {
-                prependOtherMoveCall(tx.transaction.data.transaction);
-                expect(sdk.getOperationType(address, tx)).toBe("UNDELEGATE");
-            }
-            else {
-                fail("can't prepare fixture");
-            }
-        });
-        test("getOperationType should return DELEGATE when it's not the first MoveCall ", () => {
-            const tx = mockStakingTx(address, "-1000");
-            if (tx.transaction) {
-                prependOtherMoveCall(tx.transaction.data.transaction);
-                expect(sdk.getOperationType(address, tx)).toBe("DELEGATE");
-            }
-            else {
-                fail("can't prepare fixture");
-            }
-        });
-    });
-    describe("Operation Amount Calculation", () => {
-        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 recipients = sdk.getOperationRecipients(mockStakingTx("0xdeadbeef", "-1000000000").transaction?.data);
-            expect(recipients).toEqual([]);
-        });
-        test("getOperationRecipients should return empty array for unstaking transaction", () => {
-            const recipients = sdk.getOperationRecipients(mockUnstakingTx("0xdeadbeef", "1000000000").transaction?.data);
-            expect(recipients).toEqual([]);
-        });
-    });
-    describe("Transaction Creation", () => {
-        test("createTransaction should build delegate transaction", async () => {
-            const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const transaction = {
-                mode: "delegate",
-                coinType: sdk.DEFAULT_COIN_TYPE,
-                amount: new BigNumber(1000000000), // 1 SUI
-                recipient: "0xvalidator_address_123",
-            };
-            const tx = await sdk.createTransaction(address, transaction);
-            expect(tx).toBeDefined();
-        });
-        test("createTransaction should build undelegate transaction with specific amount", async () => {
-            const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const transaction = {
-                mode: "undelegate",
-                coinType: sdk.DEFAULT_COIN_TYPE,
-                amount: new BigNumber(500000000), // 0.5 SUI
-                stakedSuiId: "0xstaked_sui_object_123",
-                useAllAmount: false,
-                recipient: "0xvalidator_address_123", // Required by type but not used for undelegate
-            };
-            const tx = await sdk.createTransaction(address, transaction);
-            expect(tx).toBeDefined();
-        });
-        test("createTransaction should build undelegate transaction with all amount", async () => {
-            const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const transaction = {
-                mode: "undelegate",
-                coinType: sdk.DEFAULT_COIN_TYPE,
-                amount: new BigNumber(0),
-                stakedSuiId: "0xstaked_sui_object_123",
-                useAllAmount: true,
-                recipient: "0xvalidator_address_123", // Required by type but not used for undelegate
-            };
-            const tx = await sdk.createTransaction(address, transaction);
-            expect(tx).toBeDefined();
-        });
-    });
-    describe("Payment Info for Staking", () => {
-        test("paymentInfo should return gas budget and fees for delegate transaction", async () => {
-            const sender = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const fakeTransaction = {
-                mode: "delegate",
-                coinType: sdk.DEFAULT_COIN_TYPE,
-                family: "sui",
-                amount: new BigNumber(1000000000), // 1 SUI
-                recipient: "0xvalidator_address_123",
-                errors: {},
-            };
-            const info = await sdk.paymentInfo(sender, fakeTransaction);
-            expect(info).toHaveProperty("gasBudget");
-            expect(info).toHaveProperty("totalGasUsed");
-            expect(info).toHaveProperty("fees");
-        });
-        test("paymentInfo should return gas budget and fees for undelegate transaction", async () => {
-            const sender = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const fakeTransaction = {
-                mode: "undelegate",
-                coinType: sdk.DEFAULT_COIN_TYPE,
-                family: "sui",
-                amount: new BigNumber(500000000), // 0.5 SUI
-                stakedSuiId: "0xstaked_sui_object_123",
-                useAllAmount: false,
-                recipient: "0xvalidator_address_123", // Required by type but not used for undelegate
-                errors: {},
-            };
-            const info = await sdk.paymentInfo(sender, fakeTransaction);
-            expect(info).toHaveProperty("gasBudget");
-            expect(info).toHaveProperty("totalGasUsed");
-            expect(info).toHaveProperty("fees");
-        });
-    });
-    describe("Transaction to Operation Mapping", () => {
-        test("transactionToOperation should map staking transaction correctly", () => {
-            const accountId = "mockAccountId";
-            const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            const operation = sdk.transactionToOperation(accountId, address, mockStakingTx(address, "-1000000000"));
-            expect(operation).toHaveProperty("id");
-            expect(operation).toHaveProperty("accountId", accountId);
-            expect(operation).toHaveProperty("type", "DELEGATE");
-            expect(operation).toHaveProperty("hash", "delegate_tx_digest_123");
-            expect(operation).toHaveProperty("extra");
-            expect(operation.extra.coinType).toBe(sdk.DEFAULT_COIN_TYPE);
-            expect(operation.value).toEqual(new BigNumber("1000000000")); // The function returns minus of the balance change
-            expect(operation.recipients).toEqual([]);
-            expect(operation.senders).toEqual([address]);
-        });
-        test("transactionToOperation should map unstaking transaction correctly", () => {
-            const accountId = "mockAccountId";
-            const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            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("-1000000000"));
-            expect(operation.recipients).toEqual([]);
-            expect(operation.senders).toEqual([address]);
-        });
-        test("transactionToOp should map staking transaction correctly", () => {
-            const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            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]);
-            expect(operation.recipients).toEqual([]);
-            expect(operation.value).toEqual(1000000000n); // The function returns minus of the balance change
-            expect(operation.asset).toEqual({ type: "native" });
-            expect(operation.tx.block.hash).toBeUndefined();
-        });
-        test("transactionToOp should map unstaking transaction correctly", () => {
-            const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-            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(1000000000n);
-            expect(operation.asset).toEqual({ type: "native" });
-            expect(operation.tx.block.hash).toBeUndefined();
-        });
-    });
-    describe("Operation Extra Information", () => {
-        test("getOperationExtra should be a function", () => {
-            expect(typeof sdk.getOperationExtra).toBe("function");
-        });
-        test("getOperationExtra should return a Promise", () => {
-            const result = sdk.getOperationExtra("test_digest");
-            expect(result).toBeInstanceOf(Promise);
-        });
-    });
-});
-describe("queryTransactions", () => {
-    it("should call api.queryTransactionBlocks with correct params for IN", async () => {
-        mockApi.queryTransactionBlocks.mockResolvedValueOnce({
-            data: [{ digest: "tx1" }],
-            hasNextPage: false,
-        });
-        const result = await sdk.queryTransactions({
-            api: mockApi,
-            addr: "0xabc",
-            type: "IN",
-            order: "ascending",
-        });
-        expect(mockApi.queryTransactionBlocks).toHaveBeenCalledWith(expect.objectContaining({
-            filter: { ToAddress: "0xabc" },
-        }));
-        expect(result.data).toHaveLength(1);
-    });
-    it("should call api.queryTransactionBlocks with correct params for OUT", async () => {
-        mockApi.queryTransactionBlocks.mockResolvedValueOnce({
-            data: [{ digest: "tx2" }],
-            hasNextPage: false,
-        });
-        const result = await sdk.queryTransactions({
-            api: mockApi,
-            addr: "0xdef",
-            type: "OUT",
-            order: "ascending",
-        });
-        expect(mockApi.queryTransactionBlocks).toHaveBeenCalledWith(expect.objectContaining({
-            filter: { FromAddress: "0xdef" },
-        }));
-        expect(result.data).toHaveLength(1);
-    });
-});
-describe("loadOperations", () => {
-    it("should paginate and accumulate results", async () => {
-        const pageSize = sdk.TRANSACTIONS_LIMIT_PER_QUERY;
-        const firstPage = Array.from({ length: pageSize }, (_, i) => ({ digest: `tx${i + 1}` }));
-        mockApi.queryTransactionBlocks
-            .mockResolvedValueOnce({
-            data: firstPage,
-            hasNextPage: true,
-            nextCursor: "cursor1",
-        })
-            .mockResolvedValueOnce({
-            data: [{ digest: `tx${pageSize + 1}` }],
-            hasNextPage: false,
-        });
-        const result = await sdk.loadOperations({
-            api: mockApi,
-            addr: "0xabc",
-            type: "IN",
-            order: "ascending",
-            operations: [],
-        });
-        expect(result.operations).toHaveLength(pageSize + 1);
-        expect(result.operations.map(tx => tx.digest)).toEqual([
-            ...firstPage.map(tx => tx.digest),
-            `tx${pageSize + 1}`,
-        ]);
-        expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(2);
-    });
-    it("should stop if less than TRANSACTIONS_LIMIT_PER_QUERY returned", async () => {
-        // Create an array with length less than TRANSACTIONS_LIMIT_PER_QUERY
-        const txs = Array.from({ length: sdk.TRANSACTIONS_LIMIT_PER_QUERY - 1 }, (_, i) => ({
-            digest: `tx${i + 1}`,
-        }));
-        mockApi.queryTransactionBlocks.mockResolvedValueOnce({
-            data: txs,
-            hasNextPage: false, // Only one call should be made
-        });
-        const result = await sdk.loadOperations({
-            api: mockApi,
-            addr: "0xabc",
-            type: "OUT",
-            order: "ascending",
-            operations: [],
-        });
-        expect(result.operations).toHaveLength(sdk.TRANSACTIONS_LIMIT_PER_QUERY - 1);
-        expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(1);
-    });
-    it("should not exceed TRANSACTIONS_LIMIT", async () => {
-        const page = Array.from({ length: sdk.TRANSACTIONS_LIMIT_PER_QUERY }, (_, i) => ({
-            digest: `tx${i + 1}`,
-        }));
-        const expectedCalls = Math.ceil(sdk.TRANSACTIONS_LIMIT / sdk.TRANSACTIONS_LIMIT_PER_QUERY);
-        let callCount = 0;
-        mockApi.queryTransactionBlocks.mockImplementation(() => {
-            callCount++;
-            return Promise.resolve({
-                data: page,
-                hasNextPage: callCount < expectedCalls,
-                nextCursor: callCount < expectedCalls ? "cursor" : null,
-            });
-        });
-        const result = await sdk.loadOperations({
-            api: mockApi,
-            addr: "0xabc",
-            type: "IN",
-            order: "ascending",
-            operations: [],
-        });
-        expect(result.operations).toHaveLength(sdk.TRANSACTIONS_LIMIT);
-        expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(expectedCalls);
-    });
-    it("should retry without cursor when InvalidParams error occurs", async () => {
-        // Reset the mock for this test
-        mockApi.queryTransactionBlocks.mockReset();
-        // Call fails with InvalidParams
-        mockApi.queryTransactionBlocks.mockRejectedValueOnce({ type: "InvalidParams" });
-        const result = await sdk.loadOperations({
-            api: mockApi,
-            addr: "0xabc",
-            type: "IN",
-            cursor: "some-cursor",
-            order: "ascending",
-            operations: [],
-        });
-        // Should have been called once (no retry in actual implementation)
-        expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(1);
-        // Should have been called with the cursor
-        expect(mockApi.queryTransactionBlocks).toHaveBeenCalledWith(expect.objectContaining({
-            filter: { ToAddress: "0xabc" },
-            cursor: "some-cursor",
-        }));
-        // Result should be empty array (no retry, just return operations)
-        expect(result.operations).toHaveLength(0);
-    });
-    it("should should not retry after unexpected errors and return empty data", async () => {
-        mockApi.queryTransactionBlocks.mockRejectedValueOnce(new Error("unexpected"));
-        const result = await sdk.loadOperations({
-            api: mockApi,
-            addr: "0xerr",
-            type: "IN",
-            order: "ascending",
-            operations: [],
-        });
-        expect(result.operations).toEqual([]);
-        expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(1);
-    });
-});
-describe("getOperations filtering logic", () => {
-    const mockAccountId = "mockAccountId";
-    const mockAddr = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
-    // Mock loadOperations to return controlled test data
-    const mockLoadOperations = jest.spyOn(sdk, "loadOperations");
-    // Helper function to create mock transaction data
-    const createMockTransaction = (digest, timestampMs, sender = mockAddr, recipients = [], balanceChangeAmount) => {
-        // If sender is mockAddr (OUT), amount is negative; if sender is otherAddr (IN), amount is positive
-        const isOut = sender === mockAddr;
-        const amount = balanceChangeAmount ?? (isOut ? "-1000000" : "1000000");
-        return {
-            digest,
-            timestampMs,
-            effects: {
-                status: { status: "success" },
-                gasUsed: {
-                    computationCost: "1000000",
-                    storageCost: "500000",
-                    storageRebate: "450000",
-                    nonRefundableStorageFee: "0",
-                },
-                executedEpoch: "1",
-                gasObject: {
-                    owner: { AddressOwner: sender },
-                    reference: {
-                        objectId: "0xgas",
-                        version: "1",
-                        digest: "gas-digest",
-                    },
-                },
-                messageVersion: "v1",
-                transactionDigest: digest,
-            },
-            balanceChanges: [
-                {
-                    owner: { AddressOwner: mockAddr },
-                    coinType: sdk.DEFAULT_COIN_TYPE,
-                    amount,
-                },
-            ],
-            transaction: {
-                data: {
-                    sender,
-                    transaction: {
-                        kind: "ProgrammableTransaction",
-                        inputs: recipients.map(r => ({ type: "pure", valueType: "address", value: r })),
-                        transactions: [],
-                    },
-                    gasData: {
-                        budget: "1000",
-                        owner: sender,
-                        payment: [],
-                        price: "1",
-                    },
-                    messageVersion: "v1",
-                },
-                txSignatures: [],
-            },
-        };
-    };
-    const otherAddr = "0xotheraddress";
-    // OUT = sender is mockAddr, IN = sender is otherAddr
-    beforeEach(() => {
-        mockLoadOperations.mockReset();
-        // Mock loadOperations to return different data based on operation type
-        mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
-            if (type === "OUT") {
-                return {
-                    operations: [
-                        createMockTransaction("sent1", "1000", mockAddr, []),
-                        createMockTransaction("sent2", "2000", mockAddr, []),
-                    ],
-                    cursor: null,
-                };
-            }
-            else if (type === "IN") {
-                return {
-                    operations: [
-                        createMockTransaction("received1", "1500", otherAddr, [mockAddr]),
-                        createMockTransaction("received2", "2500", otherAddr, [mockAddr]),
-                    ],
-                    cursor: null,
-                };
-            }
-            return { operations: [], cursor: null };
-        });
-    });
-    afterEach(() => {
-        // Remove mockRestore as it might interfere with the mock setup
-    });
-    test("should not apply timestamp filter when cursor is provided", async () => {
-        const cursor = "test-cursor";
-        const operations = await sdk.getOperations(mockAccountId, mockAddr, cursor);
-        // Should not filter by timestamp when cursor is provided
-        expect(operations).toHaveLength(4);
-        expect(operations.map(op => op.hash)).toEqual(["received2", "sent2", "received1", "sent1"]);
-    });
-    test("should not apply timestamp filter when operations don't reach limits", async () => {
-        const operations = await sdk.getOperations(mockAccountId, mockAddr);
-        // Should not filter by timestamp when limits aren't reached
-        expect(operations).toHaveLength(4);
-        expect(operations.map(op => op.hash)).toEqual(["received2", "sent2", "received1", "sent1"]);
-    });
-    test("should apply timestamp filter when sent operations reach limit", async () => {
-        // Mock to return enough sent operations to reach limit
-        mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
-            if (type === "OUT") {
-                return {
-                    operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`sent${i + 1}`, String(1000 + i * 100), mockAddr, [])),
-                    cursor: null,
-                };
-            }
-            else if (type === "IN") {
-                return {
-                    operations: [
-                        createMockTransaction("received1", "500", otherAddr, [mockAddr]),
-                        createMockTransaction("received2", "1500", otherAddr, [mockAddr]),
-                    ],
-                    cursor: null,
-                };
-            }
-            return { operations: [], cursor: null };
-        });
-        const operations = await sdk.getOperations(mockAccountId, mockAddr);
-        // Filter timestamp should be the maximum of the last timestamps from both arrays
-        // sent: last timestamp = 1000 + 299*100 = 30900
-        // received: last timestamp = 1500
-        // filter = max(30900, 1500) = 30900
-        // Only operations with timestamp >= 30900 should remain
-        expect(operations).toHaveLength(1); // Only sent300 (30900)
-        expect(operations.map(op => op.hash)).toEqual(["sent300"]);
-    });
-    test("should apply timestamp filter when received operations reach limit", async () => {
-        // Mock to return enough received operations to reach limit
-        mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
-            if (type === "OUT") {
-                return {
-                    operations: [
-                        createMockTransaction("sent1", "500", mockAddr, []),
-                        createMockTransaction("sent2", "1500", mockAddr, []),
-                    ],
-                    cursor: null,
-                };
-            }
-            else if (type === "IN") {
-                return {
-                    operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`received${i + 1}`, String(1000 + i * 100), otherAddr, [
-                        mockAddr,
-                    ])),
-                    cursor: null,
-                };
-            }
-            return { operations: [], cursor: null };
-        });
-        const operations = await sdk.getOperations(mockAccountId, mockAddr);
-        // Filter timestamp should be the maximum of the last timestamps from both arrays
-        // sent: last timestamp = 1500
-        // received: last timestamp = 1000 + 299*100 = 30900
-        // filter = max(1500, 30900) = 30900
-        // Only operations with timestamp >= 30900 should remain
-        expect(operations).toHaveLength(1); // Only received300 (30900)
-        expect(operations.map(op => op.hash)).toEqual(["received300"]);
-    });
-    test("should apply timestamp filter when both operations reach limit", async () => {
-        // Mock to return enough operations to reach limit for both types
-        mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
-            if (type === "OUT") {
-                return {
-                    operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`sent${i + 1}`, String(1000 + i * 100), mockAddr, [])),
-                    cursor: null,
-                };
-            }
-            else if (type === "IN") {
-                return {
-                    operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`received${i + 1}`, String(2000 + i * 100), otherAddr, [
-                        mockAddr,
-                    ])),
-                    cursor: null,
-                };
-            }
-            return { operations: [], cursor: null };
-        });
-        const operations = await sdk.getOperations(mockAccountId, mockAddr);
-        // Filter timestamp should be the maximum of the last timestamps from both arrays
-        // sent: last timestamp = 1000 + 299*100 = 30900
-        // received: last timestamp = 2000 + 299*100 = 31900
-        // filter = max(30900, 31900) = 31900
-        // Only operations with timestamp >= 31900 should remain
-        expect(operations).toHaveLength(1); // Only received300 (31900)
-        expect(operations.map(op => op.hash)).toEqual(["received300"]);
-    });
-    test("should handle null/undefined timestampMs values", async () => {
-        // Mock to return operations with null timestamps and reach limit
-        mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
-            if (type === "OUT") {
-                return {
-                    operations: [
-                        createMockTransaction("sent1", "1000", mockAddr, []),
-                        createMockTransaction("sent2", null, mockAddr, []),
-                        createMockTransaction("sent3", "3000", mockAddr, []),
-                        ...Array.from({ length: sdk.TRANSACTIONS_LIMIT - 3 }, (_, i) => createMockTransaction(`sent${i + 4}`, String(4000 + i * 100), mockAddr, [])),
-                    ],
-                    cursor: null,
-                };
-            }
-            else if (type === "IN") {
-                return {
-                    operations: [
-                        createMockTransaction("received1", null, otherAddr, [mockAddr]),
-                        createMockTransaction("received2", "2000", otherAddr, [mockAddr]),
-                        createMockTransaction("received3", "4000", otherAddr, [mockAddr]),
-                    ],
-                    cursor: null,
-                };
-            }
-            return { operations: [], cursor: null };
-        });
-        const operations = await sdk.getOperations(mockAccountId, mockAddr);
-        // Filter timestamp should be the timestamp of the last sent operation (4000 + 296*100 = 33600)
-        // Only operations with timestamp >= 33600 should remain
-        expect(operations).toHaveLength(1); // Only sent300 (33600)
-        expect(operations.map(op => op.hash)).toEqual(["sent300"]);
-    });
-    test("should maintain chronological order after filtering", async () => {
-        // Mock to return operations that reach limit
-        mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
-            if (type === "OUT") {
-                return {
-                    operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`sent${i + 1}`, String(1000 + i * 10), mockAddr, [])),
-                    cursor: null,
-                };
-            }
-            else if (type === "IN") {
-                return {
-                    operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`received${i + 1}`, String(500 + i * 10), otherAddr, [mockAddr])),
-                    cursor: null,
-                };
-            }
-            return { operations: [], cursor: null };
-        });
-        const operations = await sdk.getOperations(mockAccountId, mockAddr);
-        // Should be sorted by timestamp in descending order
-        const timestamps = operations.map(op => Number(op.date.getTime()));
-        expect(timestamps).toEqual(timestamps.slice().sort((a, b) => b - a));
-    });
-    test("should handle empty operations arrays", async () => {
-        // Mock to return empty arrays
-        mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
-            return { operations: [], cursor: null };
-        });
-        const operations = await sdk.getOperations(mockAccountId, mockAddr);
-        expect(operations).toHaveLength(0);
-    });
-    test("should handle mixed empty and non-empty operations", async () => {
-        // Mock to return only OUT operations
-        mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
-            if (type === "OUT") {
-                return {
-                    operations: [
-                        createMockTransaction("sent1", "1000", mockAddr, []),
-                        createMockTransaction("sent2", "2000", mockAddr, []),
-                    ],
-                    cursor: null,
-                };
-            }
-            else if (type === "IN") {
-                return { operations: [], cursor: null };
-            }
-            return { operations: [], cursor: null };
-        });
-        const operations = await sdk.getOperations(mockAccountId, mockAddr);
-        expect(operations).toHaveLength(2);
-        expect(operations.map(op => op.hash)).toEqual(["sent2", "sent1"]);
-    });
-    test("should handle operations with same timestamps", async () => {
-        // Mock to return operations with same timestamps and reach limit
-        mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
-            if (type === "OUT") {
-                return {
-                    operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`sent${i + 1}`, "1000", mockAddr, [])),
-                    cursor: null,
-                };
-            }
-            else if (type === "IN") {
-                return {
-                    operations: [
-                        createMockTransaction("received1", "1000", otherAddr, [mockAddr]),
-                        createMockTransaction("received2", "1000", otherAddr, [mockAddr]),
-                    ],
-                    cursor: null,
-                };
-            }
-            return { operations: [], cursor: null };
-        });
-        const operations = await sdk.getOperations(mockAccountId, mockAddr);
-        // Filter timestamp should be 1000 (the common timestamp)
-        // All operations have timestamp 1000, so all should pass the filter
-        expect(operations).toHaveLength(sdk.TRANSACTIONS_LIMIT + 2); // All 300 sent + 2 received
-        expect(operations[0].hash).toBe("sent1"); // First one should be the first sent
-        expect(operations[operations.length - 1].hash).toBe("received2"); // Last one should be the last received
-    });
-});
-describe("filterOperations", () => {
-    const createMockTransaction = (digest, timestampMs) => ({
-        digest,
-        timestampMs,
-        effects: {
-            status: { status: "success" },
-            gasUsed: {
-                computationCost: "1000000",
-                storageCost: "500000",
-                storageRebate: "450000",
-                nonRefundableStorageFee: "0",
-            },
-            executedEpoch: "1",
-            gasObject: {
-                owner: { AddressOwner: "0x123" },
-                reference: {
-                    objectId: "0xgas",
-                    version: "1",
-                    digest: "gas-digest",
-                },
-            },
-            messageVersion: "v1",
-            transactionDigest: digest,
-        },
-        transaction: {
-            data: {
-                sender: "0x123",
-                transaction: {
-                    kind: "ProgrammableTransaction",
-                    inputs: [],
-                    transactions: [],
-                },
-                gasData: {
-                    budget: "1000",
-                    owner: "0x123",
-                    payment: [],
-                    price: "1",
-                },
-                messageVersion: "v1",
-            },
-            txSignatures: [],
-        },
-        balanceChanges: [],
-    });
-    describe("when cursor is provided", () => {
-        test("should not apply timestamp filtering", () => {
-            const operationList1 = {
-                operations: [createMockTransaction("tx1", "1000"), createMockTransaction("tx2", "2000")],
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: [createMockTransaction("tx3", "1500"), createMockTransaction("tx4", "2500")],
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Should return all operations sorted by timestamp in descending order
-            expect(result.operations).toHaveLength(4);
-            expect(result.operations.map(tx => tx.digest)).toEqual(["tx4", "tx2", "tx3", "tx1"]);
-        });
-        test("should handle null cursor", () => {
-            const operationList1 = {
-                operations: [createMockTransaction("tx1", "1000"), createMockTransaction("tx2", "2000")],
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: [createMockTransaction("tx3", "1500"), createMockTransaction("tx4", "2500")],
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Should return all operations sorted by timestamp in descending order
-            expect(result.operations).toHaveLength(4);
-            expect(result.operations.map(tx => tx.digest)).toEqual(["tx4", "tx2", "tx3", "tx1"]);
-        });
-        test("should handle undefined cursor", () => {
-            const operationList1 = {
-                operations: [createMockTransaction("tx1", "1000"), createMockTransaction("tx2", "2000")],
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: [createMockTransaction("tx3", "1500"), createMockTransaction("tx4", "2500")],
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Should return all operations sorted by timestamp in descending order
-            expect(result.operations).toHaveLength(4);
-            expect(result.operations.map(tx => tx.digest)).toEqual(["tx4", "tx2", "tx3", "tx1"]);
-        });
-    });
-    describe("when cursor is not provided and operations reach limits", () => {
-        test("should apply timestamp filtering when both lists reach limit", () => {
-            const operationList1 = {
-                operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 100))),
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`tx2_${i + 1}`, String(2000 + i * 100))),
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Filter timestamp should be max of last timestamps:
-            // operationList1: 1000 + 299*100 = 30900
-            // operationList2: 2000 + 299*100 = 31900
-            // filter = max(30900, 31900) = 31900
-            // Only operations with timestamp >= 31900 should remain
-            const filteredOperations = result.operations.filter(tx => Number(tx.timestampMs) >= 31900);
-            expect(filteredOperations).toHaveLength(1);
-            expect(filteredOperations[0].digest).toBe("tx2_300");
-        });
-        test("should apply timestamp filtering when only first list reaches limit", () => {
-            const operationList1 = {
-                operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 100))),
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: [createMockTransaction("tx2_1", "500"), createMockTransaction("tx2_2", "1500")],
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Filter timestamp should be max of last timestamps:
-            // operationList1: 1000 + 299*100 = 30900
-            // operationList2: 1500
-            // filter = max(30900, 1500) = 30900
-            // Only operations with timestamp >= 30900 should remain
-            const filteredOperations = result.operations.filter(tx => Number(tx.timestampMs) >= 30900);
-            expect(filteredOperations).toHaveLength(1);
-            expect(filteredOperations[0].digest).toBe("tx1_300");
-        });
-        test("should apply timestamp filtering when only second list reaches limit", () => {
-            const operationList1 = {
-                operations: [createMockTransaction("tx1_1", "500"), createMockTransaction("tx1_2", "1500")],
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`tx2_${i + 1}`, String(2000 + i * 100))),
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Filter timestamp should be max of last timestamps:
-            // operationList1: 1500
-            // operationList2: 2000 + 299*100 = 31900
-            // filter = max(1500, 31900) = 31900
-            // Only operations with timestamp >= 31900 should remain
-            const filteredOperations = result.operations.filter(tx => Number(tx.timestampMs) >= 31900);
-            expect(filteredOperations).toHaveLength(1);
-            expect(filteredOperations[0].digest).toBe("tx2_300");
-        });
-    });
-    describe("when cursor is not provided and operations don't reach limits", () => {
-        test("should not apply timestamp filtering when neither list reaches limit", () => {
-            const operationList1 = {
-                operations: [
-                    createMockTransaction("tx1_1", "1000"),
-                    createMockTransaction("tx1_2", "2000"),
-                ],
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: [
-                    createMockTransaction("tx2_1", "1500"),
-                    createMockTransaction("tx2_2", "2500"),
-                ],
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Should return all operations sorted by timestamp in descending order
-            expect(result.operations).toHaveLength(4);
-            expect(result.operations.map(tx => tx.digest)).toEqual(["tx2_2", "tx1_2", "tx2_1", "tx1_1"]);
-        });
-        test("should apply timestamp filtering when only one list reaches limit", () => {
-            const operationList1 = {
-                operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 100))),
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: [createMockTransaction("tx2_1", "1500")],
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Should apply timestamp filtering since one list reaches limit
-            // Filter timestamp should be the timestamp of the last operation in list1 (1000 + 299*100 = 30900)
-            // Only operations with timestamp >= 30900 should remain
-            const filteredOperations = result.operations.filter(tx => Number(tx.timestampMs) >= 30900);
-            expect(filteredOperations).toHaveLength(1);
-            expect(filteredOperations[0].digest).toBe("tx1_300");
-        });
-    });
-    describe("edge cases", () => {
-        test("should handle null/undefined timestampMs values", () => {
-            const operationList1 = {
-                operations: [
-                    createMockTransaction("tx1_1", "1000"),
-                    createMockTransaction("tx1_2", null),
-                    createMockTransaction("tx1_3", "3000"),
-                    ...Array.from({ length: sdk.TRANSACTIONS_LIMIT - 3 }, (_, i) => createMockTransaction(`tx1_${i + 4}`, String(4000 + i * 100))),
-                ],
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: [
-                    createMockTransaction("tx2_1", null),
-                    createMockTransaction("tx2_2", "2000"),
-                    createMockTransaction("tx2_3", "4000"),
-                ],
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Filter timestamp should be the timestamp of the last operation in list1 (4000 + 296*100 = 33600)
-            // Only operations with timestamp >= 33600 should remain
-            const filteredOperations = result.operations.filter(tx => Number(tx.timestampMs) >= 33600);
-            expect(filteredOperations).toHaveLength(1);
-            expect(filteredOperations[0].digest).toBe("tx1_300");
-        });
-        test("should handle empty arrays", () => {
-            const result = sdk.filterOperations({ operations: [], cursor: null }, { operations: [], cursor: null }, "ascending");
-            expect(result.operations).toHaveLength(0);
-        });
-        test("should handle one empty array", () => {
-            const operationList1 = {
-                operations: [
-                    createMockTransaction("tx1_1", "1000"),
-                    createMockTransaction("tx1_2", "2000"),
-                ],
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: [],
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            expect(result.operations).toHaveLength(2);
-            expect(result.operations.map(tx => tx.digest)).toEqual(["tx1_2", "tx1_1"]);
-        });
-        test("should remove duplicate transactions by digest", () => {
-            const operationList1 = {
-                operations: [createMockTransaction("tx1", "1000"), createMockTransaction("tx2", "2000")],
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: [
-                    createMockTransaction("tx2", "2000"), // Duplicate digest
-                    createMockTransaction("tx3", "3000"),
-                ],
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Should remove duplicate tx2
-            expect(result.operations).toHaveLength(3);
-            expect(result.operations.map(tx => tx.digest)).toEqual(["tx3", "tx2", "tx1"]);
-        });
-        test("should maintain chronological order after filtering", () => {
-            const operationList1 = {
-                operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 10))),
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`tx2_${i + 1}`, String(500 + i * 10))),
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Should be sorted by timestamp in descending order
-            const timestamps = result.operations.map(tx => Number(tx.timestampMs));
-            expect(timestamps).toEqual(timestamps.slice().sort((a, b) => b - a));
-        });
-        test("should handle operations with same timestamps", () => {
-            const operationList1 = {
-                operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`tx1_${i + 1}`, "1000")),
-                cursor: null,
-            };
-            const operationList2 = {
-                operations: [
-                    createMockTransaction("tx2_1", "1000"),
-                    createMockTransaction("tx2_2", "1000"),
-                ],
-                cursor: null,
-            };
-            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
-            // Filter timestamp should be 1000 (the common timestamp)
-            // All operations have timestamp 1000, so all should pass the filter
-            expect(result.operations).toHaveLength(sdk.TRANSACTIONS_LIMIT + 2);
-        });
-    });
-    describe("conversion methods", () => {
-        test("toBlockOperation should map native transfers correctly", () => {
-            expect(sdk.toBlockOperation(mockTransaction, {
-                owner: {
-                    AddressOwner: "0x65449f57946938c84c5127",
-                },
-                coinType: sdk.DEFAULT_COIN_TYPE,
-                amount: "-10000000000",
-            })).toEqual([
-                {
-                    type: "transfer",
-                    address: "0x65449f57946938c84c5127",
-                    amount: -10000000000n,
-                    asset: { type: "native" },
-                },
-            ]);
-        });
-        test("toBlockOperation should ignore transfers from shared owner", () => {
-            expect(sdk.toBlockOperation(mockTransaction, {
-                owner: {
-                    Shared: {
-                        initial_shared_version: "0",
-                    },
-                },
-                coinType: sdk.DEFAULT_COIN_TYPE,
-                amount: "-10000000000",
-            })).toEqual([]);
-        });
-        test("toBlockOperation should ignore transfers from object owner", () => {
-            expect(sdk.toBlockOperation(mockTransaction, {
-                owner: {
-                    ObjectOwner: "test",
-                },
-                coinType: sdk.DEFAULT_COIN_TYPE,
-                amount: "-10000000000",
-            })).toEqual([]);
-        });
-        test("toBlockOperation should ignore transfers from immutable owner", () => {
-            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(mockTransaction, {
-                owner: {
-                    ConsensusAddressOwner: {
-                        owner: "test",
-                        start_version: "1",
-                    },
-                },
-                coinType: sdk.DEFAULT_COIN_TYPE,
-                amount: "-10000000000",
-            })).toEqual([]);
-        });
-        test("toBlockOperation should map token transfers correctly", () => {
-            expect(sdk.toBlockOperation(mockTransaction, {
-                owner: {
-                    AddressOwner: "0x65449f57946938c84c5127",
-                },
-                coinType: "0x168da5bf1f48dafc111b0a488fa454aca95e0b5e::usdc::USDC",
-                amount: "8824",
-            })).toEqual([
-                {
-                    type: "transfer",
-                    address: "0x65449f57946938c84c5127",
-                    amount: 8824n,
-                    asset: {
-                        type: "token",
-                        assetReference: "0x168da5bf1f48dafc111b0a488fa454aca95e0b5e::usdc::USDC",
-                    },
-                },
-            ]);
-        });
-        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: [],
-                digest: "0xaaaaaaaaa",
-                previousDigest: "0xbbbbbbbbbb",
-                epoch: "",
-                epochRollingGasCostSummary: {
-                    computationCost: "",
-                    nonRefundableStorageFee: "",
-                    storageCost: "",
-                    storageRebate: "",
-                },
-                networkTotalTransactions: "",
-                sequenceNumber: "42",
-                timestampMs: "1751696298663",
-                transactions: [],
-                validatorSignature: "",
-            })).toEqual({
-                height: 42,
-                hash: "0xaaaaaaaaa",
-                time: new Date(1751696298663),
-                parent: {
-                    height: 41,
-                    hash: "0xbbbbbbbbbb",
-                },
-            });
-        });
-        test("toBlockTransaction should map transactions correctly", () => {
-            expect(sdk.toBlockTransaction(
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            mockTransaction)).toEqual({
-                hash: "DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt",
-                failed: false,
-                fees: 1009880n,
-                feesPayer: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
-                operations: [
-                    {
-                        address: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
-                        amount: -10000000000n,
-                        asset: { type: "native" },
-                        type: "transfer",
-                    },
-                    {
-                        address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                        amount: 9998990120n,
-                        asset: { type: "native" },
-                        type: "transfer",
-                    },
-                    {
-                        address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
-                        amount: 500000n,
-                        asset: { type: "token", assetReference: "0x123::test::TOKEN" },
-                        type: "transfer",
-                    },
-                ],
-            });
-        });
-        test("toSuiAsset should map native coin correctly", () => {
-            expect(sdk.toSuiAsset(sdk.DEFAULT_COIN_TYPE)).toEqual({ type: "native" });
-        });
-        test("suiCoinTypeToAsset should map tokens correctly", () => {
-            expect(sdk.toSuiAsset("0x123::test::TOKEN")).toEqual({
-                type: "token",
-                assetReference: "0x123::test::TOKEN",
-            });
-        });
-    });
-});
-describe("getCoinsForAmount", () => {
-    const mockAddress = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
-    const mockCoinType = "0x2::sui::SUI";
-    beforeEach(() => {
-        mockApi.getCoins.mockReset();
-    });
-    describe("basic functionality", () => {
-        test("handles single coin scenarios", async () => {
-            const sufficientCoins = createMockCoins(["1000"]);
-            mockApi.getCoins.mockResolvedValueOnce({ data: sufficientCoins, hasNextPage: false });
-            let result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(1);
-            expect(result[0].balance).toBe("1000");
-            const insufficientCoins = createMockCoins(["500"]);
-            mockApi.getCoins.mockResolvedValueOnce({ data: insufficientCoins, hasNextPage: false });
-            result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(1);
-            expect(result[0].balance).toBe("500");
-        });
-        test("selects minimum coins needed", async () => {
-            const exactMatchCoins = createMockCoins(["600", "400", "300"]);
-            mockApi.getCoins.mockResolvedValueOnce({ data: exactMatchCoins, hasNextPage: false });
-            let result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(2);
-            expect(result[0].balance).toBe("600");
-            expect(result[1].balance).toBe("400");
-            const exceedCoins = createMockCoins(["800", "400", "200"]);
-            mockApi.getCoins.mockResolvedValueOnce({ data: exceedCoins, hasNextPage: false });
-            result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(2);
-            expect(result[0].balance).toBe("800");
-            expect(result[1].balance).toBe("400");
-        });
-        test("handles edge cases", async () => {
-            mockApi.getCoins.mockResolvedValueOnce({ data: [], hasNextPage: false });
-            let result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(0);
-            const coins = createMockCoins(["1000"]);
-            mockApi.getCoins.mockResolvedValueOnce({ data: coins, hasNextPage: false });
-            result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 0);
-            expect(result).toHaveLength(0);
-        });
-    });
-    describe("sorting and filtering", () => {
-        test("filters zero balance coins", async () => {
-            const mockCoins = createMockCoins(["1000", "500"]);
-            mockCoins.splice(1, 0, createMockCoins(["0"])[0]);
-            mockCoins.push({ coinObjectId: "0xcoin4", balance: "0", digest: "0xdigest4", version: "1" });
-            mockApi.getCoins.mockResolvedValueOnce({ data: mockCoins, hasNextPage: false });
-            const result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(1);
-            expect(result[0].balance).toBe("1000");
-            expect(result.every(coin => parseInt(coin.balance) > 0)).toBe(true);
-        });
-        test("sorts and optimizes coin selection", async () => {
-            const unsortedCoins = createMockCoins(["100", "800", "300", "500"]);
-            mockApi.getCoins.mockResolvedValueOnce({ data: unsortedCoins, hasNextPage: false });
-            let result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(2);
-            expect(result[0].balance).toBe("800");
-            expect(result[1].balance).toBe("500");
-            const mixedCoins = createMockCoins(["200", "800", "400"]);
-            mixedCoins.unshift(createMockCoins(["0"])[0]);
-            mixedCoins.splice(2, 0, createMockCoins(["0"])[0]);
-            mockApi.getCoins.mockResolvedValueOnce({ data: mixedCoins, hasNextPage: false });
-            result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(2);
-            expect(result[0].balance).toBe("800");
-            expect(result[1].balance).toBe("400");
-            expect(result.every(coin => parseInt(coin.balance) > 0)).toBe(true);
-        });
-        test("handles all zero balance coins", async () => {
-            const mockCoins = createMockCoins(["0", "0", "0"]);
-            mockApi.getCoins.mockResolvedValueOnce({ data: mockCoins, hasNextPage: false });
-            const result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(0);
-            expect(result).toEqual([]);
-        });
-    });
-    describe("pagination", () => {
-        test("handles single page scenarios", async () => {
-            const mockCoins = createMockCoins(["800", "400", "300"]);
-            mockApi.getCoins.mockResolvedValueOnce({
-                data: mockCoins,
-                hasNextPage: true,
-                nextCursor: "cursor1",
-            });
-            const result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(2);
-            expect(result[0].balance).toBe("800");
-            expect(result[1].balance).toBe("400");
-            expect(mockApi.getCoins).toHaveBeenCalledTimes(1);
-        });
-        test("handles multi-page scenarios", async () => {
-            const firstPageCoins = createMockCoins(["300", "200"]);
-            const secondPageCoins = createMockCoins(["600", "400", "100"]);
-            mockApi.getCoins
-                .mockResolvedValueOnce({
-                data: firstPageCoins,
-                hasNextPage: true,
-                nextCursor: "cursor1",
-            })
-                .mockResolvedValueOnce({
-                data: secondPageCoins,
-                hasNextPage: false,
-            });
-            const result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(3);
-            expect(result[0].balance).toBe("300");
-            expect(result[1].balance).toBe("200");
-            expect(result[2].balance).toBe("600");
-            expect(mockApi.getCoins).toHaveBeenCalledTimes(2);
-        });
-        test("handles insufficient funds across pages", async () => {
-            const firstPageCoins = createMockCoins(["300", "200"]);
-            const secondPageCoins = createMockCoins(["200", "100"]);
-            mockApi.getCoins
-                .mockResolvedValueOnce({
-                data: firstPageCoins,
-                hasNextPage: true,
-                nextCursor: "cursor1",
-            })
-                .mockResolvedValueOnce({
-                data: secondPageCoins,
-                hasNextPage: false,
-            });
-            const result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-            expect(result).toHaveLength(4);
-            expect(result[0].balance).toBe("300");
-            expect(result[1].balance).toBe("200");
-            expect(result[2].balance).toBe("200");
-            expect(result[3].balance).toBe("100");
-            expect(mockApi.getCoins).toHaveBeenCalledTimes(2);
-        });
-    });
-});
-//# sourceMappingURL=sdk.test.js.map