quantum-coin-js-sdk 2.0.1 → 2.1.1

package/example/node_modules/quantumcoin/test/unit/generator.test.ts

@@ -1,148 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Typed contract generator (file output shape)
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-import { generate, generateFromArtifacts, generateTransactionalTestJs } from "../../src/generator";
-import { logSuite, logTest } from "../verbose-logger";
-
-describe("typed contract generator", () => {
-  logSuite("typed contract generator");
-  it("generates contract + factory + types + index files", () => {
-    logTest("generates contract + factory + types + index files", {});
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "qcgen-"));
-    const abiPath = path.join(tmp, "Test.abi.json");
-    const binPath = path.join(tmp, "Test.bin");
-    const outDir = path.join(tmp, "out");
-
-    const abi = [
-      {
-        type: "function",
-        name: "balanceOf",
-        stateMutability: "view",
-        inputs: [{ name: "account", type: "address" }],
-        outputs: [{ name: "", type: "uint256" }],
-      },
-      {
-        type: "function",
-        name: "transfer",
-        stateMutability: "nonpayable",
-        inputs: [
-          { name: "to", type: "address" },
-          { name: "amount", type: "uint256" },
-        ],
-        outputs: [{ name: "", type: "bool" }],
-      },
-    ];
-
-    fs.writeFileSync(abiPath, JSON.stringify(abi, null, 2), "utf8");
-    fs.writeFileSync(binPath, "0x6000", "utf8");
-
-    const res = generate({ abiPath, binPath, outDir, contractName: "TestToken" });
-    assert.ok(fs.existsSync(res.contractFile));
-    assert.ok(fs.existsSync(res.factoryFile));
-    assert.ok(fs.existsSync(res.typesFile));
-    assert.ok(fs.existsSync(res.indexFile));
-
-    const contractSrc = fs.readFileSync(res.contractFile, "utf8");
-    assert.ok(contractSrc.includes("export class TestToken"));
-    assert.ok(contractSrc.includes("async balanceOf"));
-    assert.ok(contractSrc.includes("async transfer"));
-    assert.ok(contractSrc.includes("populateTransaction"));
-
-    const factorySrc = fs.readFileSync(res.factoryFile, "utf8");
-    assert.ok(factorySrc.includes("export class TestToken__factory"));
-  });
-
-  it("generated test for a concrete contract (with bytecode) contains the provider.getCode bytecode assertion", () => {
-    logTest("generated test for a concrete contract contains the bytecode assertion", {});
-    const src = generateTransactionalTestJs({
-      contractName: "ConcreteToken",
-      abi: [{ type: "constructor", inputs: [], stateMutability: "nonpayable" }],
-      bytecode: "0x6080604052",
-    });
-    assert.ok(src.includes("provider.getCode(contract.target"));
-    assert.ok(src.includes('assert.ok(code && code !== "0x")'));
-    assert.ok(!src.includes("Skipping bytecode check"));
-  });
-
-  it("generated test for an interface (bytecode '0x') omits the provider.getCode bytecode assertion", () => {
-    logTest("generated test for an interface omits the bytecode assertion", {});
-    const src = generateTransactionalTestJs({
-      contractName: "IThing",
-      abi: [{
-        type: "function", name: "doThing",
-        inputs: [], outputs: [], stateMutability: "nonpayable",
-      }],
-      bytecode: "0x",
-    });
-    assert.ok(!src.includes("provider.getCode(contract.target"));
-    assert.ok(!src.includes('assert.ok(code && code !== "0x")'));
-    assert.ok(src.includes("Skipping bytecode check"));
-    assert.ok(src.includes("IThing is an interface"));
-  });
-
-  it("empty/undefined/null/'0X' bytecode variants are all treated as interface", () => {
-    logTest("empty bytecode variants are all treated as interface", {});
-    for (const bc of [undefined, null, "", "0x", "0X", "  0x  "] as Array<string | null | undefined>) {
-      const src = generateTransactionalTestJs({
-        contractName: "IThing",
-        abi: [],
-        bytecode: bc as unknown as string,
-      });
-      assert.ok(
-        !src.includes("provider.getCode(contract.target"),
-        `bytecode=${JSON.stringify(bc)} should be treated as interface (no getCode assertion)`,
-      );
-      assert.ok(
-        src.includes("Skipping bytecode check"),
-        `bytecode=${JSON.stringify(bc)} should emit skip comment`,
-      );
-    }
-  });
-
-  it("includes injected docs in generated TypeScript", () => {
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "qcgen-docs-"));
-    const outDir = path.join(tmp, "out");
-
-    const abi = [
-      {
-        type: "function",
-        name: "set",
-        stateMutability: "nonpayable",
-        inputs: [{ name: "value", type: "uint256" }],
-        outputs: [],
-      },
-    ];
-
-    const res = generateFromArtifacts({
-      outDir,
-      artifacts: [
-        {
-          contractName: "DocToken",
-          abi,
-          bytecode: "0x6000",
-          docs: {
-            contract: "Example contract doc from Solidity.",
-            functions: {
-              set: "Example function doc from Solidity.",
-            },
-          },
-        },
-      ],
-    });
-
-    const contractFile = res.contracts[0].contractFile;
-    const src = fs.readFileSync(contractFile, "utf8");
-    assert.ok(src.includes("Example contract doc from Solidity."));
-    assert.ok(src.includes("Example function doc from Solidity."));
-  });
-});

