@ledgerhq/coin-kaspa 1.1.0-nightly.0

package/src/network/submitTransaction.ts

@@ -0,0 +1,27 @@
+import { API_BASE } from "./config";
+import { ApiResponseSubmitTransaction } from "../types";
+
+export const submitTransaction = async (
+  transactionJson: string,
+): Promise<ApiResponseSubmitTransaction> => {
+  try {
+    const response = await fetch(`${API_BASE}/transactions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: transactionJson,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to submit transaction. Status: ${response.status}`);
+    }
+
+    const txId: string = (await response.json()).transactionId;
+    return {
+      txId,
+    };
+  } catch (error) {
+    throw new Error(`Error submitting transaction: ${error}`);
+  }
+};

package/src/network/tests/getAddressesActive.test.ts

@@ -0,0 +1,77 @@
+import { getAddressesActive } from "../index";
+
+describe("getAddressesActive function", () => {
+  beforeEach(() => {
+    // Clear all mocks before each test to avoid interference
+    jest.clearAllMocks();
+  });
+
+  it("Gets information about addresses being active or not", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        {
+          address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+          active: true,
+        },
+      ],
+    });
+    const addresses = ["kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e"];
+    const result = await getAddressesActive(addresses);
+
+    const expectedResult = [
+      {
+        address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+        active: true,
+      },
+    ];
+
+    expect(result).toEqual(expectedResult);
+  });
+  it("Wrong address should deliver false", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        {
+          address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp42",
+          active: false,
+        },
+      ],
+    });
+
+    const addresses = ["kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp42"];
+    const result = await getAddressesActive(addresses);
+
+    const expectedResult = [
+      {
+        address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp42",
+        active: false,
+      },
+    ];
+
+    expect(result).toEqual(expectedResult);
+  });
+
+  it("Should throw an error if the server returns a bad response", async () => {
+    const addresses = ["kaspa:invalid_address"];
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+    });
+
+    await expect(getAddressesActive(addresses)).rejects.toThrow(
+      "Failed to fetch active state for addresses kaspa:invalid_address. Status: 404",
+    );
+  });
+
+  it("Should throw an error if fetch throws an exception", async () => {
+    const addresses = ["kaspa:another_invalid_address"];
+    global.fetch = jest.fn().mockImplementationOnce(() => {
+      throw new Error("Network Error");
+    });
+
+    await expect(getAddressesActive(addresses)).rejects.toThrow(
+      "Error fetching AddressesActives: Network Error",
+    );
+  });
+});

package/src/network/tests/getBalancesForAddresss.test.ts

@@ -0,0 +1,44 @@
+import { getBalancesForAddresses } from "../index";
+
+describe("getBalanceForAddress", () => {
+  beforeEach(() => {
+    // Clear all mocks before each test to avoid interference
+    jest.clearAllMocks();
+  });
+
+  it("returns the balance for a given address", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        {
+          address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+          balance: 1122124984318255,
+        },
+        {
+          address: "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73",
+          balance: 132655169913451,
+        },
+      ],
+    });
+
+    const addresses = [
+      "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73",
+    ];
+    const result = await getBalancesForAddresses(addresses);
+
+    expect(result[0].address).toBe(addresses[0]);
+    expect(result[0].balance).toBeGreaterThan(0);
+    expect(result.length).toBe(2);
+  });
+
+  it("throws an error for an invalid address", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: false,
+    });
+    const invalidAddress = "invalid:address";
+    await expect(getBalancesForAddresses([invalidAddress])).rejects.toThrow(
+      "Error fetching balance",
+    );
+  });
+});

package/src/network/tests/getBlockDagInfo.test.ts

@@ -0,0 +1,40 @@
+import { getBlockDagInfo } from "../index";
+
+describe("getBlockDagInfo", () => {
+  beforeEach(() => {
+    // Clear all mocks before each test to avoid interference
+    jest.clearAllMocks();
+  });
+
+  it("Check if getBlockDagInfo gives correct output", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        networkName: "kaspa-mainnet",
+        blockCount: "220840",
+        headerCount: "220840",
+        tipHashes: ["d604806a806c9a0e4573b772a9b6a6595b4a8ca8baa2ea48a62fb8733f1677b3"],
+        difficulty: 620427120032880600,
+        pastMedianTime: "1737569348584",
+        virtualParentHashes: ["d604806a806c9a0e4573b772a9b6a6595b4a8ca8baa2ea48a62fb8733f1677b3"],
+        pruningPointHash: "3914b495474186cbf116561e935a11a1991e42b26e7fbbc4658a0c50cb5d2fa6",
+        virtualDaaScore: "101277083",
+      }),
+    });
+
+    const result = await getBlockDagInfo();
+
+    expect(result.pastMedianTime).toBe("1737569348584");
+    expect(result.blockCount).toBe("220840");
+  });
+});
+it("Should throw an error when fetch returns a 500 response", async () => {
+  global.fetch = jest.fn().mockResolvedValueOnce({
+    ok: false,
+    status: 500,
+  });
+
+  await expect(getBlockDagInfo()).rejects.toThrow(
+    "Failed to fetch BlockDAG info. Error: Error: Status: 500",
+  );
+});

