@enclave-e3/contracts 0.1.4 → 0.1.6

package/dist/scripts/upgrade/enclave.js

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+import hre from "hardhat";
+import { upgradeAndSaveEnclave } from "../deployAndSave/enclave";
+import { readDeploymentArgs } from "../utils";
+/**
+ * Upgrades the Enclave contract implementation and saves the deployment arguments
+ * This keeps the same proxy address, only updates the implementation
+ */
+export const upgradeEnclave = async () => {
+    const { ethers } = await hre.network.connect();
+    const [signer] = await ethers.getSigners();
+    const signerAddress = await signer.getAddress();
+    const chain = (await signer.provider?.getNetwork())?.name ?? "localhost";
+    console.log("Signer:", signerAddress);
+    const preDeployedArgs = readDeploymentArgs("Enclave", chain);
+    if (!preDeployedArgs?.address) {
+        throw new Error("Enclave proxy not found. Deploy first before upgrading.");
+    }
+    if (!preDeployedArgs?.proxyRecords?.implementationAddress) {
+        throw new Error("Existing deployment is not proxy-based. Cannot upgrade non-proxy deployments.");
+    }
+    console.log("Enclave Proxy Address (from deployments):", preDeployedArgs.address);
+    const code = await ethers.provider.getCode(preDeployedArgs.address);
+    if (code === "0x") {
+        throw new Error(`No contract found at proxy address ${preDeployedArgs.address}`);
+    }
+    console.log("Proxy contract exists on-chain");
+    const { enclave, implementationAddress } = await upgradeAndSaveEnclave({
+        ownerAddress: signerAddress,
+        hre,
+    });
+    const enclaveAddress = await enclave.getAddress();
+    console.log(`
+    ============================================
+    Upgrade Complete!
+    ============================================
+    Proxy Address: ${enclaveAddress}
+    New Implementation: ${implementationAddress}
+    ============================================
+  `);
+};
+upgradeEnclave().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/scripts/utils.d.ts

