quantumcoin 7.0.15 → 8.0.1

package/test/unit/browser-provider.test.js

@@ -1,85 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description BrowserProvider (EIP-1193 wrapper) + debug event sink validation
- */
-
-const { describe, it } = require("node:test");
-const assert = require("node:assert/strict");
-
-const qc = require("../../index");
-const { logSuite, logTest } = require("../verbose-logger");
-
-describe("BrowserProvider", () => {
-  logSuite("BrowserProvider");
-  it("wraps an EIP-1193 provider and emits debug events", async () => {
-    logTest("wraps an EIP-1193 provider and emits debug events", {});
-    /** @type {any[]} */
-    const calls = [];
-
-    const fakeEip1193 = {
-      request: async ({ method, params }) => {
-        calls.push({ method, params });
-        if (method === "eth_accounts") {
-          return ["0x" + "11".repeat(32)];
-        }
-        if (method === "eth_blockNumber") {
-          return "0x10";
-        }
-        if (method === "eth_getBlockByNumber") {
-          // params: [ "latest", false ]
-          return {
-            number: "0x10",
-            hash: "0x" + "aa".repeat(32),
-            parentHash: "0x" + "bb".repeat(32),
-            timestamp: "0x1",
-            transactions: [],
-          };
-        }
-        throw new Error(`unsupported method: ${method}`);
-      },
-    };
-
-    const provider = new qc.BrowserProvider(fakeEip1193);
-
-    /** @type {any[]} */
-    const debug = [];
-    provider.on("debug", (ev) => debug.push(ev));
-
-    const bn = await provider.getBlockNumber();
-    assert.equal(bn, 16);
-
-    const latest = await provider.getBlock("latest");
-    assert.equal(latest.number, 16);
-    assert.ok(typeof latest.hash === "string");
-
-    const signer = await provider.getSigner();
-    const addr = await signer.getAddress();
-    assert.equal(addr.toLowerCase(), ("0x" + "11".repeat(32)).toLowerCase());
-    assert.equal(await provider.hasSigner(addr), true);
-
-    // Validate calls shape
-    assert.deepEqual(
-      calls.map((c) => c.method),
-      ["eth_blockNumber", "eth_getBlockByNumber", "eth_accounts", "eth_accounts"],
-    );
-
-    // Validate debug event sink: send+receive per request in order
-    const actions = debug.map((d) => d && d.action);
-    assert.deepEqual(actions, [
-      "sendEip1193Payload",
-      "receiveEip1193Result",
-      "sendEip1193Payload",
-      "receiveEip1193Result",
-      "sendEip1193Payload",
-      "receiveEip1193Result",
-      "sendEip1193Payload",
-      "receiveEip1193Result",
-    ]);
-
-    assert.equal(debug[0].payload.method, "eth_blockNumber");
-    assert.equal(debug[2].payload.method, "eth_getBlockByNumber");
-  });
-});
-

package/test/unit/browser-provider.test.ts

@@ -1,79 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description BrowserProvider (EIP-1193 wrapper) + debug event sink validation
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-import qc from "../../index";
-import { logSuite, logTest } from "../verbose-logger";
-
-describe("BrowserProvider", () => {
-  logSuite("BrowserProvider");
-  it("wraps an EIP-1193 provider and emits debug events", async () => {
-    logTest("wraps an EIP-1193 provider and emits debug events", {});
-    const calls: { method: string; params?: unknown }[] = [];
-
-    const fakeEip1193 = {
-      request: async ({ method, params }: { method: string; params?: unknown }) => {
-        calls.push({ method, params });
-        if (method === "eth_accounts") {
-          return ["0x" + "11".repeat(32)];
-        }
-        if (method === "eth_blockNumber") {
-          return "0x10";
-        }
-        if (method === "eth_getBlockByNumber") {
-          return {
-            number: "0x10",
-            hash: "0x" + "aa".repeat(32),
-            parentHash: "0x" + "bb".repeat(32),
-            timestamp: "0x1",
-            transactions: [],
-          };
-        }
-        throw new Error(`unsupported method: ${method}`);
-      },
-    };
-
-    const provider = new qc.BrowserProvider(fakeEip1193);
-
-    const debug: { action?: string; payload?: { method: string } }[] = [];
-    provider.on("debug", (ev) => debug.push(ev));
-
-    const bn = await provider.getBlockNumber();
-    assert.equal(bn, 16);
-
-    const latest = await provider.getBlock("latest");
-    assert.equal(latest.number, 16);
-    assert.ok(typeof latest.hash === "string");
-
-    const signer = await provider.getSigner();
-    const addr = await signer.getAddress();
-    assert.equal(addr.toLowerCase(), ("0x" + "11".repeat(32)).toLowerCase());
-    assert.equal(await provider.hasSigner(addr), true);
-
-    assert.deepEqual(
-      calls.map((c) => c.method),
-      ["eth_blockNumber", "eth_getBlockByNumber", "eth_accounts", "eth_accounts"],
-    );
-
-    const actions = debug.map((d) => d && d.action);
-    assert.deepEqual(actions, [
-      "sendEip1193Payload",
-      "receiveEip1193Result",
-      "sendEip1193Payload",
-      "receiveEip1193Result",
-      "sendEip1193Payload",
-      "receiveEip1193Result",
-      "sendEip1193Payload",
-      "receiveEip1193Result",
-    ]);
-
-    assert.equal(debug[0].payload!.method, "eth_blockNumber");
-    assert.equal(debug[2].payload!.method, "eth_getBlockByNumber");
-  });
-});

package/test/unit/contract.test.js

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

