quantumcoin 7.0.3 → 7.0.4

package/test/unit/contract.test.js

@@ -1,82 +1,85 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Contract behavior that can be tested offline (overrides, listeners)
- */
- 
- const { describe, it } = require("node:test");
- const assert = require("node:assert/strict");
- 
- const { Initialize } = require("../../config");
- const qc = require("../../index");
- 
- describe("Contract", () => {
-   it("_invoke treats last arg as overrides only when object-like (null is NOT overrides)", async () => {
-     await Initialize(null);
-     const addr = qc.Wallet.createRandom().address;
-     const abi = [
-       { type: "function", name: "viewFn", stateMutability: "view", inputs: [{ name: "x", type: "uint256" }], outputs: [] },
-       { type: "function", name: "writeFn", stateMutability: "nonpayable", inputs: [{ name: "x", type: "uint256" }], outputs: [] },
-     ];
- 
-     const c = new qc.Contract(addr, abi, null);
- 
-     /** @type {any[]} */
-     const seen = [];
-     c.call = async (methodName, args, overrides) => {
-       seen.push({ kind: "call", methodName, args, overrides });
-       return "ok";
-     };
-     c.send = async (methodName, args, overrides) => {
-       seen.push({ kind: "send", methodName, args, overrides });
-       return { hash: "0x" + "22".repeat(32) };
-     };
- 
-     // Overrides object extracted
-     await c._invoke("viewFn", [1n, { gasLimit: 123 }]);
-     // Passing null is NOT treated as overrides (it becomes a second argument)
-     await c._invoke("viewFn", [1n, null]);
-     // State-changing path chooses send()
-     await c._invoke("writeFn", [1n, { gasLimit: 456 }]);
- 
-     assert.deepEqual(seen[0], { kind: "call", methodName: "viewFn", args: [1n], overrides: { gasLimit: 123 } });
-     assert.deepEqual(seen[1], { kind: "call", methodName: "viewFn", args: [1n, null], overrides: undefined });
-     assert.deepEqual(seen[2], { kind: "send", methodName: "writeFn", args: [1n], overrides: { gasLimit: 456 } });
-   });
- 
-   it("removeAllListeners clears all when event omitted vs null, and clears one event when provided", async () => {
-     await Initialize(null);
-     const addr = qc.Wallet.createRandom().address;
-     const c = new qc.Contract(addr, [], null);
- 
-     const cb1 = () => {};
-     const cb2 = () => {};
-     c.on("A", cb1);
-     c.on("B", cb2);
- 
-     c.removeAllListeners("A");
-     // B remains
-     assert.equal(c._listeners.get("A")?.length || 0, 0);
-     assert.equal(c._listeners.get("B")?.length || 0, 1);
- 
-     c.removeAllListeners(null); // treated as "no event"
-     assert.equal(c._listeners.size, 0);
- 
-     c.on("C", cb1);
-     c.removeAllListeners(); // omitted => clear all
-     assert.equal(c._listeners.size, 0);
-   });
- });
- 
- describe("ContractTransactionReceipt", () => {
-   it("getEvent/getEvents filter logs by eventName", () => {
-     const receipt = new qc.ContractTransactionReceipt({
-       logs: [{ eventName: "A", data: 1 }, { eventName: "B", data: 2 }, { eventName: "A", data: 3 }],
-     });
-     assert.deepEqual(receipt.getEvents("A").map((l) => l.data), [1, 3]);
-     assert.equal(receipt.getEvent("B").data, 2);
-     assert.equal(receipt.getEvent("Missing"), null);
-   });
- });
- 
+/**
+ * @testCategory unit
+ * @blockchainRequired false
+ * @transactional false
+ * @description Contract behavior that can be tested offline (overrides, listeners)
+ */
+ 
+ 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("Contract", () => {
+   logSuite("Contract");
+   it("_invoke treats last arg as overrides only when object-like (null is NOT overrides)", async () => {
+     logTest("_invoke treats last arg as overrides only when object-like (null is NOT overrides)", {});
+     await Initialize(null);
+     const addr = qc.Wallet.createRandom().address;
+     const abi = [
+       { type: "function", name: "viewFn", stateMutability: "view", inputs: [{ name: "x", type: "uint256" }], outputs: [] },
+       { type: "function", name: "writeFn", stateMutability: "nonpayable", inputs: [{ name: "x", type: "uint256" }], outputs: [] },
+     ];
+ 
+     const c = new qc.Contract(addr, abi, null);
+ 
+     /** @type {any[]} */
+     const seen = [];
+     c.call = async (methodName, args, overrides) => {
+       seen.push({ kind: "call", methodName, args, overrides });
+       return "ok";
+     };
+     c.send = async (methodName, args, overrides) => {
+       seen.push({ kind: "send", methodName, args, overrides });
+       return { hash: "0x" + "22".repeat(32) };
+     };
+ 
+     // Overrides object extracted
+     await c._invoke("viewFn", [1n, { gasLimit: 123 }]);
+     // Passing null is NOT treated as overrides (it becomes a second argument)
+     await c._invoke("viewFn", [1n, null]);
+     // State-changing path chooses send()
+     await c._invoke("writeFn", [1n, { gasLimit: 456 }]);
+ 
+     assert.deepEqual(seen[0], { kind: "call", methodName: "viewFn", args: [1n], overrides: { gasLimit: 123 } });
+     assert.deepEqual(seen[1], { kind: "call", methodName: "viewFn", args: [1n, null], overrides: undefined });
+     assert.deepEqual(seen[2], { kind: "send", methodName: "writeFn", args: [1n], overrides: { gasLimit: 456 } });
+   });
+ 
+   it("removeAllListeners clears all when event omitted vs null, and clears one event when provided", async () => {
+     await Initialize(null);
+     const addr = qc.Wallet.createRandom().address;
+     const c = new qc.Contract(addr, [], null);
+ 
+     const cb1 = () => {};
+     const cb2 = () => {};
+     c.on("A", cb1);
+     c.on("B", cb2);
+ 
+     c.removeAllListeners("A");
+     // B remains
+     assert.equal(c._listeners.get("A")?.length || 0, 0);
+     assert.equal(c._listeners.get("B")?.length || 0, 1);
+ 
+     c.removeAllListeners(null); // treated as "no event"
+     assert.equal(c._listeners.size, 0);
+ 
+     c.on("C", cb1);
+     c.removeAllListeners(); // omitted => clear all
+     assert.equal(c._listeners.size, 0);
+   });
+ });
+ 
+ describe("ContractTransactionReceipt", () => {
+   it("getEvent/getEvents filter logs by eventName", () => {
+     const receipt = new qc.ContractTransactionReceipt({
+       logs: [{ eventName: "A", data: 1 }, { eventName: "B", data: 2 }, { eventName: "A", data: 3 }],
+     });
+     assert.deepEqual(receipt.getEvents("A").map((l) => l.data), [1, 3]);
+     assert.equal(receipt.getEvent("B").data, 2);
+     assert.equal(receipt.getEvent("Missing"), null);
+   });
+ });
+ 

