quantumcoin 7.0.15 → 8.0.1

package/test/unit/providers.test.ts

@@ -1,304 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Provider helpers, wrappers, defaults, and extra providers
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-import qc from "../../index";
-import { Initialize } from "../../config";
-import { logSuite, logTest } from "../verbose-logger";
-
-describe("JsonRpcProvider", () => {
-  logSuite("JsonRpcProvider");
-  it("defaults url/chainId when omitted vs null (no Initialize required)", () => {
-    logTest("defaults url/chainId when omitted vs null (no Initialize required)", {});
-    const p1 = new qc.JsonRpcProvider();
-    const p2 = new qc.JsonRpcProvider(null, null);
-
-    assert.equal(typeof p1.url, "string");
-    assert.ok(p1.url.length > 0);
-    assert.equal(p1.chainId, 123123);
-
-    assert.equal(p2.url, p1.url);
-    assert.equal(p2.chainId, 123123);
-  });
-
-  it("_perform defaults params when omitted vs null", async (t: { skip: (msg: string) => void }) => {
-    logTest("_perform defaults params when omitted vs null", {});
-    if (typeof (globalThis as unknown as { fetch?: unknown }).fetch !== "function") {
-      t.skip("global fetch not available");
-      return;
-    }
-
-    const originalFetch = (globalThis as unknown as { fetch: typeof fetch }).fetch;
-    const seen: unknown[][] = [];
-
-    (globalThis as unknown as { fetch: typeof fetch }).fetch = async (_url: string, init: RequestInit) => {
-      const body = JSON.parse(init.body as string);
-      seen.push(body.params);
-      const responseBody = JSON.stringify({ jsonrpc: "2.0", id: body.id, result: "0x1" });
-      return {
-        ok: true,
-        text: async () => responseBody,
-        json: async () => JSON.parse(responseBody),
-      } as Response;
-    };
-
-    try {
-      const p = new qc.JsonRpcProvider("http://example.invalid", 123123);
-      const a = await p._perform("eth_blockNumber");
-      const b = await p._perform("eth_blockNumber", null);
-      assert.equal(a, "0x1");
-      assert.equal(b, "0x1");
-      assert.deepEqual(seen, [[], []]);
-    } finally {
-      (globalThis as unknown as { fetch: typeof fetch }).fetch = originalFetch;
-    }
-  });
-});
-
-describe("AbstractProvider defaults", () => {
-  logSuite("AbstractProvider defaults");
-  it("getTransactionCount/call/getCode default blockTag when omitted vs null", async () => {
-    logTest("getTransactionCount/call/getCode default blockTag when omitted vs null", {});
-    class P extends qc.AbstractProvider {
-      calls: { method: string; params: unknown[] }[] = [];
-      constructor() {
-        super();
-      }
-      async _perform(method: string, params: unknown[]) {
-        this.calls.push({ method, params });
-        if (method === "eth_getTransactionCount") return "0x2";
-        if (method === "eth_call") return "0x";
-        if (method === "eth_getCode") return "0x";
-        throw new Error("unexpected");
-      }
-    }
-
-    const p = new P();
-    await p.getTransactionCount("0x" + "11".repeat(32));
-    await p.getTransactionCount("0x" + "11".repeat(32), null);
-    await p.call({ to: "0x" + "11".repeat(32), data: "0x" });
-    await p.call({ to: "0x" + "11".repeat(32), data: "0x" }, null);
-    await p.getCode("0x" + "11".repeat(32));
-    await p.getCode("0x" + "11".repeat(32), null);
-
-    const tags = p.calls.map((c) => c.params[c.params.length - 1]);
-    assert.deepEqual(tags, ["latest", "latest", "latest", "latest", "latest", "latest"]);
-  });
-});
-
-describe("AbstractProvider block-tag QUANTITY formatting", () => {
-  logSuite("AbstractProvider block-tag QUANTITY formatting");
-
-  it("getBlock encodes block numbers as spec-compliant quantities (no leading zeros)", async () => {
-    logTest("getBlock encodes block numbers as spec-compliant quantities", {});
-    class BlockStub extends qc.AbstractProvider {
-      calls: { method: string; params: any[] }[] = [];
-      async _perform(method: string, params: any[]) {
-        this.calls.push({ method, params });
-        return { number: "0x5", timestamp: "0x64" };
-      }
-    }
-    const p = new BlockStub();
-    await p.getBlock(0);        assert.equal(p.calls.at(-1)!.params[0], "0x0");
-    await p.getBlock(5);        assert.equal(p.calls.at(-1)!.params[0], "0x5");
-    await p.getBlock(15);       assert.equal(p.calls.at(-1)!.params[0], "0xf");
-    await p.getBlock(16);       assert.equal(p.calls.at(-1)!.params[0], "0x10");
-    await p.getBlock(256);      assert.equal(p.calls.at(-1)!.params[0], "0x100");
-    await p.getBlock(4095);     assert.equal(p.calls.at(-1)!.params[0], "0xfff");
-    await p.getBlock(4096);     assert.equal(p.calls.at(-1)!.params[0], "0x1000");
-    await p.getBlock("latest"); assert.equal(p.calls.at(-1)!.params[0], "latest");
-  });
-
-  it("getLogs encodes fromBlock/toBlock as spec-compliant quantities (no leading zeros)", async () => {
-    logTest("getLogs encodes fromBlock/toBlock as spec-compliant quantities", {});
-    class LogStub extends qc.AbstractProvider {
-      calls: { method: string; params: any[] }[] = [];
-      async _perform(method: string, params: any[]) {
-        this.calls.push({ method, params });
-        return [];
-      }
-    }
-    const lp = new LogStub();
-    await lp.getLogs({ fromBlock: 5, toBlock: 256 });
-    assert.equal(lp.calls[0].params[0].fromBlock, "0x5");
-    assert.equal(lp.calls[0].params[0].toBlock,   "0x100");
-    await lp.getLogs({ fromBlock: "latest", toBlock: "pending" });
-    assert.equal(lp.calls[1].params[0].fromBlock, "latest");
-    assert.equal(lp.calls[1].params[0].toBlock,   "pending");
-  });
-
-  it("getBlock rejects invalid block numbers with a clear typed error", async () => {
-    logTest("getBlock rejects invalid block numbers", {});
-    class StubP extends qc.AbstractProvider {
-      async _perform() { return { number: "0x0" }; }
-    }
-    const p = new StubP();
-    await assert.rejects(() => p.getBlock(-1 as unknown as number),  (e) => e instanceof RangeError);
-    await assert.rejects(() => p.getBlock(1.5 as unknown as number), (e) => e instanceof TypeError);
-    await assert.rejects(() => p.getBlock(NaN as unknown as number), (e) => e instanceof TypeError);
-  });
-});
-
-describe("TransactionResponse.wait", () => {
-  logSuite("TransactionResponse.wait");
-  it("uses default confirmations when omitted vs null", async () => {
-    logTest("uses default confirmations when omitted vs null", {});
-    const fakeProvider = {
-      getTransactionReceipt: async () => ({ blockNumber: 1 }),
-      getBlockNumber: async () => 1,
-    };
-    const tx = new qc.TransactionResponse({ hash: "0x" + "11".repeat(32) }, fakeProvider as unknown as qc.Provider);
-    const r1 = await tx.wait();
-    const r2 = await tx.wait(null, null);
-    assert.deepEqual(r1, { blockNumber: 1 });
-    assert.deepEqual(r2, { blockNumber: 1 });
-  });
-
-  it("throws if provider missing", async () => {
-    logTest("throws if provider missing", {});
-    const tx = new qc.TransactionResponse({ hash: "0x" + "11".repeat(32) }, null);
-    await assert.rejects(() => tx.wait(), (e: Error & { code?: string; message?: string }) => e && e.code === "UNKNOWN_ERROR" && /missing provider/i.test(e.message ?? ""));
-  });
-});
-
-describe("getProvider", () => {
-  logSuite("getProvider");
-  it("returns JsonRpcProvider for http/https URLs", () => {
-    logTest("returns JsonRpcProvider for http/https URLs", {});
-    const p1 = qc.getProvider("https://public.rpc.quantumcoinapi.com", 123123);
-    const p2 = qc.getProvider("http://localhost:8545");
-    assert.ok(p1 instanceof qc.JsonRpcProvider);
-    assert.ok(p2 instanceof qc.JsonRpcProvider);
-    assert.equal(p1.url, "https://public.rpc.quantumcoinapi.com");
-    assert.equal(p1.chainId, 123123);
-  });
-
-  it("returns WebSocketProvider for ws/wss URLs", () => {
-    logTest("returns WebSocketProvider for ws/wss URLs", {});
-    const p1 = qc.getProvider("ws://127.0.0.1:8546");
-    const p2 = qc.getProvider("wss://example.com/ws", 1);
-    assert.ok(p1 instanceof qc.WebSocketProvider);
-    assert.ok(p2 instanceof qc.WebSocketProvider);
-    assert.equal(p1.url, "ws://127.0.0.1:8546");
-    assert.equal(p2.chainId, 1);
-  });
-
-  it("returns IpcSocketProvider for IPC paths", () => {
-    logTest("returns IpcSocketProvider for IPC paths", {});
-    const p = qc.getProvider("\\\\.\\pipe\\geth.ipc");
-    assert.ok(p instanceof qc.IpcSocketProvider);
-    assert.equal(p.path, "\\\\.\\pipe\\geth.ipc");
-  });
-
-  it("returns JsonRpcProvider with default url/chainId when endpoint omitted or empty", () => {
-    logTest("returns JsonRpcProvider with default url/chainId when endpoint omitted or empty", {});
-    const p1 = qc.getProvider();
-    const p2 = qc.getProvider("");
-    assert.ok(p1 instanceof qc.JsonRpcProvider);
-    assert.ok(p2 instanceof qc.JsonRpcProvider);
-    assert.ok(p1.url.length > 0);
-    assert.equal(p1.chainId, 123123);
-  });
-});
-
-describe("Extra providers", () => {
-  logSuite("Extra providers");
-  it("BrowserProvider requires an EIP-1193 provider with request()", () => {
-    logTest("BrowserProvider requires an EIP-1193 provider with request()", {});
-    assert.throws(() => new qc.BrowserProvider(null), (e: Error & { code?: string }) => e && e.code === "INVALID_ARGUMENT");
-    assert.throws(() => new qc.BrowserProvider({}), (e: Error & { code?: string }) => e && e.code === "INVALID_ARGUMENT");
-    const p = new qc.BrowserProvider({ request: async () => null });
-    assert.ok(p);
-  });
-
-  it("WebSocketProvider requires a url and stores it", () => {
-    logTest("WebSocketProvider requires a url and stores it", {});
-    assert.throws(() => new qc.WebSocketProvider(), (e: Error & { code?: string }) => e && e.code === "INVALID_ARGUMENT");
-    const p = new qc.WebSocketProvider("ws://127.0.0.1:8546 ");
-    assert.equal(p.url, "ws://127.0.0.1:8546");
-  });
-
-  it("IpcSocketProvider requires a path and stores it", () => {
-    logTest("IpcSocketProvider requires a path and stores it", {});
-    assert.throws(() => new qc.IpcSocketProvider(), (e: Error & { code?: string }) => e && e.code === "INVALID_ARGUMENT");
-    const p = new qc.IpcSocketProvider("\\\\.\\pipe\\geth.ipc");
-    assert.equal(p.path, "\\\\.\\pipe\\geth.ipc");
-  });
-
-  it("FallbackProvider accepts single vs array and tries providers in order", async () => {
-    logTest("FallbackProvider accepts single vs array and tries providers in order", {});
-    const p1 = { _perform: async () => "0x10" };
-    const fp1 = new qc.FallbackProvider(p1 as unknown as qc.Provider);
-    const bn1 = await fp1.getBlockNumber();
-    assert.equal(bn1, 16);
-
-    const pFail = { _perform: async () => { throw new Error("fail"); } };
-    const pOk = { _perform: async () => "0x02" };
-    const fp2 = new qc.FallbackProvider([pFail, pOk] as unknown as qc.Provider[]);
-    const bn2 = await fp2.getBlockNumber();
-    assert.equal(bn2, 2);
-  });
-
-  it("FallbackProvider throws when no providers provided", () => {
-    logTest("FallbackProvider throws when no providers provided", {});
-    assert.throws(() => new qc.FallbackProvider([]));
-  });
-});
-
-describe("Provider.getFeeData", () => {
-  logSuite("Provider.getFeeData");
-
-  // Expected per-gas-unit prices (wei). BASE is keyType 3 (compact / context 0);
-  // keyType 3 full-sign is BASE x 30; keyType 5 is BASE x 20.
-  const FEE_BASE = 4761904761904760n;
-  const FEE_KT3_FULL = 142857142857142800n;
-  const FEE_KT5 = 95238095238095200n;
-
-  it("prices by keyType number", async () => {
-    logTest("prices by keyType number", {});
-    const p = new qc.JsonRpcProvider();
-    assert.strictEqual((await p.getFeeData(3)).gasPrice, FEE_BASE);
-    assert.strictEqual((await p.getFeeData(3, true)).gasPrice, FEE_KT3_FULL);
-    assert.strictEqual((await p.getFeeData(5)).gasPrice, FEE_KT5);
-    assert.strictEqual((await p.getFeeData(5, true)).gasPrice, FEE_KT5);
-  });
-
-  it("prices by wallet (reads keyType from wallet)", async () => {
-    logTest("prices by wallet", {});
-    await Initialize(null);
-    const p = new qc.JsonRpcProvider();
-
-    const w3 = qc.Wallet.createRandom(undefined, 3);
-    assert.strictEqual((await p.getFeeData(w3)).gasPrice, FEE_BASE);
-    assert.strictEqual((await p.getFeeData(w3, false)).gasPrice, FEE_BASE);
-    assert.strictEqual((await p.getFeeData(w3, null)).gasPrice, FEE_BASE);
-    assert.strictEqual((await p.getFeeData(w3, true)).gasPrice, FEE_KT3_FULL);
-
-    const w5 = qc.Wallet.createRandom(undefined, 5);
-    assert.strictEqual((await p.getFeeData(w5)).gasPrice, FEE_KT5);
-    assert.strictEqual((await p.getFeeData(w5, true)).gasPrice, FEE_KT5);
-  });
-
-  it("FeeData exposes only gasPrice (maxFeePerGas / maxPriorityFeePerGas unsupported)", async () => {
-    logTest("FeeData exposes only gasPrice", {});
-    const p = new qc.JsonRpcProvider();
-    const fd = await p.getFeeData(3);
-    assert.ok(fd instanceof qc.FeeData);
-    assert.strictEqual((fd as any).maxFeePerGas, undefined);
-    assert.strictEqual((fd as any).maxPriorityFeePerGas, undefined);
-  });
-
-  it("rejects invalid keyType and invalid first argument", async () => {
-    logTest("rejects invalid inputs", {});
-    const p = new qc.JsonRpcProvider();
-    await assert.rejects(() => p.getFeeData(99), /getGasPrice failed/);
-    await assert.rejects(() => p.getFeeData({} as any), /expected a Wallet or a keyType number/);
-    await assert.rejects(() => p.getFeeData(null as any), /expected a Wallet or a keyType number/);
-  });
-});

