@enclave-e3/contracts 0.1.4 → 0.1.6

package/dist/scripts/deployAndSave/ciphernodeRegistryOwnable.js

@@ -1,42 +1,99 @@
-import CiphernodeRegistryModule from "../../ignition/modules/ciphernodeRegistry";
 import { CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnableFactory, } from "../../types";
+import { getProxyAdmin, verifyProxyAdminOwner } from "../proxy";
 import { readDeploymentArgs, storeDeploymentArgs } from "../utils";
 /**
  * Deploys the CiphernodeRegistryOwnable contract and saves the deployment arguments
  * @param param0 - The deployment arguments
  * @returns The deployed CiphernodeRegistryOwnable contract
  */
-export const deployAndSaveCiphernodeRegistryOwnable = async ({ enclaveAddress, owner, hre, }) => {
-    const { ignition, ethers } = await hre.network.connect();
+export const deployAndSaveCiphernodeRegistryOwnable = async ({ enclaveAddress, owner, submissionWindow, poseidonT3Address, hre, }) => {
+    const { ethers } = await hre.network.connect();
     const [signer] = await ethers.getSigners();
     const chain = (await signer.provider?.getNetwork())?.name ?? "localhost";
-    const preDeployedArgs = readDeploymentArgs("CiphernodeRegistry", chain);
+    const preDeployedArgs = readDeploymentArgs("CiphernodeRegistryOwnable", chain);
     if (!enclaveAddress ||
         !owner ||
+        !submissionWindow ||
         (preDeployedArgs?.constructorArgs?.enclaveAddress === enclaveAddress &&
-            preDeployedArgs?.constructorArgs?.owner === owner)) {
+            preDeployedArgs?.constructorArgs?.owner === owner &&
+            preDeployedArgs?.constructorArgs?.submissionWindow ===
+                submissionWindow.toString())) {
         if (!preDeployedArgs?.address) {
             throw new Error("CiphernodeRegistry address not found, it must be deployed first");
         }
         const ciphernodeRegistryContract = CiphernodeRegistryOwnableFactory.connect(preDeployedArgs.address, signer);
         return { ciphernodeRegistry: ciphernodeRegistryContract };
     }
-    const ciphernodeRegistry = await ignition.deploy(CiphernodeRegistryModule, {
-        parameters: {
-            CiphernodeRegistry: {
-                enclaveAddress,
-                owner,
-            },
-        },
-    });
-    await ciphernodeRegistry.cipherNodeRegistry.waitForDeployment();
+    const ciphernodeRegistryFactory = await ethers.getContractFactory(CiphernodeRegistryOwnableFactory.abi, CiphernodeRegistryOwnableFactory.linkBytecode({
+        "npm/poseidon-solidity@0.0.5/PoseidonT3.sol:PoseidonT3": poseidonT3Address,
+    }), signer);
+    const ciphernodeRegistry = await ciphernodeRegistryFactory.deploy();
+    await ciphernodeRegistry.waitForDeployment();
     const blockNumber = await ethers.provider.getBlockNumber();
-    const ciphernodeRegistryAddress = await ciphernodeRegistry.cipherNodeRegistry.getAddress();
+    const ciphernodeRegistryAddress = await ciphernodeRegistry.getAddress();
+    const initData = ciphernodeRegistryFactory.interface.encodeFunctionData("initialize", [owner, enclaveAddress, submissionWindow]);
+    const ProxyCF = await ethers.getContractFactory("TransparentUpgradeableProxy");
+    const proxy = await ProxyCF.deploy(ciphernodeRegistryAddress, owner, initData);
+    await proxy.waitForDeployment();
+    const proxyAddress = await proxy.getAddress();
+    const proxyAdminAddress = await getProxyAdmin(ethers.provider, proxyAddress);
     storeDeploymentArgs({
-        constructorArgs: { enclaveAddress: enclaveAddress, owner },
+        constructorArgs: {
+            owner,
+            enclaveAddress: enclaveAddress,
+            submissionWindow: submissionWindow.toString(),
+        },
+        proxyRecords: {
+            initData,
+            initialOwner: owner,
+            proxyAddress,
+            proxyAdminAddress,
+            implementationAddress: ciphernodeRegistryAddress,
+        },
         blockNumber,
-        address: ciphernodeRegistryAddress,
-    }, "CiphernodeRegistry", chain);
-    const ciphernodeRegistryContract = CiphernodeRegistryOwnableFactory.connect(ciphernodeRegistryAddress);
+        address: proxyAddress,
+    }, "CiphernodeRegistryOwnable", chain);
+    const ciphernodeRegistryContract = CiphernodeRegistryOwnableFactory.connect(proxyAddress, signer);
     return { ciphernodeRegistry: ciphernodeRegistryContract };
 };
