quantumcoin 7.0.12 → 7.0.14

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

@@ -89,4 +89,39 @@
      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/generator.test.js

@@ -11,7 +11,7 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 
-const { generate, generateFromArtifacts } = require("../../src/generator");
+const { generate, generateFromArtifacts, generateTransactionalTestJs } = require("../../src/generator");
 const { logSuite, logTest } = require("../verbose-logger");
 
 describe("typed contract generator", () => {
@@ -62,6 +62,53 @@ describe("typed contract generator", () => {
     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  "]) {
+      const src = generateTransactionalTestJs({
+        contractName: "IThing",
+        abi: [],
+        bytecode: bc,
+      });
+      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");

package/test/unit/generator.test.ts

@@ -11,7 +11,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
-import { generate, generateFromArtifacts } from "../../src/generator";
+import { generate, generateFromArtifacts, generateTransactionalTestJs } from "../../src/generator";
 import { logSuite, logTest } from "../verbose-logger";
 
 describe("typed contract generator", () => {
@@ -62,6 +62,53 @@ describe("typed contract generator", () => {
     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");

package/test/unit/hashing.test.js

@@ -1,64 +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");
-  });
-});
- 
+/**
+ * @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/test/unit/hashing.test.ts

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

@@ -8,7 +8,7 @@
  const { describe, it } = require("node:test");
  const assert = require("node:assert/strict");
  
- const { normalizeHex, isHexString, hexToBytes, bytesToHex, arrayify } = require("../../src/internal/hex");
+ const { normalizeHex, toQuantityHex, toQuantity, isHexString, hexToBytes, bytesToHex, arrayify } = require("../../src/internal/hex");
  const { logSuite, logTest } = require("../verbose-logger");
  
  describe("internal/hex", () => {
@@ -20,6 +20,37 @@
     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);

package/test/unit/internal-hex.test.ts

@@ -8,7 +8,7 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 
-import { normalizeHex, isHexString, hexToBytes, bytesToHex, arrayify } from "../../src/internal/hex";
+import { normalizeHex, toQuantityHex, toQuantity, isHexString, hexToBytes, bytesToHex, arrayify } from "../../src/internal/hex";
 import { logSuite, logTest } from "../verbose-logger";
 
 describe("internal/hex", () => {
@@ -21,6 +21,37 @@ describe("internal/hex", () => {
     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);

package/test/unit/populate-transaction.test.js

@@ -63,3 +63,36 @@ describe("populateTransaction + sendRawTransaction", () => {
   });
 });
 
+describe("Security: mandatory chainId for signing", () => {
+  logSuite("Security: mandatory chainId for signing");
+
+  it("offline signing without a chainId throws (negative)", async () => {
+    logTest("offline signing without a chainId throws", {});
+    await Initialize(null);
+    const w = qc.Wallet.createRandom(); // no provider connected
+    await assert.rejects(
+      () => w.signTransaction({ to: w.address, value: 0n, nonce: 0 }),
+      /chainId is required for signing/i,
+    );
+  });
+
+  it("offline signing with an explicit chainId succeeds (positive)", async () => {
+    logTest("offline signing with an explicit chainId succeeds", {});
+    await Initialize(null);
+    const w = qc.Wallet.createRandom();
+    const raw = await w.signTransaction({ to: w.address, value: 0n, nonce: 0, chainId: 123123 });
+    assert.equal(typeof raw, "string");
+    assert.ok(raw.startsWith("0x"));
+  });
+
+  it("signing resolves chainId from a connected provider (positive)", async () => {
+    logTest("signing resolves chainId from a connected provider", {});
+    await Initialize(null);
+    const provider = new qc.JsonRpcProvider("http://127.0.0.1:9999", 123123);
+    const w = qc.Wallet.createRandom().connect(provider);
+    const raw = await w.signTransaction({ to: w.address, value: 0n, nonce: 0 });
+    assert.equal(typeof raw, "string");
+    assert.ok(raw.startsWith("0x"));
+  });
+});
+

package/test/unit/providers.test.js

@@ -94,7 +94,57 @@
    });
  });
  
- describe("TransactionResponse.wait", () => {
+ describe("AbstractProvider block-tag QUANTITY formatting", () => {
+  logSuite("AbstractProvider block-tag QUANTITY formatting");
+
+  it("getBlock encodes block numbers as spec-compliant quantities (no leading zeros)", async () => {
+    logTest("getBlock encodes block numbers as spec-compliant quantities", {});
+    class BlockStub extends qc.AbstractProvider {
+      constructor() { super(); this.calls = []; }
+      async _perform(method, params) {
+        this.calls.push({ method, params });
+        return { number: "0x5", timestamp: "0x64" };
+      }
+    }
+    const p = new BlockStub();
+    await p.getBlock(0);        assert.equal(p.calls.at(-1).params[0], "0x0");
+    await p.getBlock(5);        assert.equal(p.calls.at(-1).params[0], "0x5");
+    await p.getBlock(15);       assert.equal(p.calls.at(-1).params[0], "0xf");
+    await p.getBlock(16);       assert.equal(p.calls.at(-1).params[0], "0x10");
+    await p.getBlock(256);      assert.equal(p.calls.at(-1).params[0], "0x100");
+    await p.getBlock(4095);     assert.equal(p.calls.at(-1).params[0], "0xfff");
+    await p.getBlock(4096);     assert.equal(p.calls.at(-1).params[0], "0x1000");
+    await p.getBlock("latest"); assert.equal(p.calls.at(-1).params[0], "latest");
+  });
+
+  it("getLogs encodes fromBlock/toBlock as spec-compliant quantities (no leading zeros)", async () => {
+    logTest("getLogs encodes fromBlock/toBlock as spec-compliant quantities", {});
+    class LogStub extends qc.AbstractProvider {
+      constructor() { super(); this.calls = []; }
+      async _perform(method, params) { this.calls.push({ method, params }); return []; }
+    }
+    const lp = new LogStub();
+    await lp.getLogs({ fromBlock: 5, toBlock: 256 });
+    assert.equal(lp.calls[0].params[0].fromBlock, "0x5");
+    assert.equal(lp.calls[0].params[0].toBlock,   "0x100");
+    await lp.getLogs({ fromBlock: "latest", toBlock: "pending" });
+    assert.equal(lp.calls[1].params[0].fromBlock, "latest");
+    assert.equal(lp.calls[1].params[0].toBlock,   "pending");
+  });
+
+  it("getBlock rejects invalid block numbers with a clear typed error", async () => {
+    logTest("getBlock rejects invalid block numbers", {});
+    class StubP extends qc.AbstractProvider {
+      async _perform() { return { number: "0x0" }; }
+    }
+    const p = new StubP();
+    await assert.rejects(() => p.getBlock(-1),  (e) => e instanceof RangeError);
+    await assert.rejects(() => p.getBlock(1.5), (e) => e instanceof TypeError);
+    await assert.rejects(() => p.getBlock(NaN), (e) => e instanceof TypeError);
+  });
+});
+
+describe("TransactionResponse.wait", () => {
    logSuite("TransactionResponse.wait");
    it("uses default confirmations when omitted vs null", async () => {
      logTest("uses default confirmations when omitted vs null", {});