package/test/unit/result.test.js

@@ -1,80 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Result utility (optional params, deep conversions)
- */
- 
- const { describe, it } = require("node:test");
- const assert = require("node:assert/strict");
- 
- const qc = require("../../index");
- const { logSuite, logTest } = require("../verbose-logger");
- 
- describe("Result", () => {
-   logSuite("Result");
-   it("constructor supports items omitted vs provided and keys omitted vs null", () => {
-     logTest("constructor supports items omitted vs provided and keys omitted vs null", {});
-     const r1 = new qc.Result();
-     const r2 = new qc.Result(undefined, undefined);
-     const r3 = new qc.Result([], null);
- 
-     assert.deepEqual(r1.toArray(), []);
-     assert.deepEqual(r2.toArray(), []);
-     assert.deepEqual(r3.toArray(), []);
-     assert.deepEqual(r1.toObject(), {});
-   });
- 
-   it("maps named keys onto indices and supports getValue()", () => {
-     const r = new qc.Result([1, 2], ["a", "b"]);
-     assert.equal(r.a, 1);
-     assert.equal(r.b, 2);
-     assert.equal(r.getValue("a"), 1);
-   });
- 
-   it("toArray/toObject support deep=true (optional param omitted vs null)", () => {
-     const inner = new qc.Result([1], ["x"]);
-     const outer = new qc.Result([inner], ["inner"]);
- 
-     assert.deepEqual(outer.toArray(), [inner]);
-     assert.deepEqual(outer.toArray(null), [inner]); // deep omitted behavior
-     assert.deepEqual(outer.toArray(true), [[1]]);
- 
-     assert.deepEqual(outer.toObject(), { inner });
-     assert.deepEqual(outer.toObject(null), { inner }); // deep omitted behavior
-     assert.deepEqual(outer.toObject(true), { inner: { x: 1 } });
-   });
- 
-   it("fromItems creates a Result and checkResultErrors returns []", () => {
-     const r = qc.Result.fromItems([1, 2], ["a", "b"]);
-     assert.ok(r instanceof qc.Result);
-     assert.deepEqual(qc.checkResultErrors(r), []);
-   });
-
-  it("checkResultErrors finds Error instances and returns paths (nested Result)", () => {
-    const e1 = new Error("outer");
-    const e2 = new Error("inner");
-
-    const inner = new qc.Result([e2], ["x"]);
-    const outer = new qc.Result([e1, inner], ["a", "b"]);
-
-    const errs = qc.checkResultErrors(outer);
-    assert.equal(errs.length, 2);
-    assert.equal(errs[0].error, e1);
-    assert.deepEqual(errs[0].path, ["a"]);
-    assert.equal(errs[1].error, e2);
-    assert.deepEqual(errs[1].path, ["b", "x"]);
-  });
-
-  it("checkResultErrors walks plain objects (struct-like) and is cycle-safe", () => {
-    const e = new Error("boom");
-    const obj = { foo: { bar: e } };
-    obj.self = obj;
-
-    const errs = qc.checkResultErrors(obj);
-    assert.equal(errs.length, 1);
-    assert.equal(errs[0].error, e);
-    assert.deepEqual(errs[0].path, ["foo", "bar"]);
-  });
- });
- 

