quantumcoin 7.0.1 → 7.0.3

package/test/unit/generate-sdk-artifacts-json.test.js

@@ -26,6 +26,9 @@ describe("generate-sdk.js --artifacts-json", () => {
     const betaAbi = [
       { type: "function", name: "set", stateMutability: "nonpayable", inputs: [{ name: "value", type: "uint256" }], outputs: [] },
     ];
+    const gammaAbi = [
+      { type: "function", name: "ping", stateMutability: "pure", inputs: [], outputs: [{ name: "", type: "bool" }] },
+    ];
 
     fs.writeFileSync(path.join(tmp, "Alpha.abi.json"), JSON.stringify(alphaAbi, null, 2), "utf8");
     fs.writeFileSync(path.join(tmp, "Alpha.bin"), "0x6000", "utf8");
@@ -39,6 +42,8 @@ describe("generate-sdk.js --artifacts-json", () => {
         [
           { abi: "./Alpha.abi.json", bin: "./Alpha.bin" },
           { abi: "./Beta.abi.json", bin: "./Beta.bin" },
+          // Inline string form: abi is a JSON string; bin is inline bytecode (string).
+          { name: "Gamma", abi: JSON.stringify(gammaAbi), bin: "6000" },
         ],
         null,
         2,
@@ -60,6 +65,46 @@ describe("generate-sdk.js --artifacts-json", () => {
     assert.ok(fs.existsSync(path.join(outDir, "Alpha__factory.ts")));
     assert.ok(fs.existsSync(path.join(outDir, "Beta.ts")));
     assert.ok(fs.existsSync(path.join(outDir, "Beta__factory.ts")));
+    assert.ok(fs.existsSync(path.join(outDir, "Gamma.ts")));
+    assert.ok(fs.existsSync(path.join(outDir, "Gamma__factory.ts")));
+  });
+
+  it("supports --lang js (generates JS source + .d.ts types)", () => {
+    const repoRoot = path.resolve(__dirname, "..", "..");
+    const cli = path.join(repoRoot, "generate-sdk.js");
+
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "qcgen-artjson-js-"));
+    const outDir = path.join(tmp, "out");
+
+    const alphaAbi = [
+      { type: "function", name: "get", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "uint256" }] },
+    ];
+    fs.writeFileSync(path.join(tmp, "Alpha.abi.json"), JSON.stringify(alphaAbi, null, 2), "utf8");
+    fs.writeFileSync(path.join(tmp, "Alpha.bin"), "0x6000", "utf8");
+
+    const artifactsJsonPath = path.join(tmp, "artifacts.json");
+    fs.writeFileSync(artifactsJsonPath, JSON.stringify([{ abi: "./Alpha.abi.json", bin: "./Alpha.bin" }], null, 2), "utf8");
+
+    const res = spawnSync(
+      process.execPath,
+      [cli, "--lang", "js", "--artifacts-json", artifactsJsonPath, "--out", outDir, "--non-interactive"],
+      { cwd: repoRoot, encoding: "utf8", stdio: "pipe", shell: false, windowsHide: true },
+    );
+
+    assert.equal(res.status, 0, `generator failed:\n${res.stdout}\n${res.stderr}`);
+
+    assert.ok(fs.existsSync(path.join(outDir, "types.js")));
+    assert.ok(fs.existsSync(path.join(outDir, "types.d.ts")));
+    assert.ok(fs.existsSync(path.join(outDir, "index.js")));
+    assert.ok(fs.existsSync(path.join(outDir, "index.d.ts")));
+    assert.ok(fs.existsSync(path.join(outDir, "Alpha.js")));
+    assert.ok(fs.existsSync(path.join(outDir, "Alpha.d.ts")));
+    assert.ok(fs.existsSync(path.join(outDir, "Alpha__factory.js")));
+    assert.ok(fs.existsSync(path.join(outDir, "Alpha__factory.d.ts")));
+
+    // Ensure generated types re-export core Solidity types (no local re-definition).
+    const typesDts = fs.readFileSync(path.join(outDir, "types.d.ts"), "utf8");
+    assert.ok(typesDts.includes('from "quantumcoin/types"'), "expected generated types.d.ts to reference quantumcoin/types");
   });
 });
 

package/test/unit/generator.test.js

@@ -53,6 +53,7 @@ describe("typed contract generator", () => {
     assert.ok(contractSrc.includes("export class TestToken"));
     assert.ok(contractSrc.includes("async balanceOf"));
     assert.ok(contractSrc.includes("async transfer"));
+    assert.ok(contractSrc.includes("populateTransaction"));
 
     const factorySrc = fs.readFileSync(res.factoryFile, "utf8");
     assert.ok(factorySrc.includes("export class TestToken__factory"));

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

@@ -0,0 +1,62 @@
+/**
+ * @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");
+
+describe("populateTransaction + sendRawTransaction", () => {
+  it("contract.populateTransaction.<fn> builds tx request without provider/signer", async () => {
+    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]);
+  });
+});
+

package/test/unit/solidity-types.test.js

@@ -0,0 +1,46 @@
+/**
+ * @testCategory unit
+ * @blockchainRequired false
+ * @transactional false
+ * @description Core Solidity type exports exist and are wired via package exports.
+ */
+
+const { describe, it } = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+
+describe("core solidity types", () => {
+  it("has src/types/index.d.ts with expected exports", () => {
+    const repoRoot = path.resolve(__dirname, "..", "..");
+    const dts = path.join(repoRoot, "src", "types", "index.d.ts");
+    assert.ok(fs.existsSync(dts), "missing src/types/index.d.ts");
+    const src = fs.readFileSync(dts, "utf8");
+
+    for (const needle of [
+      "export type AddressLike",
+      "export type BytesLike",
+      "export type BigNumberish",
+      "export type SolidityTypeName",
+      "export type SolidityInputValue",
+      "export type SolidityOutputValue",
+    ]) {
+      assert.ok(src.includes(needle), `expected types module to include: ${needle}`);
+    }
+  });
+
+  it("exports ./types via package.json exports map", () => {
+    const repoRoot = path.resolve(__dirname, "..", "..");
+    const pkgPath = path.join(repoRoot, "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+
+    assert.equal(pkg.types, "src/index.d.ts");
+    assert.ok(pkg.typesVersions && pkg.typesVersions["*"], "package.json missing typesVersions");
+
+    assert.ok(pkg.exports, "package.json missing exports");
+    assert.ok(pkg.exports["./types"], "package.json exports missing ./types");
+    assert.equal(pkg.exports["./types"].types, "./src/types/index.d.ts");
+    assert.equal(pkg.exports["./types"].default, "./src/types/index.js");
+  });
+});
+

package/test/unit/utils.test.js

@@ -31,7 +31,7 @@ describe("Utils", () => {
     assert.equal(qc.toUtf8String(out), "hello world");
   });
 
-  it("RLP encode/decode roundtrip (ethers-style bytes)", () => {
+  it("RLP encode/decode roundtrip (hex bytes)", () => {
     const value = ["0x68656c6c6f", "0x7b", "0x01"];
     const encoded = qc.encodeRlp(value);
     assert.ok(typeof encoded === "string" && encoded.startsWith("0x"));