@diamondslab/diamonds 1.0.0 → 1.1.2

package/examples/defender-deployment/upgrade-script.ts

@@ -1,237 +0,0 @@
-import { ethers } from 'hardhat';
-import { Diamond } from '../../src/core/Diamond';
-import { DiamondDeployer } from '../../src/core/DiamondDeployer';
-import { FileDeploymentRepository } from '../../src/repositories/FileDeploymentRepository';
-import { OZDefenderDeploymentStrategy } from '../../src/strategies/OZDefenderDeploymentStrategy';
-import * as path from 'path';
-import * as fs from 'fs-extra';
-
-async function main() {
-  console.log('♻️ Starting upgrade process...');
-
-  // Get network information
-  const network = await ethers.provider.getNetwork();
-  const signers = await ethers.getSigners();
-  const deployer = signers[0];
-
-  console.log(`📍 Network: ${network.name} (${network.chainId})`);
-  console.log(`👤 Deployer: ${deployer.address}`);
-
-  // Load and update configuration
-  const configPath = path.join(__dirname, 'diamond-config.json');
-  const deploymentDataPath = path.join(__dirname, 'deployments', `examplediamond-${network.name}-${network.chainId}.json`);
-
-  // Check if initial deployment exists
-  if (!await fs.pathExists(deploymentDataPath)) {
-    console.error('❌ No existing deployment found. Please run deploy-script.ts first.');
-    process.exit(1);
-  }
-
-  console.log('📄 Loading existing deployment data...');
-
-  // Load current configuration
-  const config = await fs.readJson(configPath);
-  const originalVersion = config.protocolVersion;
-
-  console.log(`📊 Current protocol version: ${originalVersion}`);
-
-  // Update configuration for upgrade
-  config.protocolVersion = 1.0;
-
-  // Add new UpgradeFacet
-  config.facets['UpgradeFacet'] = {
-    priority: 50,
-    versions: {
-      "1.0": {
-        deployInit: "initialize()",
-        callbacks: ["logUpgrade"]
-      }
-    }
-  };
-
-  // Upgrade existing ExampleFacet1 to version 1.0
-  if (!config.facets['ExampleFacet1'].versions) {
-    config.facets['ExampleFacet1'].versions = {};
-  }
-  config.facets['ExampleFacet1'].versions["1.0"] = {
-    upgradeInit: "upgradeToV1()",
-    callbacks: ["validateUpgrade"]
-  };
-
-  console.log('📝 Updated configuration:');
-  console.log(`  - Protocol version: ${originalVersion} → ${config.protocolVersion}`);
-  console.log('  - Added UpgradeFacet v1.0');
-  console.log('  - Upgraded ExampleFacet1 to v1.0');
-
-  // Save updated configuration
-  await fs.writeJson(configPath, config, { spaces: 2 });
-
-  // Setup diamond configuration
-  const diamondConfig = {
-    diamondName: 'ExampleDiamond',
-    networkName: network.name,
-    chainId: network.chainId,
-    deploymentsPath: path.join(__dirname, 'deployments'),
-    contractsPath: path.join(__dirname, 'contracts'),
-    callbacksPath: path.join(__dirname, 'callbacks'),
-    configFilePath: configPath,
-    deployedDiamondDataFilePath: deploymentDataPath
-  };
-
-  // Create diamond instance
-  const repository = new FileDeploymentRepository(diamondConfig);
-  const diamond = new Diamond(diamondConfig, repository);
-
-  diamond.setProvider(ethers.provider);
-  diamond.setSigner(deployer);
-
-  // Validate environment variables
-  const requiredEnvVars = [
-    'DEFENDER_API_KEY',
-    'DEFENDER_API_SECRET',
-    'DEFENDER_RELAYER_ADDRESS',
-    'DEFENDER_SAFE_ADDRESS'
-  ];
-
-  for (const envVar of requiredEnvVars) {
-    if (!process.env[envVar]) {
-      console.error(`❌ Missing required environment variable: ${envVar}`);
-      process.exit(1);
-    }
-  }
-
-  // Create Defender strategy
-  const strategy = new OZDefenderDeploymentStrategy(
-    process.env.DEFENDER_API_KEY!,
-    process.env.DEFENDER_API_SECRET!,
-    process.env.DEFENDER_RELAYER_ADDRESS!,
-    process.env.AUTO_APPROVE === 'true',
-    process.env.DEFENDER_SAFE_ADDRESS!,
-    'Safe',
-    true // verbose logging
-  );
-
-  console.log('🛡️ Defender strategy configured for upgrade');
-
-  // Load existing deployment data to show before state
-  const existingData = diamond.getDeployedDiamondData();
-  console.log('\n📊 Pre-upgrade State:');
-  console.log(`Diamond Address: ${existingData.DiamondAddress}`);
-  if (existingData.DeployedFacets) {
-    console.log('Current Facets:');
-    Object.entries(existingData.DeployedFacets).forEach(([name, facet]) => {
-      console.log(`  ${name}: v${facet.version} at ${facet.address}`);
-    });
-  }
-
-  // Execute upgrade
-  const diamondDeployer = new DiamondDeployer(diamond, strategy);
-
-  try {
-    console.log('\n🚀 Starting upgrade deployment...');
-    await diamondDeployer.deployDiamond(); // Automatically detects upgrade scenario
-
-    console.log('\n✅ Upgrade completed successfully!');
-
-    // Output upgrade information
-    const upgradedData = diamond.getDeployedDiamondData();
-    console.log('\n📊 Post-upgrade State:');
-    console.log(`Diamond Address: ${upgradedData.DiamondAddress}`);
-
-    if (upgradedData.DeployedFacets) {
-      console.log('Updated Facets:');
-      Object.entries(upgradedData.DeployedFacets).forEach(([name, facet]) => {
-        const isNew = !existingData.DeployedFacets?.[name];
-        const isUpgraded = existingData.DeployedFacets?.[name]?.version !== facet.version;
-
-        let status = '';
-        if (isNew) status = ' [NEW]';
-        else if (isUpgraded) status = ' [UPGRADED]';
-
-        console.log(`  ${name}: v${facet.version} at ${facet.address}${status}`);
-      });
-    }
-
-    // Create upgrade summary
-    const upgradeSummary = {
-      timestamp: new Date().toISOString(),
-      network: network.name,
-      chainId: network.chainId,
-      deployerAddress: deployer.address,
-      diamondAddress: upgradedData.DiamondAddress,
-      upgrade: {
-        fromVersion: originalVersion,
-        toVersion: config.protocolVersion,
-        newFacets: ['UpgradeFacet'],
-        upgradedFacets: ['ExampleFacet1'],
-        deploymentMethod: 'OpenZeppelin Defender'
-      },
-      facets: upgradedData.DeployedFacets
-    };
-
-    const summaryPath = path.join(diamondConfig.deploymentsPath, 'upgrade-summary.json');
-    await fs.writeJson(summaryPath, upgradeSummary, { spaces: 2 });
-
-    console.log(`\n📄 Upgrade summary saved to: ${summaryPath}`);
-
-    // Display next steps
-    console.log('\n🎯 Next Steps:');
-    console.log('1. Test new functionality');
-    console.log('2. Verify upgrade initialization');
-    console.log('3. Update documentation');
-    console.log('4. Notify stakeholders');
-
-    if (process.env.AUTO_APPROVE !== 'true') {
-      console.log('\n⚠️ Note: Auto-approval is disabled. Check your Defender dashboard for pending proposals.');
-    }
-
-  } catch (error) {
-    console.error('\n❌ Upgrade failed:', error);
-
-    // Restore original configuration
-    config.protocolVersion = originalVersion;
-    delete config.facets['UpgradeFacet'];
-    if (config.facets['ExampleFacet1'].versions && config.facets['ExampleFacet1'].versions["1.0"]) {
-      delete config.facets['ExampleFacet1'].versions["1.0"];
-    }
-    await fs.writeJson(configPath, config, { spaces: 2 });
-
-    console.log('🔄 Configuration restored to pre-upgrade state');
-
-    // Save error information
-    const errorInfo = {
-      timestamp: new Date().toISOString(),
-      error: error instanceof Error ? {
-        message: error.message,
-        stack: error.stack,
-        name: error.name
-      } : String(error),
-      network: network.name,
-      chainId: network.chainId,
-      deployerAddress: deployer.address,
-      attemptedUpgrade: {
-        fromVersion: originalVersion,
-        toVersion: 1.0
-      }
-    };
-
-    const errorPath = path.join(diamondConfig.deploymentsPath, 'upgrade-error.json');
-    await fs.writeJson(errorPath, errorInfo, { spaces: 2 });
-
-    console.log(`\n🔍 Error details saved to: ${errorPath}`);
-
-    process.exit(1);
-  }
-}
-
-// Handle script execution
-if (require.main === module) {
-  main()
-    .then(() => process.exit(0))
-    .catch((error) => {
-      console.error('Unhandled error:', error);
-      process.exit(1);
-    });
-}
-
-export { main as upgradeWithDefender };

