quantumcoin 6.14.4 → 7.0.1

package/test/unit/interface.test.js

@@ -0,0 +1,53 @@
+/**
+ * @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");
+
+describe("Interface.parseLog", () => {
+  it("parses an encoded event log and returns LogDescription-like result", async () => {
+    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/test/unit/internal-hex.test.js

@@ -0,0 +1,47 @@
+/**
+ * @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, isHexString, hexToBytes, bytesToHex, arrayify } = require("../../src/internal/hex");
+ 
+ describe("internal/hex", () => {
+   it("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("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/test/unit/providers.test.js

@@ -0,0 +1,144 @@
+/**
+ * @testCategory unit
+ * @blockchainRequired false
+ * @transactional false
+ * @description Provider helpers, wrappers, defaults, and extra providers
+ */
+ 
+ const { describe, it } = require("node:test");
+ const assert = require("node:assert/strict");
+ 
+ const qc = require("../../index");
+ 
+ describe("JsonRpcProvider", () => {
+   it("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) => {
+     if (typeof fetch !== "function") {
+       t.skip("global fetch not available");
+       return;
+     }
+ 
+     const originalFetch = fetch;
+     /** @type {any[]} */
+     const seen = [];
+ 
+     global.fetch = async (_url, init) => {
+       const body = JSON.parse(init.body);
+       seen.push(body.params);
+       return {
+         ok: true,
+         json: async () => ({ jsonrpc: "2.0", id: body.id, result: "0x1" }),
+       };
+     };
+ 
+     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 {
+       global.fetch = originalFetch;
+     }
+   });
+ });
+ 
+ describe("AbstractProvider defaults", () => {
+   it("getTransactionCount/call/getCode default blockTag when omitted vs null", async () => {
+     class P extends qc.AbstractProvider {
+       constructor() {
+         super();
+         this.calls = [];
+       }
+       async _perform(method, params) {
+         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]);
+     // All these methods use `blockTag || "latest"`, so omitted/null => "latest"
+     assert.deepEqual(tags, ["latest", "latest", "latest", "latest", "latest", "latest"]);
+   });
+ });
+ 
+ describe("TransactionResponse.wait", () => {
+   it("uses default confirmations when omitted vs null", async () => {
+     const fakeProvider = {
+       getTransactionReceipt: async () => ({ blockNumber: 1 }),
+       getBlockNumber: async () => 1,
+     };
+     const tx = new qc.TransactionResponse({ hash: "0x" + "11".repeat(32) }, fakeProvider);
+     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 () => {
+     const tx = new qc.TransactionResponse({ hash: "0x" + "11".repeat(32) }, null);
+     await assert.rejects(() => tx.wait(), (e) => e && e.code === "UNKNOWN_ERROR" && /missing provider/i.test(e.message));
+   });
+ });
+ 
+ describe("Extra providers", () => {
+  it("BrowserProvider requires an EIP-1193 provider with request()", () => {
+     assert.throws(() => new qc.BrowserProvider(null), (e) => e && e.code === "INVALID_ARGUMENT");
+     assert.throws(() => new qc.BrowserProvider({}), (e) => e && e.code === "INVALID_ARGUMENT");
+     const p = new qc.BrowserProvider({ request: async () => null });
+     assert.ok(p);
+   });
+ 
+ it("WebSocketProvider requires a url and stores it", () => {
+   assert.throws(() => new qc.WebSocketProvider(), (e) => 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", () => {
+    assert.throws(() => new qc.IpcSocketProvider(), (e) => 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 () => {
+     const p1 = { _perform: async () => "0x10" };
+     const fp1 = new qc.FallbackProvider(p1);
+     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]);
+     const bn2 = await fp2.getBlockNumber();
+     assert.equal(bn2, 2);
+   });
+ 
+   it("FallbackProvider throws when no providers provided", () => {
+     assert.throws(() => new qc.FallbackProvider([]));
+   });
+ });
+ 

package/test/unit/result.test.js

@@ -0,0 +1,77 @@
+/**
+ * @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");
+ 
+ describe("Result", () => {
+   it("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/utils.test.js

@@ -0,0 +1,54 @@
+/**
+ * @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");
+
+describe("Utils", () => {
+  it("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 (ethers-style 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");
+  });
+});
+