+export const upgradeAndSaveCiphernodeRegistryOwnable = async ({ poseidonT3Address, ownerAddress, hre, }) => {
+    const { ethers } = await hre.network.connect();
+    const [signer] = await ethers.getSigners();
+    const chain = hre.globalOptions.network;
+    const preDeployedArgs = readDeploymentArgs("CiphernodeRegistryOwnable", chain);
+    if (!preDeployedArgs?.address) {
+        throw new Error("CiphernodeRegistryOwnable proxy not found. Deploy first before upgrading.");
+    }
+    const proxyAddress = preDeployedArgs.address;
+    const autoProxyAdminAddress = await getProxyAdmin(ethers.provider, proxyAddress);
+    console.log("Auto-deployed ProxyAdmin address:", autoProxyAdminAddress);
+    const ciphernodeRegistryFactory = await ethers.getContractFactory(CiphernodeRegistryOwnableFactory.abi, CiphernodeRegistryOwnableFactory.linkBytecode({
+        "npm/poseidon-solidity@0.0.5/PoseidonT3.sol:PoseidonT3": poseidonT3Address,
+    }), signer);
+    const newImplementation = await ciphernodeRegistryFactory.deploy();
+    await newImplementation.waitForDeployment();
+    const newImplementationAddress = await newImplementation.getAddress();
+    console.log("New Implementation Address:", newImplementationAddress);
+    const proxyAdmin = await ethers.getContractAt("ProxyAdmin", autoProxyAdminAddress, signer);
+    await verifyProxyAdminOwner(proxyAdmin, ownerAddress);
+    // TODO: Add init data if needed
+    const initData = "0x";
+    const upgradeTx = await proxyAdmin.upgradeAndCall(proxyAddress, newImplementationAddress, initData);
+    await upgradeTx.wait();
+    const existingProxyRecords = preDeployedArgs.proxyRecords
+        ? Object.fromEntries(Object.entries(preDeployedArgs.proxyRecords).filter(([, value]) => value !== undefined))
+        : {};
+    const proxyRecords = {
+        ...existingProxyRecords,
+        implementationAddress: newImplementationAddress,
+    };
+    if (initData !== "0x") {
+        proxyRecords.initData = initData;
+    }
+    storeDeploymentArgs({ ...preDeployedArgs, proxyRecords }, "CiphernodeRegistryOwnable", chain);
+    const ciphernodeRegistryContract = CiphernodeRegistryOwnableFactory.connect(proxyAddress, signer);
+    return {
+        ciphernodeRegistry: ciphernodeRegistryContract,
+        implementationAddress: newImplementationAddress,
+    };
+};

package/dist/scripts/deployAndSave/enclave.d.ts

@@ -4,10 +4,12 @@ import { Enclave } from "../../types";
  * The arguments for the deployAndSaveEnclave function
  */
 export interface EnclaveArgs {
-    params?: string;
+    params?: string[];
     owner?: string;
     maxDuration?: string;
     registry?: string;
+    bondingRegistry?: string;
+    feeToken?: string;
     hre: HardhatRuntimeEnvironment;
 }
 /**
@@ -15,7 +17,19 @@ export interface EnclaveArgs {
  * @param param0 - The deployment arguments
  * @returns The deployed Enclave contract
  */
