merkle-tree-poseidon-sdk 1.0.0

package/.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Run tests
+        run: npm test
+
+      - name: Build
+        run: npm run build

package/.github/workflows/publish.yml

@@ -0,0 +1,19 @@
+name: Publish to NPM
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          registry-url: "https://registry.npmjs.org"
+      - run: npm install
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1,75 @@
+# Merkle Tree Poseidon SDK
+
+A TypeScript SDK for generating Merkle Tree proofs and selective disclosure inputs compatible with Poseidon-based Circom circuits.
+
+This SDK is the companion to the official [HARA-ORG/circom-zk](https://github.com/HARA-ORG/circom-zk) repository, which contains the Circom circuit implementations and verification keys.
+
+## Features
+
+- **Poseidon Hashing**: Uses `circomlibjs` for Snark-friendly hashing on the BN254 curve.
+- **Merkle Tree Proofs**: Generates inclusion proofs for a fixed-depth (8) Merkle Tree.
+- **Selective Disclosure**: Supports generating proof inputs for:
+  - **Numeric/Date Claims**: Proves that a value is greater than or equal to a threshold (e.g., age verification).
+  - **String Claims**: Proves equality to a known value without revealing the value itself (using Poseidon hashes).
+- **Identity Binding**: Binds credentials to a public commitment (e.g., a wallet address).
+
+## Project Structure
+
+```text
+src/
+├── core/           # Low-level primitives (Poseidon, Merkle, Encoding)
+├── sdk/            # Main SDK interface
+└── index.ts        # Library entry point
+tests/
+└── sdk.test.ts     # Logic simulation (mirrors Circom constraints)
+```
+
+## Installation
+
+```bash
+npm install
+```
+
+## Scripts
+
+### Run Logic Simulation
+
+Verifies the SDK's logic against a TypeScript implementation of the `SelectiveDisclosure.circom` constraints.
+
+```bash
+npm test
+```
+
+### Build SDK
+
+Compiles TypeScript into the `dist/` directory.
+
+```bash
+npm run build
+```
+
+## Usage Example
+
+```typescript
+import { ZkIdentitySDK } from "merkle-tree-poseidon-sdk";
+
+// 1. Define fields
+const fields = [{ label: "credit_score", type: "number", value: 750 }];
+
+// 2. Initialize SDK and build tree with a salt
+const sdk = new ZkIdentitySDK(fields);
+const salt = BigInt(123456);
+await sdk.build(salt);
+
+// 3. Generate input for SelectiveDisclosure circuit
+const proofInput = await sdk.generateProofInput({
+  label: "credit_score",
+  identitySecret: BigInt("0x..."),
+  publicCommitment: BigInt("0x..."),
+  threshold: 700n,
+});
+```
+
+## License
+
+MIT

package/dist/core/fields.d.ts

@@ -0,0 +1,16 @@
+export type FieldElement = bigint;
+export declare const CredentialType: {
+    readonly TEXT: 0n;
+    readonly EMAIL: 1n;
+    readonly NUMBER: 2n;
+    readonly DATE: 3n;
+    readonly ATTACHMENT: 4n;
+    readonly LONG_TEXT: 5n;
+};
+export interface CredentialField {
+    key: FieldElement;
+    typ: FieldElement;
+    value: FieldElement;
+}
+export declare function stringToField(input: string): FieldElement;
+export declare function dateToField(dateStr: string): FieldElement;

package/dist/core/fields.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredentialType = void 0;
+exports.stringToField = stringToField;
+exports.dateToField = dateToField;
+const crypto_1 = require("crypto");
+exports.CredentialType = {
+    TEXT: 0n,
+    EMAIL: 1n,
+    NUMBER: 2n,
+    DATE: 3n,
+    ATTACHMENT: 4n,
+    LONG_TEXT: 5n,
+};
+function stringToField(input) {
+    const BN254_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+    const bytes = Buffer.from(input, "utf8");
+    if (bytes.length <= 30) {
+        return BigInt("0x" + bytes.toString("hex")) % BN254_PRIME;
+    }
+    const digest = (0, crypto_1.createHash)("sha256").update(bytes).digest();
+    digest[0] &= 0x1f; // 253-bit truncation
+    return BigInt("0x" + digest.toString("hex")) % BN254_PRIME;
+}
+function dateToField(dateStr) {
+    const clean = dateStr.replace(/-/g, "");
+    if (!/^\d{8}$/.test(clean))
+        throw new Error(`Invalid date: ${dateStr}`);
+    return BigInt(clean);
+}

package/dist/core/poseidon.d.ts

@@ -0,0 +1,9 @@
+import { FieldElement } from "./fields";
+declare class PoseidonHasher {
+    private poseidon;
+    private F;
+    init(): Promise<void>;
+    hash(inputs: FieldElement[]): FieldElement;
+}
+export declare const poseidonHasher: PoseidonHasher;
+export {};

package/dist/core/poseidon.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.poseidonHasher = void 0;
+const circomlibjs_1 = require("circomlibjs");
+class PoseidonHasher {
+    constructor() {
+        this.poseidon = null;
+        this.F = null;
+    }
+    async init() {
+        if (!this.poseidon) {
+            this.poseidon = await (0, circomlibjs_1.buildPoseidon)();
+            this.F = this.poseidon.F;
+        }
+    }
+    hash(inputs) {
+        if (!this.poseidon)
+            throw new Error("Call init() first");
+        return this.F.toObject(this.poseidon(inputs.map((x) => this.F.e(x))));
+    }
+}
+exports.poseidonHasher = new PoseidonHasher();

package/dist/core/tree.d.ts

@@ -0,0 +1,15 @@
+import { FieldElement } from "./fields";
+export declare class MerkleTree {
+    private leaves;
+    private zeroLeaf;
+    private layers;
+    constructor();
+    init(zeroInputs?: FieldElement[]): Promise<void>;
+    setLeaf(index: number, leaf: FieldElement): void;
+    build(): bigint;
+    get root(): FieldElement;
+    generateProof(index: number): {
+        pathElements: FieldElement[];
+        pathIndices: number[];
+    };
+}

package/dist/core/tree.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleTree = void 0;
+const poseidon_1 = require("./poseidon");
+const TREE_DEPTH = 8;
+const TREE_SIZE = 2 ** TREE_DEPTH; // 256
+class MerkleTree {
+    constructor() {
+        this.leaves = [];
+        this.layers = [];
+    }
+    async init(zeroInputs = [0n, 0n, 0n, 0n]) {
+        await poseidon_1.poseidonHasher.init();
+        this.zeroLeaf = poseidon_1.poseidonHasher.hash(zeroInputs);
+        this.leaves = new Array(TREE_SIZE).fill(this.zeroLeaf);
+    }
+    setLeaf(index, leaf) {
+        if (index < 0 || index >= TREE_SIZE)
+            throw new Error("Index out of bounds");
+        this.leaves[index] = leaf;
+        this.layers = []; // invalidate cache
+    }
+    build() {
+        this.layers = [this.leaves.slice()];
+        let current = this.leaves.slice();
+        for (let d = 0; d < TREE_DEPTH; d++) {
+            const next = [];
+            for (let i = 0; i < current.length; i += 2) {
+                next.push(poseidon_1.poseidonHasher.hash([current[i], current[i + 1]]));
+            }
+            this.layers.push(next);
+            current = next;
+        }
+        return current[0];
+    }
+    get root() {
+        if (this.layers.length === 0)
+            this.build();
+        return this.layers[TREE_DEPTH][0];
+    }
+    generateProof(index) {
+        if (this.layers.length === 0)
+            this.build();
+        const pathElements = [];
+        const pathIndices = [];
+        let cur = index;
+        for (let d = 0; d < TREE_DEPTH; d++) {
+            const isRight = cur % 2 === 1;
+            pathIndices.push(isRight ? 1 : 0);
+            pathElements.push(this.layers[d][isRight ? cur - 1 : cur + 1]);
+            cur = Math.floor(cur / 2);
+        }
+        return { pathElements, pathIndices };
+    }
+}
+exports.MerkleTree = MerkleTree;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./sdk/index";
+export * from "./core/poseidon";
+export * from "./core/fields";
+export * from "./core/tree";

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sdk/index"), exports);
+__exportStar(require("./core/poseidon"), exports);
+__exportStar(require("./core/fields"), exports);
+__exportStar(require("./core/tree"), exports);

package/dist/sdk/index.d.ts

@@ -0,0 +1,45 @@
+import { FieldElement } from "../core/fields";
+export interface UserField {
+    label: string;
+    type: "text" | "email" | "number" | "date" | "attachment" | "long_text";
+    value: string | number | bigint;
+    required?: boolean;
+}
+export interface SDKProofInput {
+    key: string;
+    typ: string;
+    value: string;
+    salt: string;
+    pathElements: string[];
+    pathIndices: number[];
+    identitySecret: string;
+    credentialRoot: string;
+    publicCommitment: string;
+    threshold: string;
+    expectedValueHash: string;
+}
+export declare class ZkIdentitySDK {
+    private tree;
+    private fields;
+    private salt;
+    constructor(fields: UserField[]);
+    /**
+     * Encodes a user-friendly field value into a BN254 field element.
+     */
+    private encodeValue;
+    /**
+     * Builds the Merkle Tree using the provided salt.
+     * Indices are auto-generated based on the order in the constructor.
+     */
+    build(salt: FieldElement): Promise<FieldElement>;
+    get root(): FieldElement;
+    /**
+     * Generates the input for a ZK proof for a specific field (by label).
+     */
+    generateProofInput(params: {
+        label: string;
+        identitySecret: FieldElement;
+        publicCommitment: FieldElement;
+        threshold?: FieldElement;
+    }): Promise<SDKProofInput>;
+}

package/dist/sdk/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZkIdentitySDK = void 0;
+const tree_1 = require("../core/tree");
+const poseidon_1 = require("../core/poseidon");
+const fields_1 = require("../core/fields");
+class ZkIdentitySDK {
+    constructor(fields) {
+        this.salt = null;
+        this.fields = fields;
+        this.tree = new tree_1.MerkleTree();
+    }
+    /**
+     * Encodes a user-friendly field value into a BN254 field element.
+     */
+    encodeValue(type, value) {
+        if (typeof value === "bigint")
+            return value;
+        if (typeof value === "number")
+            return BigInt(value);
+        switch (type) {
+            case "date":
+                return (0, fields_1.dateToField)(value);
+            case "number":
+                return BigInt(value);
+            default:
+                return (0, fields_1.stringToField)(value);
+        }
+    }
+    /**
+     * Builds the Merkle Tree using the provided salt.
+     * Indices are auto-generated based on the order in the constructor.
+     */
+    async build(salt) {
+        this.salt = salt;
+        await this.tree.init();
+        for (let i = 0; i < this.fields.length; i++) {
+            const field = this.fields[i];
+            const key = (0, fields_1.stringToField)(field.label);
+            const typ = fields_1.CredentialType[field.type.toUpperCase()];
+            const val = this.encodeValue(field.type, field.value);
+            // leaf = Poseidon(key, typ, value, salt)
+            const leaf = poseidon_1.poseidonHasher.hash([key, typ, val, salt]);
+            this.tree.setLeaf(i, leaf);
+        }
+        return this.tree.build();
+    }
+    get root() {
+        return this.tree.root;
+    }
+    /**
+     * Generates the input for a ZK proof for a specific field (by label).
+     */
+    async generateProofInput(params) {
+        if (this.salt === null)
+            throw new Error("Call build(salt) first");
+        const index = this.fields.findIndex(f => f.label === params.label);
+        if (index === -1)
+            throw new Error(`Field with label "${params.label}" not found`);
+        const field = this.fields[index];
+        const key = (0, fields_1.stringToField)(field.label);
+        const typ = fields_1.CredentialType[field.type.toUpperCase()];
+        const val = this.encodeValue(field.type, field.value);
+        const { pathElements, pathIndices } = this.tree.generateProof(index);
+        // Compute expectedValueHash for string/equality types
+        let expectedValueHash = 0n;
+        const isNumeric = field.type === "number" || field.type === "date";
+        if (!isNumeric) {
+            expectedValueHash = poseidon_1.poseidonHasher.hash([val]);
+        }
+        return {
+            key: key.toString(),
+            typ: typ.toString(),
+            value: val.toString(),
+            salt: this.salt.toString(),
+            pathElements: pathElements.map(x => x.toString()),
+            pathIndices,
+            identitySecret: params.identitySecret.toString(),
+            credentialRoot: this.tree.root.toString(),
+            publicCommitment: params.publicCommitment.toString(),
+            threshold: (params.threshold ?? 0n).toString(),
+            expectedValueHash: expectedValueHash.toString(),
+        };
+    }
+}
+exports.ZkIdentitySDK = ZkIdentitySDK;

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "merkle-tree-poseidon-sdk",
+  "version": "1.0.0",
+  "author": "ardial@hara.ag",
+  "description": "TypeScript SDK for Merkle Tree and Poseidon Selective Disclosure",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "ts-node -T tests/sdk.test.ts",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "dependencies": {
+    "circomlibjs": "^0.1.7",
+    "merkletreejs": "^0.3.11",
+    "snarkjs": "^0.7.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}

package/src/core/fields.ts

@@ -0,0 +1,35 @@
+import { createHash } from "crypto";
+
+export type FieldElement = bigint;
+
+export const CredentialType = {
+    TEXT: 0n,
+    EMAIL: 1n,
+    NUMBER: 2n,
+    DATE: 3n,
+    ATTACHMENT: 4n,
+    LONG_TEXT: 5n,
+} as const;
+
+export interface CredentialField {
+    key: FieldElement;    // Numeric label identifier
+    typ: FieldElement;    // CredentialType value
+    value: FieldElement;  // The credential value
+}
+
+export function stringToField(input: string): FieldElement {
+    const BN254_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+    const bytes = Buffer.from(input, "utf8");
+    if (bytes.length <= 30) {
+        return BigInt("0x" + bytes.toString("hex")) % BN254_PRIME;
+    }
+    const digest = createHash("sha256").update(bytes).digest();
+    digest[0] &= 0x1f; // 253-bit truncation
+    return BigInt("0x" + digest.toString("hex")) % BN254_PRIME;
+}
+
+export function dateToField(dateStr: string): FieldElement {
+    const clean = dateStr.replace(/-/g, "");
+    if (!/^\d{8}$/.test(clean)) throw new Error(`Invalid date: ${dateStr}`);
+    return BigInt(clean);
+}

package/src/core/poseidon.ts

@@ -0,0 +1,21 @@
+import { buildPoseidon } from "circomlibjs";
+import { FieldElement } from "./fields";
+
+class PoseidonHasher {
+    private poseidon: any = null;
+    private F: any = null;
+
+    async init() {
+        if (!this.poseidon) {
+            this.poseidon = await buildPoseidon();
+            this.F = this.poseidon.F;
+        }
+    }
+
+    hash(inputs: FieldElement[]): FieldElement {
+        if (!this.poseidon) throw new Error("Call init() first");
+        return this.F.toObject(this.poseidon(inputs.map((x) => this.F.e(x)))) as bigint;
+    }
+}
+
+export const poseidonHasher = new PoseidonHasher();

package/src/core/tree.ts

@@ -0,0 +1,62 @@
+import { poseidonHasher } from "./poseidon";
+import { FieldElement } from "./fields";
+
+const TREE_DEPTH = 8;
+const TREE_SIZE = 2 ** TREE_DEPTH; // 256
+
+export class MerkleTree {
+    private leaves: FieldElement[] = [];
+    private zeroLeaf!: FieldElement;
+    private layers: FieldElement[][] = [];
+
+    constructor() { }
+
+    async init(zeroInputs: FieldElement[] = [0n, 0n, 0n, 0n]) {
+        await poseidonHasher.init();
+        this.zeroLeaf = poseidonHasher.hash(zeroInputs);
+        this.leaves = new Array(TREE_SIZE).fill(this.zeroLeaf);
+    }
+
+    setLeaf(index: number, leaf: FieldElement) {
+        if (index < 0 || index >= TREE_SIZE) throw new Error("Index out of bounds");
+        this.leaves[index] = leaf;
+        this.layers = []; // invalidate cache
+    }
+
+    build() {
+        this.layers = [this.leaves.slice()];
+        let current = this.leaves.slice();
+
+        for (let d = 0; d < TREE_DEPTH; d++) {
+            const next: FieldElement[] = [];
+            for (let i = 0; i < current.length; i += 2) {
+                next.push(poseidonHasher.hash([current[i], current[i + 1]]));
+            }
+            this.layers.push(next);
+            current = next;
+        }
+        return current[0];
+    }
+
+    get root(): FieldElement {
+        if (this.layers.length === 0) this.build();
+        return this.layers[TREE_DEPTH][0];
+    }
+
+    generateProof(index: number): { pathElements: FieldElement[]; pathIndices: number[] } {
+        if (this.layers.length === 0) this.build();
+
+        const pathElements: FieldElement[] = [];
+        const pathIndices: number[] = [];
+        let cur = index;
+
+        for (let d = 0; d < TREE_DEPTH; d++) {
+            const isRight = cur % 2 === 1;
+            pathIndices.push(isRight ? 1 : 0);
+            pathElements.push(this.layers[d][isRight ? cur - 1 : cur + 1]);
+            cur = Math.floor(cur / 2);
+        }
+
+        return { pathElements, pathIndices };
+    }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./sdk/index";
+export * from "./core/poseidon";
+export * from "./core/fields";
+export * from "./core/tree";

package/src/sdk/index.ts

@@ -0,0 +1,126 @@
+import { MerkleTree } from "../core/tree";
+import { poseidonHasher } from "../core/poseidon";
+import {
+    stringToField,
+    dateToField,
+    CredentialType,
+    FieldElement
+} from "../core/fields";
+
+export interface UserField {
+    label: string;
+    type: "text" | "email" | "number" | "date" | "attachment" | "long_text";
+    value: string | number | bigint;
+    required?: boolean;
+}
+
+export interface SDKProofInput {
+    key: string;
+    typ: string;
+    value: string;
+    salt: string;
+    pathElements: string[];
+    pathIndices: number[];
+    identitySecret: string;
+    credentialRoot: string;
+    publicCommitment: string;
+    threshold: string;
+    expectedValueHash: string;
+}
+
+export class ZkIdentitySDK {
+    private tree: MerkleTree;
+    private fields: UserField[];
+    private salt: FieldElement | null = null;
+
+    constructor(fields: UserField[]) {
+        this.fields = fields;
+        this.tree = new MerkleTree();
+    }
+
+    /**
+     * Encodes a user-friendly field value into a BN254 field element.
+     */
+    private encodeValue(type: string, value: any): FieldElement {
+        if (typeof value === "bigint") return value;
+        if (typeof value === "number") return BigInt(value);
+
+        switch (type) {
+            case "date":
+                return dateToField(value);
+            case "number":
+                return BigInt(value);
+            default:
+                return stringToField(value);
+        }
+    }
+
+    /**
+     * Builds the Merkle Tree using the provided salt.
+     * Indices are auto-generated based on the order in the constructor.
+     */
+    async build(salt: FieldElement): Promise<FieldElement> {
+        this.salt = salt;
+        await this.tree.init();
+
+        for (let i = 0; i < this.fields.length; i++) {
+            const field = this.fields[i];
+            const key = stringToField(field.label);
+            const typ = CredentialType[field.type.toUpperCase() as keyof typeof CredentialType];
+            const val = this.encodeValue(field.type, field.value);
+
+            // leaf = Poseidon(key, typ, value, salt)
+            const leaf = poseidonHasher.hash([key, typ, val, salt]);
+            this.tree.setLeaf(i, leaf);
+        }
+
+        return this.tree.build();
+    }
+
+    get root(): FieldElement {
+        return this.tree.root;
+    }
+
+    /**
+     * Generates the input for a ZK proof for a specific field (by label).
+     */
+    async generateProofInput(params: {
+        label: string;
+        identitySecret: FieldElement;
+        publicCommitment: FieldElement;
+        threshold?: FieldElement;
+    }): Promise<SDKProofInput> {
+        if (this.salt === null) throw new Error("Call build(salt) first");
+
+        const index = this.fields.findIndex(f => f.label === params.label);
+        if (index === -1) throw new Error(`Field with label "${params.label}" not found`);
+
+        const field = this.fields[index];
+        const key = stringToField(field.label);
+        const typ = CredentialType[field.type.toUpperCase() as keyof typeof CredentialType];
+        const val = this.encodeValue(field.type, field.value);
+
+        const { pathElements, pathIndices } = this.tree.generateProof(index);
+
+        // Compute expectedValueHash for string/equality types
+        let expectedValueHash = 0n;
+        const isNumeric = field.type === "number" || field.type === "date";
+        if (!isNumeric) {
+            expectedValueHash = poseidonHasher.hash([val]);
+        }
+
+        return {
+            key: key.toString(),
+            typ: typ.toString(),
+            value: val.toString(),
+            salt: this.salt.toString(),
+            pathElements: pathElements.map(x => x.toString()),
+            pathIndices,
+            identitySecret: params.identitySecret.toString(),
+            credentialRoot: this.tree.root.toString(),
+            publicCommitment: params.publicCommitment.toString(),
+            threshold: (params.threshold ?? 0n).toString(),
+            expectedValueHash: expectedValueHash.toString(),
+        };
+    }
+}

package/src/types.d.ts

@@ -0,0 +1 @@
+declare module 'circomlibjs';

package/tests/sdk.test.ts

@@ -0,0 +1,136 @@
+import { ZkIdentitySDK } from "../src/sdk";
+import { poseidonHasher } from "../src/core/poseidon";
+import { createHash } from "crypto";
+import { CredentialType, stringToField } from "../src/core/fields";
+
+async function runSimulation() {
+    console.log("━━━ SDK Logic Simulation (Circom Logic) ━━━\n");
+
+    // Initialize Poseidon
+    await poseidonHasher.init();
+
+    // 1. Setup Prover state
+    const identitySecret = BigInt("0x" + createHash("sha256").update("alice-secret-key").digest("hex"));
+    const publicCommitment = poseidonHasher.hash([identitySecret]);
+
+    const fields = [
+        { label: "full_name", type: "text" as const, value: "Alice Wanderer" },
+        { label: "email", type: "email" as const, value: "alice@example.com" },
+        { label: "credit_score", type: "number" as const, value: 750 },
+        { label: "Expiry Date", type: "date" as const, value: "2026-12-31" }
+    ];
+
+    const sdk = new ZkIdentitySDK(fields);
+    const salt = BigInt(987654321);
+    const root = await sdk.build(salt);
+
+    console.log("Prover state initialized.");
+    console.log(`Merkle Root: ${root}`);
+    console.log(`Public Commitment: ${publicCommitment}\n`);
+
+    // 2. Simulate Selective Disclosure for "credit_score" (Numeric)
+    console.log("--- Simulating Numeric Disclosure (credit_score >= 700) ---");
+    const threshold = 700n;
+    const numericInput = await sdk.generateProofInput({
+        label: "credit_score",
+        identitySecret,
+        publicCommitment,
+        threshold
+    });
+
+    // Simulated Circuit Verification Logic
+    const isVerifiedNumeric = await simulateCircuit(numericInput);
+    console.log(`Simulation Result: ${isVerifiedNumeric ? "✅ PASSED" : "❌ FAILED"}\n`);
+
+    // 3. Simulate Selective Disclosure for "email" (String Equality)
+    console.log("--- Simulating String Equality Disclosure (email) ---");
+    const emailInput = await sdk.generateProofInput({
+        label: "email",
+        identitySecret,
+        publicCommitment
+    });
+
+    // Simulated Circuit Verification Logic
+    const isVerifiedString = await simulateCircuit(emailInput);
+    console.log(`Simulation Result: ${isVerifiedString ? "✅ PASSED" : "❌ FAILED"}\n`);
+
+    console.log("━━━ All Simulations Complete ━━━");
+}
+
+/**
+ * Simulates the SelectiveDisclosure.circom logic in TypeScript.
+ */
+async function simulateCircuit(input: any): Promise<boolean> {
+    const {
+        key,
+        typ,
+        value,
+        salt,
+        pathElements,
+        pathIndices,
+        identitySecret,
+        credentialRoot,
+        publicCommitment,
+        threshold,
+        expectedValueHash
+    } = input;
+
+    const bKey = BigInt(key);
+    const bTyp = BigInt(typ);
+    const bValue = BigInt(value);
+    const bSalt = BigInt(salt);
+    const bIdentitySecret = BigInt(identitySecret);
+    const bCredentialRoot = BigInt(credentialRoot);
+    const bPublicCommitment = BigInt(publicCommitment);
+    const bThreshold = BigInt(threshold);
+    const bExpectedValueHash = BigInt(expectedValueHash);
+
+    // 1. IDENTITY BINDING
+    const computedCommitment = poseidonHasher.hash([bIdentitySecret]);
+    if (computedCommitment !== bPublicCommitment) {
+        console.error("❌ Simulation: Identity Binding failed");
+        return false;
+    }
+
+    // 2. LEAF CONSTRUCTION
+    const leaf = poseidonHasher.hash([bKey, bTyp, bValue, bSalt]);
+
+    // 3. MERKLE ROOT VERIFICATION
+    let current = leaf;
+    for (let i = 0; i < pathElements.length; i++) {
+        const element = BigInt(pathElements[i]);
+        const index = pathIndices[i];
+        if (index === 0) {
+            current = poseidonHasher.hash([current, element]);
+        } else {
+            current = poseidonHasher.hash([element, current]);
+        }
+    }
+
+    if (current !== bCredentialRoot) {
+        console.error("❌ Simulation: Merkle Proof failed");
+        return false;
+    }
+
+    // 4. TYPE ROUTING
+    const isNumeric = bTyp === 2n || bTyp === 3n; // NUMBER=2, DATE=3
+
+    if (isNumeric) {
+        // 4a. NUMERIC CHECK
+        if (bValue < bThreshold) {
+            console.error(`❌ Simulation: Numeric check failed (${bValue} < ${bThreshold})`);
+            return false;
+        }
+    } else {
+        // 4b. HASH EQUALITY CHECK
+        const valueHash = poseidonHasher.hash([bValue]);
+        if (valueHash !== bExpectedValueHash) {
+            console.error("❌ Simulation: Hash equality failed");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+runSimulation().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}