package/src/network/tests/getFeeEstimate.test.ts

@@ -0,0 +1,57 @@
+import { getFeeEstimate } from "../index";
+
+describe("getFees", () => {
+  beforeEach(() => {
+    // Clear all mocks before each test to avoid interference
+    jest.clearAllMocks();
+  });
+
+  it("Error response", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      statusText: "Internal Server Error",
+    });
+
+    await expect(getFeeEstimate()).rejects.toThrow("Network response was not ok");
+  });
+
+  it("Check if getFees gives correct output", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        priorityBucket: {
+          feerate: 1,
+          estimatedSeconds: 0.004,
+        },
+        normalBuckets: [
+          {
+            feerate: 1,
+            estimatedSeconds: 0.004,
+          },
+          {
+            feerate: 1,
+            estimatedSeconds: 0.004,
+          },
+        ],
+        lowBuckets: [
+          {
+            feerate: 1,
+            estimatedSeconds: 0.004,
+          },
+        ],
+      }),
+    });
+
+    const result = await getFeeEstimate();
+
+    expect(result.priorityBucket.feerate).toBeGreaterThan(0);
+    expect(result.priorityBucket.estimatedSeconds).toBeGreaterThan(0);
+    expect(result.normalBuckets.length).toBeGreaterThan(0);
+    expect(result.normalBuckets[0].feerate).toBeGreaterThan(0);
+    expect(result.normalBuckets[0].estimatedSeconds).toBeGreaterThan(0);
+    expect(result.lowBuckets.length).toBeGreaterThan(0);
+    expect(result.lowBuckets[0].feerate).toBeGreaterThan(0);
+    expect(result.lowBuckets[0].estimatedSeconds).toBeGreaterThan(0);
+  });
+});

package/src/network/tests/getTransactions.test.ts

