@carbonx3/cx3.js 0.1.0 → 0.2.0

package/src/contract.js

@@ -64,6 +64,11 @@ class Contract {
         const provider = this.provider;
         const sender = this.signer ? this.signer.address : "";
         const res = await provider.call(this.address, method, params, sender);
+        // the node answers a failed read with HTTP 200 + { success: false, error }
+        if (res && res.success === false) {
+            const code = String(res.error || res.message || "CALL_FAILED");
+            throw new Cx3Error(code, code, res);
+        }
         return res.value !== undefined ? res.value : res;
     }
 

package/src/crypto.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const crypto = require("crypto");
+// @noble/secp256k1 3.x is an ES module: require() loads it on Node 20.19+ / 22.12+ (package.json "engines").
 const secp = require("@noble/secp256k1");
 const { strip0x, ensure0x } = require("./utils");
 const { Cx3Error } = require("./errors");
@@ -48,10 +49,11 @@ async function signMessage(message, privateKeyInput) {
         ? Buffer.from(message, "utf8")
         : Buffer.from(message);
     const msgHash = sha256(msgBytes);
-    const signed = await secp.sign(msgHash, priv, { der: false, recovered: true });
-    const sigBytes = Array.isArray(signed) ? signed[0] : signed;
-    const recovery = Array.isArray(signed) ? signed[1] : (signed.recovery != null ? signed.recovery : 0);
-    const signature = Buffer.from(sigBytes).toString("hex");
+    // msgHash is already the digest (prehash: false); deterministic RFC 6979, low-S — the same bytes 1.7.x produced.
+    // "recovered" = 65 bytes: recovery id, then r || s.
+    const signed = await secp.signAsync(msgHash, priv, { prehash: false, format: "recovered" });
+    const recovery = signed[0];
+    const signature = Buffer.from(signed.subarray(1)).toString("hex");
     const publicKey = privateKeyToPublicKey(priv, true).toString("hex");
     const publicKeyUncompressed = privateKeyToPublicKey(priv, false).toString("hex");
     return {

package/src/digest.js

@@ -14,16 +14,10 @@ function buildDeployDigest({
     initialSupply = "0",
     timestamp
 }) {
-    return [
-        "deploy",
-        owner || "",
-        standard || "",
-        name || "",
-        symbol || "",
-        decimals !== undefined ? decimals : 18,
-        initialSupply !== undefined ? String(initialSupply) : "0",
-        timestamp || 0
-    ].join("|");
+    // Template literal like the node (join() would turn null into "")
+    const dec = decimals !== undefined ? decimals : 18;
+    const supply = initialSupply !== undefined ? String(initialSupply) : "0";
+    return `deploy|${owner || ""}|${standard || ""}|${name || ""}|${symbol || ""}|${dec}|${supply}|${timestamp || 0}`;
 }
 
 function buildSendDigest(contractAddress, method, params, fromAddress, timestamp) {

package/src/factory.js

@@ -2,9 +2,49 @@
 
 const { Cx3Error } = require("./errors");
 const { Contract } = require("./contract");
+const { normalizeAddress, isPlainObject } = require("./utils");
+
+// the token standards the CX3WebUI deploys as Public or Private
+const PRIVATE_STANDARDS = new Set(["CX30", "CX31", "CX300", "CX315", "CX3192"]);
+const MAX_AUTHORIZED_WALLETS = 200;
+
+function authorizedWalletList(list) {
+    if (list == null) return [];
+    if (!Array.isArray(list)) {
+        throw new Cx3Error("authorizedWallets is an array of wallet addresses", "BAD_DEPLOY_ARGS");
+    }
+    const out = [];
+    for (const raw of list) {
+        const a = normalizeAddress(raw);
+        if (!/^0x[0-9a-f]{40}$/.test(a)) {
+            throw new Cx3Error("authorizedWallets: every entry is a wallet address (0x + 40 hex)", "INVALID_AUTHORIZED_WALLET", { wallet: String(raw) });
+        }
+        if (!out.includes(a)) out.push(a);
+    }
+    if (out.length > MAX_AUTHORIZED_WALLETS) {
+        throw new Cx3Error(`authorizedWallets takes at most ${MAX_AUTHORIZED_WALLETS} wallets`, "TOO_MANY_AUTHORIZED_WALLETS");
+    }
+    return out;
+}
+
+// addToWhitelist params by the contract's ABI names (addr or account, then kycHash / invType = "")
+function whitelistParams(def, wallet) {
+    const names = (def && Array.isArray(def.inputs) ? def.inputs : [])
+        .map((i) => (typeof i === "string" ? i : i && i.name))
+        .filter(Boolean);
+    if (!names.length) return { addr: wallet, kycHash: "" };
+    const params = {};
+    names.forEach((n, i) => { params[n] = i === 0 ? wallet : ""; });
+    return params;
+}
 
 /**
  * Standard token deploy helpers.
+ *
+ * `visibility: "private"` deploys a private token, like the CX3WebUI "Private" choice: only the owner
+ * and `authorizedWallets` send, receive and see it. The chain renders a private CX30 itself; CX31,
+ * CX300, CX315 and CX3192 take their CX3WebUI source (`sourceCode`). Each authorized wallet is added
+ * with one signed `addToWhitelist` after the deploy (`result.authorized`).
  */
 class Cx3TokenFactory {
     /**
@@ -104,8 +144,18 @@ class Cx3TokenFactory {
         if (!fields.name || !fields.symbol) {
             throw new Cx3Error("name and symbol are required", "BAD_DEPLOY_ARGS");
         }
+        const { visibility, authorizedWallets, ...rest } = fields;
+        let body = rest;
+        let wallets = [];
+        if (visibility === "private") {
+            ({ body, wallets } = this._privateFields(standard, rest, authorizedWallets));
+        } else if (visibility != null && visibility !== "public") {
+            throw new Cx3Error('visibility is "public" or "private"', "BAD_DEPLOY_ARGS");
+        } else if (authorizedWallets != null) {
+            throw new Cx3Error('authorizedWallets belongs to visibility: "private"', "BAD_DEPLOY_ARGS");
+        }
         const result = await this.wallet.deployContract({
-            ...fields,
+            ...body,
             standard
         });
         if (result && result.success !== false && result.contractAddress) {
@@ -122,9 +172,63 @@ class Cx3TokenFactory {
                     this.wallet
                 );
             }
+            if (wallets.length) result.authorized = await this._authorize(result.contract, wallets);
         }
         return result;
     }
+
+    _privateFields(standard, fields, list) {
+        if (!PRIVATE_STANDARDS.has(standard)) {
+            throw new Cx3Error(`${standard} has no private variant (CX30, CX31, CX300, CX315 and CX3192 do)`, "PRIVATE_NOT_SUPPORTED");
+        }
+        const wallets = authorizedWalletList(list);
+        const hasSource = !!(fields.sourceCode || fields.bytecode);
+        if (!hasSource && (standard !== "CX30" || (fields.target && fields.target !== "CX3WASM"))) {
+            throw new Cx3Error(
+                `A private ${standard} ${standard === "CX30" ? "on CX3JS " : ""}is deployed from its CX3WebUI source (sourceCode); the chain renders only a CX3WASM CX30 itself`,
+                "PRIVATE_NEEDS_SOURCE"
+            );
+        }
+        const metadata = {
+            ...(isPlainObject(fields.metadata) ? fields.metadata : {}),
+            visibility: "private",
+            authorizedWallets: wallets.length
+        };
+        const body = { ...fields, whitelistable: true, metadata };
+        if (!hasSource) {
+            // the chain renders CX30 from constructorArgs; whitelistable adds the authorized list
+            // (isWhitelisted, addToWhitelist / removeFromWhitelist) and the transfer guards
+            body.constructorArgs = {
+                name: fields.name,
+                symbol: fields.symbol,
+                decimals: fields.decimals !== undefined ? Number(fields.decimals) : 18,
+                totalSupply: fields.initialSupply || fields.totalSupply || "0",
+                owner: fields.owner || this.wallet.address,
+                mintable: fields.mintable !== undefined ? fields.mintable : true,
+                burnable: fields.burnable !== undefined ? fields.burnable : true,
+                pausable: fields.pausable !== undefined ? fields.pausable : true,
+                blacklistable: !!fields.blacklistable,
+                ...(isPlainObject(fields.constructorArgs) ? fields.constructorArgs : {}),
+                whitelistable: true
+            };
+        }
+        return { body, wallets };
+    }
+
+    // one signed addToWhitelist per wallet (the CX3WebUI writes them into the constructor instead)
+    async _authorize(contract, wallets) {
+        const def = contract.interface && contract.interface.addToWhitelist;
+        const out = [];
+        for (const w of wallets) {
+            try {
+                const tx = await this.wallet.sendTransaction(contract.address, "addToWhitelist", whitelistParams(def, w));
+                out.push({ wallet: w, success: tx.success !== false, txHash: tx.txHash || null });
+            } catch (e) {
+                out.push({ wallet: w, success: false, error: (e && (e.code || e.message)) || "SEND_FAILED" });
+            }
+        }
+        return out;
+    }
 }
 
 module.exports = { Cx3TokenFactory };