@zentity/fhevm-contracts 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,459 @@
+/**
+ * @zentity/fhevm-contracts
+ *
+ * fhEVM smart contracts for privacy-preserving identity attestations
+ */
+export declare const CONTRACT_NAMES: readonly ["IdentityRegistry", "ComplianceRules", "CompliantERC20"];
+export type ContractName = (typeof CONTRACT_NAMES)[number];
+export type ContractAddresses = {
+    IdentityRegistry: string;
+    ComplianceRules: string;
+    CompliantERC20: string;
+};
+export type DeploymentManifest = {
+    network: string;
+    chainId: number;
+    deployedAt?: string;
+    deployer?: string;
+    contracts: Record<ContractName, {
+        address: string;
+        txHash?: string;
+    }>;
+};
+export declare const CHAIN_ID_BY_NETWORK: {
+    readonly hardhat: 31337;
+    readonly localhost: 31337;
+    readonly sepolia: 11155111;
+};
+export type NetworkName = keyof typeof CHAIN_ID_BY_NETWORK;
+export type ChainId = (typeof CHAIN_ID_BY_NETWORK)[NetworkName];
+export declare const DEPLOYMENTS: Partial<Record<NetworkName, DeploymentManifest>>;
+export declare const ADDRESSES: {
+    readonly hardhat: {
+        readonly IdentityRegistry: string;
+        readonly ComplianceRules: string;
+        readonly CompliantERC20: string;
+    };
+    readonly localhost: {
+        readonly IdentityRegistry: string;
+        readonly ComplianceRules: string;
+        readonly CompliantERC20: string;
+    };
+};
+export declare const ABIS: {
+    readonly IdentityRegistry: ({
+        inputs: never[];
+        stateMutability: string;
+        type: string;
+        name?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: never[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
+    readonly ComplianceRules: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        name?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: never[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
+    readonly CompliantERC20: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        name?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: never[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
+};
+export type AbiMap = typeof ABIS;
+export declare function getAbi(name: ContractName): ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: never[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[] | ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: never[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[] | ({
+    inputs: never[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: never[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+export declare const IdentityRegistryABI: ({
+    inputs: never[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: never[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+export declare const ComplianceRulesABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: never[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+export declare const CompliantERC20ABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: never[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+export declare function getDeployment(network: NetworkName): DeploymentManifest;
+export declare function hasDeployment(network: NetworkName): boolean;
+export declare function isNetworkName(value: string): value is NetworkName;
+export declare function getNetworkNames(chainId: number): NetworkName[];
+export declare function getNetworkName(chainId: number, prefer?: NetworkName): NetworkName;
+export declare function getContractAddresses(networkOrChainId: NetworkName | number, options?: {
+    prefer?: NetworkName;
+    overrides?: Partial<ContractAddresses>;
+}): ContractAddresses;
+export declare function resolveContractAddresses(networkOrChainId: NetworkName | number, options?: {
+    prefer?: NetworkName;
+    overrides?: Partial<ContractAddresses>;
+}): ContractAddresses;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * @zentity/fhevm-contracts
+ *
+ * fhEVM smart contracts for privacy-preserving identity attestations
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompliantERC20ABI = exports.ComplianceRulesABI = exports.IdentityRegistryABI = exports.ABIS = exports.ADDRESSES = exports.DEPLOYMENTS = exports.CHAIN_ID_BY_NETWORK = exports.CONTRACT_NAMES = void 0;
+exports.getAbi = getAbi;
+exports.getDeployment = getDeployment;
+exports.hasDeployment = hasDeployment;
+exports.isNetworkName = isNetworkName;
+exports.getNetworkNames = getNetworkNames;
+exports.getNetworkName = getNetworkName;
+exports.getContractAddresses = getContractAddresses;
+exports.resolveContractAddresses = resolveContractAddresses;
+const ComplianceRules_json_1 = __importDefault(require("../abi/ComplianceRules.json"));
+const CompliantERC20_json_1 = __importDefault(require("../abi/CompliantERC20.json"));
+const IdentityRegistry_json_1 = __importDefault(require("../abi/IdentityRegistry.json"));
+const addresses_json_1 = __importDefault(require("../deployments/hardhat/addresses.json"));
+const ComplianceRules_json_2 = __importDefault(require("../deployments/localhost/ComplianceRules.json"));
+const CompliantERC20_json_2 = __importDefault(require("../deployments/localhost/CompliantERC20.json"));
+const IdentityRegistry_json_2 = __importDefault(require("../deployments/localhost/IdentityRegistry.json"));
+exports.CONTRACT_NAMES = ["IdentityRegistry", "ComplianceRules", "CompliantERC20"];
+const hardhatAddresses = addresses_json_1.default;
+exports.CHAIN_ID_BY_NETWORK = {
+    hardhat: 31337,
+    localhost: 31337,
+    sepolia: 11155111,
+};
+exports.DEPLOYMENTS = {
+    hardhat: {
+        network: hardhatAddresses.network ?? "hardhat",
+        chainId: hardhatAddresses.chainId ?? exports.CHAIN_ID_BY_NETWORK.hardhat,
+        deployedAt: hardhatAddresses.deployedAt,
+        deployer: hardhatAddresses.deployer,
+        contracts: {
+            IdentityRegistry: hardhatAddresses.contracts.IdentityRegistry,
+            ComplianceRules: hardhatAddresses.contracts.ComplianceRules,
+            CompliantERC20: hardhatAddresses.contracts.CompliantERC20,
+        },
+    },
+    localhost: {
+        network: "localhost",
+        chainId: exports.CHAIN_ID_BY_NETWORK.localhost,
+        contracts: {
+            IdentityRegistry: {
+                address: IdentityRegistry_json_2.default.address,
+            },
+            ComplianceRules: {
+                address: ComplianceRules_json_2.default.address,
+            },
+            CompliantERC20: {
+                address: CompliantERC20_json_2.default.address,
+            },
+        },
+    },
+};
+exports.ADDRESSES = {
+    hardhat: {
+        IdentityRegistry: hardhatAddresses.contracts.IdentityRegistry.address,
+        ComplianceRules: hardhatAddresses.contracts.ComplianceRules.address,
+        CompliantERC20: hardhatAddresses.contracts.CompliantERC20.address,
+    },
+    localhost: {
+        IdentityRegistry: IdentityRegistry_json_2.default.address,
+        ComplianceRules: ComplianceRules_json_2.default.address,
+        CompliantERC20: CompliantERC20_json_2.default.address,
+    },
+};
+exports.ABIS = {
+    IdentityRegistry: IdentityRegistry_json_1.default,
+    ComplianceRules: ComplianceRules_json_1.default,
+    CompliantERC20: CompliantERC20_json_1.default,
+};
+function getAbi(name) {
+    return exports.ABIS[name];
+}
+exports.IdentityRegistryABI = IdentityRegistry_json_1.default;
+exports.ComplianceRulesABI = ComplianceRules_json_1.default;
+exports.CompliantERC20ABI = CompliantERC20_json_1.default;
+function getDeployment(network) {
+    const deployment = exports.DEPLOYMENTS[network];
+    if (!deployment) {
+        throw new Error(`No deployments found for network "${network}". Deploy contracts and add deployments/${network}/*.json.`);
+    }
+    return deployment;
+}
+function hasDeployment(network) {
+    return Boolean(exports.DEPLOYMENTS[network]);
+}
+function isNetworkName(value) {
+    return value in exports.CHAIN_ID_BY_NETWORK;
+}
+function getNetworkNames(chainId) {
+    return Object.keys(exports.CHAIN_ID_BY_NETWORK).filter((name) => exports.CHAIN_ID_BY_NETWORK[name] === chainId);
+}
+function getNetworkName(chainId, prefer) {
+    const matches = getNetworkNames(chainId);
+    if (matches.length === 0) {
+        throw new Error(`No network mapped for chainId ${chainId}`);
+    }
+    if (prefer && matches.includes(prefer))
+        return prefer;
+    return matches[0];
+}
+function getContractAddresses(networkOrChainId, options) {
+    const network = typeof networkOrChainId === "number"
+        ? getNetworkName(networkOrChainId, options?.prefer)
+        : networkOrChainId;
+    const deployment = getDeployment(network);
+    const base = {
+        IdentityRegistry: deployment.contracts.IdentityRegistry.address,
+        ComplianceRules: deployment.contracts.ComplianceRules.address,
+        CompliantERC20: deployment.contracts.CompliantERC20.address,
+    };
+    return { ...base, ...(options?.overrides ?? {}) };
+}
+function resolveContractAddresses(networkOrChainId, options) {
+    const network = typeof networkOrChainId === "number"
+        ? getNetworkName(networkOrChainId, options?.prefer)
+        : networkOrChainId;
+    if (hasDeployment(network)) {
+        return getContractAddresses(network, options);
+    }
+    const overrides = options?.overrides ?? {};
+    const missing = exports.CONTRACT_NAMES.filter((name) => !overrides[name]);
+    if (missing.length > 0) {
+        throw new Error(`No deployment found for "${network}". Provide overrides for: ${missing.join(", ")}.`);
+    }
+    return overrides;
+}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@zentity/fhevm-contracts",
+  "version": "0.1.0",
+  "description": "fhEVM smart contracts for Zentity privacy-preserving identity attestations",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "abi/",
+    "contracts/",
+    "deployments/",
+    "dist/",
+    "typechain-types/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./abi": {
+      "types": "./abi/index.d.ts",
+      "default": "./abi/index.js"
+    },
+    "./abi/IdentityRegistry": "./abi/IdentityRegistry.json",
+    "./abi/ComplianceRules": "./abi/ComplianceRules.json",
+    "./abi/CompliantERC20": "./abi/CompliantERC20.json",
+    "./deployments/*": "./deployments/*",
+    "./typechain-types": "./typechain-types/index.ts"
+  },
+  "scripts": {
+    "compile": "hardhat compile",
+    "test": "hardhat test",
+    "test:mocked": "HARDHAT_NETWORK=hardhat hardhat test",
+    "test:local": "hardhat test --network localhost",
+    "test:sepolia": "hardhat test --network sepolia --grep Integration",
+    "lint": "biome check .",
+    "lint:fix": "biome check . --write",
+    "lint:sol": "solhint 'contracts/**/*.sol'",
+    "lint:sol:fix": "solhint 'contracts/**/*.sol' --fix",
+    "format": "biome format . --write",
+    "typecheck": "tsc --noEmit",
+    "fix": "bun run lint:fix && bun run lint:sol:fix && bun run format",
+    "fix:verify": "bun run fix && bun run verify",
+    "verify": "bun run lint && bun run lint:sol && bun run compile && bun run typecheck",
+    "verify:full": "bun run verify && bun run test:mocked",
+    "deploy:mocked": "hardhat deploy --network hardhat",
+    "deploy:local": "hardhat deploy --network localhost",
+    "deploy:sepolia": "hardhat deploy --network sepolia",
+    "typechain": "hardhat typechain",
+    "export-abi": "bun scripts/export-abi.ts",
+    "print:deployments": "bun scripts/print-deployments.ts",
+    "build": "bun run compile && bun run typechain && bun run export-abi && tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
+    "ci:version": "changeset version && bun update",
+    "ci:publish": "changeset publish",
+    "clean": "hardhat clean && rm -rf dist typechain-types abi/*.json",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@fhevm/solidity": "0.9.1",
+    "@openzeppelin/confidential-contracts": "0.3.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.9",
+    "@changesets/cli": "^2.29.8",
+    "@commitlint/cli": "^20.2.0",
+    "@commitlint/config-conventional": "^20.2.0",
+    "@fhevm/hardhat-plugin": "^0.3.0-3",
+    "@nomicfoundation/hardhat-chai-matchers": "^2.1.0",
+    "@nomicfoundation/hardhat-toolbox": "^6.1.0",
+    "@openzeppelin/contracts": "^5.4.0",
+    "@types/node": "^22.0.0",
+    "chai": "^4.5.0",
+    "dotenv": "^17.2.3",
+    "hardhat": "^2.28.0",
+    "hardhat-deploy": "^1.0.4",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "solhint": "^6.0.1",
+    "solidity-docgen": "^0.6.0-beta.36",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "ethers": "^6.0.0",
+    "viem": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=22.0.0 <25.0.0",
+    "bun": ">=1.3.0"
+  },
+  "packageManager": "bun@1.3.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gustavovalverde/zentity-fhevm-contracts.git"
+  },
+  "keywords": [
+    "fhevm",
+    "fhe",
+    "zama",
+    "identity",
+    "kyc",
+    "privacy",
+    "ethereum",
+    "solidity"
+  ],
+  "author": "Gustavo Valverde",
+  "license": "MIT"
+}