@layerzerolabs/hardhat-deploy/dist/src/DeploymentsManager.d.ts

Hardhat Plugin For Replicable Deployments And Tests

import { Deployment, DeploymentsExtension, DeploymentSubmission } from '../types';
import { BigNumber } from '@ethersproject/bignumber';
import { TransactionResponse } from '@ethersproject/providers';
import { HardhatRuntimeEnvironment, Network } from 'hardhat/types';
export declare class DeploymentsManager {
    deploymentsExtension: DeploymentsExtension;
    private db;
    private env;
    private deploymentsPath;
    impersonateUnknownAccounts: boolean;
    impersonatedAccounts: string[];
    addressesToProtocol: {
        [address: string]: string;
    };
    readonly isTronNetworkWithTronSolc: boolean;
    private network;
    private partialExtension;
    private utils;
    constructor(env: HardhatRuntimeEnvironment, network: Network);
    private networkWasSetup;
    setupNetwork(): void;
    private _chainId;
    getChainId(): Promise<string>;
    runAsNode(enabled: boolean): void;
    dealWithPendingTransactions(): Promise<void>;
    onPendingTx(tx: TransactionResponse, name?: string, deployment?: any): Promise<TransactionResponse>;
    getNamedAccounts(): Promise<{
        [name: string]: string;
    }>;
    getUnnamedAccounts(): Promise<string[]>;
    private getDeterminisityDeploymentInfo;
    getDeterministicDeploymentFactoryAddress(): Promise<string>;
    getDeterministicDeploymentFactoryDeployer(): Promise<string>;
    getDeterministicDeploymentFactoryFunding(isTron?: any): Promise<BigNumber>;
    getDeterministicDeploymentFactoryDeploymentTx(): Promise<string>;
    loadDeployments(chainIdExpected?: boolean): Promise<{
        [name: string]: Deployment;
    }>;
    deletePreviousDeployments(folderPath?: string): Promise<void>;
    getSolcInputPath(): string;
    deleteDotFile(name: string): Promise<void>;
    readDotFile(name: string): Promise<string>;
    saveDotFile(name: string, content: string): Promise<void>;
    deleteDeployment(name: string): Promise<void>;
    saveDeployment(name: string, deployment: DeploymentSubmission): Promise<boolean>;
    private companionManagers;
    addCompanionManager(name: string, networkDeploymentsManager: DeploymentsManager): void;
    runDeploy(tags?: string | string[], options?: {
        deletePreviousDeployments: boolean;
        log: boolean;
        resetMemory: boolean;
        writeDeploymentsToFiles: boolean;
        savePendingTx: boolean;
        export?: string;
        exportAll?: string;
        gasPrice?: string;
        maxFeePerGas?: string;
        maxPriorityFeePerGas?: string;
        tagsRequireAll?: boolean;
    }): Promise<{
        [name: string]: Deployment;
    }>;
    executeDeployScripts(deployScriptsPaths: string[], tags?: string[], tagsRequireAll?: boolean): Promise<void>;
    export(options: {
        exportAll?: string;
        export?: string;
    }): Promise<void>;
    private _writeExports;
    /**
     * Retrieves import paths for Tron-specific contracts.
     *
     * This method enforces a safety check to ensure that only contracts compiled for Tron are deployed.
     * It requires that import paths for external folders must end with '-tron'. The method checks both
     * the project's own import paths and any external contracts specified in the configuration.
     *
     * @returns {string[]} An array of import paths that conform to the Tron-specific naming convention.
     */
    private getTronImportPaths;
    private getImportPaths;
    private setup;
    private saveSnapshot;
    private revertSnapshot;
    disableAutomaticImpersonation(): void;
    private getNetworkName;
    private getDeploymentNetworkName;
    private deploymentFolder;
    private impersonateAccounts;
    setupAccounts(): Promise<{
        namedAccounts: {
            [name: string]: string;
        };
        unnamedAccounts: string[];
    }>;
}
//# sourceMappingURL=DeploymentsManager.d.ts.map