package/test/unit/result.test.ts

@@ -1,79 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Result utility (optional params, deep conversions)
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-import qc from "../../index";
-import { logSuite, logTest } from "../verbose-logger";
-
-describe("Result", () => {
-  logSuite("Result");
-  it("constructor supports items omitted vs provided and keys omitted vs null", () => {
-    logTest("constructor supports items omitted vs provided and keys omitted vs null", {});
-    const r1 = new qc.Result();
-    const r2 = new qc.Result(undefined, undefined);
-    const r3 = new qc.Result([], null);
-
-    assert.deepEqual(r1.toArray(), []);
-    assert.deepEqual(r2.toArray(), []);
-    assert.deepEqual(r3.toArray(), []);
-    assert.deepEqual(r1.toObject(), {});
-  });
-
-  it("maps named keys onto indices and supports getValue()", () => {
-    const r = new qc.Result([1, 2], ["a", "b"]);
-    assert.equal(r.a, 1);
-    assert.equal(r.b, 2);
-    assert.equal(r.getValue("a"), 1);
-  });
-
-  it("toArray/toObject support deep=true (optional param omitted vs null)", () => {
-    const inner = new qc.Result([1], ["x"]);
-    const outer = new qc.Result([inner], ["inner"]);
-
-    assert.deepEqual(outer.toArray(), [inner]);
-    assert.deepEqual(outer.toArray(null), [inner]);
-    assert.deepEqual(outer.toArray(true), [[1]]);
-
-    assert.deepEqual(outer.toObject(), { inner });
-    assert.deepEqual(outer.toObject(null), { inner });
-    assert.deepEqual(outer.toObject(true), { inner: { x: 1 } });
-  });
-
-  it("fromItems creates a Result and checkResultErrors returns []", () => {
-    const r = qc.Result.fromItems([1, 2], ["a", "b"]);
-    assert.ok(r instanceof qc.Result);
-    assert.deepEqual(qc.checkResultErrors(r), []);
-  });
-
-  it("checkResultErrors finds Error instances and returns paths (nested Result)", () => {
-    const e1 = new Error("outer");
-    const e2 = new Error("inner");
-
-    const inner = new qc.Result([e2], ["x"]);
-    const outer = new qc.Result([e1, inner], ["a", "b"]);
-
-    const errs = qc.checkResultErrors(outer);
-    assert.equal(errs.length, 2);
-    assert.equal(errs[0].error, e1);
-    assert.deepEqual(errs[0].path, ["a"]);
-    assert.equal(errs[1].error, e2);
-    assert.deepEqual(errs[1].path, ["b", "x"]);
-  });
-
-  it("checkResultErrors walks plain objects (struct-like) and is cycle-safe", () => {
-    const e = new Error("boom");
-    const obj: { foo: { bar: Error }; self?: unknown } = { foo: { bar: e } };
-    obj.self = obj;
-
-    const errs = qc.checkResultErrors(obj);
-    assert.equal(errs.length, 1);
-    assert.equal(errs[0].error, e);
-    assert.deepEqual(errs[0].path, ["foo", "bar"]);
-  });
-});