package/examples/hardhat-diamonds-config.example.ts

@@ -1,41 +0,0 @@
-// Example hardhat.config.ts extension for hardhat-diamonds integration
-// This would be used when the hardhat-diamonds plugin is available
-
-import { HardhatUserConfig } from "hardhat/config";
-import "@nomiclabs/hardhat-waffle";
-import "@nomiclabs/hardhat-ethers";
-// import "@gnus.ai/hardhat-diamonds"; // When available
-
-const config: HardhatUserConfig = {
-  solidity: "0.8.17",
-
-  // Extended configuration for hardhat-diamonds plugin
-  diamonds: {
-    // Multiple diamond configurations can be defined
-    ProxyDiamond: {
-      deploymentsPath: "./diamonds",
-      contractsPath: "./contracts",
-      callbacksPath: "./diamonds/ProxyDiamond/callbacks",
-      configFilePath: "./diamonds/ProxyDiamond/proxydiamond.config.json",
-      // Network-specific deployment file paths will be auto-generated
-    },
-
-    TestDiamond: {
-      deploymentsPath: "./test-diamonds",
-      contractsPath: "./test/mocks/contracts",
-      callbacksPath: "./test-diamonds/TestDiamond/callbacks",
-      configFilePath: "./test-diamonds/TestDiamond/testdiamond.config.json",
-    },
-
-    // More diamonds can be configured...
-  },
-
-  networks: {
-    hardhat: {
-      chainId: 31337,
-    },
-    // Other networks...
-  },
-};
-
-export default config;