package/example/node_modules/quantumcoin/test/unit/hashing.test.js

@@ -1,64 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Hashing helpers (optional params, deterministic behavior)
- */
- 
- const { describe, it } = require("node:test");
- const assert = require("node:assert/strict");
- 
- const qc = require("../../index");
- const { logSuite, logTest } = require("../verbose-logger");
- 
- describe("Hashing", () => {
-   logSuite("Hashing");
-   it("keccak256 returns a 32-byte hex digest for empty bytes", () => {
-     logTest("keccak256 returns a 32-byte hex digest for empty bytes", {});
-     const out = qc.keccak256(new Uint8Array([]));
-     assert.equal(typeof out, "string");
-     assert.ok(out.startsWith("0x"));
-     assert.equal(out.length, 66);
-   });
- 
-   it("sha256/sha512/ripemd160 output lengths are correct", () => {
-     const data = qc.toUtf8Bytes("hello");
-     assert.equal(qc.sha256(data).length, 66);
-     assert.equal(qc.sha512(data).length, 130);
-     assert.equal(qc.ripemd160(data).length, 42);
-   });
- 
-   it("randomBytes returns requested length", () => {
-     const b = qc.randomBytes(16);
-     assert.ok(b instanceof Uint8Array);
-     assert.equal(b.length, 16);
-   });
- 
-   it("pbkdf2 algorithm defaults when omitted vs null vs explicit", () => {
-     const pw = qc.toUtf8Bytes("password");
-     const salt = qc.toUtf8Bytes("salt");
- 
-     const a = qc.pbkdf2(pw, salt, 1, 32);
-     const b = qc.pbkdf2(pw, salt, 1, 32, "sha256");
-     const c = qc.pbkdf2(pw, salt, 1, 32, null);
- 
-     assert.equal(a, b);
-     assert.equal(a, c);
-     assert.ok(a.startsWith("0x") && a.length === 66);
-   });
- 
-  it("computeHmac produces a hex string", () => {
-    const key = qc.toUtf8Bytes("key");
-    const data = qc.toUtf8Bytes("data");
-    const out = qc.computeHmac("sha256", key, data);
-    assert.ok(typeof out === "string" && out.startsWith("0x") && out.length === 66);
-  });
-
-  it("scryptSync with N=262144, r=8, p=1 produces expected hardcoded output", () => {
-    const pw = qc.toUtf8Bytes("password");
-    const salt = qc.toUtf8Bytes("salt");
-    const out = qc.scryptSync(pw, salt, 262144, 8, 1, 32);
-    assert.equal(out, "0xd36e883d93698af49daa529419bb1d97da262bbaa225c12fcf05651268659f42");
-  });
-});
- 

package/example/node_modules/quantumcoin/test/unit/hashing.test.ts

