@diamondslab/diamonds 1.0.0 → 1.1.2

package/dist/schemas/DeploymentSchema.d.ts

@@ -3,40 +3,16 @@ export declare const DeployedFacetSchema: z.ZodObject<{
     address: z.ZodOptional<z.ZodString>;
     tx_hash: z.ZodOptional<z.ZodString>;
     version: z.ZodOptional<z.ZodNumber>;
-    funcSelectors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    funcSelectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
     verified: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    address?: string | undefined;
-    tx_hash?: string | undefined;
-    version?: number | undefined;
-    funcSelectors?: string[] | undefined;
-    verified?: boolean | undefined;
-}, {
-    address?: string | undefined;
-    tx_hash?: string | undefined;
-    version?: number | undefined;
-    funcSelectors?: string[] | undefined;
-    verified?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export declare const DeployedFacetsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
     address: z.ZodOptional<z.ZodString>;
     tx_hash: z.ZodOptional<z.ZodString>;
     version: z.ZodOptional<z.ZodNumber>;
-    funcSelectors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    funcSelectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
     verified: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    address?: string | undefined;
-    tx_hash?: string | undefined;
-    version?: number | undefined;
-    funcSelectors?: string[] | undefined;
-    verified?: boolean | undefined;
-}, {
-    address?: string | undefined;
-    tx_hash?: string | undefined;
-    version?: number | undefined;
-    funcSelectors?: string[] | undefined;
-    verified?: boolean | undefined;
-}>>;
+}, z.core.$strip>>;
 export declare const ExternalLibrariesSchema: z.ZodRecord<z.ZodString, z.ZodString>;
 export declare const DeployedDiamondDataSchema: z.ZodObject<{
     DiamondAddress: z.ZodOptional<z.ZodString>;
@@ -45,260 +21,70 @@ export declare const DeployedDiamondDataSchema: z.ZodObject<{
         address: z.ZodOptional<z.ZodString>;
         tx_hash: z.ZodOptional<z.ZodString>;
         version: z.ZodOptional<z.ZodNumber>;
-        funcSelectors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        funcSelectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
         verified: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        address?: string | undefined;
-        tx_hash?: string | undefined;
-        version?: number | undefined;
-        funcSelectors?: string[] | undefined;
-        verified?: boolean | undefined;
-    }, {
-        address?: string | undefined;
-        tx_hash?: string | undefined;
-        version?: number | undefined;
-        funcSelectors?: string[] | undefined;
-        verified?: boolean | undefined;
-    }>>>;
+    }, z.core.$strip>>>;
     ExternalLibraries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     protocolVersion: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    DiamondAddress?: string | undefined;