package/src/core/CallbackManager.ts

@@ -1,70 +0,0 @@
-import * as fs from "fs-extra";
-import { resolve, join } from "path";
-import { CallbackArgs } from "../types";
-
-export class CallbackManager {
-  private static instances: Map<string, CallbackManager> = new Map();
-
-  private callbacks: Record<string, Record<string, (args: CallbackArgs) => Promise<void>>> = {};
-
-  private constructor(private callbacksPath: string) {
-    this.loadCallbacks();
-  }
-
-  public static getInstance(diamondName: string, deploymentsPath: string): CallbackManager {
-    if (!this.instances.has(diamondName)) {
-      const callbacksPath = join(deploymentsPath, diamondName, "callbacks");
-      this.instances.set(diamondName, new CallbackManager(callbacksPath));
-    }
-    return this.instances.get(diamondName)!;
-  }
-
-  public static clearInstances(): void {
-    this.instances.clear();
-  }
-
-  public static clearInstance(diamondName: string): void {
-    this.instances.delete(diamondName);
-  }
-
-  private loadCallbacks(): void {
-    if (!fs.existsSync(this.callbacksPath)) {
-      console.error(`Facet callbacks path "${this.callbacksPath}" does not exist.`);
-      return;
-    }
-
-    const files = fs.readdirSync(this.callbacksPath);
-
-    files.forEach(file => {
-      if (!file.endsWith(".ts") && !file.endsWith(".js")) return;
-
-      const facetName = file.split(".")[0];
-      const filePath = resolve(this.callbacksPath, file);
-      const module = require(filePath);
-
-      this.callbacks[facetName] = {};
-
-      Object.entries(module).forEach(([callbackName, callbackFn]) => {
-        if (typeof callbackFn === 'function') {
-          this.callbacks[facetName][callbackName] = callbackFn as (args: CallbackArgs) => Promise<void>;
-        }
-      });
-    });
-  }
-
-  public async executeCallback(facetName: string, callbacks: string[], args: CallbackArgs): Promise<void> {
-    const registeredCallbacks = this.callbacks[facetName];
-    for (const callbackName of callbacks) {
-      if (!registeredCallbacks) {
-        throw new Error(`Callbacks for facet "${facetName}" not found.`);
-      }
-
-      const callback = registeredCallbacks[callbackName];
-      if (!callback) {
-        throw new Error(`Callback "${callbackName}" for facet "${facetName}" not found.`);
-      }
-
-      await callback(args);
-    }
-  }
-}

package/src/core/DeploymentManager.ts

