dop-stick/dist/types/upgrade.d.ts

Source control tooling for versionable-upgradeable smart contracts

import { BigNumber } from 'ethers';
import { DiamondCutActionType, FacetCut } from './diamond';
/**
 * Represents statistics for the upgrade process
 */
export interface UpgradeStats {
    successfulModules: number;
    totalModules: number;
    successfulSelectors: number;
    totalSelectors: number;
    totalGasUsed: BigNumber;
    totalCostInEth: string;
    failedUpgrades: FailedUpgrade[];
}
/**
 * Represents a failed upgrade attempt
 */
export interface FailedUpgrade {
    module: string;
    selectors: string[];
    error: string;
}
/**
 * Result of a single module upgrade operation
 */
export interface UpgradeModuleResult {
    moduleName: string;
    originalFacetName?: string;
    deployedAddress: string;
    originalAction: number;
    wasRetried: boolean;
    retryAction?: number;
    retrySuccess?: boolean;
    deploymentTime: string;
    deploymentHash?: string;
    gasUsed: string;
    costInEth: string;
    functions: {
        signature: string;
        selector: string;
        status: string;
    }[];
    error?: string;
}
/**
 * Context for the entire upgrade process
 */
export interface UpgradeContext {
    startTime: number;
    endTime?: number;
    duration?: number;
    error?: string;
    moduleResults: UpgradeModuleResult[];
    successfulModules: number;
    successfulSelectors: number;
    failedUpgrades: {
        module: string;
        selectors: string[];
        error: string;
    }[];
    totalGasUsed: BigNumber;
    upgradeTxHash?: string;
    upgradeBlockNumber?: number;
    upgradeGasUsed?: string;
    upgradeCostInEth?: string;
    warnings?: UpgradeWarning[];
}
/**
 * Structure of the upgrade.json file
 */
export interface UpgradeJson {
    upgrades: UpgradeModule[];
}
/**
 * Single module configuration in upgrade.json
 */
export interface UpgradeModule {
    module: string;
    add?: string[];
    replace?: string[];
    remove?: string[];
}
/**
 * Represents a module's functions grouped for batch processing
 */
export interface BatchedModuleFunctions {
    /** Name of the module */
    moduleName: string;
    /** All function signatures for this module */
    functionSignatures: string[];
    /** Original action mapping for each function */
    originalActions: Map<string, DiamondCutActionType>;
    /** Suggested action mapping for each function (after validation) */
    suggestedActions?: Map<string, DiamondCutActionType>;
}
/**
 * Result of batch validation for a single module
 */
export interface ModuleBatchValidationResult {
    /** Name of the module */
    moduleName: string;
    /** Whether the validation passed */
    isValid: boolean;
    /** Array of error messages */
    errors: string[];
    /** Array of warning messages */
    warnings: string[];
    /** Details of any function collisions found */
    collisions: Map<string, boolean>;
    /** Map of function signatures to their suggested actions */
    suggestedChanges: Map<string, DiamondCutActionType>;
    /** Map of original function signatures to their original actions */
    originalSignatures: Map<string, DiamondCutActionType>;
    /** Array of function signatures */
    functionSignatures: string[];
    needsReview: boolean;
    pendingMissingFunctions?: string[];
    pendingRemovals: Array<{
        signature: string;
        reason: string;
    }>;
    pendingSuggestions: Array<{
        signature: string;
        originalAction: DiamondCutActionType;
        suggestedAction: DiamondCutActionType;
        reason: string;
    }>;
    pendingDiscardedFunctions: Array<{
        signature: string;
        reason: string;
    }>;
}
/**
 * Extends the FacetCut interface to include module information
 */
export interface ExtendedFacetCut extends FacetCut {
    /** Name of the module this cut belongs to */
    moduleName: string;
    functionSignatures?: string[];
    changed?: boolean;
    originalAction?: DiamondCutActionType;
    removedReason?: 'missing' | 'invalid';
    removedFunctions?: Array<{
        signature: string;
        reason: 'missing' | 'invalid' | 'discarded';
    }>;
    originalFacetName?: string;
}
export type UpgradeEntry = string | DetailedUpgradeModule;
export interface DetailedUpgradeModule {
    module: string;
    add?: string[];
    replace?: string[];
    remove?: string[];
}
export interface BaseUpgradeConfig {
    fail_all_if_one_fails: boolean;
    add_or_replace: boolean;
}
export interface UpgradeConfig extends BaseUpgradeConfig {
    modules: (string | UpgradeModule)[];
    upgrades?: (string | UpgradeModule)[];
}
/**
 * Represents a batch validation error
 */
export interface BatchValidationError {
    moduleName: string;
    error: string;
    details?: string;
}
/**
 * Represents a pre-deployment check
 */
export type PreDeploymentCheckType = 'cuts' | 'emergency' | 'gas' | 'balance' | 'libraries';
export type PreDeploymentCheckStatus = 'success' | 'warning' | 'failed';
export interface PreDeploymentCheckDetails {
    moduleCount?: number;
    functionCount?: number;
    error?: string;
    gasPrice?: string;
    current?: string;
    minimum?: string;
    balance?: string;
    blockDelay?: number;
    blockNumber?: number;
    count?: number;
    libraries?: string[];
}
export interface PreDeploymentCheck {
    type: PreDeploymentCheckType;
    status: PreDeploymentCheckStatus;
    details?: PreDeploymentCheckDetails;
}
export interface UpgradeWarning {
    timestamp: number;
    message: string;
    severity: 'LOW' | 'MEDIUM' | 'HIGH';
}
//# sourceMappingURL=upgrade.d.ts.map