@auditable/privacy-pool-zk-sdk 0.0.2-rc.6

package/dist/cli.js

@@ -0,0 +1,701 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs = require('fs');
+var wasmBindings = require('privacy-pool-client-sdk/pkg/client_sdk_wasm.js');
+var snarkjs = require('snarkjs');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var wasmBindings__namespace = /*#__PURE__*/_interopNamespaceDefault(wasmBindings);
+var snarkjs__namespace = /*#__PURE__*/_interopNamespaceDefault(snarkjs);
+
+const isNode$2 = typeof process !== 'undefined' && !!process.versions?.node;
+let wasmModule = null;
+async function loadWasm(wasmBinary) {
+    if (wasmModule)
+        return wasmModule;
+    if (isNode$2) {
+        if (wasmBinary) {
+            wasmBindings__namespace.initSync(wasmBinary);
+        }
+        else {
+            const path = await import('path');
+            const { fileURLToPath } = await import('url');
+            const fs = await import('fs');
+            const dir = path.dirname(fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href))));
+            const wasmPath = path.resolve(dir, '..', 'pkg', 'client_sdk_wasm_bg.wasm');
+            const buffer = fs.readFileSync(wasmPath);
+            wasmBindings__namespace.initSync(buffer);
+        }
+        wasmModule = wasmBindings__namespace;
+    }
+    else {
+        if (wasmBinary) {
+            wasmBindings__namespace.initSync(wasmBinary);
+        }
+        else {
+            await wasmBindings__namespace.default();
+        }
+        wasmModule = wasmBindings__namespace;
+    }
+    return wasmModule;
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var witness_calculator = async function builder(code, options) {
+
+    options = options || {};
+
+    let wasmModule;
+    try {
+	wasmModule = await WebAssembly.compile(code);
+    }  catch (err) {
+	console.log(err);
+	console.log("\nTry to run circom --c in order to generate c++ code instead\n");
+	throw new Error(err);
+    }
+
+    let wc;
+
+    let errStr = "";
+    let msgStr = "";
+    
+    const instance = await WebAssembly.instantiate(wasmModule, {
+        runtime: {
+            exceptionHandler : function(code) {
+		let err;
+                if (code == 1) {
+                    err = "Signal not found.\n";
+                } else if (code == 2) {
+                    err = "Too many signals set.\n";
+                } else if (code == 3) {
+                    err = "Signal already set.\n";
+		} else if (code == 4) {
+                    err = "Assert Failed.\n";
+		} else if (code == 5) {
+                    err = "Not enough memory.\n";
+		} else if (code == 6) {
+                    err = "Input signal array access exceeds the size.\n";
+		} else {
+		    err = "Unknown error.\n";
+                }
+                throw new Error(err + errStr);
+            },
+	    printErrorMessage : function() {
+		errStr += getMessage() + "\n";
+                // console.error(getMessage());
+	    },
+	    writeBufferMessage : function() {
+			const msg = getMessage();
+			// Any calls to `log()` will always end with a `\n`, so that's when we print and reset
+			if (msg === "\n") {
+				console.log(msgStr);
+				msgStr = "";
+			} else {
+				// If we've buffered other content, put a space in between the items
+				if (msgStr !== "") {
+					msgStr += " ";
+				}
+				// Then append the message to the message we are creating
+				msgStr += msg;
+			}
+	    },
+	    showSharedRWMemory : function() {
+		printSharedRWMemory ();
+            }
+
+        }
+    });
+
+    const sanityCheck =
+        options;
+//        options &&
+//        (
+//            options.sanityCheck ||
+//            options.logGetSignal ||
+//            options.logSetSignal ||
+//            options.logStartComponent ||
+//            options.logFinishComponent
+//        );
+
+    
+    wc = new WitnessCalculator(instance, sanityCheck);
+    return wc;
+
+    function getMessage() {
+        var message = "";
+	var c = instance.exports.getMessageChar();
+        while ( c != 0 ) {
+	    message += String.fromCharCode(c);
+	    c = instance.exports.getMessageChar();
+	}
+        return message;
+    }
+	
+    function printSharedRWMemory () {
+	const shared_rw_memory_size = instance.exports.getFieldNumLen32();
+	const arr = new Uint32Array(shared_rw_memory_size);
+	for (let j=0; j<shared_rw_memory_size; j++) {
+	    arr[shared_rw_memory_size-1-j] = instance.exports.readSharedRWMemory(j);
+	}
+
+	// If we've buffered other content, put a space in between the items
+	if (msgStr !== "") {
+		msgStr += " ";
+	}
+	// Then append the value to the message we are creating
+	msgStr += (fromArray32(arr).toString());
+	}
+
+};
+
+class WitnessCalculator {
+    constructor(instance, sanityCheck) {
+        this.instance = instance;
+
+	this.version = this.instance.exports.getVersion();
+        this.n32 = this.instance.exports.getFieldNumLen32();
+
+        this.instance.exports.getRawPrime();
+        const arr = new Uint32Array(this.n32);
+        for (let i=0; i<this.n32; i++) {
+            arr[this.n32-1-i] = this.instance.exports.readSharedRWMemory(i);
+        }
+        this.prime = fromArray32(arr);
+
+        this.witnessSize = this.instance.exports.getWitnessSize();
+
+        this.sanityCheck = sanityCheck;
+    }
+    
+    circom_version() {
+	return this.instance.exports.getVersion();
+    }
+
+    async _doCalculateWitness(input_orig, sanityCheck) {
+	//input is assumed to be a map from signals to arrays of bigints
+        this.instance.exports.init((this.sanityCheck || sanityCheck) ? 1 : 0);
+	let prefix = "";
+	var input = new Object();
+	//console.log("Input: ", input_orig);
+	qualify_input(prefix,input_orig,input);
+	//console.log("Input after: ",input);	
+        const keys = Object.keys(input);
+	var input_counter = 0;
+        keys.forEach( (k) => {
+            const h = fnvHash(k);
+            const hMSB = parseInt(h.slice(0,8), 16);
+            const hLSB = parseInt(h.slice(8,16), 16);
+            const fArr = flatArray(input[k]);
+	    let signalSize = this.instance.exports.getInputSignalSize(hMSB, hLSB);
+	    if (signalSize < 0){
+		throw new Error(`Signal ${k} not found\n`);
+	    }
+	    if (fArr.length < signalSize) {
+		throw new Error(`Not enough values for input signal ${k}\n`);
+	    }
+	    if (fArr.length > signalSize) {
+		throw new Error(`Too many values for input signal ${k}\n`);
+	    }
+            for (let i=0; i<fArr.length; i++) {
+                const arrFr = toArray32(normalize(fArr[i],this.prime),this.n32);
+                for (let j=0; j<this.n32; j++) {
+		    this.instance.exports.writeSharedRWMemory(j,arrFr[this.n32-1-j]);
+		}
+		try {
+                    this.instance.exports.setInputSignal(hMSB, hLSB,i);
+		    input_counter++;
+		} catch (err) {
+		    // console.log(`After adding signal ${i} of ${k}`)
+                    throw new Error(err);
+		}
+            }
+
+        });
+	if (input_counter < this.instance.exports.getInputSize()) {
+	    throw new Error(`Not all inputs have been set. Only ${input_counter} out of ${this.instance.exports.getInputSize()}`);
+	}
+    }
+
+    async calculateWitness(input, sanityCheck) {
+
+        const w = [];
+        await this._doCalculateWitness(input, sanityCheck);
+
+        for (let i=0; i<this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+	    const arr = new Uint32Array(this.n32);
+            for (let j=0; j<this.n32; j++) {
+            arr[this.n32-1-j] = this.instance.exports.readSharedRWMemory(j);
+            }
+            w.push(fromArray32(arr));
+        }
+
+        return w;
+    }
+    
+
+    async calculateBinWitness(input, sanityCheck) {
+
+        const buff32 = new Uint32Array(this.witnessSize*this.n32);
+	const buff = new  Uint8Array( buff32.buffer);
+        await this._doCalculateWitness(input, sanityCheck);
+
+        for (let i=0; i<this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+	    const pos = i*this.n32;
+            for (let j=0; j<this.n32; j++) {
+		buff32[pos+j] = this.instance.exports.readSharedRWMemory(j);
+            }
+        }
+
+	return buff;
+    }
+    
+
+    async calculateWTNSBin(input, sanityCheck) {
+
+        const buff32 = new Uint32Array(this.witnessSize*this.n32+this.n32+11);
+	const buff = new  Uint8Array( buff32.buffer);
+        await this._doCalculateWitness(input, sanityCheck);
+  
+	//"wtns"
+	buff[0] = "w".charCodeAt(0);
+	buff[1] = "t".charCodeAt(0);
+	buff[2] = "n".charCodeAt(0);
+	buff[3] = "s".charCodeAt(0);
+
+	//version 2
+	buff32[1] = 2;
+
+	//number of sections: 2
+	buff32[2] = 2;
+
+	//id section 1
+	buff32[3] = 1;
+
+	const n8 = this.n32*4;
+	//id section 1 length in 64bytes
+	const idSection1length = 8 + n8;
+	const idSection1lengthHex = idSection1length.toString(16);
+        buff32[4] = parseInt(idSection1lengthHex.slice(0,8), 16);
+        buff32[5] = parseInt(idSection1lengthHex.slice(8,16), 16);
+
+	//this.n32
+	buff32[6] = n8;
+
+	//prime number
+	this.instance.exports.getRawPrime();
+
+	var pos = 7;
+        for (let j=0; j<this.n32; j++) {
+	    buff32[pos+j] = this.instance.exports.readSharedRWMemory(j);
+        }
+	pos += this.n32;
+
+	// witness size
+	buff32[pos] = this.witnessSize;
+	pos++;
+
+	//id section 2
+	buff32[pos] = 2;
+	pos++;
+
+	// section 2 length
+	const idSection2length = n8*this.witnessSize;
+	const idSection2lengthHex = idSection2length.toString(16);
+        buff32[pos] = parseInt(idSection2lengthHex.slice(0,8), 16);
+        buff32[pos+1] = parseInt(idSection2lengthHex.slice(8,16), 16);
+
+	pos += 2;
+        for (let i=0; i<this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+            for (let j=0; j<this.n32; j++) {
+		buff32[pos+j] = this.instance.exports.readSharedRWMemory(j);
+            }
+	    pos += this.n32;
+        }
+
+	return buff;
+    }
+
+}
+
+
+function qualify_input_list(prefix,input,input1){
+    if (Array.isArray(input)) {
+	for (let i = 0; i<input.length; i++) {
+	    let new_prefix = prefix + "[" + i + "]";
+	    qualify_input_list(new_prefix,input[i],input1);
+	}
+    } else {
+	qualify_input(prefix,input,input1);
+    }
+}
+
+function qualify_input(prefix,input,input1) {
+    if (Array.isArray(input)) {
+	let a = flatArray(input);
+	if (a.length > 0) {
+	    let t = typeof a[0];
+	    for (let i = 1; i<a.length; i++) {
+		if (typeof a[i] != t){
+		    throw new Error(`Types are not the same in the key ${prefix}`);
+		}
+	    }
+	    if (t == "object") {
+		qualify_input_list(prefix,input,input1);
+	    } else {
+		input1[prefix] = input;
+	    }
+	} else {	    
+	    input1[prefix] = input;
+	}
+    } else if (typeof input == "object") {
+        const keys = Object.keys(input);
+	keys.forEach( (k) => {
+	    let new_prefix = prefix == ""? k : prefix + "." + k;
+	    qualify_input(new_prefix,input[k],input1);
+	});
+    } else {
+	input1[prefix] = input;
+    }
+}
+
+function toArray32(rem,size) {
+    const res = []; //new Uint32Array(size); //has no unshift
+    const radix = BigInt(0x100000000);
+    while (rem) {
+        res.unshift( Number(rem % radix));
+        rem = rem / radix;
+    }
+    if (size) {
+	var i = size - res.length;
+	while (i>0) {
+	    res.unshift(0);
+	    i--;
+	}
+    }
+    return res;
+}
+
+function fromArray32(arr) { //returns a BigInt
+    var res = BigInt(0);
+    const radix = BigInt(0x100000000);
+    for (let i = 0; i<arr.length; i++) {
+        res = res*radix + BigInt(arr[i]);
+    }
+    return res;
+}
+
+function flatArray(a) {
+    var res = [];
+    fillArray(res, a);
+    return res;
+
+    function fillArray(res, a) {
+        if (Array.isArray(a)) {
+            for (let i=0; i<a.length; i++) {
+                fillArray(res, a[i]);
+            }
+        } else {
+            res.push(a);
+        }
+    }
+}
+
+function normalize(n, prime) {
+    let res = BigInt(n) % prime;
+    if (res < 0) res += prime;
+    return res
+}
+
+function fnvHash(str) {
+    const uint64_max = BigInt(2) ** BigInt(64);
+    let hash = BigInt("0xCBF29CE484222325");
+    for (var i = 0; i < str.length; i++) {
+	hash ^= BigInt(str[i].charCodeAt());
+	hash *= BigInt(0x100000001B3);
+	hash %= uint64_max;
+    }
+    let shash = hash.toString(16);
+    let n = 16 - shash.length;
+    shash = '0'.repeat(n).concat(shash);
+    return shash;
+}
+
+var witnessCalculatorModule = /*@__PURE__*/getDefaultExportFromCjs(witness_calculator);
+
+const isNode$1 = typeof process !== 'undefined' && !!process.versions?.node;
+async function generateWitness(input, circuitWasm) {
+    let wasmBuffer;
+    let wc;
+    if (isNode$1) {
+        const fs = await import('fs');
+        const nodePath = await import('path');
+        const { fileURLToPath } = await import('url');
+        const dir = nodePath.dirname(fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href))));
+        const assetsDir = nodePath.resolve(dir, '..', 'assets');
+        wc = { default: witnessCalculatorModule };
+        if (circuitWasm) {
+            wasmBuffer = circuitWasm;
+        }
+        else {
+            const wasmPath = nodePath.resolve(assetsDir, 'main.wasm');
+            if (!fs.existsSync(wasmPath)) {
+                throw new Error(`Circuit WASM not found at ${wasmPath}. Run build.sh first.`);
+            }
+            wasmBuffer = fs.readFileSync(wasmPath);
+        }
+    }
+    else {
+        if (!circuitWasm) {
+            throw new Error('In browser, you must pass circuitWasm to PrivacyPoolSDK.init(). ' +
+                'Load the circuit WASM file via fetch() and pass the ArrayBuffer.');
+        }
+        wasmBuffer = circuitWasm;
+        wc = { default: witnessCalculatorModule };
+    }
+    const calculator = await wc.default(wasmBuffer);
+    const wtns = await calculator.calculateWTNSBin(input, 0);
+    return wtns;
+}
+
+// @ts-ignore - snarkjs types
+const isNode = typeof process !== 'undefined' && !!process.versions?.node;
+/**
+ * Normalize BufferSource to Uint8Array. Required for @iden3/binfileutils/fastfile:
+ * they read via data.buffer and data.byteOffset, which ArrayBuffer does not have.
+ */
+function toUint8Array(src) {
+    if (src instanceof Uint8Array)
+        return src;
+    if (src instanceof ArrayBuffer)
+        return new Uint8Array(src);
+    return new Uint8Array(src.buffer, src.byteOffset, src.byteLength);
+}
+async function generateProof(wtns, zkey) {
+    let zkeyData;
+    if (zkey) {
+        zkeyData = toUint8Array(zkey);
+    }
+    else if (isNode) {
+        const fs = await import('fs');
+        const nodePath = await import('path');
+        const { fileURLToPath } = await import('url');
+        const dir = nodePath.dirname(fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href))));
+        const zkeyPath = nodePath.resolve(dir, '..', 'assets', 'main_final.zkey');
+        if (!fs.existsSync(zkeyPath)) {
+            throw new Error(`Proving key not found at ${zkeyPath}. Run build.sh first.`);
+        }
+        const zkeyBuffer = fs.readFileSync(zkeyPath);
+        zkeyData = toUint8Array(zkeyBuffer);
+    }
+    else {
+        throw new Error('In browser, you must pass zkey to PrivacyPoolSDK.init(). ' +
+            'Load the zkey file via fetch() and pass the ArrayBuffer.');
+    }
+    const wtnsData = toUint8Array(wtns);
+    const { proof, publicSignals } = await snarkjs__namespace.groth16.prove({ type: 'mem', data: zkeyData }, { type: 'mem', data: wtnsData });
+    return { proof, publicSignals };
+}
+
+class PrivacyPoolSDK {
+    constructor(wasm, options) {
+        this.wasm = wasm;
+        this.options = options;
+    }
+    /**
+     * Initialize the SDK by loading WASM modules.
+     *
+     * In Node.js, assets are loaded from the filesystem automatically.
+     * In browser, pass pre-loaded buffers via options:
+     * ```ts
+     * const sdk = await PrivacyPoolSDK.init({
+     *   wasmBinary: await fetch('/pkg/client_sdk_wasm_bg.wasm').then(r => r.arrayBuffer()),
+     *   circuitWasm: await fetch('/assets/main.wasm').then(r => r.arrayBuffer()),
+     *   zkey: await fetch('/assets/main_final.zkey').then(r => r.arrayBuffer()),
+     * });
+     * ```
+     */
+    static async init(options) {
+        const opts = options ?? {};
+        const wasm = await loadWasm(opts.wasmBinary);
+        return new PrivacyPoolSDK(wasm, opts);
+    }
+    /**
+     * Generate a new coin with random nullifier and secret.
+     */
+    generateCoin() {
+        return this.wasm.generateCoin();
+    }
+    /**
+     * Generate withdrawal SNARK input from coin data and state.
+     */
+    generateWithdrawalInput(coin, state) {
+        const coinJson = JSON.stringify(coin);
+        const stateJson = JSON.stringify(state);
+        const resultJson = this.wasm.generateWithdrawalInput(coinJson, stateJson);
+        return JSON.parse(resultJson);
+    }
+    /**
+     * Convert a snarkjs proof JSON to hex bytes for Soroban.
+     */
+    proofToHex(proof) {
+        return this.wasm.proofToHex(JSON.stringify(proof));
+    }
+    /**
+     * Convert snarkjs public signals to hex bytes for Soroban.
+     */
+    publicToHex(publicSignals) {
+        return this.wasm.publicToHex(JSON.stringify(publicSignals));
+    }
+    /**
+     * Full withdrawal flow: generate input -> witness -> proof -> serialize.
+     * Returns proof_hex and public_hex ready for Soroban contract call.
+     */
+    async prepareWithdrawal(coin, state) {
+        const snarkInput = this.generateWithdrawalInput(coin, state);
+        const wtns = await generateWitness(snarkInput, this.options.circuitWasm);
+        const { proof, publicSignals } = await generateProof(wtns, this.options.zkey);
+        const proof_hex = this.proofToHex(proof);
+        const public_hex = this.publicToHex(publicSignals);
+        return { proof_hex, public_hex };
+    }
+    /**
+     * Calculate nullifier hash: Poseidon(nullifier)
+     * @param nullifier Nullifier decimal string from coin data
+     * @returns Hex string (0x...) of the hash bytes
+     */
+    calculateNullifierHash(nullifier) {
+        return this.wasm.calculateNullifierHash(nullifier);
+    }
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        printUsage();
+        process.exit(0);
+    }
+    const command = args[0];
+    if (command === 'withdraw') {
+        await handleWithdraw(args.slice(1));
+    }
+    else if (command === 'generate') {
+        await handleGenerate(args.slice(1));
+    }
+    else {
+        console.error(`Unknown command: ${command}`);
+        printUsage();
+        process.exit(1);
+    }
+    // Exit explicitly so the process doesn't hang (e.g. snarkjs workers / timers)
+    process.exit(0);
+}
+function printUsage() {
+    console.error(`Usage: client-sdk-cli <command> [options]
+
+Commands:
+  generate                         Generate a new coin
+    --output, -o <file>            Output coin to file (default: stdout)
+
+  withdraw                         Generate a withdrawal proof
+    --coin <file>                  Path to coin JSON file
+    --state <file>                 Path to state JSON file
+    --output-proof <file>          Write proof hex to file
+    --output-public <file>         Write public signals hex to file
+
+Output (withdraw):
+  Prints proof_hex on first line and public_hex on second line to stdout.
+`);
+}
+function parseArgs(args) {
+    const parsed = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            const value = args[i + 1];
+            if (value && !value.startsWith('--')) {
+                parsed[key] = value;
+                i++;
+            }
+            else {
+                parsed[key] = 'true';
+            }
+        }
+        else if (arg === '-o' && i + 1 < args.length) {
+            parsed['output'] = args[++i];
+        }
+    }
+    return parsed;
+}
+async function handleGenerate(args) {
+    const parsed = parseArgs(args);
+    const sdk = await PrivacyPoolSDK.init();
+    const coin = sdk.generateCoin();
+    const json = JSON.stringify(coin, null, 2);
+    if (parsed['output']) {
+        fs__namespace.writeFileSync(parsed['output'], json);
+        console.error(`Coin saved to: ${parsed['output']}`);
+        console.error(`Commitment: ${coin.commitment_hex}`);
+    }
+    else {
+        console.log(json);
+    }
+}
+async function handleWithdraw(args) {
+    const parsed = parseArgs(args);
+    if (!parsed['coin']) {
+        console.error('Error: --coin <file> is required');
+        process.exit(1);
+    }
+    if (!parsed['state']) {
+        console.error('Error: --state <file> is required');
+        process.exit(1);
+    }
+    const coinFile = JSON.parse(fs__namespace.readFileSync(parsed['coin'], 'utf-8'));
+    const coin = coinFile.coin || coinFile;
+    const state = JSON.parse(fs__namespace.readFileSync(parsed['state'], 'utf-8'));
+    const sdk = await PrivacyPoolSDK.init();
+    const result = await sdk.prepareWithdrawal(coin, state);
+    // Output proof and public hex to stdout (newline-separated)
+    console.log(result.proof_hex);
+    console.log(result.public_hex);
+    // Optionally write to files
+    if (parsed['output-proof']) {
+        fs__namespace.writeFileSync(parsed['output-proof'], result.proof_hex);
+        console.error(`Proof written to: ${parsed['output-proof']}`);
+    }
+    if (parsed['output-public']) {
+        fs__namespace.writeFileSync(parsed['output-public'], result.public_hex);
+        console.error(`Public signals written to: ${parsed['output-public']}`);
+    }
+}
+main().catch((err) => {
+    console.error('Error:', err.message || err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map