@@ -1,64 +0,0 @@
-import { DeploymentStrategy } from "../strategies/DeploymentStrategy";
-import { Diamond } from "./Diamond";
-
-export class DeploymentManager {
-  private diamond: Diamond;
-  private strategy: DeploymentStrategy;
-
-  constructor(diamond: Diamond, strategy: DeploymentStrategy) {
-    this.diamond = diamond;
-    this.strategy = strategy;
-  }
-
-  async deploy(): Promise<void> {
-    console.log(`🚀 Starting deployment for Diamond: ${this.diamond.diamondName}`);
-    this.diamond.newDeployment = true;
-
-    await this.strategy.preDeployDiamond(this.diamond);
-    await this.strategy.deployDiamond(this.diamond);
-    await this.strategy.postDeployDiamond(this.diamond);
-
-    await this.strategy.preDeployFacets(this.diamond);
-    await this.strategy.deployFacets(this.diamond);
-    await this.strategy.postDeployFacets(this.diamond);
-
-    await this.strategy.preUpdateFunctionSelectorRegistry(this.diamond);
-    await this.strategy.updateFunctionSelectorRegistry(this.diamond);
-    await this.strategy.postUpdateFunctionSelectorRegistry(this.diamond);
-
-    await this.strategy.prePerformDiamondCut(this.diamond);
-    await this.strategy.performDiamondCut(this.diamond);
-    await this.strategy.postPerformDiamondCut(this.diamond);
-
-    await this.strategy.preRunPostDeployCallbacks(this.diamond);
-    await this.strategy.runPostDeployCallbacks(this.diamond);
-    await this.strategy.postRunPostDeployCallbacks(this.diamond);
-
-    console.log(`✅ Deployment completed successfully.`);
-  }
-
-  async upgrade(): Promise<void> {
-    console.log(`♻️ Starting upgrade for Diamond: ${this.diamond.diamondName}`);
-
-    this.diamond.newDeployment = false;
-
-    await this.strategy.preDeployFacets(this.diamond);
-    await this.strategy.deployFacets(this.diamond);
-    await this.strategy.postDeployFacets(this.diamond);
-
-    await this.strategy.preUpdateFunctionSelectorRegistry(this.diamond);
-    await this.strategy.updateFunctionSelectorRegistry(this.diamond);
-    await this.strategy.postUpdateFunctionSelectorRegistry(this.diamond);
-
-    await this.strategy.prePerformDiamondCut(this.diamond);
-    await this.strategy.performDiamondCut(this.diamond);
-    await this.strategy.postPerformDiamondCut(this.diamond);
-
-    await this.strategy.preRunPostDeployCallbacks(this.diamond);
-    await this.strategy.runPostDeployCallbacks(this.diamond);
-    await this.strategy.postRunPostDeployCallbacks(this.diamond);
-
-    console.log(`✅ Upgrade completed successfully.`);
-  }
-
-}

package/src/core/Diamond.ts