-    DeployerAddress?: string | undefined;
-    DeployedFacets?: Record<string, {
-        address?: string | undefined;
-        tx_hash?: string | undefined;
-        version?: number | undefined;
-        funcSelectors?: string[] | undefined;
-        verified?: boolean | undefined;
-    }> | undefined;
-    ExternalLibraries?: Record<string, string> | undefined;
-    protocolVersion?: number | undefined;
-}, {
-    DiamondAddress?: string | undefined;
-    DeployerAddress?: string | undefined;
-    DeployedFacets?: Record<string, {
-        address?: string | undefined;
-        tx_hash?: string | undefined;
-        version?: number | undefined;
-        funcSelectors?: string[] | undefined;
-        verified?: boolean | undefined;
-    }> | undefined;
-    ExternalLibraries?: Record<string, string> | undefined;
-    protocolVersion?: number | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Schema for the version information of a facet configuration to be deployed
  */
 export declare const FacetVersionConfigSchema: z.ZodObject<{
     deployInit: z.ZodOptional<z.ZodString>;
     upgradeInit: z.ZodOptional<z.ZodString>;
-    fromVersions: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-    callbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    deployInclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    deployExclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    deployInit?: string | undefined;
-    upgradeInit?: string | undefined;
-    fromVersions?: number[] | undefined;
-    callbacks?: string[] | undefined;
-    deployInclude?: string[] | undefined;
-    deployExclude?: string[] | undefined;
-}, {
-    deployInit?: string | undefined;
-    upgradeInit?: string | undefined;
-    fromVersions?: number[] | undefined;
-    callbacks?: string[] | undefined;
-    deployInclude?: string[] | undefined;
-    deployExclude?: string[] | undefined;
-}>;
+    fromVersions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    callbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deployInclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deployExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 /**
  * Schema for the deployment information of a single facet
  */
 export declare const FacetConfigSchema: z.ZodObject<{
     priority: z.ZodNumber;
-    libraries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    libraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
     versions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         deployInit: z.ZodOptional<z.ZodString>;
         upgradeInit: z.ZodOptional<z.ZodString>;
-        fromVersions: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-        callbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        deployInclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        deployExclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        deployInit?: string | undefined;
-        upgradeInit?: string | undefined;
-        fromVersions?: number[] | undefined;
-        callbacks?: string[] | undefined;
-        deployInclude?: string[] | undefined;
-        deployExclude?: string[] | undefined;
-    }, {
-        deployInit?: string | undefined;
-        upgradeInit?: string | undefined;
-        fromVersions?: number[] | undefined;
-        callbacks?: string[] | undefined;
-        deployInclude?: string[] | undefined;
-        deployExclude?: string[] | undefined;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    priority: number;
-    libraries?: string[] | undefined;
-    versions?: Record<string, {
-        deployInit?: string | undefined;
-        upgradeInit?: string | undefined;
-        fromVersions?: number[] | undefined;
-        callbacks?: string[] | undefined;
-        deployInclude?: string[] | undefined;
-        deployExclude?: string[] | undefined;
-    }> | undefined;
-}, {
-    priority: number;
-    libraries?: string[] | undefined;
-    versions?: Record<string, {
-        deployInit?: string | undefined;
-        upgradeInit?: string | undefined;
-        fromVersions?: number[] | undefined;
-        callbacks?: string[] | undefined;
-        deployInclude?: string[] | undefined;
-        deployExclude?: string[] | undefined;
-    }> | undefined;
-}>;
+        fromVersions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        callbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deployInclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deployExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 /**
  * Schema for the deployment configuration information of ALL facets to be deployed
  */
 export declare const FacetsConfigSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
     priority: z.ZodNumber;
-    libraries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    libraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
     versions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         deployInit: z.ZodOptional<z.ZodString>;
         upgradeInit: z.ZodOptional<z.ZodString>;
-        fromVersions: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-        callbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        deployInclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        deployExclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        deployInit?: string | undefined;
-        upgradeInit?: string | undefined;
-        fromVersions?: number[] | undefined;
-        callbacks?: string[] | undefined;
-        deployInclude?: string[] | undefined;
-        deployExclude?: string[] | undefined;
-    }, {
-        deployInit?: string | undefined;
-        upgradeInit?: string | undefined;
-        fromVersions?: number[] | undefined;
-        callbacks?: string[] | undefined;
-        deployInclude?: string[] | undefined;
-        deployExclude?: string[] | undefined;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    priority: number;
-    libraries?: string[] | undefined;
-    versions?: Record<string, {
-        deployInit?: string | undefined;
-        upgradeInit?: string | undefined;
-        fromVersions?: number[] | undefined;
-        callbacks?: string[] | undefined;
-        deployInclude?: string[] | undefined;
-        deployExclude?: string[] | undefined;
-    }> | undefined;
-}, {
-    priority: number;
-    libraries?: string[] | undefined;
-    versions?: Record<string, {
-        deployInit?: string | undefined;
-        upgradeInit?: string | undefined;
-        fromVersions?: number[] | undefined;
-        callbacks?: string[] | undefined;
-        deployInclude?: string[] | undefined;
-        deployExclude?: string[] | undefined;
-    }> | undefined;
-}>>;
+        fromVersions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        callbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deployInclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deployExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;
 export declare const DeployConfigSchema: z.ZodObject<{
     protocolVersion: z.ZodNumber;
     protocolInitFacet: z.ZodOptional<z.ZodString>;
     protocolCallback: z.ZodOptional<z.ZodString>;
     facets: z.ZodRecord<z.ZodString, z.ZodObject<{
         priority: z.ZodNumber;
-        libraries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        libraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
         versions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             deployInit: z.ZodOptional<z.ZodString>;
             upgradeInit: z.ZodOptional<z.ZodString>;
-            fromVersions: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-            callbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            deployInclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            deployExclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            deployInit?: string | undefined;
-            upgradeInit?: string | undefined;
-            fromVersions?: number[] | undefined;
-            callbacks?: string[] | undefined;
-            deployInclude?: string[] | undefined;
-            deployExclude?: string[] | undefined;
-        }, {
-            deployInit?: string | undefined;
-            upgradeInit?: string | undefined;
-            fromVersions?: number[] | undefined;
-            callbacks?: string[] | undefined;
-            deployInclude?: string[] | undefined;
-            deployExclude?: string[] | undefined;
-        }>>>;
-    }, "strip", z.ZodTypeAny, {
-        priority: number;
-        libraries?: string[] | undefined;
-        versions?: Record<string, {
-            deployInit?: string | undefined;
-            upgradeInit?: string | undefined;
-            fromVersions?: number[] | undefined;
-            callbacks?: string[] | undefined;
-            deployInclude?: string[] | undefined;
-            deployExclude?: string[] | undefined;
-        }> | undefined;
-    }, {
-        priority: number;
-        libraries?: string[] | undefined;
-        versions?: Record<string, {
-            deployInit?: string | undefined;
-            upgradeInit?: string | undefined;
-            fromVersions?: number[] | undefined;
-            callbacks?: string[] | undefined;
-            deployInclude?: string[] | undefined;
-            deployExclude?: string[] | undefined;
-        }> | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    protocolVersion: number;
-    facets: Record<string, {
-        priority: number;
-        libraries?: string[] | undefined;
-        versions?: Record<string, {
-            deployInit?: string | undefined;
-            upgradeInit?: string | undefined;
-            fromVersions?: number[] | undefined;
-            callbacks?: string[] | undefined;
-            deployInclude?: string[] | undefined;
-            deployExclude?: string[] | undefined;
-        }> | undefined;
-    }>;
-    protocolInitFacet?: string | undefined;
-    protocolCallback?: string | undefined;
-}, {
-    protocolVersion: number;
-    facets: Record<string, {
-        priority: number;
-        libraries?: string[] | undefined;
-        versions?: Record<string, {
-            deployInit?: string | undefined;
-            upgradeInit?: string | undefined;
-            fromVersions?: number[] | undefined;
-            callbacks?: string[] | undefined;
-            deployInclude?: string[] | undefined;
-            deployExclude?: string[] | undefined;
-        }> | undefined;
-    }>;
-    protocolInitFacet?: string | undefined;
-    protocolCallback?: string | undefined;
-}>;
+            fromVersions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            callbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            deployInclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            deployExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type FacetVersionConfig = z.infer<typeof FacetVersionConfigSchema>;
 export type FacetConfig = z.infer<typeof FacetConfigSchema>;
 export type FacetsConfig = z.infer<typeof FacetsConfigSchema>;