@@ -1,63 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Hashing helpers (optional params, deterministic behavior)
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-import qc from "../../index";
-import { logSuite, logTest } from "../verbose-logger";
-
-describe("Hashing", () => {
-  logSuite("Hashing");
-  it("keccak256 returns a 32-byte hex digest for empty bytes", () => {
-    logTest("keccak256 returns a 32-byte hex digest for empty bytes", {});
-    const out = qc.keccak256(new Uint8Array([]));
-    assert.equal(typeof out, "string");
-    assert.ok(out.startsWith("0x"));
-    assert.equal(out.length, 66);
-  });
-
-  it("sha256/sha512/ripemd160 output lengths are correct", () => {
-    const data = qc.toUtf8Bytes("hello");
-    assert.equal(qc.sha256(data).length, 66);
-    assert.equal(qc.sha512(data).length, 130);
-    assert.equal(qc.ripemd160(data).length, 42);
-  });
-
-  it("randomBytes returns requested length", () => {
-    const b = qc.randomBytes(16);
-    assert.ok(b instanceof Uint8Array);
-    assert.equal(b.length, 16);
-  });
-
-  it("pbkdf2 algorithm defaults when omitted vs null vs explicit", () => {
-    const pw = qc.toUtf8Bytes("password");
-    const salt = qc.toUtf8Bytes("salt");
-
-    const a = qc.pbkdf2(pw, salt, 1, 32);
-    const b = qc.pbkdf2(pw, salt, 1, 32, "sha256");
-    const c = qc.pbkdf2(pw, salt, 1, 32, null);
-
-    assert.equal(a, b);
-    assert.equal(a, c);
-    assert.ok(a.startsWith("0x") && a.length === 66);
-  });
-
-  it("computeHmac produces a hex string", () => {
-    const key = qc.toUtf8Bytes("key");
-    const data = qc.toUtf8Bytes("data");
-    const out = qc.computeHmac("sha256", key, data);
-    assert.ok(typeof out === "string" && out.startsWith("0x") && out.length === 66);
-  });
-
-  it("scryptSync with N=262144, r=8, p=1 produces expected hardcoded output", () => {
-    const pw = qc.toUtf8Bytes("password");
-    const salt = qc.toUtf8Bytes("salt");
-    const out = qc.scryptSync(pw, salt, 262144, 8, 1, 32);
-    assert.equal(out, "0xd36e883d93698af49daa529419bb1d97da262bbaa225c12fcf05651268659f42");
-  });
-});

package/example/node_modules/quantumcoin/test/unit/init.test.js

@@ -1,39 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description SDK initialization and basic constants
- */
-
-const { describe, it } = require("node:test");
-const assert = require("node:assert/strict");
-
-const { Initialize, isInitialized, Config } = require("../../config");
-const qc = require("../../index");
-const { logSuite, logTest } = require("../verbose-logger");
-
-describe("Initialize()", () => {
-  logSuite("Initialize()");
-  it("initializes with default config (null)", async () => {
-    logTest("initializes with default config (null)", {});
-    const ok = await Initialize(null);
-    assert.equal(ok, true);
-    assert.equal(isInitialized(), true);
-  });
-
-  it("exposes constants with QuantumCoin address size", async () => {
-    await Initialize(null);
-    assert.equal(typeof qc.version, "string");
-    assert.equal(qc.ZeroAddress.length, 66);
-    assert.equal(qc.ZeroHash.length, 66);
-    assert.equal(qc.ZeroAddress, "0x" + "00".repeat(32));
-    assert.equal(qc.WeiPerEther, 1000000000000000000n);
-  });
-
-  it("Config defaults match SPEC.md", () => {
-    const cfg = new Config();
-    assert.equal(cfg.chainId, 123123);
-    assert.equal(cfg.rpcEndpoint, "https://public.rpc.quantumcoinapi.com");
-  });
-});
-

package/example/node_modules/quantumcoin/test/unit/init.test.ts

