quantumcoin 7.0.15 → 8.0.1

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

@@ -1,98 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description populateTransaction namespace and sendRawTransaction API
- */
-
-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("populateTransaction + sendRawTransaction", () => {
-  logSuite("populateTransaction + sendRawTransaction");
-  it("contract.populateTransaction.<fn> builds tx request without provider/signer", async () => {
-    logTest("contract.populateTransaction.<fn> builds tx request without provider/signer", {});
-    await Initialize(null);
-
-    const abi = [
-      {
-        type: "function",
-        name: "setValue",
-        stateMutability: "nonpayable",
-        inputs: [{ name: "value", type: "uint256" }],
-        outputs: [],
-      },
-    ];
-
-    const addr = "0x" + "11".repeat(32);
-    const contract = new qc.Contract(addr, abi);
-
-    const tx = await contract.populateTransaction.setValue(123, { gasLimit: 50000 });
-    assert.equal(tx.to, addr);
-    assert.equal(typeof tx.data, "string");
-    assert.ok(tx.data.startsWith("0x") && tx.data.length > 10);
-    assert.equal(tx.gasLimit, 50000);
-  });
-
-  it("provider.sendRawTransaction exists and forwards to eth_sendRawTransaction", async () => {
-    await Initialize(null);
-
-    class TestProvider extends qc.AbstractProvider {
-      constructor() {
-        super();
-        this.calls = [];
-      }
-      async _perform(method, params) {
-        this.calls.push({ method, params });
-        if (method === "eth_sendRawTransaction") return "0x" + "aa".repeat(32);
-        if (method === "eth_getTransactionByHash") return null;
-        return null;
-      }
-    }
-
-    const p = new TestProvider();
-    const raw = "0xdeadbeef";
-    const resp = await p.sendRawTransaction(raw);
-    assert.ok(resp && typeof resp.hash === "string");
-    assert.equal(p.calls[0].method, "eth_sendRawTransaction");
-    assert.deepEqual(p.calls[0].params, [raw]);
-  });
-});
-
-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/populate-transaction.test.ts

@@ -1,64 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description populateTransaction namespace and sendRawTransaction API
- */
-
-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("populateTransaction + sendRawTransaction", () => {
-  logSuite("populateTransaction + sendRawTransaction");
-  it("contract.populateTransaction.<fn> builds tx request without provider/signer", async () => {
-    logTest("contract.populateTransaction.<fn> builds tx request without provider/signer", {});
-    await Initialize(null);
-
-    const abi = [
-      {
-        type: "function",
-        name: "setValue",
-        stateMutability: "nonpayable",
-        inputs: [{ name: "value", type: "uint256" }],
-        outputs: [],
-      },
-    ];
-
-    const addr = "0x" + "11".repeat(32);
-    const contract = new qc.Contract(addr, abi);
-
-    const tx = await contract.populateTransaction.setValue(123, { gasLimit: 50000 });
-    assert.equal(tx.to, addr);
-    assert.equal(typeof tx.data, "string");
-    assert.ok(tx.data.startsWith("0x") && tx.data.length > 10);
-    assert.equal(tx.gasLimit, 50000);
-  });
-
-  it("provider.sendRawTransaction exists and forwards to eth_sendRawTransaction", async () => {
-    await Initialize(null);
-
-    class TestProvider extends qc.AbstractProvider {
-      calls: { method: string; params: unknown[] }[] = [];
-      constructor() {
-        super();
-      }
-      async _perform(method: string, params: unknown[]) {
-        this.calls.push({ method, params });
-        if (method === "eth_sendRawTransaction") return "0x" + "aa".repeat(32);
-        if (method === "eth_getTransactionByHash") return null;
-        return null;
-      }
-    }
-
-    const p = new TestProvider();
-    const raw = "0xdeadbeef";
-    const resp = await p.sendRawTransaction(raw);
-    assert.ok(resp && typeof resp.hash === "string");
-    assert.equal(p.calls[0].method, "eth_sendRawTransaction");
-    assert.deepEqual(p.calls[0].params, [raw]);
-  });
-});

package/test/unit/providers.test.js

