quantumcoin 7.0.3 → 7.0.5

package/test/unit/hashing.test.js

@@ -1,54 +1,68 @@
-/**
- * @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");
- 
- describe("Hashing", () => {
-   it("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);
-   });
- });
- 
+/**
+ * @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("hashMessage follows EIP-191 / ethers.js pattern (prefix + length + message, keccak256)", () => {
+    // Known digest from ethers.js hashMessage("Hello World")
+    const expectedHelloWorld = "0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2";
+    assert.equal(qc.hashMessage("Hello World"), expectedHelloWorld);
+    // String and UTF-8 bytes of same content produce the same digest
+    assert.equal(qc.hashMessage("Hello World"), qc.hashMessage(qc.toUtf8Bytes("Hello World")));
+    // Empty message
+    const emptyDigest = qc.hashMessage("");
+    assert.ok(emptyDigest.startsWith("0x") && emptyDigest.length === 66);
+  });
+});
+ 

package/test/unit/hashing.test.ts

@@ -0,0 +1,67 @@
+/**
+ * @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("hashMessage follows EIP-191 / ethers.js pattern (prefix + length + message, keccak256)", () => {
+    // Known digest from ethers.js hashMessage("Hello World")
+    const expectedHelloWorld = "0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2";
+    assert.equal(qc.hashMessage("Hello World"), expectedHelloWorld);
+    // String and UTF-8 bytes of same content produce the same digest
+    assert.equal(qc.hashMessage("Hello World"), qc.hashMessage(qc.toUtf8Bytes("Hello World")));
+    // Empty message
+    const emptyDigest = qc.hashMessage("");
+    assert.ok(emptyDigest.startsWith("0x") && emptyDigest.length === 66);
+  });
+});

package/test/unit/init.test.js

@@ -1,36 +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");
-
-describe("Initialize()", () => {
-  it("initializes with default config (null)", async () => {
-    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");
-  });
-});
-
+/**
+ * @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/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/test/unit/interface.test.js

@@ -1,53 +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");
-
-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);
-  });
-});
-
+/**
+ * @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/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/test/unit/internal-hex.test.js

@@ -1,47 +1,50 @@
-/**
- * @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));
-   });
- });
- 
+/**
+ * @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");
+ 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("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/internal-hex.test.ts

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