package/test/unit/contract.test.ts

@@ -0,0 +1,83 @@
+/**
+ * @testCategory unit
+ * @blockchainRequired false
+ * @transactional false
+ * @description Contract behavior that can be tested offline (overrides, listeners)
+ */
+
+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("Contract", () => {
+  logSuite("Contract");
+  it("_invoke treats last arg as overrides only when object-like (null is NOT overrides)", async () => {
+    logTest("_invoke treats last arg as overrides only when object-like (null is NOT overrides)", {});
+    await Initialize(null);
+    const addr = qc.Wallet.createRandom().address;
+    const abi = [
+      { type: "function", name: "viewFn", stateMutability: "view", inputs: [{ name: "x", type: "uint256" }], outputs: [] },
+      { type: "function", name: "writeFn", stateMutability: "nonpayable", inputs: [{ name: "x", type: "uint256" }], outputs: [] },
+    ];
+
+    const c = new qc.Contract(addr, abi, null);
+
+    const seen: { kind: string; methodName: string; args: unknown[]; overrides?: unknown }[] = [];
+    c.call = async (methodName: string, args: unknown[], overrides?: unknown) => {
+      seen.push({ kind: "call", methodName, args, overrides });
+      return "ok";
+    };
+    c.send = async (methodName: string, args: unknown[], overrides?: unknown) => {
+      seen.push({ kind: "send", methodName, args, overrides });
+      return { hash: "0x" + "22".repeat(32) };
+    };
+
+    await c._invoke("viewFn", [1n, { gasLimit: 123 }]);
+    await c._invoke("viewFn", [1n, null]);
+    await c._invoke("writeFn", [1n, { gasLimit: 456 }]);
+
+    assert.deepEqual(seen[0], { kind: "call", methodName: "viewFn", args: [1n], overrides: { gasLimit: 123 } });
+    assert.deepEqual(seen[1], { kind: "call", methodName: "viewFn", args: [1n, null], overrides: undefined });
+    assert.deepEqual(seen[2], { kind: "send", methodName: "writeFn", args: [1n], overrides: { gasLimit: 456 } });
+  });
+
+  it("removeAllListeners clears all when event omitted vs null, and clears one event when provided", async () => {
+    await Initialize(null);
+    const addr = qc.Wallet.createRandom().address;
+    const c = new qc.Contract(addr, [], null);
+
+    const cb1 = () => {};
+    const cb2 = () => {};
+    c.on("A", cb1);
+    c.on("B", cb2);
+
+    c.removeAllListeners("A");
+    assert.equal(c._listeners.get("A")?.length || 0, 0);
+    assert.equal(c._listeners.get("B")?.length || 0, 1);
+
+    c.removeAllListeners(null);
+    assert.equal(c._listeners.size, 0);
+
+    c.on("C", cb1);
+    c.removeAllListeners();
+    assert.equal(c._listeners.size, 0);
+  });
+});
+
+describe("ContractTransactionReceipt", () => {
+  it("getEvent/getEvents filter logs by eventName", () => {
+    const receipt = new qc.ContractTransactionReceipt({
+      logs: [
+        { eventName: "A", data: 1 },
+        { eventName: "B", data: 2 },
+        { eventName: "A", data: 3 },
+      ],
+    });
+    assert.deepEqual(receipt.getEvents("A").map((l) => l.data), [1, 3]);
+    assert.equal(receipt.getEvent("B").data, 2);
+    assert.equal(receipt.getEvent("Missing"), null);
+  });
+});