@@ -1,38 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description SDK initialization and basic constants
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-import { Initialize, isInitialized, Config } from "../../config";
-import qc from "../../index";
-import { logSuite, logTest } from "../verbose-logger";
-
-describe("Initialize()", () => {
-  logSuite("Initialize()");
-  it("initializes with default config (null)", async () => {
-    logTest("initializes with default config (null)", {});
-    const ok = await Initialize(null);
-    assert.equal(ok, true);
-    assert.equal(isInitialized(), true);
-  });
-
-  it("exposes constants with QuantumCoin address size", async () => {
-    await Initialize(null);
-    assert.equal(typeof qc.version, "string");
-    assert.equal(qc.ZeroAddress.length, 66);
-    assert.equal(qc.ZeroHash.length, 66);
-    assert.equal(qc.ZeroAddress, "0x" + "00".repeat(32));
-    assert.equal(qc.WeiPerEther, 1000000000000000000n);
-  });
-
-  it("Config defaults match SPEC.md", () => {
-    const cfg = new Config();
-    assert.equal(cfg.chainId, 123123);
-    assert.equal(cfg.rpcEndpoint, "https://public.rpc.quantumcoinapi.com");
-  });
-});

package/example/node_modules/quantumcoin/test/unit/interface.test.js

@@ -1,56 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @description Interface.parseLog (event decoding) using quantum-coin-js-sdk decodeEventLog
- */
-
-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("Interface.parseLog", () => {
-  logSuite("Interface.parseLog");
-  it("parses an encoded event log and returns LogDescription-like result", async () => {
-    logTest("parses an encoded event log and returns LogDescription-like result", {});
-    await Initialize(null);
-
-    const abi = [
-      {
-        name: "Transfer",
-        type: "event",
-        anonymous: false,
-        inputs: [
-          { name: "from", type: "address", indexed: true },
-          { name: "to", type: "address", indexed: true },
-          { name: "value", type: "uint256", indexed: false },
-        ],
-      },
-    ];
-
-    const iface = new qc.Interface(abi);
-    const from = qc.Wallet.createRandom().address;
-    const to = qc.Wallet.createRandom().address;
-    const value = 123n;
-
-    const encoded = iface.encodeEventLog("Transfer", [from, to, value]);
-    assert.ok(Array.isArray(encoded.topics) && encoded.topics.length >= 1);
-    assert.ok(typeof encoded.data === "string");
-
-    const parsed = iface.parseLog({ topics: encoded.topics, data: encoded.data });
-    assert.equal(parsed.name, "Transfer");
-    assert.ok(parsed.topic && parsed.topic.startsWith("0x"));
-    assert.ok(parsed.signature.includes("Transfer("));
-
-    // Args should be array-like and have named keys
-    assert.equal(parsed.args.from.toLowerCase(), from.toLowerCase());
-    assert.equal(parsed.args.to.toLowerCase(), to.toLowerCase());
-    assert.equal(BigInt(parsed.args.value), value);
-    assert.equal(parsed.args[0].toLowerCase(), from.toLowerCase());
-    assert.equal(parsed.args[1].toLowerCase(), to.toLowerCase());
-    assert.equal(BigInt(parsed.args[2]), value);
-  });
-});
-

package/example/node_modules/quantumcoin/test/unit/interface.test.ts

@@ -1,54 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @description Interface.parseLog (event decoding) using quantum-coin-js-sdk decodeEventLog
- */
-
-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("Interface.parseLog", () => {
-  logSuite("Interface.parseLog");
-  it("parses an encoded event log and returns LogDescription-like result", async () => {
-    logTest("parses an encoded event log and returns LogDescription-like result", {});
-    await Initialize(null);
-
-    const abi = [
-      {
-        name: "Transfer",
-        type: "event",
-        anonymous: false,
-        inputs: [
-          { name: "from", type: "address", indexed: true },
-          { name: "to", type: "address", indexed: true },
-          { name: "value", type: "uint256", indexed: false },
-        ],
-      },
-    ];
-
-    const iface = new qc.Interface(abi);
-    const from = qc.Wallet.createRandom().address;
-    const to = qc.Wallet.createRandom().address;
-    const value = 123n;
-
-    const encoded = iface.encodeEventLog("Transfer", [from, to, value]);
-    assert.ok(Array.isArray(encoded.topics) && encoded.topics.length >= 1);
-    assert.ok(typeof encoded.data === "string");
-
-    const parsed = iface.parseLog({ topics: encoded.topics, data: encoded.data });
-    assert.equal(parsed.name, "Transfer");
-    assert.ok(parsed.topic && parsed.topic.startsWith("0x"));
-    assert.ok(parsed.signature.includes("Transfer("));
-
-    assert.equal(parsed.args.from.toLowerCase(), from.toLowerCase());
-    assert.equal(parsed.args.to.toLowerCase(), to.toLowerCase());
-    assert.equal(BigInt(parsed.args.value), value);
-    assert.equal(parsed.args[0].toLowerCase(), from.toLowerCase());
-    assert.equal(parsed.args[1].toLowerCase(), to.toLowerCase());
-    assert.equal(BigInt(parsed.args[2]), value);
-  });
-});