@@ -0,0 +1,173 @@
+import { getTransactions } from "../index";
+
+describe("getTransactions function", () => {
+  beforeEach(() => {
+    // Clear all mocks before each test to avoid interference
+    jest.clearAllMocks();
+  });
+  it("should fetch TXs for (burn)address from real API", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: true,
+      headers: {
+        get: jest.fn(() => ""),
+      },
+      json: async () => [
+        {
+          subnetwork_id: "0000000000000000000000000000000000000000",
+          transaction_id: "72cee02d1c323e0a9154ebac60630f7e370eb9149afaa3eab9277a284c343964",
+          hash: "f383585dd39e9459dd97c0551c359e882c8248db618b8726ff9ed57dfb165440",
+          mass: "2036",
+          block_hash: [
+            "89193a460ae5c9dfc5983b72e71ffba2699d75420e906b4475e69861d62fa124",
+            "e194ab7d88ae78a212a388309f0994c3a819dc8d0a5c1f69bd0c811c9017e4bd",
+          ],
+          block_time: 1733730605449,
+          is_accepted: true,
+          accepting_block_hash: "9a2bdd094ae393f94f1a1dee87a9f467d406f8b2a7d9fd9becf9019f0e5eb922",
+          accepting_block_blue_score: 95828655,
+          inputs: [
+            {
+              transaction_id: "72cee02d1c323e0a9154ebac60630f7e370eb9149afaa3eab9277a284c343964",
+              index: 0,
+              previous_outpoint_hash:
+                "6735abfcfeade8fdad092afd5a51ed6089b761fec30ee46a66db3a59ef009b74",
+              previous_outpoint_index: "0",
+              previous_outpoint_resolved: null,
+              previous_outpoint_address: null,
+              previous_outpoint_amount: null,
+              signature_script:
+                "41b317450a27b848bb8e500cdacbf0fd53b1c6e7dfc9e9752e9f4a1892a8b63508f50a47e96acd45995223fb5d41e791f147d7f52fe5d13418a8a7e68cfa2c638901",
+              sig_op_count: "1",
+            },
+          ],
+          outputs: [
+            {
+              transaction_id: "72cee02d1c323e0a9154ebac60630f7e370eb9149afaa3eab9277a284c343964",
+              index: 0,
+              amount: 69000000,
+              script_public_key:
+                "200000000000000000000000000000000000000000000000000000000000000000ac",
+              script_public_key_address:
+                "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+              script_public_key_type: "pubkey",
+              accepting_block_hash: null,
+            },
+            {
+              transaction_id: "72cee02d1c323e0a9154ebac60630f7e370eb9149afaa3eab9277a284c343964",
+              index: 1,
+              amount: 230984512,
+              script_public_key:
+                "2055b8f71e0175003a8ad8ce895d0f0ed6ca84d131115192df4e3842c5d8b049f7ac",
+              script_public_key_address:
+                "kaspa:qp2m3ac7q96sqw52mr8gjhg0pmtv4px3xyg4ryklfcuy93wckpylwuna456vq",
+              script_public_key_type: "pubkey",
+              accepting_block_hash: null,
+            },
+          ],
+        },
+        {
+          subnetwork_id: "0000000000000000000000000000000000000000",
+          transaction_id: "0ae596c60c4a8b8ff8f9397e70266f68d32effb79ad37826b958f41e40759f90",
+          hash: "92d44bdb0fcb210650f7bd62043cb9c0c2013053ac54d1f5ffcb9c016f42f2ea",
+          mass: "1624",
+          block_hash: ["46ce80a5ff71f84b2a37d7ea615cd93edc4fcacf45a7a95d1d6e51d85360a72e"],
+          block_time: 1730564218472,
+          is_accepted: true,
+          accepting_block_hash: "d16be8f74302ed5fb2ee9873cc4e916aecd3ac346639f44fd5cc4fb0ec7dd076",
+          accepting_block_blue_score: 92661331,
+          inputs: [
+            {
+              transaction_id: "0ae596c60c4a8b8ff8f9397e70266f68d32effb79ad37826b958f41e40759f90",
+              index: 0,
+              previous_outpoint_hash:
+                "48c1f630fe28ec4be1fabb8101dade0022d74dbfadab75e52619d5dde6ffdd5f",
+              previous_outpoint_index: "0",
+              previous_outpoint_resolved: null,
+              previous_outpoint_address: null,
+              previous_outpoint_amount: null,
+              signature_script:
+                "419e980873eae21f245208162b341bf62b4702a56d94cd0ab55014359001bf3597bf3936b3cb1634f51c232567f2fa1fdd03fefe126ede1c320e4fa2574aa2506f01",
+              sig_op_count: "1",
+            },
+          ],
+          outputs: [
+            {
+              transaction_id: "0ae596c60c4a8b8ff8f9397e70266f68d32effb79ad37826b958f41e40759f90",
+              index: 0,
+              amount: 3499890212,
+              script_public_key:
+                "200000000000000000000000000000000000000000000000000000000000000000ac",
+              script_public_key_address:
+                "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+              script_public_key_type: "pubkey",
+              accepting_block_hash: null,
+            },
+          ],
+        },
+        {
+          subnetwork_id: "0000000000000000000000000000000000000000",
+          transaction_id: "0958e37fef35f5cc5f53e383f19a1fb589d110bd2e967a34122a48dea1232cb9",
+          hash: "7c9881a09bbacefad1f3ed199a7ff531431675dd9e479a46deb97c71aa35fe02",
+          mass: "2036",
+          block_hash: ["f926e1d1ebb621ce9dc87efca9c4bc02110dee8078ea304c21ab7c65a3d7285b"],
+          block_time: 1730187373390,
+          is_accepted: true,
+          accepting_block_hash: "7bf390afb0a46cd5cc2140540d1aea36f040613873a39fb7d86920ee8ea1cee6",
+          accepting_block_blue_score: 92283556,
+          inputs: [
+            {
+              transaction_id: "0958e37fef35f5cc5f53e383f19a1fb589d110bd2e967a34122a48dea1232cb9",
+              index: 0,
+              previous_outpoint_hash:
+                "ba4d2b0d594e61b003036231c88abcc9a5c1f5ef2d6ea878f8b25a2ab9146d2a",
+              previous_outpoint_index: "0",
+              previous_outpoint_resolved: null,
+              previous_outpoint_address: null,
+              previous_outpoint_amount: null,
+              signature_script:
+                "41a157a87e0a98d18fa4bd2b3a21925e4d961861b84a1be6bf37e495e49dba28406692ce0f4075c7b2ddc08edd6bb7db511ac6a2fd48e30cd88e38cc3999294ec301",
+              sig_op_count: "1",
+            },
+          ],
+          outputs: [
+            {
+              transaction_id: "0958e37fef35f5cc5f53e383f19a1fb589d110bd2e967a34122a48dea1232cb9",
+              index: 0,
+              amount: 100000000,
+              script_public_key:
+                "200000000000000000000000000000000000000000000000000000000000000000ac",
+              script_public_key_address:
+                "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+              script_public_key_type: "pubkey",
+              accepting_block_hash: null,
+            },
+            {
+              transaction_id: "0958e37fef35f5cc5f53e383f19a1fb589d110bd2e967a34122a48dea1232cb9",
+              index: 1,
+              amount: 1557776051,
+              script_public_key:
+                "20ba05376ad62963e66d4a92ac2c73f8183dafcc66dc50960006359a7ad01a75cdac",
+              script_public_key_address:
+                "kaspa:qzaq2dm26c5k8endf2f2ctrnlqvrmt7vvmw9p9sqqc6e57ksrf6u6xafdlpx5",
+              script_public_key_type: "pubkey",
+              accepting_block_hash: null,
+            },
+          ],
+        },
+      ],
+    });
+    const address = "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e";
+    const result = await getTransactions(address);
+    expect(result.transactions.length).toBe(3);
+  });
+
+  it("should return an error if fetch returns a 500 response", async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: false,
+      status: 500,
+    });
+
+    const address = "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e";
+    await expect(getTransactions(address)).rejects.toThrowError("Network response was not ok.");
+  });
+});