package/dist/schemas/DeploymentSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeploymentSchema.d.ts","sourceRoot":"","sources":["../../src/schemas/DeploymentSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAM9B,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;GAA4C,CAAC;AAG9E,eAAO,MAAM,uBAAuB,uCAAmC,CAAC;AAGxE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0C,CAAC;AAE1E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK7B,CAAC;AAGH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"DeploymentSchema.d.ts","sourceRoot":"","sources":["../../src/schemas/DeploymentSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,mBAAmB;;;;;;iBAM9B,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;;kBAA4C,CAAC;AAG9E,eAAO,MAAM,uBAAuB,uCAAmC,CAAC;AAGxE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAOpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;iBAOnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAK5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;kBAA0C,CAAC;AAE1E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;iBAK7B,CAAC;AAGH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diamondslab/diamonds",
-  "version": "1.0.0",
+  "version": "1.1.2",
   "description": "Tools for deploying and interfacing with ERC-2535 Diamond Proxies",
   "repository": "github:diamondslab/diamonds",
   "main": "dist/index.js",
@@ -36,7 +36,7 @@
     "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",
+    "build": "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",
@@ -124,16 +124,13 @@
   },
   "files": [
     "dist/",
-    "src/",
-    "docs/",
-    "examples/",
     "LICENSE",
-    "README.md",
-    "package.json"
+    "README.md"
   ],
   "devDependencies": {
     "@commitlint/cli": "^19.8.1",
     "@commitlint/config-conventional": "^19.8.1",
+    "@diamondslab/hardhat-diamonds": "^1.0.0",
     "@ethersproject/abi": "^5.8.0",
     "@ethersproject/bytes": "^5.8.0",
     "@ethersproject/providers": "^5.8.0",
@@ -185,7 +182,6 @@
     "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",

package/docs/DIAMOND_ABI_CONFIGURATION_SUMMARY.md

@@ -1,40 +0,0 @@
-# Diamond ABI Configuration
-
-The Diamond ABI generator is configurable with storage location and file naming. Here's what was accomplished:
-
-✅ Configuration Features
-Configurable Storage Path: Added diamondAbiPath to DiamondPathsConfig with default ./diamond-abi
-Configurable File Naming: Added diamondAbiFileName to DiamondConfig with default using diamond name
-Smart Defaults: When not specified, the filename defaults to {diamondName}.json
-
-Diamond Class (Diamond.ts):
-
-Added properties and getter methods for ABI path configuration
-Implemented path resolution with sensible defaults
-
-DiamondAbiGenerator (diamondAbiGenerator.ts):
-
-Updated to use Diamond's configured paths instead of hardcoded values
-Maintained backward compatibility with existing usage
-
-Deployment Strategies:
-
-Updated BaseDeploymentStrategy and OZDefenderDeploymentStrategy
-Pass Diamond objects to contract mapping functions
-Test Suite Updates:
-
-Updated CLI tools - The diamond-abi-cli.ts now uses Diamond's configured paths instead of hardcoded defaults.
-deployment strategies - Confirmed that BaseDeploymentStrategy and OZDefenderDeploymentStrategy use facet artifacts directly and don't need diamond ABI file loading.
-
-Flexibility: Users can now specify custom ABI storage locations
-Customization: Diamond ABI files can have custom names
-Backward Compatibility: Existing code works without changes
-Smart Defaults: Sensible defaults when configuration not provided
-Professional Standards: Clean, maintainable code with full test coverage
-
-Hardhat Compatibility: ✅ Tested - diamond ABI files stored safely outside artifacts directory
-
-Default: {configFileDirectory}/diamond-abi/
-Custom: User-configurable via diamondAbiPath config option
-Avoids: artifacts directory to prevent hardhat compile conflicts
-The implementation maintains full backward compatibility while providing professional-grade configuration management throughout the diamond system.

package/docs/DIAMOND_ABI_GENERATION.md

@@ -1,220 +0,0 @@
-# Diamond ABI Generation System - Implementation Summary
-
-## Overview
-
-This document summarizes the comprehensive Diamond ABI generation system that has been implemented for the ERC-2535 Diamond Proxy contract management system. The system provides sophisticated ABI generation capabilities that integrate seamlessly with the existing diamond deployment infrastructure.
-
-## Key Features Implemented
-
-### 1. Core ABI Generation System
-
-- **DiamondAbiGenerator Class**: Comprehensive ABI generation with configurability
-- **Function Selector Registry Integration**: Seamless integration with existing diamond deployment system
-- **Artifact Management**: Automatic loading and processing of contract artifacts
-- **Metadata Enrichment**: Enhanced ABI artifacts with diamond-specific metadata
-
-### 2. Advanced Functionality
-
-- **Preview Mode**: Preview ABI changes before applying diamond cuts
-- **Selective Facet Inclusion**: Configure which facets to include in generated ABI
-- **Source Information**: Optional inclusion of source code information in ABI
-- **Validation**: Function selector uniqueness validation
-- **Performance Optimization**: Efficient processing of large diamond deployments
-
-### 3. Command Line Interface
-
-- **Professional CLI Tool**: Full-featured command-line interface for ABI operations
-- **Multiple Commands**: Generate, preview, compare, and validate ABI files
-- **Rich Output**: Colored output with detailed progress information
-- **Flexible Configuration**: Support for different networks, chain IDs, and deployment paths
-
-### 4. Integration Features
-
-- **Deployment Repository Integration**: Works with existing FileDeploymentRepository
-- **Strategy Pattern Support**: Compatible with Local and OpenZeppelin Defender strategies
-- **Configuration Management**: Leverages existing DiamondConfig system
-- **Error Handling**: Comprehensive error handling and recovery
-
-## Files Created/Modified
-
-### Core Implementation
-
-- `src/utils/diamondAbiGenerator.ts` - Main ABI generation system
-- `src/utils/index.ts` - Export configuration
-- `src/index.ts` - Main module exports
-
-### Scripts and Tools
-
-- `scripts/diamond-abi-cli.ts` - Professional CLI tool
-- `scripts/create-diamond-abi.ts` - Updated ABI generation script
-
-### Testing Infrastructure
-
-- `test/unit/diamondAbiGenerator.test.ts` - Comprehensive unit tests
-- `test/integration/diamondAbiGeneration.test.ts` - End-to-end integration tests
-
-### Configuration
-
-- `package.json` - Updated with new scripts and CLI configuration
-- `tsconfig.json` - Fixed for proper module compilation
-
-## Technical Architecture
-
-### Class Structure
-
-```typescript
-class DiamondAbiGenerator {
-  constructor(diamond: Diamond, options?: DiamondAbiGeneratorOptions)
-  
-  // Core functionality
-  generateAbi(options?: GenerateAbiOptions): Promise<DiamondAbiResult>
-  previewAbi(cuts: FacetCut[], options?: GenerateAbiOptions): Promise<DiamondAbiResult>
-  
-  // Configuration
-  setFacetFilter(filter: (facetName: string) => boolean): void
-  setIncludeSourceInfo(include: boolean): void
-  setValidateSelectors(validate: boolean): void
-}
-```
-
-### Function Exports
-
-```typescript
-// High-level functions for easy use
-export function generateDiamondAbi(diamond: Diamond, options?: GenerateAbiOptions): Promise<DiamondAbiResult>
-export function previewDiamondAbi(diamond: Diamond, cuts: FacetCut[], options?: GenerateAbiOptions): Promise<DiamondAbiResult>
-```
-
-### CLI Commands
-
-```bash
-# Generate ABI for deployed diamond
-diamond-abi generate [options]
-
-# Preview ABI changes for planned cuts
-diamond-abi preview [options]
-
-# Compare two ABI files
-diamond-abi compare <file1> <file2>
-
-# Validate ABI file
-diamond-abi validate <file>
-```
-
-## Key Implementation Details
-
-### 1. Artifact Processing
-
-- Automatic loading of contract artifacts from Hardhat compilation
-- Fallback handling for missing artifacts in test environments
-- Support for both deployed and planned facets
-
-### 2. Function Selector Management
-
-- Integration with existing function selector registry
-- Duplicate selector detection and handling
-- Selector-to-facet mapping generation
-
-### 3. Metadata Generation
-
-- Diamond-specific metadata inclusion
-- Timestamp and version information
-- Deployment configuration details
-- Performance statistics
-
-### 4. Error Handling
-
-- Graceful handling of missing artifacts
-- Comprehensive error reporting
-- Fallback mechanisms for test environments
-
-## Usage Examples
-
-### Programmatic Usage
-
-```typescript
-import { generateDiamondAbi, Diamond } from 'diamonds';
-
-const diamond = new Diamond(config, repository);
-const result = await generateDiamondAbi(diamond, {
-  outputDir: './artifacts/diamond-abi',
-  includeSourceInfo: true,
-  validateSelectors: true
-});
-```
-
-### CLI Usage
-
-```bash
-# Generate ABI for localhost deployment
-npx diamond-abi generate --diamond GeniusDiamond --network localhost
-
-# Preview changes with verbose output
-npx diamond-abi preview --diamond GeniusDiamond --verbose
-
-# Compare two versions
-npx diamond-abi compare old-abi.json new-abi.json
-
-# Validate ABI file
-npx diamond-abi validate diamond-abi.json
-```
-
-## Test Coverage
-
-### Unit Tests
-
-- ✅ Basic ABI generation functionality
-- ✅ Preview mode with planned cuts
-- ✅ Configuration options
-- ✅ Error handling scenarios
-- ✅ Output validation
-- ✅ Performance characteristics
-
-### Integration Tests
-
-- ✅ End-to-end workflow with real diamond deployments
-- ✅ Integration with deployment strategies
-- ✅ ABI integrity validation
-- ✅ Performance benchmarking
-- ✅ Large-scale deployment testing
-
-## Performance Characteristics
-
-### Benchmarks (from integration tests)
-
-- **Small diamonds (1-5 facets)**: ~50-200ms generation time
-- **Medium diamonds (10-20 facets)**: ~100-300ms generation time
-- **Large diamonds (50+ facets)**: ~500-1000ms generation time
-- **Memory usage**: Scales linearly with diamond complexity
-- **Artifact processing**: Efficient caching and reuse
-
-## Future Enhancements
-
-### Planned Features
-
-1. **TypeScript Interface Generation**: Generate TypeScript interfaces from ABI
-2. **Documentation Generation**: Auto-generate API documentation
-3. **Version Management**: Track ABI versions and changes over time
-4. **External Tool Integration**: Integration with front-end frameworks
-5. **Advanced Validation**: Extended validation rules and checks
-
-### Performance Optimizations
-
-1. **Parallel Processing**: Process multiple facets in parallel
-2. **Caching**: Implement intelligent caching for repeated operations
-3. **Streaming**: Stream processing for very large diamonds
-4. **Compression**: Optional compression for large ABI files
-
-## Conclusion
-
-The Diamond ABI generation system provides a comprehensive, professional-grade solution for managing ERC-2535 Diamond Proxy ABIs. The implementation includes:
-
-- ✅ Complete feature set with advanced capabilities
-- ✅ Seamless integration with existing diamond deployment infrastructure
-- ✅ Professional CLI tools for developer productivity
-- ✅ Comprehensive testing suite with 100% passing tests
-- ✅ Excellent performance characteristics
-- ✅ Proper error handling and validation
-- ✅ Extensible architecture for future enhancements
-
-The system is ready for production use and provides a solid foundation for diamond-based smart contract development workflows.