package/example/node_modules/quantumcoin/test/unit/internal-hex.test.js

@@ -1,81 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Internal hex utilities (optional params, edge cases)
- */
- 
- const { describe, it } = require("node:test");
- const assert = require("node:assert/strict");
- 
- const { normalizeHex, toQuantityHex, toQuantity, isHexString, hexToBytes, bytesToHex, arrayify } = require("../../src/internal/hex");
- const { logSuite, logTest } = require("../verbose-logger");
- 
- describe("internal/hex", () => {
-   logSuite("internal/hex");
-   it("normalizeHex lowercases, adds 0x, pads odd length", () => {
-     logTest("normalizeHex lowercases, adds 0x, pads odd length", {});
-     assert.equal(normalizeHex("aa"), "0xaa");
-    assert.equal(normalizeHex("0xAa"), "0xaa");
-    assert.equal(normalizeHex("0xa"), "0x0a");
-     assert.equal(normalizeHex("0x0A"), "0x0a");
-   });
-
-  it("toQuantityHex produces spec-compliant quantities (no leading zeros, 0x0 for zero)", () => {
-    logTest("toQuantityHex produces spec-compliant quantities", {});
-    assert.equal(toQuantityHex(0), "0x0");
-    assert.equal(toQuantityHex(0n), "0x0");
-    assert.equal(toQuantityHex(1), "0x1");
-    assert.equal(toQuantityHex(5), "0x5");
-    assert.equal(toQuantityHex(15), "0xf");
-    assert.equal(toQuantityHex(16), "0x10");
-    assert.equal(toQuantityHex(255), "0xff");
-    assert.equal(toQuantityHex(256), "0x100");
-    assert.equal(toQuantityHex(4095), "0xfff");
-    assert.equal(toQuantityHex(4096), "0x1000");
-    assert.equal(toQuantityHex(65535n), "0xffff");
-    assert.equal(toQuantityHex(2n ** 64n), "0x10000000000000000");
-
-    assert.equal(toQuantity, toQuantityHex);
-    assert.equal(toQuantity(5), "0x5");
-  });
-
-  it("toQuantityHex rejects invalid inputs", () => {
-    logTest("toQuantityHex rejects invalid inputs", {});
-    assert.throws(() => toQuantityHex(-1), RangeError);
-    assert.throws(() => toQuantityHex(-1n), RangeError);
-    assert.throws(() => toQuantityHex(1.5), TypeError);
-    assert.throws(() => toQuantityHex(NaN), TypeError);
-    assert.throws(() => toQuantityHex(Infinity), TypeError);
-    assert.throws(() => toQuantityHex("5"), TypeError);
-    assert.throws(() => toQuantityHex(null), TypeError);
-    assert.throws(() => toQuantityHex(undefined), TypeError);
-  });
- 
-   it("isHexString validates and supports optional lengthBytes", () => {
-     const h32 = "0x" + "11".repeat(32);
-     assert.equal(isHexString(h32), true);
-     assert.equal(isHexString(h32, 32), true);
-     assert.equal(isHexString(h32, null), true); // optional param passed as null => ignored
-     assert.equal(isHexString(h32, 31), false);
- 
-     assert.equal(isHexString("0x"), false);
-     assert.equal(isHexString("0x0"), false); // odd length after 0x
-     assert.equal(isHexString("0xzz"), false);
-   });
- 
-   it("hexToBytes/bytesToHex roundtrip", () => {
-     const h = "0x1234abcd";
-     const b = hexToBytes(h);
-     assert.ok(b instanceof Uint8Array);
-     assert.equal(bytesToHex(b), h);
-   });
- 
-   it("arrayify accepts hex string and Uint8Array; rejects others", () => {
-     assert.deepEqual(arrayify("0x1234"), new Uint8Array([0x12, 0x34]));
-     assert.deepEqual(arrayify(new Uint8Array([1, 2, 3])), new Uint8Array([1, 2, 3]));
-     assert.throws(() => arrayify("not-hex"));
-     assert.throws(() => arrayify(123));
-   });
- });
- 