@@ -1,305 +0,0 @@
-/**
- * @testCategory unit
- * @blockchainRequired false
- * @transactional false
- * @description Provider helpers, wrappers, defaults, and extra providers
- * Run with VERBOSE=1 for test names.
- */
- 
- const { describe, it } = require("node:test");
- const assert = require("node:assert/strict");
- 
- const qc = require("../../index");
- const { Initialize } = require("../../config");
- const { logSuite, logTest } = require("../verbose-logger");
- 
- describe("JsonRpcProvider", () => {
-   logSuite("JsonRpcProvider");
-   it("defaults url/chainId when omitted vs null (no Initialize required)", () => {
-     logTest("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) => {
-     logTest("_perform defaults params when omitted vs null", {});
-     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);
-       const responseBody = JSON.stringify({ jsonrpc: "2.0", id: body.id, result: "0x1" });
-       return {
-         ok: true,
-         text: async () => responseBody,
-         json: async () => JSON.parse(responseBody),
-       };
-     };
- 
-     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", () => {
-   logSuite("AbstractProvider defaults");
-   it("getTransactionCount/call/getCode default blockTag when omitted vs null", async () => {
-     logTest("getTransactionCount/call/getCode default blockTag when omitted vs null", {});
-     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("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", {});
-     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 () => {
-     logTest("throws if provider missing", {});
-     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("getProvider", () => {
-  logSuite("getProvider");
-  it("returns JsonRpcProvider for http/https URLs", () => {
-    logTest("returns JsonRpcProvider for http/https URLs", {});
-    const p1 = qc.getProvider("https://public.rpc.quantumcoinapi.com", 123123);
-    const p2 = qc.getProvider("http://localhost:8545");
-    assert.ok(p1 instanceof qc.JsonRpcProvider);
-    assert.ok(p2 instanceof qc.JsonRpcProvider);
-    assert.equal(p1.url, "https://public.rpc.quantumcoinapi.com");
-    assert.equal(p1.chainId, 123123);
-  });
-
-  it("returns WebSocketProvider for ws/wss URLs", () => {
-    logTest("returns WebSocketProvider for ws/wss URLs", {});
-    const p1 = qc.getProvider("ws://127.0.0.1:8546");
-    const p2 = qc.getProvider("wss://example.com/ws", 1);
-    assert.ok(p1 instanceof qc.WebSocketProvider);
-    assert.ok(p2 instanceof qc.WebSocketProvider);
-    assert.equal(p1.url, "ws://127.0.0.1:8546");
-    assert.equal(p2.chainId, 1);
-  });
-
-  it("returns IpcSocketProvider for IPC paths", () => {
-    logTest("returns IpcSocketProvider for IPC paths", {});
-    const p = qc.getProvider("\\\\.\\pipe\\geth.ipc");
-    assert.ok(p instanceof qc.IpcSocketProvider);
-    assert.equal(p.path, "\\\\.\\pipe\\geth.ipc");
-  });
-
-  it("returns JsonRpcProvider with default url/chainId when endpoint omitted or empty", () => {
-    logTest("returns JsonRpcProvider with default url/chainId when endpoint omitted or empty", {});
-    const p1 = qc.getProvider();
-    const p2 = qc.getProvider("");
-    assert.ok(p1 instanceof qc.JsonRpcProvider);
-    assert.ok(p2 instanceof qc.JsonRpcProvider);
-    assert.ok(p1.url.length > 0);
-    assert.equal(p1.chainId, 123123);
-  });
-});
-
-describe("Extra providers", () => {
-  logSuite("Extra providers");
-  it("BrowserProvider requires an EIP-1193 provider with request()", () => {
-     logTest("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", () => {
-   logTest("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", () => {
-    logTest("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 () => {
-     logTest("FallbackProvider accepts single vs array and tries providers in order", {});
-     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", () => {
-     logTest("FallbackProvider throws when no providers provided", {});
-     assert.throws(() => new qc.FallbackProvider([]));
-   });
- });
-
-describe("Provider.getFeeData", () => {
-  logSuite("Provider.getFeeData");
-
-  // Expected per-gas-unit prices (wei). BASE is keyType 3 (compact / context 0);
-  // keyType 3 full-sign is BASE x 30; keyType 5 is BASE x 20.
-  const FEE_BASE = 4761904761904760n;
-  const FEE_KT3_FULL = 142857142857142800n;
-  const FEE_KT5 = 95238095238095200n;
-
-  it("prices by keyType number", async () => {
-    logTest("prices by keyType number", {});
-    const p = new qc.JsonRpcProvider();
-    assert.strictEqual((await p.getFeeData(3)).gasPrice, FEE_BASE);
-    assert.strictEqual((await p.getFeeData(3, true)).gasPrice, FEE_KT3_FULL);
-    assert.strictEqual((await p.getFeeData(5)).gasPrice, FEE_KT5);
-    assert.strictEqual((await p.getFeeData(5, true)).gasPrice, FEE_KT5);
-  });
-
-  it("prices by wallet (reads keyType from wallet)", async () => {
-    logTest("prices by wallet", {});
-    await Initialize(null);
-    const p = new qc.JsonRpcProvider();
-
-    const w3 = qc.Wallet.createRandom(undefined, 3);
-    assert.strictEqual((await p.getFeeData(w3)).gasPrice, FEE_BASE);
-    assert.strictEqual((await p.getFeeData(w3, false)).gasPrice, FEE_BASE);
-    assert.strictEqual((await p.getFeeData(w3, null)).gasPrice, FEE_BASE);
-    assert.strictEqual((await p.getFeeData(w3, true)).gasPrice, FEE_KT3_FULL);
-
-    const w5 = qc.Wallet.createRandom(undefined, 5);
-    assert.strictEqual((await p.getFeeData(w5)).gasPrice, FEE_KT5);
-    assert.strictEqual((await p.getFeeData(w5, true)).gasPrice, FEE_KT5);
-  });
-
-  it("FeeData exposes only gasPrice (maxFeePerGas / maxPriorityFeePerGas unsupported)", async () => {
-    logTest("FeeData exposes only gasPrice", {});
-    const p = new qc.JsonRpcProvider();
-    const fd = await p.getFeeData(3);
-    assert.ok(fd instanceof qc.FeeData);
-    assert.strictEqual(fd.maxFeePerGas, undefined);
-    assert.strictEqual(fd.maxPriorityFeePerGas, undefined);
-  });
-
-  it("rejects invalid keyType and invalid first argument", async () => {
-    logTest("rejects invalid inputs", {});
-    const p = new qc.JsonRpcProvider();
-    await assert.rejects(() => p.getFeeData(99), /getGasPrice failed/);
-    await assert.rejects(() => p.getFeeData({}), /expected a Wallet or a keyType number/);
-    await assert.rejects(() => p.getFeeData(null), /expected a Wallet or a keyType number/);
-  });
-});
-