package/test/unit/encoding-units-rlp.test.js

@@ -1,89 +1,92 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Encoding + units + RLP edge cases (optional params, negative paths)
- */
- 
- const { describe, it } = require("node:test");
- const assert = require("node:assert/strict");
- 
- const qc = require("../../index");
- 
- describe("Encoding", () => {
-   it("toHex/hexlify normalize strings and bytes", () => {
-     assert.equal(qc.toHex("0x0A"), "0x0a");
-     assert.equal(qc.hexlify(new Uint8Array([0x0a])), "0x0a");
-   });
- 
-   it("concat concatenates and rejects non-array", () => {
-     const out = qc.concat([new Uint8Array([1, 2]), "0x03"]);
-     assert.equal(out, "0x010203");
-     assert.throws(() => qc.concat("nope"));
-   });
- 
-   it("stripZerosLeft removes leading zeros", () => {
-     assert.equal(qc.stripZerosLeft("0x0000"), "0x");
-     assert.equal(qc.stripZerosLeft("0x000001"), "0x01");
-   });
- 
-   it("zeroPad throws when value exceeds length", () => {
-     assert.throws(() => qc.zeroPad("0x1234", 1));
-     assert.equal(qc.zeroPad("0x12", 2), "0x0012");
-   });
- 
-   it("base64 encode/decode roundtrip", () => {
-     const b = qc.toUtf8Bytes("hello");
-     const b64 = qc.encodeBase64(b);
-     const out = qc.decodeBase64(b64);
-     assert.equal(qc.toUtf8String(out), "hello");
-   });
- 
-   it("isBytesLike returns true for hex and Uint8Array", () => {
-     assert.equal(qc.isBytesLike("0x1234"), true);
-     assert.equal(qc.isBytesLike(new Uint8Array([1, 2, 3])), true);
-     assert.equal(qc.isBytesLike("not-hex"), false);
-   });
- 
-   it("solidityPacked helpers throw (not implemented)", () => {
-     assert.throws(() => qc.solidityPacked(), /not implemented/i);
-     assert.throws(() => qc.solidityPackedKeccak256(), /not implemented/i);
-     assert.throws(() => qc.solidityPackedSha256(), /not implemented/i);
-   });
- });
- 
- describe("Units", () => {
-   it("parseUnits defaults decimals when omitted vs null", () => {
-     const a = qc.parseUnits("1.5");
-     const b = qc.parseUnits("1.5", null);
-     assert.equal(a, 1500000000000000000n);
-     assert.equal(a, b);
-   });
- 
-   it("formatUnits defaults decimals when omitted vs null", () => {
-     const a = qc.formatUnits(1500000000000000000n);
-     const b = qc.formatUnits(1500000000000000000n, null);
-     assert.equal(a, "1.5");
-     assert.equal(a, b);
-   });
- });
- 
- describe("RLP", () => {
-   it("decodeRlp rejects non-string input", () => {
-     assert.throws(() => qc.decodeRlp(123));
-   });
- 
-   it("decodeRlp rejects trailing data", () => {
-     const encoded = qc.encodeRlp("0x01");
-     const withTrailing = "0x" + encoded.slice(2) + "00";
-     assert.throws(() => qc.decodeRlp(withTrailing), /trailing data/i);
-   });
- 
-   it("encodeRlp supports null as empty bytes", () => {
-     const encoded = qc.encodeRlp(null);
-     assert.ok(typeof encoded === "string" && encoded.startsWith("0x"));
-     const decoded = qc.decodeRlp(encoded);
-     assert.equal(decoded, "0x");
-   });
- });
- 
+/**
+ * @testCategory unit
+ * @blockchainRequired false
+ * @transactional false
+ * @description Encoding + units + RLP edge cases (optional params, negative paths)
+ */
+ 
+ const { describe, it } = require("node:test");
+ const assert = require("node:assert/strict");
+ 
+ const qc = require("../../index");
+ const { logSuite, logTest } = require("../verbose-logger");
+ 
+ describe("Encoding", () => {
+   logSuite("Encoding");
+   it("toHex/hexlify normalize strings and bytes", () => {
+     logTest("toHex/hexlify normalize strings and bytes", {});
+     assert.equal(qc.toHex("0x0A"), "0x0a");
+     assert.equal(qc.hexlify(new Uint8Array([0x0a])), "0x0a");
+   });
+ 
+   it("concat concatenates and rejects non-array", () => {
+     const out = qc.concat([new Uint8Array([1, 2]), "0x03"]);
+     assert.equal(out, "0x010203");
+     assert.throws(() => qc.concat("nope"));
+   });
+ 
+   it("stripZerosLeft removes leading zeros", () => {
+     assert.equal(qc.stripZerosLeft("0x0000"), "0x");
+     assert.equal(qc.stripZerosLeft("0x000001"), "0x01");
+   });
+ 
+   it("zeroPad throws when value exceeds length", () => {
+     assert.throws(() => qc.zeroPad("0x1234", 1));
+     assert.equal(qc.zeroPad("0x12", 2), "0x0012");
+   });
+ 
+   it("base64 encode/decode roundtrip", () => {
+     const b = qc.toUtf8Bytes("hello");
+     const b64 = qc.encodeBase64(b);
+     const out = qc.decodeBase64(b64);
+     assert.equal(qc.toUtf8String(out), "hello");
+   });
+ 
+   it("isBytesLike returns true for hex and Uint8Array", () => {
+     assert.equal(qc.isBytesLike("0x1234"), true);
+     assert.equal(qc.isBytesLike(new Uint8Array([1, 2, 3])), true);
+     assert.equal(qc.isBytesLike("not-hex"), false);
+   });
+ 
+   it("solidityPacked helpers throw (not implemented)", () => {
+     assert.throws(() => qc.solidityPacked(), /not implemented/i);
+     assert.throws(() => qc.solidityPackedKeccak256(), /not implemented/i);
+     assert.throws(() => qc.solidityPackedSha256(), /not implemented/i);
+   });
+ });
+ 
+ describe("Units", () => {
+   it("parseUnits defaults decimals when omitted vs null", () => {
+     const a = qc.parseUnits("1.5");
+     const b = qc.parseUnits("1.5", null);
+     assert.equal(a, 1500000000000000000n);
+     assert.equal(a, b);
+   });
+ 
+   it("formatUnits defaults decimals when omitted vs null", () => {
+     const a = qc.formatUnits(1500000000000000000n);
+     const b = qc.formatUnits(1500000000000000000n, null);
+     assert.equal(a, "1.5");
+     assert.equal(a, b);
+   });
+ });
+ 
+ describe("RLP", () => {
+   it("decodeRlp rejects non-string input", () => {
+     assert.throws(() => qc.decodeRlp(123));
+   });
+ 
+   it("decodeRlp rejects trailing data", () => {
+     const encoded = qc.encodeRlp("0x01");
+     const withTrailing = "0x" + encoded.slice(2) + "00";
+     assert.throws(() => qc.decodeRlp(withTrailing), /trailing data/i);
+   });
+ 
+   it("encodeRlp supports null as empty bytes", () => {
+     const encoded = qc.encodeRlp(null);
+     assert.ok(typeof encoded === "string" && encoded.startsWith("0x"));
+     const decoded = qc.decodeRlp(encoded);
+     assert.equal(decoded, "0x");
+   });
+ });
+ 