@@ -1,6 +1,8 @@
+export declare const deploymentsFile: string;
 export interface DeploymentArgs {
     address: string;
-    constructorArgs?: Record<string, string>;
+    constructorArgs?: Record<string, string | string[]>;
+    proxyRecords?: Record<string, string | string[]>;
     blockNumber?: number | null;
 }
 export interface ChainDeployments {
@@ -9,6 +11,39 @@ export interface ChainDeployments {
 export interface Deployments {
     [chainName: string]: ChainDeployments;
 }
+/**
+ * Defines the Enclave.config.yaml structure
+ */
+export interface EnclaveConfig {
+    chains: Array<{
+        name: string;
+        rpc_url: string;
+        contracts: {
+            e3_program?: {
+                address: string;
+                deploy_block: number;
+            };
+            enclave?: {
+                address: string;
+                deploy_block: number;
+            };
+            ciphernode_registry?: {
+                address: string;
+                deploy_block: number;
+            };
+            bonding_registry?: {
+                address: string;
+                deploy_block: number;
+            };
+            fee_token?: {
+                address: string;
+                deploy_block: number;
+            };
+        };
+    }>;
+    program: unknown;
+    nodes: unknown;
+}
 /**
  * Store the deployment arguments for a given contract and chain
  * @param args - The deployment arguments to store
@@ -30,7 +65,21 @@ export declare const readDeploymentArgs: (contractName: string, chain: string) =
 export declare const readAllDeployments: () => Deployments;
 /**
  * Clean the deployments for a given network
- * @param network
+ * @param network - The network for which to clean the deployments
  */
 export declare const cleanDeployments: (network: string) => void;
+/**
+ * Check if two arrays are equal by checking the values inside
+ * @param arr1 - The first array
+ * @param arr2 - The second array to check
+ * @returns Whether the two arrays are equal
+ */
+export declare function areArraysEqual<T>(arr1: T[], arr2: T[]): boolean;
+/**
+ * The function to update the enclave.config.yaml file with the deployed contract addresses
+ * @param chainToConfig - The chain name to update in the config
+ * @param pathToConfigFile - The path to the enclave.config.yaml file
+ * @param contractMapping - A mapping of contract names to config keys
+ */
+export declare const updateE3Config: (chainToConfig: string, pathToConfigFile: string, contractMapping: Record<string, string>, rpcUrl?: string) => void;
 //# sourceMappingURL=utils.d.ts.map

package/dist/scripts/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../scripts/utils.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAGD,MAAM,WAAW,gBAAgB;IAC/B,CAAC,YAAY,EAAE,MAAM,GAAG,cAAc,CAAC;CACxC;AAGD,MAAM,WAAW,WAAW;IAC1B,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAAC;CACvC;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAC9B,MAAM,cAAc,EACpB,cAAc,MAAM,EACpB,OAAO,MAAM,KACZ,IA4BF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,cAAc,MAAM,EACpB,OAAO,MAAM,KACZ,cAAc,GAAG,SAWnB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAO,WAWrC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,IAUlD,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../scripts/utils.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,eAAe,QAAuC,CAAC;AAGpE,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IACpD,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IACjD,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAGD,MAAM,WAAW,gBAAgB;IAC/B,CAAC,YAAY,EAAE,MAAM,GAAG,cAAc,CAAC;CACxC;AAGD,MAAM,WAAW,WAAW;IAC1B,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE;YACT,UAAU,CAAC,EAAE;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,YAAY,EAAE,MAAM,CAAA;aAAE,CAAC;YACvD,OAAO,CAAC,EAAE;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,YAAY,EAAE,MAAM,CAAA;aAAE,CAAC;YACpD,mBAAmB,CAAC,EAAE;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,YAAY,EAAE,MAAM,CAAA;aAAE,CAAC;YAChE,gBAAgB,CAAC,EAAE;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,YAAY,EAAE,MAAM,CAAA;aAAE,CAAC;YAC7D,SAAS,CAAC,EAAE;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,YAAY,EAAE,MAAM,CAAA;aAAE,CAAC;SACvD,CAAC;KACH,CAAC,CAAC;IAEH,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAC9B,MAAM,cAAc,EACpB,cAAc,MAAM,EACpB,OAAO,MAAM,KACZ,IA4BF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,cAAc,MAAM,EACpB,OAAO,MAAM,KACZ,cAAc,GAAG,SAWnB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAO,WAWrC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,IAUlD,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAY/D;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,eAAe,MAAM,EACrB,kBAAkB,MAAM,EACxB,iBAAiB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACvC,SAAS,MAAM,KACd,IAsDF,CAAC"}

package/dist/scripts/utils.js

@@ -4,8 +4,9 @@
 // without even the implied warranty of MERCHANTABILITY
 // or FITNESS FOR A PARTICULAR PURPOSE.
 import fs from "fs";
+import yaml from "js-yaml";
 import path from "path";
-const deploymentsFile = path.join("deployed_contracts.json");
+export const deploymentsFile = path.join("deployed_contracts.json");
 /**
  * Store the deployment arguments for a given contract and chain
  * @param args - The deployment arguments to store
@@ -19,7 +20,7 @@ export const storeDeploymentArgs = (args, contractName, chain) => {
         try {
             deployments = JSON.parse(fs.readFileSync(deploymentsFile, "utf8"));
         }
-        catch (error) {
+        catch {
             console.warn("Failed to parse existing deployments file, starting fresh");
             deployments = {};
         }
@@ -63,14 +64,14 @@ export const readAllDeployments = () => {
     try {
         return JSON.parse(fs.readFileSync(deploymentsFile, "utf8"));
     }
-    catch (error) {
+    catch {
         console.warn("Failed to parse deployments file");
         return {};
     }
 };
 /**
  * Clean the deployments for a given network
- * @param network
+ * @param network - The network for which to clean the deployments
  */
 export const cleanDeployments = (network) => {
     if (!fs.existsSync(deploymentsFile)) {
@@ -82,3 +83,65 @@ export const cleanDeployments = (network) => {
     }
     fs.writeFileSync(deploymentsFile, JSON.stringify(deployments, null, 2));
 };
+/**
+ * Check if two arrays are equal by checking the values inside
+ * @param arr1 - The first array
+ * @param arr2 - The second array to check
+ * @returns Whether the two arrays are equal
+ */
+export function areArraysEqual(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    for (let i = 0; i < arr1.length; i++) {
+        if (arr1[i] !== arr2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * The function to update the enclave.config.yaml file with the deployed contract addresses
+ * @param chainToConfig - The chain name to update in the config
+ * @param pathToConfigFile - The path to the enclave.config.yaml file
+ * @param contractMapping - A mapping of contract names to config keys
+ */
+export const updateE3Config = (chainToConfig, pathToConfigFile, contractMapping, rpcUrl) => {
+    const fileContent = fs.readFileSync(pathToConfigFile, "utf8");
+    const config = yaml.load(fileContent);
+    // Find the hardhat chain config
+    // Find the chain config or create it
+    let configChain = config.chains.find((chain) => chain.name === chainToConfig);
+    if (!configChain) {
+        console.log(`Chain "${chainToConfig}" not found in config. Creating new entry...`);
+        if (!rpcUrl) {
+            console.warn("Warning: No RPC URL provided. You'll need to update it manually in the config.");
+        }
+        configChain = {
+            name: chainToConfig,
+            rpc_url: rpcUrl || `ws://localhost:8545`,
+            contracts: {},
+        };
+        config.chains.push(configChain);
+        console.log(`✓ Created new chain entry for "${chainToConfig}"`);
+    }
+    console.log(`\nUpdating contracts for chain: ${chainToConfig}`);
+    // Update contract addresses and deploy blocks
+    for (const [contractName, configKey] of Object.entries(contractMapping)) {
+        const deployment = readDeploymentArgs(contractName, chainToConfig);
+        if (deployment) {
+            configChain.contracts[configKey] = {
+                address: deployment.address,
+                deploy_block: deployment.blockNumber ?? 1,
+            };
+            console.log(`✓ Updated ${configKey}: ${deployment.address} (block ${deployment.blockNumber ?? 1})`);
+        }
+    }
+    // Write updated config back to file
+    const yamlStr = yaml.dump(config, {
+        indent: 2,
+        lineWidth: -1, // Don't wrap lines
+    });
+    fs.writeFileSync(pathToConfigFile, yamlStr + "\n", "utf8");
+    console.log("\n✓ enclave.config.yaml updated successfully!");
+};

package/dist/scripts/verify.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Deploy and verify all contracts on a given chain
+ * @param chain - The chain to verify the contracts on
+ */
+export declare const verifyContracts: (chain: string) => void;
+//# sourceMappingURL=verify.d.ts.map

package/dist/scripts/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../scripts/verify.ts"],"names":[],"mappings":"AAsHA;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,KAAG,IA6E/C,CAAC"}

package/dist/scripts/verify.js

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { readAllDeployments } from "./utils";
+/**
+ * Find the fully qualified contract name by searching the contracts directory
+ * @param contractName - Simple contract name (e.g., "Enclave")
+ * @param contractsDir - Directory to search (default: "contracts")
+ * @returns Fully qualified name or undefined if not found
+ */
+const findContractPath = (contractName, artifactsDir = "artifacts") => {
+    const searchDir = (dir) => {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            const fullPath = path.join(dir, file);
+            const stat = fs.statSync(fullPath);
+            if (stat.isDirectory()) {
+                const result = searchDir(fullPath);
+                if (result)
+                    return result;
+            }
+            else if (file === `${contractName}.json`) {
+                try {
+                    const artifact = JSON.parse(fs.readFileSync(fullPath, "utf-8"));
+                    if (artifact.sourceName && artifact.contractName === contractName) {
+                        const sourceName = artifact.sourceName;
+                        // Skip external packages - return undefined so they won't be verified
+                        if (sourceName.startsWith("./@") ||
+                            sourceName.startsWith("@") ||
+                            sourceName.includes("node_modules")) {
+                            console.log(`⏭️  Skipping external contract: ${contractName} (from ${sourceName})`);
+                            return undefined;
+                        }
+                        // For local contracts, remove leading './' and return the path
+                        let localPath = sourceName;
+                        if (localPath.startsWith("./")) {
+                            localPath = localPath.slice(2);
+                        }
+                        return `${localPath}:${contractName}`;
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to parse artifact at ${fullPath}:`, error);
+                }
+            }
+        }
+        return undefined;
+    };
+    return searchDir(artifactsDir);
+};
+/**
+ * Verify a single contract using Hardhat CLI
+ * @param address - Contract address
+ * @param constructorArgs - Constructor arguments as a record
+ * @param network - Network name
+ */
+const verifyContract = (contractName, address, constructorArgs, network) => {
+    // Create a temporary args file
+    const argsFile = path.join(process.cwd(), `verify-args-${address}.cjs`);
+    try {
+        if (constructorArgs) {
+            const argsArray = Object.values(constructorArgs);
+            const fileContent = `module.exports = ${JSON.stringify(argsArray, null, 2)};`;
+            fs.writeFileSync(argsFile, fileContent);
+            const command = `pnpm hardhat verify --build-profile default --network ${network} --contract ${contractName} ${address} --constructor-args-path ${argsFile}`;
+            console.log(`Executing: ${command}`);
+            execSync(command, { stdio: "inherit" });
+            console.log(`✅ Contract verified successfully at ${address}\n`);
+        }
+        else {
+            const command = `pnpm hardhat verify --build-profile default --network ${network} --contract ${contractName} ${address}`;
+            execSync(command, { stdio: "inherit" });
+        }
+    }
+    catch (error) {
+        if (error.message?.includes("Already Verified")) {
+            console.log(`ℹ️  Contract at ${address} is already verified\n`);
+        }
+        else {
+            console.error(`❌ Failed to verify contract at ${address}:`, error.message, "\n");
+        }
+    }
+    finally {
+        // ensure that we always clean up even if there was some early failure
+        if (fs.existsSync(argsFile)) {
+            fs.unlinkSync(argsFile);
+        }
+    }
+};
+/**
+ * Deploy and verify all contracts on a given chain
+ * @param chain - The chain to verify the contracts on
+ */
+export const verifyContracts = (chain) => {
+    const deployments = readAllDeployments();
+    const chainDeployments = deployments[chain];
+    if (!chainDeployments) {
+        console.log(`❌ No deployments found for chain: ${chain}`);
+        return;
+    }
+    const contractNames = Object.keys(chainDeployments);
+    console.log(`\n🔍 Verifying ${contractNames.length} contracts on ${chain}...\n`);
+    contractNames.forEach((contractName, _) => {
+        // we skip PoseidonT3 as it's a library
+        if (contractName === "PoseidonT3") {
+            console.log(`ℹ️  Skipping verification for library contract: ${contractName}`);
+            return;
+        }
+        const deployment = chainDeployments[contractName];
+        const isProxy = Boolean(deployment.proxyRecords?.implementationAddress);
+        if (isProxy && deployment.proxyRecords) {
+            console.log(`  📦 Proxy deployment detected`);
+            console.log(`  ├─ Verifying TransparentUpgradeableProxy...`);
+            verifyContract("@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol:TransparentUpgradeableProxy", deployment.address, {
+                _logic: deployment.proxyRecords.implementationAddress,
+                _owner: deployment.proxyRecords.initialOwner,
+                _data: deployment.proxyRecords.initData,
+            }, chain);
+            console.log(`  ├─ Verifying ProxyAdmin...`);
+            verifyContract("@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol:ProxyAdmin", deployment.proxyRecords.proxyAdminAddress, { owner: deployment.proxyRecords.initialOwner }, chain);
+        }
+        // Verify the main contract (or implementation if proxy)
+        const fullyQualifiedName = findContractPath(contractName);
+        if (!fullyQualifiedName) {
+            console.log(`  ❌ Could not find contract source for ${contractName}. Skipping.\n`);
+            return;
+        }
+        const targetAddress = isProxy
+            ? deployment.proxyRecords?.implementationAddress
+            : deployment.address;
+        const constructorArgs = isProxy ? undefined : deployment.constructorArgs;
+        console.log(`  ${isProxy ? "└─" : "  "} Verifying ${isProxy ? "implementation" : "contract"} at ${targetAddress.slice(0, 10)}...`);
+        verifyContract(fullyQualifiedName, targetAddress, constructorArgs, chain);
+        console.log(`  ✅ ${contractName} verification complete\n`);
+    });
+    console.log(`\n🎉 Verification process completed for ${chain}!\n`);
+};

package/dist/tasks/ciphernode.d.ts

@@ -1,4 +1,6 @@
 export declare const ciphernodeAdd: import("hardhat/types/tasks").NewTaskDefinition;
 export declare const ciphernodeRemove: import("hardhat/types/tasks").NewTaskDefinition;
+export declare const ciphernodeMintTokens: import("hardhat/types/tasks").NewTaskDefinition;
+export declare const ciphernodeAdminAdd: import("hardhat/types/tasks").NewTaskDefinition;
 export declare const ciphernodeSiblings: import("hardhat/types/tasks").NewTaskDefinition;
 //# sourceMappingURL=ciphernode.d.ts.map

package/dist/tasks/ciphernode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ciphernode.d.ts","sourceRoot":"","sources":["../../tasks/ciphernode.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,aAAa,iDAsBhB,CAAC;AAEX,eAAO,MAAM,gBAAgB,iDAiCnB,CAAC;AAEX,eAAO,MAAM,kBAAkB,iDAgCrB,CAAC"}
+{"version":3,"file":"ciphernode.d.ts","sourceRoot":"","sources":["../../tasks/ciphernode.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,aAAa,iDA0IhB,CAAC;AAEX,eAAO,MAAM,gBAAgB,iDA4CnB,CAAC;AAEX,eAAO,MAAM,oBAAoB,iDA2FvB,CAAC;AAEX,eAAO,MAAM,kBAAkB,iDAkNrB,CAAC;AAEX,eAAO,MAAM,kBAAkB,iDAgCrB,CAAC"}