package/test/unit/solidity-types.test.js

@@ -1,49 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Core Solidity type exports exist and are wired via package exports.
- */
-
-const { describe, it } = require("node:test");
-const assert = require("node:assert/strict");
-const fs = require("node:fs");
-const path = require("node:path");
-const { logSuite, logTest } = require("../verbose-logger");
-
-describe("core solidity types", () => {
-  logSuite("core solidity types");
-  it("has src/types/index.d.ts with expected exports", () => {
-    logTest("has src/types/index.d.ts with expected exports", {});
-    const repoRoot = path.resolve(__dirname, "..", "..");
-    const dts = path.join(repoRoot, "src", "types", "index.d.ts");
-    assert.ok(fs.existsSync(dts), "missing src/types/index.d.ts");
-    const src = fs.readFileSync(dts, "utf8");
-
-    for (const needle of [
-      "export type AddressLike",
-      "export type BytesLike",
-      "export type BigNumberish",
-      "export type SolidityTypeName",
-      "export type SolidityInputValue",
-      "export type SolidityOutputValue",
-    ]) {
-      assert.ok(src.includes(needle), `expected types module to include: ${needle}`);
-    }
-  });
-
-  it("exports ./types via package.json exports map", () => {
-    const repoRoot = path.resolve(__dirname, "..", "..");
-    const pkgPath = path.join(repoRoot, "package.json");
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-
-    assert.equal(pkg.types, "src/index.d.ts");
-    assert.ok(pkg.typesVersions && pkg.typesVersions["*"], "package.json missing typesVersions");
-
-    assert.ok(pkg.exports, "package.json missing exports");
-    assert.ok(pkg.exports["./types"], "package.json exports missing ./types");
-    assert.equal(pkg.exports["./types"].types, "./src/types/index.d.ts");
-    assert.equal(pkg.exports["./types"].default, "./src/types/index.js");
-  });
-});
-

