@diamondslab/diamonds 1.0.0

package/package.json

@@ -0,0 +1,228 @@
+{
+  "name": "@diamondslab/diamonds",
+  "version": "1.0.0",
+  "description": "Tools for deploying and interfacing with ERC-2535 Diamond Proxies",
+  "repository": "github:diamondslab/diamonds",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "authors": [
+    "Am0rfu5",
+    "SuperGenius"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "ethereum",
+    "smart-contracts",
+    "hardhat",
+    "hardhat-plugin",
+    "diamond",
+    "diamond-proxy",
+    "diamond-upgradeable",
+    "blockchain"
+  ],
+  "bugs": {
+    "url": "https://github.com/diamondslab/diamonds/issues"
+  },
+  "scripts": {
+    "test": "hardhat test --config hardhat.config.ts",
+    "test:unit": "hardhat test test/unit/**/*.test.ts --config hardhat.config.ts",
+    "test:integration": "hardhat test test/integration/**/*.test.ts --config hardhat.config.ts",
+    "test:coverage": "hardhat coverage --config hardhat.config.ts",
+    "test:performance": "hardhat test test/integration/performance/**/*.test.ts --config hardhat.config.ts",
+    "build": "yarn clean-compile && npx tsc",
+    "clean": "rimraf artifacts/* cache/* diamond-abi/* typechain-types/* diamond-typechain-types/*",
+    "compile": "npx hardhat compile --config hardhat.config.ts && yarn diamond:generate-abi-typechain",
+    "clean-compile": "yarn clean && yarn compile",
+    "lint:fix": "prettier --write 'src/**/*.{js,ts}' 'test/**/*.{js,ts}' && tslint --fix --config tslint.json --project tsconfig.dev.json",
+    "lint": "tslint --config tslint.json --project tsconfig.dev.json",
+    "build:dev": "tsc --project tsconfig.dev.json --noEmit",
+    "watch": "tsc --project tsconfig.json -w",
+    "prepublishOnly": "yarn build",
+    "defender:deploy": "ts-node scripts/defender-cli.ts deploy",
+    "defender:upgrade": "ts-node scripts/defender-cli.ts upgrade",
+    "defender:status": "ts-node scripts/defender-cli.ts status",
+    "defender:verify": "ts-node scripts/defender-cli.ts verify",
+    "defender:init": "ts-node scripts/defender-cli.ts init",
+    "rpc:deploy": "ts-node scripts/deploy-rpc.ts deploy",
+    "rpc:deploy-quick": "ts-node scripts/deploy-rpc.ts quick",
+    "rpc:upgrade": "ts-node scripts/upgrade-rpc.ts upgrade",
+    "rpc:upgrade-quick": "ts-node scripts/upgrade-rpc.ts quick",
+    "rpc:status": "ts-node scripts/status-rpc.ts check",
+    "rpc:status-quick": "ts-node scripts/status-rpc.ts quick",
+    "rpc:verify": "ts-node scripts/verify-rpc.ts verify",
+    "rpc:verify-full": "ts-node scripts/verify-rpc.ts full",
+    "rpc:deploy-manual": "ts-node scripts/deploy-rpc-manual.ts deploy",
+    "rpc:deploy-interactive": "ts-node scripts/deploy-rpc-manual.ts interactive",
+    "diamonds-clean": "rm -rf diamond-typechain-types diamond-abi && npx hardhat clean",
+    "coverage": "npx hardhat coverage",
+    "diamond:generate-abi": "npx hardhat diamond:generate-abi --diamond-name Diamond",
+    "diamond:generate-abi-typechain": "npx hardhat diamond:generate-abi-typechain --diamond-name Diamond",
+    "format": "prettier --write \"**/*.{ts,js,json,md,sol}\"",
+    "install:frozen": "yarn install --frozen-lockfile",
+    "precommit": ".husky/pre-commit",
+    "prepush": ".husky/pre-push",
+    "pc": "yarn precommit",
+    "pp": "yarn prepush",
+    "ls": "lint-staged",
+    "commitlint": "commitlint --edit",
+    "lint-staged": "npx lint-staged",
+    "audit": "yarn npm audit --severity moderate",
+    "depcheck": "yarn dlx depcheck",
+    "snyk:test": "snyk test --all-projects --exclude=yarn.lock --severity-threshold=medium",
+    "socket:scan": "SOCKET_CLI_API_TOKEN=$(grep SOCKET_CLI_API_TOKEN .env | cut -d'=' -f2) npx socket ci",
+    "osv:scan": "osv-scanner --lockfile=yarn.lock --format=json",
+    "semgrep:scan": "semgrep scan --config .semgrep.yml --exclude-rule weak-encryption --error",
+    "slither:scan": "slither . --config-file slither.config.json --ignore-compile",
+    "slither:check": "slither . --config-file slither.config.json --checklist",
+    "git-secrets:scan": "git secrets --scan",
+    "perf-monitor": "npx ts-node scripts/devops/perf-monitor.ts",
+    "ci-perf-monitor": "node scripts/devops/ci-perf-monitor.js",
+    "sign-artifacts": "npx ts-node scripts/devops/sign-artifacts.ts",
+    "emergency-bypass": "npx ts-node scripts/devops/emergency-bypass.ts",
+    "security-check": "yarn audit && yarn snyk:test && yarn socket:scan && yarn osv:scan && yarn semgrep:scan && yarn slither:scan && yarn git-secrets:scan",
+    "security-tool-update": "npx ts-node scripts/devops/security-tool-updater.ts",
+    "provenance-check": "npx ts-node scripts/devops/provenance-validator.ts",
+    "slsa-attest": "npx ts-node scripts/devops/slsa-attestation.ts generate",
+    "sigstore-sign": "npx ts-node scripts/devops/sigstore-integration.ts sign-all",
+    "sigstore-verify": "npx ts-node scripts/devops/sigstore-integration.ts verify-all",
+    "supply-chain-assess": "npx ts-node scripts/devops/supply-chain-risk-assessment.ts assess",
+    "supply-chain-quick": "npx ts-node scripts/devops/supply-chain-risk-assessment.ts quick",
+    "security-webhook": "npx ts-node scripts/devops/security-monitoring-webhook.ts",
+    "security-alerting": "npx ts-node scripts/devops/security-alerting.ts",
+    "security-metrics": "npx ts-node scripts/devops/security-metrics-dashboard.ts",
+    "ci-performance-dashboard": "node scripts/devops/ci-performance-dashboard.js",
+    "cost-analyzer": "npx ts-node scripts/devops/cost-analyzer.ts",
+    "test-sharding": "npx ts-node scripts/devops/test-sharding.ts",
+    "smart-trigger": "npx ts-node scripts/devops/smart-trigger.ts",
+    "health-check": "npx ts-node scripts/devops/health-check.ts",
+    "maintenance-automation": "npx ts-node scripts/devops/maintenance-automation.ts",
+    "incident-response": "npx ts-node scripts/devops/incident-response.ts",
+    "security-health-checks": "npx ts-node scripts/devops/security-health-checks.ts",
+    "security-commit-check": "npx ts-node scripts/devops/security-commit-check.ts",
+    "prepare": "husky",
+    "container:build": "node scripts/devops/container-registry-manager.sh build",
+    "container:push": "node scripts/devops/container-registry-manager.sh push",
+    "container:pull": "node scripts/devops/container-registry-manager.sh pull",
+    "container:exists": "node scripts/devops/container-registry-manager.sh exists",
+    "container:validate": "bash scripts/devops/devcontainer-setup-validation.sh",
+    "container:cleanup": "node scripts/devops/container-registry-manager.sh cleanup",
+    "container:report": "node scripts/devops/container-registry-manager.sh report",
+    "env:parity": "bash scripts/devops/environment-parity-validation.sh",
+    "perf:benchmark": "bash scripts/devops/devcontainer-performance-benchmark.sh all --environment native",
+    "perf:benchmark:container": "bash scripts/devops/devcontainer-performance-benchmark.sh all --environment container",
+    "perf:compare": "bash scripts/devops/devcontainer-performance-benchmark.sh compare"
+  },
+  "bin": {
+    "diamond-abi": "dist/scripts/diamond-abi-cli.js"
+  },
+  "files": [
+    "dist/",
+    "src/",
+    "docs/",
+    "examples/",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@ethersproject/abi": "^5.8.0",
+    "@ethersproject/bytes": "^5.8.0",
+    "@ethersproject/providers": "^5.8.0",
+    "@gnus.ai/contracts-upgradeable-diamond": "=4.5.0",
+    "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
+    "@nomicfoundation/hardhat-ignition": "^0.15.0",
+    "@nomicfoundation/hardhat-ignition-ethers": "^0.15.0",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
+    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
+    "@nomicfoundation/hardhat-verify": "^2.0.0",
+    "@nomicfoundation/hardhat-web3-v4": "^1.0.0",
+    "@nomicfoundation/ignition-core": "^0.15.9",
+    "@openzeppelin/defender-sdk": "^2.6.0",
+    "@openzeppelin/defender-sdk-base-client": "^2.6.0",
+    "@openzeppelin/defender-sdk-deploy-client": "^2.6.0",
+    "@openzeppelin/defender-sdk-proposal-client": "^2.6.0",
+    "@socketsecurity/cli": "^1.0.0",
+    "@typechain/ethers-v6": "^0.5.1",
+    "@typechain/hardhat": "^9.1.0",
+    "@types/chai": "^4.2.0",
+    "@types/chai-as-promised": "^8.0.1",
+    "@types/debug": "^4.1.12",
+    "@types/fs-extra": "^5.0.4",
+    "@types/glob": "^8.1.0",
+    "@types/jest": "^29.5.14",
+    "@types/lodash": "^4",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.0.12",
+    "@types/sinon-chai": "^4.0.0",
+    "@types/uint32": "^0.2.0",
+    "@typescript-eslint/eslint-plugin": "^8.18.1",
+    "@typescript-eslint/parser": "^8.18.10",
+    "abi2oas": "^0.1.4",
+    "chai": "^4.2.0",
+    "chai-as-promised": "^7.1.1",
+    "chalk": "^4.1.2",
+    "commander": "^9.4.1",
+    "concurrently": "^8.2.2",
+    "contracts-starter": "git+https://github.com/mudgen/diamond-2-hardhat.git",
+    "dotenv": "^10.0.0",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-n": "^17.15.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-security": "^3.0.0",
+    "ethers": "^6.4.0",
+    "globals": "^15.14.0",
+    "hardhat": "^2.26.0",
+    "hardhat-diamonds": "git+https://github.com/diamondslab/hardhat-diamonds.git#develop",
+    "hardhat-gas-reporter": "^1.0.8",
+    "husky": "^9.1.7",
+    "jest": "^30.0.4",
+    "jest-mock": "^29.7.0",
+    "lint-staged": "^15.2.0",
+    "mocha": "^9.2.2",
+    "prettier": "^3.4.2",
+    "prettier-plugin-solidity": "^1.4.1",
+    "rimraf": "^6.0.1",
+    "semgrep": "^1.0.0",
+    "sinon": "^21.0.0",
+    "snyk": "^1.1294.0",
+    "solhint": "^3.3.7",
+    "solidity-coverage": "^0.8.16",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.4.0",
+    "typechain": "^8.3.2",
+    "typescript": "^5.9.3",
+    "uint32": "^0.2.1",
+    "web3": "^4.16.0",
+    "web3-core": "^4.7.1",
+    "web3-utils": "^4.3.3",
+    "winston": "^3.17.0",
+    "zod": "^4.0.2"
+  },
+  "peerDependencies": {
+    "ethers": "^6.0.0",
+    "hardhat": "^2.0.0",
+    "ts-node": "^10.0.0",
+    "typescript": "^5.0.0"
+  },
+  "packageManager": "yarn@4.10.3",
+  "dependencies": {
+    "@ethersproject/abstract-signer": "^5.8.0",
+    "axios": "^1.12.0",
+    "debug": "^4.4.1",
+    "fs-extra": "^11.3.0",
+    "lodash": "^4.17.21"
+  }
+}

package/src/core/CallbackManager.ts

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,197 @@
+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

@@ -0,0 +1,36 @@
+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

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

package/src/index.ts

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

package/src/repositories/DBDeploymentRepository.ts

@@ -0,0 +1,22 @@
+// 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

@@ -0,0 +1,12 @@
+// 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;
+}