@@ -1,83 +0,0 @@
-/**
- * @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,127 +0,0 @@
-/**
- * @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");
-   });
- });
-
-describe("Security: RLP canonical encoding & length overflow", () => {
-  it("rejects a single byte < 0x80 encoded as a 1-byte string (negative)", () => {
-    // 0x81 0x00 = "short string of length 1 containing 0x00" — must be 0x00.
-    assert.throws(() => qc.decodeRlp("0x8100"), /non-canonical single byte/i);
-  });
-
-  it("rejects a long-string form whose length fits the short form (negative)", () => {
-    // 0xb8 (long string, lenOfLen=1) 0x01 0xff -> declared length 1 (<= 55).
-    assert.throws(() => qc.decodeRlp("0xb801ff"), /non-canonical long string/i);
-  });
-
-  it("rejects a length field with a leading zero byte (negative)", () => {
-    // 0xb9 (long string, lenOfLen=2) 0x00 0x38 -> leading zero in the length.
-    assert.throws(() => qc.decodeRlp("0xb9003800"), /leading zero/i);
-  });
-
-  it("rejects a length that overflows MAX_SAFE_INTEGER (negative)", () => {
-    // 0xbf (long string, lenOfLen=8) followed by an 8-byte length starting at 0x20.
-    assert.throws(() => qc.decodeRlp("0xbf2000000000000000"), /maximum safe integer/i);
-  });
-
-  it("round-trips a canonical long string (> 55 bytes) (positive)", () => {
-    const big = "0x" + "ab".repeat(60); // 60-byte string -> long-string form
-    const encoded = qc.encodeRlp(big);
-    const decoded = qc.decodeRlp(encoded);
-    assert.equal(decoded, big);
-  });
-
-  it("round-trips a canonical nested list (positive)", () => {
-    const encoded = qc.encodeRlp([["0x01", "0x02"], "0x03"]);
-    const decoded = qc.decodeRlp(encoded);
-    assert.deepEqual(decoded, [["0x01", "0x02"], "0x03"]);
-  });
-});
- 

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

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

package/test/unit/errors.test.js

@@ -1,77 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Error helpers and error classes (direct coverage)
- */
- 
- const { describe, it } = require("node:test");
- const assert = require("node:assert/strict");
- 
- const qc = require("../../index");
- const { logSuite, logTest } = require("../verbose-logger");
- 
- describe("Errors", () => {
-   logSuite("Errors");
-   it("makeError sets code and shortMessage (info omitted vs null)", () => {
-     logTest("makeError sets code and shortMessage (info omitted vs null)", {});
-     const e1 = qc.makeError("boom", "UNKNOWN_ERROR");
-     const e2 = qc.makeError("boom", "UNKNOWN_ERROR", null);
- 
-     assert.equal(e1.code, "UNKNOWN_ERROR");
-     assert.equal(e1.shortMessage, "boom");
-     assert.equal(e2.code, "UNKNOWN_ERROR");
-     assert.equal(e2.shortMessage, "boom");
-   });
- 
-   it("makeError attaches info and protects message/code/name", () => {
-    const e = qc.makeError("boom", "UNKNOWN_ERROR", { operation: "x" });
-     assert.equal(e.code, "UNKNOWN_ERROR");
-     assert.equal(e.shortMessage, "boom");
-     assert.equal(e.operation, "x");
- 
-     assert.throws(() => qc.makeError("boom", "UNKNOWN_ERROR", { message: "nope" }));
-     assert.throws(() => qc.makeError("boom", "UNKNOWN_ERROR", { code: "NOPE" }));
-     assert.throws(() => qc.makeError("boom", "UNKNOWN_ERROR", { name: "Nope" }));
-    // shortMessage is defined read-only by makeError; passing it via info causes a TypeError
-    assert.throws(() => qc.makeError("boom", "UNKNOWN_ERROR", { shortMessage: "nope" }));
-   });
- 
-   it("assert and assertArgument throw INVALID_ARGUMENT with metadata", () => {
-     assert.throws(
-       () => qc.assert(false, "bad", "INVALID_ARGUMENT", { operation: "test" }),
-       (err) => err && err.code === "INVALID_ARGUMENT" && String(err.message).includes("operation"),
-     );
- 
-     assert.throws(
-       () => qc.assertArgument(false, "bad arg", "foo", 123),
-       (err) => err && err.code === "INVALID_ARGUMENT" && err.argument === "foo" && err.value === 123,
-     );
-   });
- 
-   it("isError and isCallException match code", () => {
-     const err = qc.makeError("x", "CALL_EXCEPTION");
-     assert.equal(qc.isError(err, "CALL_EXCEPTION"), true);
-     assert.equal(qc.isCallException(err), true);
-     assert.equal(qc.isCallException(qc.makeError("x", "UNKNOWN_ERROR")), false);
-   });
- 
-   it("ProviderError/TransactionError/ContractError set code and include info (info omitted vs null)", () => {
-     const p1 = new qc.ProviderError("p");
-     const p2 = new qc.ProviderError("p", null);
-     const p3 = new qc.ProviderError("p", { operation: "op" });
-     assert.equal(p1.code, "UNKNOWN_ERROR");
-     assert.equal(p1.shortMessage, "p");
-     assert.equal(p2.code, "UNKNOWN_ERROR");
-     assert.equal(p3.operation, "op");
- 
-     const t1 = new qc.TransactionError("t", { reason: "r" });
-     assert.equal(t1.code, "UNKNOWN_ERROR");
-     assert.equal(t1.reason, "r");
- 
-     const c1 = new qc.ContractError("c", { contract: "X" });
-     assert.equal(c1.code, "UNKNOWN_ERROR");
-     assert.equal(c1.contract, "X");
-   });
- });
-