package/test/unit/solidity-types.test.ts

@@ -1,39 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Core Solidity type exports exist and are wired via package exports.
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-import { logSuite, logTest } from "../verbose-logger";
-
-describe("core solidity types", () => {
-  logSuite("core solidity types");
-  it("has src/types/index.d.ts with expected exports", () => {
-    logTest("has src/types/index.d.ts with expected exports", {});
-    const repoRoot = path.resolve(__dirname, "..", "..");
-    const dts = path.join(repoRoot, "src", "types", "index.d.ts");
-    assert.ok(fs.existsSync(dts), "missing src/types/index.d.ts");
-    const src = fs.readFileSync(dts, "utf8");
-    // Types may be defined here or re-exported; at minimum the module exists and exports something.
-    assert.ok(src.includes("export"), "expected types module to have an export");
-  });
-
-  it("exports ./types via package.json exports map", () => {
-    const repoRoot = path.resolve(__dirname, "..", "..");
-    const pkgPath = path.join(repoRoot, "package.json");
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-
-    assert.equal(pkg.types, "src/index.d.ts");
-    assert.ok(pkg.typesVersions && pkg.typesVersions["*"], "package.json missing typesVersions");
-
-    assert.ok(pkg.exports, "package.json missing exports");
-    assert.ok(pkg.exports["./types"], "package.json exports missing ./types");
-    assert.equal(pkg.exports["./types"].types, "./src/types/index.d.ts");
-    assert.equal(pkg.exports["./types"].default, "./src/types/index.js");
-  });
-});