@@ -1,197 +0,0 @@
-import { join } from "path";
-import {
-  DeployedDiamondData,
-  DeployedFacets,
-  DeployedFacet,
-  DeployConfig,
-  FacetsConfig
-} from "../schemas";
-import { CallbackManager } from "./CallbackManager";
-import { JsonRpcProvider, Provider } from "@ethersproject/providers";
-import { Signer } from "ethers";
-import { DeploymentRepository } from "../repositories/DeploymentRepository";
-import {
-  DiamondConfig,
-  RegistryFacetCutAction,
-  FunctionSelectorRegistryEntry,
-  NewDeployedFacets,
-  NewDeployedFacet
-} from "../types";
-import { ethers } from "ethers";
-import { HardhatEthersProvider } from "@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider";
-
-export class Diamond {
-  private static instances: Map<string, Diamond> = new Map();
-
-  public diamondName: string;
-  public networkName: string;
-  public chainId: number | bigint;
-  public deploymentsPath: string;
-  public contractsPath: string;
-  public diamondAbiPath: string;
-  public diamondAbiFileName: string;
-  public deploymentId: string;
-  public facetSelectors: string[] = [];
-  public callbackManager: CallbackManager;
-  private deployedDiamondData: DeployedDiamondData;
-  private config: DiamondConfig;
-  private facetsConfig: FacetsConfig;
-  private repository: DeploymentRepository;
-  public signer: Signer | undefined;
-  public provider: JsonRpcProvider | Provider | HardhatEthersProvider | undefined;
-  public deployConfig: DeployConfig;
-  public newDeployment: boolean = true;
-  public initAddress: string | undefined;
-
-  constructor(config: DiamondConfig, repository: DeploymentRepository) {
-    this.config = config;
-    this.diamondName = config.diamondName;
-    this.networkName = config.networkName || "hardhat";
-    this.chainId = config.chainId || 31337;
-    this.deploymentsPath = config.deploymentsPath || "diamonds";
-    this.contractsPath = config.contractsPath || "contracts";
-    this.diamondAbiFileName = config.diamondAbiFileName || config.diamondName;
-    
-    // Set diamond ABI path - default to diamond-abi subdirectory of configFilePath directory
-    if (config.diamondAbiPath) {
-      this.diamondAbiPath = config.diamondAbiPath;
-    } else {
-      const configDir = config.configFilePath 
-        ? config.configFilePath.replace(/\/[^\/]*$/, '') // Remove filename from path
-        : join(this.deploymentsPath, config.diamondName);
-      this.diamondAbiPath = join(configDir, 'diamond-abi');
-    }
-    
-    this.repository = repository;
-    this.deploymentId = repository.getDeploymentId();
-
-    // Load existing deployment info
-    this.deployedDiamondData = this.repository.loadDeployedDiamondData();
-    this.deployConfig = this.repository.loadDeployConfig();
-
-    this.facetsConfig = this.deployConfig.facets;
-
-    this.callbackManager = CallbackManager.getInstance(
-      this.diamondName, this.deploymentsPath);
-
-    this._initializeFunctionSelectorRegistry(this);
-  }
-
-  public functionSelectorRegistry = new Map<string, FunctionSelectorRegistryEntry>();
-
-  private _initializeFunctionSelectorRegistry(
-    diamond: Diamond
-  ) {
-    const diamondConfig: DiamondConfig = diamond.getDiamondConfig();
-    const deployedDiamondData: DeployedDiamondData = diamond.getDeployedDiamondData();
-    const deployedFacets: DeployedFacets = deployedDiamondData.DeployedFacets || {};
-
-    for (const [facetName, { address: contractAddress, funcSelectors: selectors }] of Object.entries(deployedFacets)) {
-      console.log(facetName);
-      for (const selector of selectors!) {
-        this.functionSelectorRegistry.set(selector, {
-          facetName,
-          priority: this.facetsConfig[facetName]?.priority! || 1000,
-          address: contractAddress!,
-          action: RegistryFacetCutAction.Deployed,
-        });
-      }
-    }
-  }
-
-  public registerFunctionSelectors(selectors: Record<string, Omit<FunctionSelectorRegistryEntry, "selector">>): void {
-    Object.entries(selectors).forEach(([selector, entry]) => {
-      this.functionSelectorRegistry.set(selector, entry);
-    });
-  }
-
-  public updateFunctionSelectorRegistry(selector: string, entry: FunctionSelectorRegistryEntry): void {
-    this.functionSelectorRegistry.set(selector, entry);
-  }
-
-  public isFunctionSelectorRegistered(selector: string): boolean {
-    return this.functionSelectorRegistry.has(selector);
-  }
-
-  public newDeployedFacets: NewDeployedFacets = {};
-
-  public getNewDeployedFacets(): NewDeployedFacets {
-    return this.newDeployedFacets || {};
-  }
-
-  public updateNewDeployedFacets(facetName: string, facet: NewDeployedFacet): void {
-    this.newDeployedFacets[facetName] = facet;
-  }
-
-  getDeployedDiamondData(): DeployedDiamondData {
-    return this.deployedDiamondData;
-  }
-
-  setDeployedDiamondData(data: DeployedDiamondData) {
-    this.deployedDiamondData = data;
-  }
-
-  updateDeployedDiamondData(data: DeployedDiamondData): void {
-    this.deployedDiamondData = data;
-    this.repository.saveDeployedDiamondData(data);
-  }
-
-  public getDiamondConfig(): DiamondConfig {
-    return this.config;
-  }
-
-  public getDeployConfig(): DeployConfig {
-    return this.deployConfig;
-  }
-
-  public getFacetsConfig(): FacetsConfig {
-    return this.facetsConfig;
-  }
-
-  public setProvider(provider: JsonRpcProvider | Provider | HardhatEthersProvider): void {
-    this.provider = provider;
-  }
-
-  public getProvider(): JsonRpcProvider | Provider | HardhatEthersProvider | undefined {
-    return this.provider;
-  }
-
-  public setSigner(signer: Signer): void {
-    this.signer = signer;
-  }
-
-  public getSigner(): Signer | undefined {
-    return this.signer;
-  }
-
-  public isUpgradeDeployment(): boolean {
-    return !!this.deployedDiamondData.DiamondAddress;
-  }
-
-  public initializerRegistry: Map<string, string> = new Map();
-
-  public registerInitializers(facetName: string, initFunction: string): void {
-    this.initializerRegistry.set(facetName, initFunction);
-  }
-
-  public setInitAddress(initAddress: string): void {
-    this.initAddress = initAddress;
-  }
-  public getInitAddress(): string | undefined {
-    return this.initAddress;
-  }
-
-  public getDiamondAbiPath(): string {
-    return this.diamondAbiPath;
-  }
-
-  public getDiamondAbiFileName(): string {
-    return this.diamondAbiFileName;
-  }
-
-  public getDiamondAbiFilePath(): string {
-    return join(this.diamondAbiPath, `${this.diamondAbiFileName}.json`);
-  }
-}
-
-export default Diamond;