package/src/network/tests/getUtxosForAddress.test.ts

@@ -0,0 +1,159 @@
+import { getUtxosForAddresses } from "../index";
+
+interface Outpoint {
+  transactionId: string;
+  index: number;
+}
+
+function getUtxoForOutpoint(utxos: any[], outpoint: Outpoint): any | null {
+  for (const utxo of utxos) {
+    if (
+      utxo.outpoint.transactionId === outpoint.transactionId &&
+      utxo.outpoint.index === outpoint.index
+    ) {
+      return utxo;
+    }
+  }
+  return null;
+}
+
+describe("getUtxosForAddress function", () => {
+  beforeEach(() => {
+    // Clear all mocks before each test to avoid interference
+    jest.clearAllMocks();
+  });
+  it("should fetch UTXOs for given address from real API", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        {
+          address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+          outpoint: {
+            transactionId: "402f0762218346d622bbaeaa25107ab2398733f44f2369c902b176b25fa81e37",
+            index: 0,
+          },
+          utxoEntry: {
+            amount: "5000000000000",
+            scriptPublicKey: {
+              scriptPublicKey:
+                "200000000000000000000000000000000000000000000000000000000000000000ac",
+            },
+            blockDaaScore: "1490933",
+            isCoinbase: false,
+          },
+        },
+        {
+          address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+          outpoint: {
+            transactionId: "6ef083d4a8a1d3cf31a90409f6af5fdc00264c684da80fd3aeb4f6f29684824b",
+            index: 0,
+          },
+          utxoEntry: {
+            amount: "5000000000000",
+            scriptPublicKey: {
+              scriptPublicKey:
+                "200000000000000000000000000000000000000000000000000000000000000000ac",
+            },
+            blockDaaScore: "1491330",
+            isCoinbase: false,
+          },
+        },
+        {
+          address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+          outpoint: {
+            transactionId: "4413257fa1f7884b7cd6f7b42c326da71b45f8c609c3c19609cbf00e5cc66bf4",
+            index: 0,
+          },
+          utxoEntry: {
+            amount: "10000000000",
+            scriptPublicKey: {
+              scriptPublicKey:
+                "200000000000000000000000000000000000000000000000000000000000000000ac",
+            },
+            blockDaaScore: "78211249",
+            isCoinbase: false,
+          },
+        },
+      ],
+    });
+    const addresses = ["kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e"];
+    const result = await getUtxosForAddresses(addresses);
+
+    const expectedUtxos = [
+      {
+        address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+        outpoint: {
+          transactionId: "402f0762218346d622bbaeaa25107ab2398733f44f2369c902b176b25fa81e37",
+          index: 0,
+        },
+        utxoEntry: {
+          amount: "5000000000000",
+          scriptPublicKey: {
+            scriptPublicKey: "200000000000000000000000000000000000000000000000000000000000000000ac",
+          },
+          blockDaaScore: "1490933",
+          isCoinbase: false,
+        },
+      },
+      {
+        address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+        outpoint: {
+          transactionId: "6ef083d4a8a1d3cf31a90409f6af5fdc00264c684da80fd3aeb4f6f29684824b",
+          index: 0,
+        },
+        utxoEntry: {
+          amount: "5000000000000",
+          scriptPublicKey: {
+            scriptPublicKey: "200000000000000000000000000000000000000000000000000000000000000000ac",
+          },
+          blockDaaScore: "1491330",
+          isCoinbase: false,
+        },
+      },
+      {
+        address: "kaspa:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkx9awp4e",
+        outpoint: {
+          transactionId: "4413257fa1f7884b7cd6f7b42c326da71b45f8c609c3c19609cbf00e5cc66bf4",
+          index: 0,
+        },
+        utxoEntry: {
+          amount: "10000000000",
+          scriptPublicKey: {
+            scriptPublicKey: "200000000000000000000000000000000000000000000000000000000000000000ac",
+          },
+          blockDaaScore: "78211249",
+          isCoinbase: false,
+        },
+      },
+    ];
+
+    for (const expectedUtxo of expectedUtxos) {
+      const utxoFromResponse = getUtxoForOutpoint(result, {
+        transactionId: expectedUtxo.outpoint.transactionId,
+        index: 0,
+      });
+
+      expect(utxoFromResponse).not.toBeNull();
+      expect(utxoFromResponse.address).toEqual(expectedUtxo.address);
+      expect(utxoFromResponse.outpoint.transactionId).toEqual(expectedUtxo.outpoint.transactionId);
+      expect(utxoFromResponse.outpoint.index).toEqual(expectedUtxo.outpoint.index);
+      expect(utxoFromResponse.utxoEntry.amount).toEqual(expectedUtxo.utxoEntry.amount);
+      expect(utxoFromResponse.utxoEntry.scriptPublicKey.scriptPublicKey).toEqual(
+        expectedUtxo.utxoEntry.scriptPublicKey.scriptPublicKey,
+      );
+      expect(utxoFromResponse.utxoEntry.blockDaaScore).toEqual(
+        expectedUtxo.utxoEntry.blockDaaScore,
+      );
+      expect(utxoFromResponse.utxoEntry.isCoinbase).toEqual(expectedUtxo.utxoEntry.isCoinbase);
+    }
+  });
+
+  it("should throw an error if the response is not ok", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+    });
+    const addresses = ["invalidAddress"];
+    await expect(getUtxosForAddresses(addresses)).rejects.toThrow();
+  });
+});