package/test/unit/utils.test.js

@@ -1,57 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Utility helpers (units, encoding, hashing, rlp, abi coder)
- */
-
-const { describe, it } = require("node:test");
-const assert = require("node:assert/strict");
-
-const { Initialize } = require("../../config");
-const qc = require("../../index");
-const { logSuite, logTest } = require("../verbose-logger");
-
-describe("Utils", () => {
-  logSuite("Utils");
-  it("parseEther/formatEther roundtrip", () => {
-    logTest("parseEther/formatEther roundtrip", {});
-    const wei = qc.parseEther("1.5");
-    assert.equal(wei, 1500000000000000000n);
-    assert.equal(qc.formatEther(wei), "1.5");
-  });
-
-  it("encodeBytes32String/decodeBytes32String roundtrip", () => {
-    const hex = qc.encodeBytes32String("hello");
-    assert.equal(hex.length, 66);
-    assert.equal(qc.decodeBytes32String(hex), "hello");
-  });
-
-  it("base58 encode/decode roundtrip", () => {
-    const bytes = qc.toUtf8Bytes("hello world");
-    const b58 = qc.encodeBase58(bytes);
-    const out = qc.decodeBase58(b58);
-    assert.equal(qc.toUtf8String(out), "hello world");
-  });
-
-  it("RLP encode/decode roundtrip (hex bytes)", () => {
-    const value = ["0x68656c6c6f", "0x7b", "0x01"];
-    const encoded = qc.encodeRlp(value);
-    assert.ok(typeof encoded === "string" && encoded.startsWith("0x"));
-    const decoded = qc.decodeRlp(encoded);
-    assert.deepEqual(decoded, value);
-  });
-
-  it("AbiCoder encode/decode roundtrip", async () => {
-    await Initialize(null);
-    const coder = new qc.AbiCoder();
-    const data = coder.encode(["uint256", "bool", "string"], [123n, true, "hello"]);
-    assert.ok(typeof data === "string" && data.startsWith("0x"));
-    const decoded = coder.decode(["uint256", "bool", "string"], data);
-    // qcsdk returns JSON array, so we accept array-like output
-    assert.equal(decoded[0].toString(), "123");
-    assert.equal(Boolean(decoded[1]), true);
-    assert.equal(decoded[2], "hello");
-  });
-});
-

