@ledgerhq/coin-sui 0.15.0 → 0.15.1-nightly.0

package/src/network/sdk.test.ts

@@ -4,6 +4,7 @@ import coinConfig from "../config";
 import { BigNumber } from "bignumber.js";
 import { SuiClient } from "@mysten/sui/client";
 import type { TransactionBlockData, SuiTransactionBlockResponse } from "@mysten/sui/client";
+import assert from "assert";
 
 // Mock SUI client for tests
 jest.mock("@mysten/sui/client", () => {
@@ -185,7 +186,90 @@ const mockTransaction = {
   ],
   timestampMs: "1742294454878",
   checkpoint: "313024",
-};
+} as SuiTransactionBlockResponse;
+
+// Create a mock staking transaction
+// amount must be a negative number
+function mockStakingTx(address: string, amount: string) {
+  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",
+  } as unknown as SuiTransactionBlockResponse;
+}
+
+// amount must be a positive number
+function mockUnstakingTx(address: string, amount: string) {
+  assert(new BigNumber(amount).gte(0), "amount must be a positive number");
+  return {
+    digest: "undelegate_tx_digest_456",
+    transaction: {
+      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",
+  } as unknown as SuiTransactionBlockResponse;
+}
 
 const mockApi = new SuiClient({ url: "mock" }) as jest.Mocked<SuiClient>;
 
@@ -254,16 +338,12 @@ describe("SDK Functions", () => {
 
   test("getOperationType should return IN for incoming tx", () => {
     const address = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
-    expect(sdk.getOperationType(address, mockTransaction as SuiTransactionBlockResponse)).toBe(
-      "IN",
-    );
+    expect(sdk.getOperationType(address, mockTransaction)).toBe("IN");
   });
 
   test("getOperationType should return OUT for outgoing tx", () => {
     const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
-    expect(sdk.getOperationType(address, mockTransaction as SuiTransactionBlockResponse)).toBe(
-      "OUT",
-    );
+    expect(sdk.getOperationType(address, mockTransaction)).toBe("OUT");
   });
 
   test("getOperationSenders should return sender address", () => {
@@ -278,36 +358,12 @@ describe("SDK Functions", () => {
     ).toEqual(["0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0"]);
   });
 
-  test("getOperationAmount should calculate amount correctly for SUI", () => {
-    const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
-    expect(
-      sdk.getOperationAmount(
-        address,
-        mockTransaction as SuiTransactionBlockResponse,
-        sdk.DEFAULT_COIN_TYPE,
-      ),
-    ).toEqual(new BigNumber("9998990120"));
-  });
-
-  test("getOperationAmount should calculate amount correctly for tokens", () => {
-    const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
-    expect(
-      sdk.getOperationAmount(
-        address,
-        mockTransaction as SuiTransactionBlockResponse,
-        "0x123::test::TOKEN",
-      ),
-    ).toEqual(new BigNumber("500000"));
-  });
-
   test("getOperationFee should calculate fee correctly", () => {
-    expect(sdk.getOperationFee(mockTransaction as SuiTransactionBlockResponse)).toEqual(
-      new BigNumber(1009880),
-    );
+    expect(sdk.getOperationFee(mockTransaction)).toEqual(new BigNumber(1009880));
   });
 
   test("getOperationDate should return correct date", () => {
-    const date = sdk.getOperationDate(mockTransaction as SuiTransactionBlockResponse);
+    const date = sdk.getOperationDate(mockTransaction);
     expect(date).toBeDefined();
     expect(date).toBeInstanceOf(Date);
   });
@@ -477,7 +533,7 @@ describe("SDK Functions", () => {
       ],
     };
 
-    const operation = sdk.transactionToOp(address, tokenTx as SuiTransactionBlockResponse);
+    const operation = sdk.alpacaTransactionToOp(address, tokenTx as SuiTransactionBlockResponse);
     expect(operation.id).toEqual("DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt");
     expect(operation.type).toEqual("IN");
     expect(operation.senders).toEqual([
@@ -555,201 +611,89 @@ 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",
-      } as unknown as SuiTransactionBlockResponse;
-
-      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",
-      } as unknown as SuiTransactionBlockResponse;
-
-      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 address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
 
-      const mockStakingTx = {
-        transaction: {
-          data: {
-            transaction: {
-              kind: "ProgrammableTransaction",
-              transactions: [
-                {
-                  MoveCall: {
-                    function: "request_add_stake",
-                  },
-                },
-              ],
-            },
-          },
-        },
-        balanceChanges: [
-          {
-            owner: { AddressOwner: address },
-            coinType: "0x2::sui::SUI",
-            amount: "-1000000000",
-          },
-        ],
-      } as unknown as SuiTransactionBlockResponse;
+    function bridgeOperationAmount(
+      mock: SuiTransactionBlockResponse,
+      coinType: string = sdk.DEFAULT_COIN_TYPE,
+    ) {
+      return sdk.getOperationAmount(address, mock, coinType);
+    }
 
-      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 staking amount", () =>
+      expect(bridgeOperationAmount(mockStakingTx(address, "-1000000000"))).toEqual(
+        new BigNumber("1000000000"),
+      ));
 
-    test("getOperationAmount should calculate unstaking amount correctly", () => {
-      const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
+    test("getOperationAmount should calculate unstaking amount of 1000", () =>
+      expect(bridgeOperationAmount(mockUnstakingTx(address, "1000"))).toEqual(
+        new BigNumber("-1000"),
+      ));
 
-      const mockUnstakingTx = {
-        transaction: {
-          data: {
-            transaction: {
-              kind: "ProgrammableTransaction",
-              transactions: [
-                {
-                  MoveCall: {
-                    function: "request_withdraw_stake",
-                  },
-                },
-              ],
-            },
-          },
-        },
-        balanceChanges: [
-          {
-            owner: { AddressOwner: address },
-            coinType: "0x2::sui::SUI",
-            amount: "0",
-          },
-        ],
-      } as unknown as SuiTransactionBlockResponse;
+    test("getOperationAmount should calculate unstaking amount of 0", () =>
+      expect(bridgeOperationAmount(mockUnstakingTx(address, "0"))).toEqual(new BigNumber("0")));
 
-      const amount = sdk.getOperationAmount(address, mockUnstakingTx, sdk.DEFAULT_COIN_TYPE);
-      expect(amount).toEqual(new BigNumber("0"));
-    });
+    test("getOperationAmount should calculate amount correctly for SUI", () =>
+      expect(bridgeOperationAmount(mockTransaction)).toEqual(new BigNumber("9998990120")));
+
+    test("getOperationAmount should calculate amount correctly for tokens", () =>
+      expect(bridgeOperationAmount(mockTransaction, "0x123::test::TOKEN")).toEqual(
+        new BigNumber("500000"),
+      ));
+
+    function alpacaOperationAmount(
+      mock: SuiTransactionBlockResponse,
+      coinType: string = sdk.DEFAULT_COIN_TYPE,
+    ) {
+      return sdk.alpacaGetOperationAmount(address, mock, coinType);
+    }
+
+    test("alpaca getOperationAmount should calculate staking amount", () =>
+      expect(alpacaOperationAmount(mockStakingTx(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",
-                  },
-                },
-              ],
-            },
-          },
-        },
-      } as unknown as SuiTransactionBlockResponse;
-
-      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",
-                  },
-                },
-              ],
-            },
-          },
-        },
-      } as unknown as SuiTransactionBlockResponse;
-
-      const recipients = sdk.getOperationRecipients(mockUnstakingTx.transaction?.data);
+      const recipients = sdk.getOperationRecipients(
+        mockUnstakingTx("0xdeadbeef", "1000000000").transaction?.data,
+      );
       expect(recipients).toEqual([]);
     });
   });