-export declare const deployAndSaveEnclave: ({ params, owner, maxDuration, registry, hre, }: EnclaveArgs) => Promise<{
+export declare const deployAndSaveEnclave: ({ params, owner, maxDuration, registry, bondingRegistry, feeToken, hre, }: EnclaveArgs) => Promise<{
     enclave: Enclave;
 }>;
+/**
+ * Upgrades the Enclave implementation while keeping the same proxy address
+ * @param param0 - The upgrade arguments
+ * @returns The upgraded Enclave contract (same proxy address)
+ */
+export declare const upgradeAndSaveEnclave: ({ ownerAddress, hre, }: {
+    ownerAddress: string;
+    hre: HardhatRuntimeEnvironment;
+}) => Promise<{
+    enclave: Enclave;
+    implementationAddress: string;
+}>;
 //# sourceMappingURL=enclave.d.ts.map

package/dist/scripts/deployAndSave/enclave.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enclave.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/enclave.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAGnE,OAAO,EAAE,OAAO,EAAsC,MAAM,aAAa,CAAC;AAG1E;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,yBAAyB,CAAC;CAChC;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAU,gDAMxC,WAAW,KAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAyD5C,CAAC"}
+{"version":3,"file":"enclave.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/enclave.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EAAE,OAAO,EAAsC,MAAM,aAAa,CAAC;AAQ1E;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,yBAAyB,CAAC;CAChC;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAU,2EAQxC,WAAW,KAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAuF5C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAU,wBAGzC;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,yBAAyB,CAAC;CAChC,KAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,qBAAqB,EAAE,MAAM,CAAA;CAAE,CAiE9D,CAAC"}

package/dist/scripts/deployAndSave/enclave.js

@@ -1,13 +1,13 @@
-import EnclaveModule from "../../ignition/modules/enclave";
 import { Enclave__factory as EnclaveFactory } from "../../types";
-import { readDeploymentArgs, storeDeploymentArgs } from "../utils";
+import { getProxyAdmin, verifyProxyAdminOwner } from "../proxy";
+import { areArraysEqual, readDeploymentArgs, storeDeploymentArgs, } from "../utils";
 /**
  * Deploys the Enclave contract and saves the deployment arguments
  * @param param0 - The deployment arguments
  * @returns The deployed Enclave contract
  */
-export const deployAndSaveEnclave = async ({ params, owner, maxDuration, registry, hre, }) => {
-    const { ignition, ethers } = await hre.network.connect();
+export const deployAndSaveEnclave = async ({ params, owner, maxDuration, registry, bondingRegistry, feeToken, hre, }) => {
+    const { ethers } = await hre.network.connect();
     const [signer] = await ethers.getSigners();
     const chain = hre.globalOptions.network;
     const preDeployedArgs = readDeploymentArgs("Enclave", chain);
@@ -15,34 +15,101 @@ export const deployAndSaveEnclave = async ({ params, owner, maxDuration, registr
         !owner ||
         !maxDuration ||
         !registry ||
-        (preDeployedArgs?.constructorArgs?.params === params &&
-            preDeployedArgs?.constructorArgs?.owner === owner &&
+        !bondingRegistry ||
+        !feeToken ||
+        (preDeployedArgs?.constructorArgs?.owner === owner &&
             preDeployedArgs?.constructorArgs?.maxDuration === maxDuration &&
-            preDeployedArgs?.constructorArgs?.registry === registry)) {
+            preDeployedArgs?.constructorArgs?.registry === registry &&
+            preDeployedArgs?.constructorArgs?.bondingRegistry === bondingRegistry &&
+            preDeployedArgs?.constructorArgs?.feeToken === feeToken &&
+            areArraysEqual(preDeployedArgs?.constructorArgs?.params, params))) {
         if (!preDeployedArgs?.address) {
             throw new Error("Enclave address not found, it must be deployed first");
         }
         const enclaveContract = EnclaveFactory.connect(preDeployedArgs.address, signer);
         return { enclave: enclaveContract };
     }
-    const enclave = await ignition.deploy(EnclaveModule, {
-        parameters: {
-            Enclave: {
-                params,
-                owner,
-                maxDuration,
-                registry,
-            },
-        },
-    });
-    await enclave.enclave.waitForDeployment();
-    const enclaveAddress = await enclave.enclave.getAddress();
+    const enclaveFactory = await ethers.getContractFactory("Enclave", signer);
+    const enclave = await enclaveFactory.deploy();
+    await enclave.waitForDeployment();
     const blockNumber = await ethers.provider.getBlockNumber();
+    const enclaveAddress = await enclave.getAddress();
+    const initData = enclaveFactory.interface.encodeFunctionData("initialize", [
+        owner,
+        registry,
+        bondingRegistry,
+        feeToken,
+        maxDuration,
+        params,
+    ]);
+    const ProxyCF = await ethers.getContractFactory("TransparentUpgradeableProxy");
+    const proxy = await ProxyCF.deploy(enclaveAddress, owner, initData);
+    await proxy.waitForDeployment();
+    const proxyAddress = await proxy.getAddress();
+    const proxyAdminAddress = await getProxyAdmin(ethers.provider, proxyAddress);
     storeDeploymentArgs({
-        constructorArgs: { params, owner, maxDuration, registry },
+        constructorArgs: {
+            owner,
+            registry,
+            bondingRegistry,
+            feeToken,
+            maxDuration,
+            params,
+        },
+        proxyRecords: {
+            initData,
+            initialOwner: owner,
+            proxyAddress,
+            proxyAdminAddress,
+            implementationAddress: enclaveAddress,
+        },
         blockNumber,
-        address: enclaveAddress,
+        address: proxyAddress,
     }, "Enclave", chain);
-    const enclaveContract = EnclaveFactory.connect(enclaveAddress, signer);
+    const enclaveContract = EnclaveFactory.connect(proxyAddress, signer);
     return { enclave: enclaveContract };
 };
+/**
+ * Upgrades the Enclave implementation while keeping the same proxy address
+ * @param param0 - The upgrade arguments
+ * @returns The upgraded Enclave contract (same proxy address)
+ */
+export const upgradeAndSaveEnclave = async ({ ownerAddress, hre, }) => {
+    const { ethers } = await hre.network.connect();
+    const [signer] = await ethers.getSigners();
+    const chain = hre.globalOptions.network;
+    const preDeployedArgs = readDeploymentArgs("Enclave", chain);
+    if (!preDeployedArgs?.address) {
+        throw new Error("Enclave proxy not found. Deploy first before upgrading.");
+    }
+    const proxyAddress = preDeployedArgs.address;
+    const autoProxyAdminAddress = await getProxyAdmin(ethers.provider, proxyAddress);
+    console.log("Auto-deployed ProxyAdmin address:", autoProxyAdminAddress);
+    const enclaveFactory = await ethers.getContractFactory("Enclave", signer);
+    const newImplementation = await enclaveFactory.deploy();
+    await newImplementation.waitForDeployment();
+    const newImplementationAddress = await newImplementation.getAddress();
+    console.log("New Implementation Address:", newImplementationAddress);
+    const proxyAdmin = await ethers.getContractAt("ProxyAdmin", autoProxyAdminAddress, signer);
+    await verifyProxyAdminOwner(proxyAdmin, ownerAddress);
+    // TODO: Add init data if needed
+    const initData = "0x";
+    const upgradeTx = await proxyAdmin.upgradeAndCall(proxyAddress, newImplementationAddress, initData);
+    await upgradeTx.wait();
+    const existingProxyRecords = preDeployedArgs.proxyRecords
+        ? Object.fromEntries(Object.entries(preDeployedArgs.proxyRecords).filter(([, value]) => value !== undefined))
+        : {};
+    const proxyRecords = {
+        ...existingProxyRecords,
+        implementationAddress: newImplementationAddress,
+    };
+    if (initData !== "0x") {
+        proxyRecords.initData = initData;
+    }
+    storeDeploymentArgs({ ...preDeployedArgs, proxyRecords }, "Enclave", chain);
+    const enclaveContract = EnclaveFactory.connect(proxyAddress, signer);
+    return {
+        enclave: enclaveContract,
+        implementationAddress: newImplementationAddress,
+    };
+};

package/dist/scripts/deployAndSave/enclaveTicketToken.d.ts

@@ -0,0 +1,20 @@
+import type { HardhatRuntimeEnvironment } from "hardhat/types/hre";
+import { EnclaveTicketToken } from "../../types";
+/**
+ * The arguments for the deployAndSaveEnclaveTicketToken function
+ */
+export interface EnclaveTicketTokenArgs {
+    baseToken?: string;
+    registry?: string;
+    owner?: string;
+    hre: HardhatRuntimeEnvironment;
+}
+/**
+ * Deploys the EnclaveTicketToken contract and saves the deployment arguments
+ * @param param0 - The deployment arguments
+ * @returns The deployed EnclaveTicketToken contract
+ */
+export declare const deployAndSaveEnclaveTicketToken: ({ baseToken, registry, owner, hre, }: EnclaveTicketTokenArgs) => Promise<{
+    enclaveTicketToken: EnclaveTicketToken;
+}>;
+//# sourceMappingURL=enclaveTicketToken.d.ts.map

package/dist/scripts/deployAndSave/enclaveTicketToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enclaveTicketToken.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/enclaveTicketToken.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EACL,kBAAkB,EAEnB,MAAM,aAAa,CAAC;AAGrB;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,yBAAyB,CAAC;CAChC;AAED;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,GAAU,sCAKnD,sBAAsB,KAAG,OAAO,CAAC;IAClC,kBAAkB,EAAE,kBAAkB,CAAC;CACxC,CA6DA,CAAC"}

package/dist/scripts/deployAndSave/enclaveTicketToken.js

@@ -0,0 +1,41 @@
+import { EnclaveTicketToken__factory as EnclaveTicketTokenFactory, } from "../../types";
+import { readDeploymentArgs, storeDeploymentArgs } from "../utils";
+/**
+ * Deploys the EnclaveTicketToken contract and saves the deployment arguments
+ * @param param0 - The deployment arguments
+ * @returns The deployed EnclaveTicketToken contract
+ */
+export const deployAndSaveEnclaveTicketToken = async ({ baseToken, registry, owner, hre, }) => {
+    const { ethers } = await hre.network.connect();
+    const [signer] = await ethers.getSigners();
+    const chain = (await signer.provider?.getNetwork())?.name ?? "localhost";
+    const preDeployedArgs = readDeploymentArgs("EnclaveTicketToken", chain);
+    if (!baseToken ||
+        !registry ||
+        !owner ||
+        (preDeployedArgs?.constructorArgs?.baseToken === baseToken &&
+            preDeployedArgs?.constructorArgs?.registry === registry &&
+            preDeployedArgs?.constructorArgs?.owner === owner)) {
+        if (!preDeployedArgs?.address) {
+            throw new Error("EnclaveTicketToken address not found, it must be deployed first");
+        }
+        const enclaveTicketTokenContract = EnclaveTicketTokenFactory.connect(preDeployedArgs.address, signer);
+        return { enclaveTicketToken: enclaveTicketTokenContract };
+    }
+    const enclaveTicketTokenFactory = await ethers.getContractFactory("EnclaveTicketToken");
+    const enclaveTicketToken = await enclaveTicketTokenFactory.deploy(baseToken, registry, owner);
+    await enclaveTicketToken.waitForDeployment();
+    const blockNumber = await ethers.provider.getBlockNumber();
+    const enclaveTicketTokenAddress = await enclaveTicketToken.getAddress();
+    storeDeploymentArgs({
+        constructorArgs: {
+            baseToken,
+            registry,
+            owner,
+        },
+        blockNumber,
+        address: enclaveTicketTokenAddress,
+    }, "EnclaveTicketToken", chain);
+    const enclaveTicketTokenContract = EnclaveTicketTokenFactory.connect(enclaveTicketTokenAddress, signer);
+    return { enclaveTicketToken: enclaveTicketTokenContract };
+};

package/dist/scripts/deployAndSave/enclaveToken.d.ts

@@ -0,0 +1,18 @@
+import type { HardhatRuntimeEnvironment } from "hardhat/types/hre";
+import { EnclaveToken } from "../../types";
+/**
+ * The arguments for the deployAndSaveEnclaveToken function
+ */
+export interface EnclaveTokenArgs {
+    owner?: string;
+    hre: HardhatRuntimeEnvironment;
+}
+/**
+ * Deploys the EnclaveToken contract and saves the deployment arguments
+ * @param param0 - The deployment arguments
+ * @returns The deployed EnclaveToken contract
+ */
+export declare const deployAndSaveEnclaveToken: ({ owner, hre, }: EnclaveTokenArgs) => Promise<{
+    enclaveToken: EnclaveToken;
+}>;
+//# sourceMappingURL=enclaveToken.d.ts.map

package/dist/scripts/deployAndSave/enclaveToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enclaveToken.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/enclaveToken.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EACL,YAAY,EAEb,MAAM,aAAa,CAAC;AAGrB;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,yBAAyB,CAAC;CAChC;AA2BD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GAAU,iBAG7C,gBAAgB,KAAG,OAAO,CAAC;IAC5B,YAAY,EAAE,YAAY,CAAC;CAC5B,CAoDA,CAAC"}

package/dist/scripts/deployAndSave/enclaveToken.js

@@ -0,0 +1,57 @@
+import { EnclaveToken__factory as EnclaveTokenFactory, } from "../../types";
+import { readDeploymentArgs, storeDeploymentArgs } from "../utils";
+/**
+ * Disables transfer restrictions for local development
+ */
+async function disableTransferRestrictionsForLocal(contract, chain) {
+    if (chain !== "localhost" && chain !== "hardhat") {
+        return;
+    }
+    console.log("Disabling transfer restrictions for chain", chain);
+    console.log("Contract address", await contract.getAddress());
+    try {
+        const isRestricted = await contract.transfersRestricted();
+        if (isRestricted) {
+            const tx = await contract.setTransferRestriction(false);
+            await tx.wait();
+            console.log("Transfer restrictions disabled for local development");
+        }
+    }
+    catch (error) {
+        console.warn("Failed to disable transfer restrictions:", error);
+    }
+}
+/**
+ * Deploys the EnclaveToken contract and saves the deployment arguments
+ * @param param0 - The deployment arguments
+ * @returns The deployed EnclaveToken contract
+ */
+export const deployAndSaveEnclaveToken = async ({ owner, hre, }) => {
+    const { ethers } = await hre.network.connect();
+    const [signer] = await ethers.getSigners();
+    const chain = (await signer.provider?.getNetwork())?.name ?? "localhost";
+    const preDeployedArgs = readDeploymentArgs("EnclaveToken", chain);
+    if (!owner || preDeployedArgs?.constructorArgs?.owner === owner) {
+        if (!preDeployedArgs?.address) {
+            throw new Error("EnclaveToken address not found, it must be deployed first");
+        }
+        const enclaveTokenContract = EnclaveTokenFactory.connect(preDeployedArgs.address, signer);
+        await disableTransferRestrictionsForLocal(enclaveTokenContract, chain);
+        return { enclaveToken: enclaveTokenContract };
+    }
+    const enclaveTokenFactory = await ethers.getContractFactory("EnclaveToken");
+    const enclaveToken = await enclaveTokenFactory.deploy(owner);
+    await enclaveToken.waitForDeployment();
+    const blockNumber = await ethers.provider.getBlockNumber();
+    const enclaveTokenAddress = await enclaveToken.getAddress();
+    storeDeploymentArgs({
+        constructorArgs: {
+            owner,
+        },
+        blockNumber,
+        address: enclaveTokenAddress,
+    }, "EnclaveToken", chain);
+    const enclaveTokenContract = EnclaveTokenFactory.connect(enclaveTokenAddress, signer);
+    await disableTransferRestrictionsForLocal(enclaveTokenContract, chain);
+    return { enclaveToken: enclaveTokenContract };
+};

package/dist/scripts/deployAndSave/mockComputeProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mockComputeProvider.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/mockComputeProvider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAGnE,OAAO,EACL,mBAAmB,EAEpB,MAAM,aAAa,CAAC;AAGrB,eAAO,MAAM,gCAAgC,GAC3C,KAAK,yBAAyB,KAC7B,OAAO,CAAC;IACT,eAAe,EAAE,mBAAmB,CAAC;CACtC,CA6BA,CAAC"}
+{"version":3,"file":"mockComputeProvider.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/mockComputeProvider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EACL,mBAAmB,EAEpB,MAAM,aAAa,CAAC;AAGrB,eAAO,MAAM,gCAAgC,GAC3C,KAAK,yBAAyB,KAC7B,OAAO,CAAC;IACT,eAAe,EAAE,mBAAmB,CAAC;CACtC,CA+BA,CAAC"}

package/dist/scripts/deployAndSave/mockComputeProvider.js

@@ -1,11 +1,11 @@
-import MockComputeProviderModule from "../../ignition/modules/mockComputeProvider";
 import { MockComputeProvider__factory as MockComputeProviderFactory, } from "../../types";
 import { storeDeploymentArgs } from "../utils";
 export const deployAndSaveMockComputeProvider = async (hre) => {
-    const { ignition, ethers } = await hre.network.connect();
-    const computeProvider = await ignition.deploy(MockComputeProviderModule);
-    await computeProvider.mockComputeProvider.waitForDeployment();
-    const computeProviderAddress = await computeProvider.mockComputeProvider.getAddress();
+    const { ethers } = await hre.network.connect();
+    const computeProviderFactory = await ethers.getContractFactory("MockComputeProvider");
+    const computeProvider = await computeProviderFactory.deploy();
+    await computeProvider.waitForDeployment();
+    const computeProviderAddress = await computeProvider.getAddress();
     const [signer] = await ethers.getSigners();
     const chain = hre.globalOptions.network;
     const blockNumber = await ethers.provider.getBlockNumber();

package/dist/scripts/deployAndSave/mockDecryptionVerifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mockDecryptionVerifier.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/mockDecryptionVerifier.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAGnE,OAAO,EACL,sBAAsB,EAEvB,MAAM,aAAa,CAAC;AAGrB,eAAO,MAAM,mCAAmC,GAC9C,KAAK,yBAAyB,KAC7B,OAAO,CAAC;IACT,kBAAkB,EAAE,sBAAsB,CAAC;CAC5C,CA8BA,CAAC"}
+{"version":3,"file":"mockDecryptionVerifier.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/mockDecryptionVerifier.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EACL,sBAAsB,EAEvB,MAAM,aAAa,CAAC;AAGrB,eAAO,MAAM,mCAAmC,GAC9C,KAAK,yBAAyB,KAC7B,OAAO,CAAC;IACT,kBAAkB,EAAE,sBAAsB,CAAC;CAC5C,CA8BA,CAAC"}

package/dist/scripts/deployAndSave/mockDecryptionVerifier.js

@@ -1,13 +1,13 @@
-import MockDecryptionVerifierModule from "../../ignition/modules/mockDecryptionVerifier";
 import { MockDecryptionVerifier__factory as MockDecryptionVerifierFactory, } from "../../types";
 import { storeDeploymentArgs } from "../utils";
 export const deployAndSaveMockDecryptionVerifier = async (hre) => {
-    const { ignition, ethers } = await hre.network.connect();
+    const { ethers } = await hre.network.connect();
     const [signer] = await ethers.getSigners();
     const chain = hre.globalOptions.network;
-    const decryptionVerifier = await ignition.deploy(MockDecryptionVerifierModule);
-    await decryptionVerifier.mockDecryptionVerifier.waitForDeployment();
-    const decryptionVerifierAddress = await decryptionVerifier.mockDecryptionVerifier.getAddress();
+    const decryptionVerifierFactory = await ethers.getContractFactory("MockDecryptionVerifier");
+    const decryptionVerifier = await decryptionVerifierFactory.deploy();
+    await decryptionVerifier.waitForDeployment();
+    const decryptionVerifierAddress = await decryptionVerifier.getAddress();
     const blockNumber = await ethers.provider.getBlockNumber();
     storeDeploymentArgs({
         blockNumber,

package/dist/scripts/deployAndSave/mockProgram.d.ts

@@ -1,10 +1,9 @@
 import type { HardhatRuntimeEnvironment } from "hardhat/types/hre";
 import { MockE3Program } from "../../types";
 interface MockProgramArgs {
-    mockInputValidator: string;
     hre: HardhatRuntimeEnvironment;
 }
-export declare const deployAndSaveMockProgram: ({ mockInputValidator, hre, }: MockProgramArgs) => Promise<{
+export declare const deployAndSaveMockProgram: ({ hre, }: MockProgramArgs) => Promise<{
     e3Program: MockE3Program;
 }>;
 export {};

package/dist/scripts/deployAndSave/mockProgram.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mockProgram.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/mockProgram.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAGnE,OAAO,EACL,aAAa,EAEd,MAAM,aAAa,CAAC;AAGrB,UAAU,eAAe;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,GAAG,EAAE,yBAAyB,CAAC;CAChC;AAED,eAAO,MAAM,wBAAwB,GAAU,8BAG5C,eAAe,KAAG,OAAO,CAAC;IAC3B,SAAS,EAAE,aAAa,CAAC;CAC1B,CA8CA,CAAC"}
+{"version":3,"file":"mockProgram.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/mockProgram.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EACL,aAAa,EAEd,MAAM,aAAa,CAAC;AAGrB,UAAU,eAAe;IACvB,GAAG,EAAE,yBAAyB,CAAC;CAChC;AAED,eAAO,MAAM,wBAAwB,GAAU,UAE5C,eAAe,KAAG,OAAO,CAAC;IAC3B,SAAS,EAAE,aAAa,CAAC;CAC1B,CA4BA,CAAC"}

package/dist/scripts/deployAndSave/mockProgram.js

@@ -1,27 +1,15 @@
-import MockE3ProgramModule from "../../ignition/modules/mockE3Program";
 import { MockE3Program__factory as MockE3ProgramFactory, } from "../../types";
-import { readDeploymentArgs, storeDeploymentArgs } from "../utils";
-export const deployAndSaveMockProgram = async ({ mockInputValidator, hre, }) => {
-    const { ignition, ethers } = await hre.network.connect();
+import { storeDeploymentArgs } from "../utils";
+export const deployAndSaveMockProgram = async ({ hre, }) => {
+    const { ethers } = await hre.network.connect();
     const [signer] = await ethers.getSigners();
     const chain = (await signer.provider?.getNetwork())?.name ?? "localhost";
-    const preDeployedArgs = readDeploymentArgs("MockE3Program", chain);
-    if (preDeployedArgs?.constructorArgs?.mockInputValidator === mockInputValidator) {
-        const e3ProgramContract = MockE3ProgramFactory.connect(preDeployedArgs.address, signer);
-        return { e3Program: e3ProgramContract };
-    }
-    const e3Program = await ignition.deploy(MockE3ProgramModule, {
-        parameters: {
-            MockE3Program: {
-                mockInputValidator,
-            },
-        },
-    });
-    await e3Program.mockE3Program.waitForDeployment();
-    const e3ProgramAddress = await e3Program.mockE3Program.getAddress();
+    const e3ProgramFactory = await ethers.getContractFactory("MockE3Program");
+    const e3Program = await e3ProgramFactory.deploy();
+    await e3Program.waitForDeployment();
+    const e3ProgramAddress = await e3Program.getAddress();
     const blockNumber = await ethers.provider.getBlockNumber();
     storeDeploymentArgs({
-        constructorArgs: { mockInputValidator },
         blockNumber,
         address: e3ProgramAddress,
     }, "MockE3Program", chain);

package/dist/scripts/deployAndSave/mockStableToken.d.ts

@@ -0,0 +1,18 @@
+import type { HardhatRuntimeEnvironment } from "hardhat/types/hre";
+import { MockUSDC } from "../../types";
+/**
+ * The arguments for the deployAndSaveMockStableToken function
+ */
+export interface MockStableTokenArgs {
+    initialSupply?: number;
+    hre: HardhatRuntimeEnvironment;
+}
+/**
+ * Deploys the MockStableToken contract and saves the deployment arguments
+ * @param param0 - The deployment arguments
+ * @returns The deployed MockStableToken contract
+ */
+export declare const deployAndSaveMockStableToken: ({ initialSupply, hre, }: MockStableTokenArgs) => Promise<{
+    mockStableToken: MockUSDC;
+}>;
+//# sourceMappingURL=mockStableToken.d.ts.map

package/dist/scripts/deployAndSave/mockStableToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockStableToken.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/mockStableToken.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EAAE,QAAQ,EAAwC,MAAM,aAAa,CAAC;AAG7E;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,GAAG,EAAE,yBAAyB,CAAC;CAChC;AAED;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,GAAU,yBAGhD,mBAAmB,KAAG,OAAO,CAAC;IAC/B,eAAe,EAAE,QAAQ,CAAC;CAC3B,CAiDA,CAAC"}

package/dist/scripts/deployAndSave/mockStableToken.js

@@ -0,0 +1,36 @@
+import { MockUSDC__factory as MockUSDCFactory } from "../../types";
+import { readDeploymentArgs, storeDeploymentArgs } from "../utils";
+/**
+ * Deploys the MockStableToken contract and saves the deployment arguments
+ * @param param0 - The deployment arguments
+ * @returns The deployed MockStableToken contract
+ */
+export const deployAndSaveMockStableToken = async ({ initialSupply, hre, }) => {
+    const { ethers } = await hre.network.connect();
+    const [signer] = await ethers.getSigners();
+    const chain = (await signer.provider?.getNetwork())?.name ?? "localhost";
+    const preDeployedArgs = readDeploymentArgs("MockUSDC", chain);
+    if (initialSupply === undefined ||
+        preDeployedArgs?.constructorArgs?.initialSupply ===
+            initialSupply?.toString()) {
+        if (!preDeployedArgs?.address) {
+            throw new Error("MockUSDC address not found, it must be deployed first");
+        }
+        const mockStableTokenContract = MockUSDCFactory.connect(preDeployedArgs.address, signer);
+        return { mockStableToken: mockStableTokenContract };
+    }
+    const mockStableTokenFactory = await ethers.getContractFactory("MockUSDC");
+    const mockStableToken = await mockStableTokenFactory.deploy(initialSupply);
+    await mockStableToken.waitForDeployment();
+    const blockNumber = await ethers.provider.getBlockNumber();
+    const mockStableTokenAddress = await mockStableToken.getAddress();
+    storeDeploymentArgs({
+        constructorArgs: {
+            initialSupply: initialSupply?.toString(),
+        },
+        blockNumber,
+        address: mockStableTokenAddress,
+    }, "MockUSDC", chain);
+    const mockStableTokenContract = MockUSDCFactory.connect(mockStableTokenAddress, signer);
+    return { mockStableToken: mockStableTokenContract };
+};

package/dist/scripts/deployAndSave/poseidonT3.d.ts

@@ -0,0 +1,11 @@
+import type { HardhatRuntimeEnvironment } from "hardhat/types/hre";
+interface PoseidonT3ProxyDeployArgs {
+    hre: HardhatRuntimeEnvironment;
+}
+/**
+ * Deploy and save PoseidonT3 contract behind a proxy
+ * @param param0
+ */
+export declare const deployAndSavePoseidonT3: ({ hre, }: PoseidonT3ProxyDeployArgs) => Promise<string>;
+export {};
+//# sourceMappingURL=poseidonT3.d.ts.map

package/dist/scripts/deployAndSave/poseidonT3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poseidonT3.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/poseidonT3.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAKnE,UAAU,yBAAyB;IACjC,GAAG,EAAE,yBAAyB,CAAC;CAChC;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAU,UAE3C,yBAAyB,KAAG,OAAO,CAAC,MAAM,CA6C5C,CAAC"}