package/test/unit/utils.test.ts

@@ -1,56 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Utility helpers (units, encoding, hashing, rlp, abi coder)
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-import { Initialize } from "../../config";
-import qc from "../../index";
-import { logSuite, logTest } from "../verbose-logger";
-
-describe("Utils", () => {
-  logSuite("Utils");
-  it("parseEther/formatEther roundtrip", () => {
-    logTest("parseEther/formatEther roundtrip", {});
-    const wei = qc.parseEther("1.5");
-    assert.equal(wei, 1500000000000000000n);
-    assert.equal(qc.formatEther(wei), "1.5");
-  });
-
-  it("encodeBytes32String/decodeBytes32String roundtrip", () => {
-    const hex = qc.encodeBytes32String("hello");
-    assert.equal(hex.length, 66);
-    assert.equal(qc.decodeBytes32String(hex), "hello");
-  });
-
-  it("base58 encode/decode roundtrip", () => {
-    const bytes = qc.toUtf8Bytes("hello world");
-    const b58 = qc.encodeBase58(bytes);
-    const out = qc.decodeBase58(b58);
-    assert.equal(qc.toUtf8String(out), "hello world");
-  });
-
-  it("RLP encode/decode roundtrip (hex bytes)", () => {
-    const value = ["0x68656c6c6f", "0x7b", "0x01"];
-    const encoded = qc.encodeRlp(value);
-    assert.ok(typeof encoded === "string" && encoded.startsWith("0x"));
-    const decoded = qc.decodeRlp(encoded);
-    assert.deepEqual(decoded, value);
-  });
-
-  it("AbiCoder encode/decode roundtrip", async () => {
-    await Initialize(null);
-    const coder = new qc.AbiCoder();
-    const data = coder.encode(["uint256", "bool", "string"], [123n, true, "hello"]);
-    assert.ok(typeof data === "string" && data.startsWith("0x"));
-    const decoded = coder.decode(["uint256", "bool", "string"], data);
-    // qcsdk returns JSON array, so we accept array-like output
-    assert.equal(decoded[0].toString(), "123");
-    assert.equal(Boolean(decoded[1]), true);
-    assert.equal(decoded[2], "hello");
-  });
-});