@@ -840,44 +784,11 @@ describe("Staking Operations", () => {
       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",
-      } as unknown as SuiTransactionBlockResponse;
-
-      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);
@@ -893,45 +804,11 @@ 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",
-      } as unknown as SuiTransactionBlockResponse;
-
-      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);
@@ -939,7 +816,7 @@ describe("Staking Operations", () => {
       expect(operation).toHaveProperty("hash", "undelegate_tx_digest_456");
       expect(operation).toHaveProperty("extra");
       expect((operation.extra as { coinType: string }).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]);
     });
@@ -947,44 +824,7 @@ describe("Staking Operations", () => {
     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",
-      } as unknown as SuiTransactionBlockResponse;
-
-      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");
@@ -998,50 +838,13 @@ 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",
-      } as unknown as SuiTransactionBlockResponse;
-
-      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();
     });
@@ -1934,7 +1737,7 @@ describe("filterOperations", () => {
   describe("conversion methods", () => {
     test("toBlockOperation should map native transfers correctly", () => {
       expect(
-        sdk.toBlockOperation({
+        sdk.toBlockOperation(mockTransaction, {
           owner: {
             AddressOwner: "0x65449f57946938c84c5127",
           },
@@ -1953,7 +1756,7 @@ describe("filterOperations", () => {
 
     test("toBlockOperation should ignore transfers from shared owner", () => {
       expect(
-        sdk.toBlockOperation({
+        sdk.toBlockOperation(mockTransaction, {
           owner: {
             Shared: {
               initial_shared_version: "0",
@@ -1967,7 +1770,7 @@ describe("filterOperations", () => {
 
     test("toBlockOperation should ignore transfers from object owner", () => {
       expect(
-        sdk.toBlockOperation({
+        sdk.toBlockOperation(mockTransaction, {
           owner: {
             ObjectOwner: "test",
           },
@@ -1979,7 +1782,7 @@ describe("filterOperations", () => {
 
     test("toBlockOperation should ignore transfers from immutable owner", () => {
       expect(
-        sdk.toBlockOperation({
+        sdk.toBlockOperation(mockTransaction, {
           owner: "Immutable",
           coinType: sdk.DEFAULT_COIN_TYPE,
           amount: "-10000000000",
@@ -1989,7 +1792,7 @@ describe("filterOperations", () => {
 
     test("toBlockOperation should ignore transfers from consensus owner", () => {
       expect(
-        sdk.toBlockOperation({
+        sdk.toBlockOperation(mockTransaction, {
           owner: {
             ConsensusAddressOwner: {
               owner: "test",
@@ -2004,7 +1807,7 @@ describe("filterOperations", () => {
 
     test("toBlockOperation should map token transfers correctly", () => {
       expect(
-        sdk.toBlockOperation({
+        sdk.toBlockOperation(mockTransaction, {
           owner: {
             AddressOwner: "0x65449f57946938c84c5127",
           },
@@ -2024,6 +1827,44 @@ 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({