package/src/network/tests/getVirtualChainBlueScore.test.ts

@@ -0,0 +1,29 @@
+import { getVirtualChainBlueScore } from "../index";
+
+describe("getVirtualChainBlueScore", () => {
+  beforeEach(() => {
+    // Clear all mocks before each test to avoid interference
+    jest.clearAllMocks();
+  });
+
+  it("should return the blue score from the API response", async () => {
+    // Mock the global fetch function
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ blueScore: 12345 }),
+    });
+
+    const result = await getVirtualChainBlueScore();
+    expect(result).toBe(12345);
+  });
+
+  it("should throw an error when the fetch fails", async () => {
+    // Mock a failed fetch response
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: false,
+    });
+
+    await expect(getVirtualChainBlueScore()).rejects.toThrow("Failed to fetch");
+    expect(global.fetch).toHaveBeenCalledTimes(1);
+  });
+});

package/src/network/tests/submitTransaction.test.ts

@@ -0,0 +1,53 @@
+import { submitTransaction } from "../index";
+
+describe("submitTransaction function", () => {
+  beforeEach(() => {
+    // Clear all mocks before each test to avoid interference
+    jest.clearAllMocks();
+  });
+  it("Gets information about addresses being active or not", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        transactionId: "396f29c47bdd95dddbe868203ce905535a3de1b48af7adeb40b769662885c008",
+      }),
+    });
+    const transactionDetails = {
+      dummy: "data",
+    };
+    const result = await submitTransaction(JSON.stringify(transactionDetails));
+
+    const expectedResult = {
+      txId: "396f29c47bdd95dddbe868203ce905535a3de1b48af7adeb40b769662885c008",
+    };
+
+    expect(result).toEqual(expectedResult);
+  });
+
+  it("Throws an error if the response is not ok", async () => {
+    global.fetch = jest.fn().mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+    });
+
+    const transactionDetails = {
+      dummy: "data",
+    };
+
+    await expect(submitTransaction(JSON.stringify(transactionDetails))).rejects.toThrow(
+      "Failed to submit transaction. Status: 500",
+    );
+  });
+
+  it("Throws an error if there is an exception while submitting", async () => {
+    global.fetch = jest.fn().mockRejectedValueOnce(new Error("Network error"));
+
+    const transactionDetails = {
+      dummy: "data",
+    };
+
+    await expect(submitTransaction(JSON.stringify(transactionDetails))).rejects.toThrow(
+      "Error submitting transaction: Error: Network error",
+    );
+  });
+});