package/test/unit/encoding-units-rlp.test.ts

@@ -0,0 +1,91 @@
+/**
+ * @testCategory unit
+ * @blockchainRequired false
+ * @transactional false
+ * @description Encoding + units + RLP edge cases (optional params, negative paths)
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import qc from "../../index";
+import { logSuite, logTest } from "../verbose-logger";
+
+describe("Encoding", () => {
+  logSuite("Encoding");
+  it("toHex/hexlify normalize strings and bytes", () => {
+    logTest("toHex/hexlify normalize strings and bytes", {});
+    assert.equal(qc.toHex("0x0A"), "0x0a");
+    assert.equal(qc.hexlify(new Uint8Array([0x0a])), "0x0a");
+  });
+
+  it("concat concatenates and rejects non-array", () => {
+    const out = qc.concat([new Uint8Array([1, 2]), "0x03"]);
+    assert.equal(out, "0x010203");
+    assert.throws(() => qc.concat("nope" as unknown as (string | Uint8Array)[]));
+  });
+
+  it("stripZerosLeft removes leading zeros", () => {
+    assert.equal(qc.stripZerosLeft("0x0000"), "0x");
+    assert.equal(qc.stripZerosLeft("0x000001"), "0x01");
+  });
+
+  it("zeroPad throws when value exceeds length", () => {
+    assert.throws(() => qc.zeroPad("0x1234", 1));
+    assert.equal(qc.zeroPad("0x12", 2), "0x0012");
+  });
+
+  it("base64 encode/decode roundtrip", () => {
+    const b = qc.toUtf8Bytes("hello");
+    const b64 = qc.encodeBase64(b);
+    const out = qc.decodeBase64(b64);
+    assert.equal(qc.toUtf8String(out), "hello");
+  });
+
+  it("isBytesLike returns true for hex and Uint8Array", () => {
+    assert.equal(qc.isBytesLike("0x1234"), true);
+    assert.equal(qc.isBytesLike(new Uint8Array([1, 2, 3])), true);
+    assert.equal(qc.isBytesLike("not-hex"), false);
+  });
+
+  it("solidityPacked helpers throw (not implemented)", () => {
+    assert.throws(() => qc.solidityPacked(), /not implemented/i);
+    assert.throws(() => qc.solidityPackedKeccak256(), /not implemented/i);
+    assert.throws(() => qc.solidityPackedSha256(), /not implemented/i);
+  });
+});
+
+describe("Units", () => {
+  it("parseUnits defaults decimals when omitted vs null", () => {
+    const a = qc.parseUnits("1.5");
+    const b = qc.parseUnits("1.5", null);
+    assert.equal(a, 1500000000000000000n);
+    assert.equal(a, b);
+  });
+
+  it("formatUnits defaults decimals when omitted vs null", () => {
+    const a = qc.formatUnits(1500000000000000000n);
+    const b = qc.formatUnits(1500000000000000000n, null);
+    assert.equal(a, "1.5");
+    assert.equal(a, b);
+  });
+});
+
+describe("RLP", () => {
+  it("decodeRlp rejects non-string input", () => {
+    assert.throws(() => qc.decodeRlp(123 as unknown as string));
+  });
+
+  it("decodeRlp rejects trailing data", () => {
+    const encoded = qc.encodeRlp("0x01");
+    const withTrailing = "0x" + encoded.slice(2) + "00";
+    assert.throws(() => qc.decodeRlp(withTrailing), /trailing data/i);
+  });
+
+  it("encodeRlp supports null as empty bytes", () => {
+    const encoded = qc.encodeRlp(null);
+    assert.ok(typeof encoded === "string" && encoded.startsWith("0x"));
+    const decoded = qc.decodeRlp(encoded);
+    assert.equal(decoded, "0x");
+  });
+});