package/example/node_modules/quantumcoin/test/unit/internal-hex.test.ts

@@ -1,80 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Internal hex utilities (optional params, edge cases)
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-import { normalizeHex, toQuantityHex, toQuantity, isHexString, hexToBytes, bytesToHex, arrayify } from "../../src/internal/hex";
-import { logSuite, logTest } from "../verbose-logger";
-
-describe("internal/hex", () => {
-  logSuite("internal/hex");
-  it("normalizeHex lowercases, adds 0x, pads odd length", () => {
-    logTest("normalizeHex lowercases, adds 0x, pads odd length", {});
-    assert.equal(normalizeHex("aa"), "0xaa");
-    assert.equal(normalizeHex("0xAa"), "0xaa");
-    assert.equal(normalizeHex("0xa"), "0x0a");
-    assert.equal(normalizeHex("0x0A"), "0x0a");
-  });
-
-  it("toQuantityHex produces spec-compliant quantities (no leading zeros, 0x0 for zero)", () => {
-    logTest("toQuantityHex produces spec-compliant quantities", {});
-    assert.equal(toQuantityHex(0), "0x0");
-    assert.equal(toQuantityHex(0n), "0x0");
-    assert.equal(toQuantityHex(1), "0x1");
-    assert.equal(toQuantityHex(5), "0x5");
-    assert.equal(toQuantityHex(15), "0xf");
-    assert.equal(toQuantityHex(16), "0x10");
-    assert.equal(toQuantityHex(255), "0xff");
-    assert.equal(toQuantityHex(256), "0x100");
-    assert.equal(toQuantityHex(4095), "0xfff");
-    assert.equal(toQuantityHex(4096), "0x1000");
-    assert.equal(toQuantityHex(65535n), "0xffff");
-    assert.equal(toQuantityHex(2n ** 64n), "0x10000000000000000");
-
-    assert.equal(toQuantity, toQuantityHex);
-    assert.equal(toQuantity(5), "0x5");
-  });
-
-  it("toQuantityHex rejects invalid inputs", () => {
-    logTest("toQuantityHex rejects invalid inputs", {});
-    assert.throws(() => toQuantityHex(-1), RangeError);
-    assert.throws(() => toQuantityHex(-1n), RangeError);
-    assert.throws(() => toQuantityHex(1.5), TypeError);
-    assert.throws(() => toQuantityHex(NaN), TypeError);
-    assert.throws(() => toQuantityHex(Infinity), TypeError);
-    assert.throws(() => toQuantityHex("5" as unknown as number), TypeError);
-    assert.throws(() => toQuantityHex(null as unknown as number), TypeError);
-    assert.throws(() => toQuantityHex(undefined as unknown as number), TypeError);
-  });
-
-  it("isHexString validates and supports optional lengthBytes", () => {
-    const h32 = "0x" + "11".repeat(32);
-    assert.equal(isHexString(h32), true);
-    assert.equal(isHexString(h32, 32), true);
-    assert.equal(isHexString(h32, null), true); // optional param passed as null => ignored
-    assert.equal(isHexString(h32, 31), false);
-
-    assert.equal(isHexString("0x"), false);
-    assert.equal(isHexString("0x0"), false); // odd length after 0x
-    assert.equal(isHexString("0xzz"), false);
-  });
-
-  it("hexToBytes/bytesToHex roundtrip", () => {
-    const h = "0x1234abcd";
-    const b = hexToBytes(h);
-    assert.ok(b instanceof Uint8Array);
-    assert.equal(bytesToHex(b), h);
-  });
-
-  it("arrayify accepts hex string and Uint8Array; rejects others", () => {
-    assert.deepEqual(arrayify("0x1234"), new Uint8Array([0x12, 0x34]));
-    assert.deepEqual(arrayify(new Uint8Array([1, 2, 3])), new Uint8Array([1, 2, 3]));
-    assert.throws(() => arrayify("not-hex"));
-    assert.throws(() => arrayify(123 as unknown));
-  });
-});