quantum-coin-js-sdk 1.0.36 → 1.0.39

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

@@ -0,0 +1,148 @@
+/**
+ * @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

@@ -0,0 +1,64 @@
+/**
+ * @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

@@ -0,0 +1,63 @@
+/**
+ * @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

@@ -0,0 +1,39 @@
+/**
+ * @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

@@ -0,0 +1,38 @@
+/**
+ * @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

@@ -0,0 +1,56 @@
+/**
+ * @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

@@ -0,0 +1,54 @@
+/**
+ * @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

@@ -0,0 +1,81 @@
+/**
+ * @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

@@ -0,0 +1,80 @@
+/**
+ * @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));
+  });
+});