@newos/cli/lib/models/network/NetworkController.d.ts

Command-line interface for the NewOS

import { Contract, ProxyAdminProject, AppProject, BuildArtifacts, App, TxParams } from '@newos/upgrades';
import { AppProjectDeployer, ProxyAdminProjectDeployer } from './ProjectDeployer';
import LocalController from '../local/LocalController';
import ContractManager from '../local/ContractManager';
import NetworkFile, { ProxyInterface } from '../files/NetworkFile';
import ProjectFile from '../files/ProjectFile';
import { ProxyType } from '../../scripts/interfaces';
declare type Project = ProxyAdminProject | AppProject;
declare type ProjectDeployer = ProxyAdminProjectDeployer | AppProjectDeployer;
export default class NetworkController {
    localController: LocalController;
    txParams: TxParams;
    network: string;
    networkFile: NetworkFile;
    project: Project;
    contractManager: ContractManager;
    constructor(network: string, txParams: TxParams, networkFile?: NetworkFile);
    get projectFile(): ProjectFile;
    get projectVersion(): string;
    get currentVersion(): string;
    get currentManifestVersion(): string;
    get packageAddress(): string;
    get proxyAdminAddress(): string;
    get proxyFactoryAddress(): string;
    checkNotFrozen(): void | never;
    fetchOrDeploy(requestedVersion: string): Promise<Project>;
    deployChangedSolidityLibs(contractNames: string): Promise<void>;
    push(contracts: string[] | undefined, { reupload, force }?: {
        reupload?: boolean;
        force?: boolean;
    }): Promise<void | never>;
    deployProxyFactory(): Promise<void>;
    deployProxyAdmin(): Promise<void>;
    private checkVersion;
    private isNewVersionRequired;
    private contractsListForPush;
    private getLibsToDeploy;
    private solidityLibsForPush;
    uploadSolidityLibs(libs: Contract[]): Promise<void>;
    private uploadSolidityLib;
    uploadContracts(contracts: [string, Contract][]): Promise<void>;
    uploadContract(contractName: string, contract: Contract): Promise<void | never>;
    private setSolidityLibs;
    private unsetSolidityLibs;
    private unsetSolidityLib;
    private hasChangedLibraries;
    private getAllSolidityLibNames;
    private populateDependencyGraph;
    private getContractDependencies;
    unsetMissingContracts(): Promise<void>;
    unsetContractAndImplementation(contractName: string): Promise<void | never>;
    validateContracts(contracts: [string, Contract][], buildArtifacts: BuildArtifacts): boolean;
    validateContract(contractName: string, contract: Contract, buildArtifacts: BuildArtifacts): boolean;
    logErrorIfContractPackageIsInvalid(packageName: string, contractName: string, throwIfFail?: boolean): void;
    logErrorIfProjectDeploymentIsInvalid(throwIfFail?: boolean): void;
    logErrorIfContractDeploymentIsInvalid(contractName: string, throwIfFail?: boolean): void;
    private getDeploymentErrorForProject;
    private getContractDeploymentError;
    private logErrorMessage;
    private hasSolidityLibChanged;
    hasContractChanged(contractName: string, contract?: Contract): boolean;
    isProjectFileContract(contractName: string): boolean;
    isNetworkFileContract(contractName: string): boolean;
    verifyAndPublishContract(contractName: string, optimizer: boolean, optimizerRuns: string, remote: string, apiKey: string): Promise<void>;
    writeNetworkPackageIfNeeded(): void;
    freeze(): Promise<void | never>;
    get isPublished(): boolean;
    getDeployer(requestedVersion: string): ProjectDeployer;
    get appAddress(): string;
    get app(): App | null;
    private migrate;
    private migrateManifestVersionIfNeeded;
    publish(): Promise<void>;
    createProxy(packageName: string, contractName: string, initMethod: string, initArgs: any[], kind?: ProxyType, admin?: string, salt?: string, signature?: string): Promise<Contract>;
    createInstance(packageName: string, contractName: string, initArgs: unknown[]): Promise<Contract>;
    private createProxyInstance;
    getProxyDeploymentAddress(salt: string, sender?: string): Promise<string>;
    getProxySignedDeployment(salt: string, signature: string, packageName: string, contractName: string, initMethod?: string, initArgs?: string[], admin?: string): Promise<{
        address: string;
        signer: string;
    }>;
    private checkDeploymentAddress;
    private tryRegisterProxyAdmin;
    private tryRegisterProxyFactory;
    checkInitialization(contract: Contract, calledInitMethod: string): void;
    private updateTruffleDeployedInformation;
    setProxiesAdmin(packageName: string, contractName: string, proxyAddress: string, newAdmin: string): Promise<ProxyInterface[]>;
    setProxyAdminOwner(newAdminOwner: string): Promise<void>;
    private changeProxiesAdmin;
    upgradeProxies(packageName: string, contractName: string, proxyAddress: string, initMethod: string, initArgs: string[]): Promise<ProxyInterface[]>;
    private upgradeProxy;
    private fetchOwnedProxies;
    deployDependencies(): Promise<void>;
    deployDependencyIfNeeded(depName: string, depVersion: string): Promise<void | never>;
    handleDependenciesLink(): Promise<void>;
    unlinkDependency(depName: string): Promise<void | never>;
    linkDependency(depName: string, depVersion: string): Promise<boolean | void | never>;
    private getPackageContractError;
    private updateManifestVersionsIfNeeded;
}
export {};
//# sourceMappingURL=NetworkController.d.ts.map