package/src/core/DiamondDeployer.ts

@@ -1,36 +0,0 @@
-import { Diamond } from './Diamond';
-import { DeploymentManager } from './DeploymentManager';
-import { DeploymentStrategy } from '../strategies';
-import { DeployedDiamondData } from '../schemas';
-
-export class DiamondDeployer {
-  // private provider: JsonRpcProvider;
-  private diamond: Diamond;
-  private strategy: DeploymentStrategy;
-
-  constructor(
-    diamond: Diamond,
-    strategy: DeploymentStrategy
-  ) {
-    this.diamond = diamond;
-    this.strategy = strategy;;
-  }
-
-  async deployDiamond(): Promise<void> {
-    const manager = new DeploymentManager(this.diamond, this.strategy);
-    let deployedDiamondData: DeployedDiamondData;
-    const deployedData = this.diamond.getDeployedDiamondData();
-    if (deployedData && deployedData.DiamondAddress) {
-      deployedDiamondData = deployedData;
-      console.log(`Diamond already deployed at ${deployedDiamondData.DiamondAddress}. Performing upgrade...`);
-      await manager.upgrade();
-    } else {
-      console.log(`Diamond not previously deployed. Performing initial deployment...`);
-      await manager.deploy();
-    }
-  }
-
-  public getDiamond(): Diamond {
-    return this.diamond;
-  }
-}

package/src/core/index.ts

@@ -1,4 +0,0 @@
-export { Diamond } from "./Diamond";
-export { DiamondDeployer } from "./DiamondDeployer";
-export { DeploymentManager } from "./DeploymentManager";
-export { CallbackManager } from "./CallbackManager";

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from "./core";
-export * from "./types";
-export * from "./strategies";
-export * from "./schemas";
-export * from "./utils";

package/src/repositories/DBDeploymentRepository.ts

@@ -1,22 +0,0 @@
-// import {
-//   readDeployedDiamondData,
-//   saveDeploymentInfo,
-//   getDeployConfigData
-// } from './databaseHandler';
-
-// import { DeploymentRepository } from './DeploymentRepository';
-// import { DeployedDiamondData, DeployConfig } from '../schemas';
-
-// export class DbDeploymentRepository implements DeploymentRepository {
-//   async loadDeployInfo(key: { network: string; diamond: string }): Promise<DeployedDiamondData> {
-//     return await readDeployedDiamondData(key.network, key.diamond);
-//   }
-
-//   async saveDeployInfo(key: { network: string; diamond: string }, info: DeployedDiamondData): Promise<void> {
-//     await saveDeploymentInfo(key.network, key.diamond, info);
-//   }
-
-//   async loadDeployConfig(key: { projectId: string }): Promise<DeployConfig> {
-//     return await getDeployConfigData(key.projectId);
-//   }
-// }

package/src/repositories/DeploymentRepository.ts

@@ -1,12 +0,0 @@
-// DeploymentRepository.ts
-import { DeployedDiamondData, DeployConfig } from "../schemas";
-
-export abstract class DeploymentRepository {
-  abstract loadDeployedDiamondData(): DeployedDiamondData;
-
-  abstract saveDeployedDiamondData(info: DeployedDiamondData): void;
-
-  abstract loadDeployConfig(): DeployConfig;
-
-  abstract getDeploymentId(): string;
-}