dop-stick/dist/index.d.ts

Source control tooling for versionable-upgradeable smart contracts

import { BigNumber } from 'ethers';
import { DiamondCutActionType } from './types/diamond';
export declare function _initializeSDK(): void;
import { upgrade as originalUpgrade, deployModule as originalDeployModule } from './upgrade';
import { mine as originalMine } from "./mine";
import { BaseDiamondInfo } from './info';
/**
 * Upgrades an existing diamond contract with new or modified facets.
 * Handles the entire upgrade process including compilation, deployment, and diamond cuts.
 *
 * @param config - Configuration object for the upgrade process
 * @param config.paths - Contract and artifact paths
 * @param config.paths.contracts - Path to contract source files
 * @param config.paths.artifacts - Path to compiled contract artifacts
 * @param config.compiler - Compiler settings
 * @param config.compiler.name - Compiler name (e.g., 'hardhat', 'foundry')
 * @param config.modules - Array of module names to upgrade
 * @param config.parallelization - Parallel processing settings
 * @param config.parallelization.enabled - Enable parallel processing
 * @param config.parallelization.maxConcurrent - Maximum concurrent operations
 * @param config.fail_all_if_one_fails - Stop all upgrades if any module fails
 *
 * @returns Promise<UpgradeContext> - Detailed results of the upgrade process
 * @throws {Error} If compilation fails, deployment fails, or diamond cut fails
 *
 * Example usage:
 * ```ts
 * const config = {
 *    paths: {
 *      contracts: './contracts',
 *      artifacts: './artifacts'
 *    },
 *    compiler: {
 *      name: 'hardhat'
 *    },
 *    modules: ['TokenModule', 'StakingModule'],
 *    parallelization: {
 *      enabled: true,
 *      maxConcurrent: 3
 *    },
 *    fail_all_if_one_fails: true
 * };
 *
 * const result = await upgrade(config);
 * ```
 *
 * The upgrade process includes:
 * 1. Compilation check of contracts
 * 2. Parallel or sequential module deployment
 * 3. Pre-deployment validation
 * 4. Batched diamond cuts
 * 5. Automatic retry with different cut actions on failure
 * 6. Detailed reporting and gas usage tracking
 */
export declare const upgrade: typeof originalUpgrade;
/**
 * Deploys a new module to be used with a diamond contract.
 *
 * @param config - Configuration for module deployment
 * @returns Promise<string> - Deployed module address
 *
 * Example:
 * ```ts
 * const moduleAddress = await deployModule({
 *    paths: { contracts: './contracts' },
 *    module: 'MyNewModule'
 * });
 * ```
 */
export declare const deployModule: typeof originalDeployModule;
/**
 * Deploys a new diamond contract with specified facets.
 *
 * @param config - Configuration for diamond deployment
 * @returns Promise<string> - Deployed diamond address
 *
 * Example:
 * ```ts
 * const diamondAddress = await mine({
 *    paths: { contracts: './contracts' },
 *    modules: ['BaseModule', 'ExtendedModule'],
 *    compiler: { name: 'hardhat' }
 * });
 * ```
 */
export declare const mine: typeof originalMine;
declare const DiamondInfo: typeof BaseDiamondInfo;
export { DiamondInfo };
export { DiamondCutAction } from './types/diamond';
export { diamondHelper } from './utils/diamondHelpers';
export { InitializationHelper, InitializationData } from './utils/initialization';
export { configLoader } from './utils/configLoader';
export { sleep, formatDuration, isDefined, safeStringify, ensureSuffix } from './utils/common';
export interface UpgradeContext {
    startTime: number;
    moduleResults: ModuleUpgradeResult[];
    totalGasUsed: BigNumber;
    successfulModules: number;
    successfulSelectors: number;
    failedUpgrades: Array<{
        module: string;
        selectors: string[];
        error: string;
    }>;
}
export interface ModuleUpgradeResult {
    moduleName: string;
    deployedAddress: string;
    originalAction: DiamondCutActionType;
    wasRetried: boolean;
    retryAction?: DiamondCutActionType;
    retrySuccess?: boolean;
    deploymentTime: string;
    gasUsed: string;
    costInEth: string;
    functions: {
        signature: string;
        selector: string;
        status: string;
    }[];
    error?: string;
}
export interface GasInfo {
    gasLimit: BigNumber;
    gasPrice: BigNumber;
    maxFeePerGas?: BigNumber;
    maxPriorityFeePerGas?: BigNumber;
}
export type { DiamondCutActionType, FacetCut, FacetInfo, DiamondCutParams, } from './types/diamond';
export type { IUpgradeService, TransactionConfig, UpgradeDetailsStruct, } from './types/contracts';
export type { DopStickConfig, } from './types/config';
export declare function initializeEnvironment(): void;
//# sourceMappingURL=index.d.ts.map