@hyperlane-xyz/sdk/dist/ism/HyperlaneIsmFactory.d.ts

The official SDK for the Hyperlane Network

import { Logger } from 'pino';
import { ArbL2ToL1Ism__factory, CCIPIsm, CCIPIsm__factory, IAggregationIsm, IMultisigIsm, IRoutingIsm, IStaticWeightedMultisigIsm, OPStackIsm__factory, PausableIsm__factory, StaticAddressSetFactory, StaticThresholdAddressSetFactory, StaticWeightedValidatorSetFactory, TestIsm__factory, TrustedRelayerIsm__factory } from '@hyperlane-xyz/core';
import { Address } from '@hyperlane-xyz/utils';
import { HyperlaneApp } from '../app/HyperlaneApp.js';
import { CCIPContractCache } from '../ccip/utils.js';
import { HyperlaneAddressesMap, HyperlaneContractsMap } from '../contracts/types.js';
import { HyperlaneDeployer } from '../deploy/HyperlaneDeployer.js';
import { ProxyFactoryFactories } from '../deploy/contracts.js';
import { MultiProvider } from '../providers/MultiProvider.js';
import { ChainMap, ChainName } from '../types.js';
import { AggregationIsmConfig, CCIPIsmConfig, DeployedIsm, IsmConfig, MultisigIsmConfig, RoutingIsmConfig, WeightedMultisigIsmConfig } from './types.js';
declare const ismFactories: {
    pausableIsm: PausableIsm__factory;
    trustedRelayerIsm: TrustedRelayerIsm__factory;
    testIsm: TestIsm__factory;
    opStackIsm: OPStackIsm__factory;
    arbL2ToL1Ism: ArbL2ToL1Ism__factory;
    ccipIsm: CCIPIsm__factory;
};
declare class IsmDeployer extends HyperlaneDeployer<{}, typeof ismFactories> {
    protected readonly cachingEnabled = false;
    deployContracts(_chain: ChainName, _config: any): Promise<any>;
}
export declare class HyperlaneIsmFactory extends HyperlaneApp<ProxyFactoryFactories> {
    readonly multiProvider: MultiProvider;
    readonly ccipContractCache: CCIPContractCache;
    deployedIsms: ChainMap<any>;
    protected readonly deployer: IsmDeployer;
    constructor(contractsMap: HyperlaneContractsMap<ProxyFactoryFactories>, multiProvider: MultiProvider, ccipContractCache?: CCIPContractCache);
    static fromAddressesMap(addressesMap: HyperlaneAddressesMap<any>, multiProvider: MultiProvider, ccipContractCache?: CCIPContractCache): HyperlaneIsmFactory;
    deploy<C extends IsmConfig>(params: {
        destination: ChainName;
        config: C;
        origin?: ChainName;
        mailbox?: Address;
        existingIsmAddress?: Address;
    }): Promise<DeployedIsm>;
    protected deployCCIPIsm(destination: ChainName, config: CCIPIsmConfig): Promise<CCIPIsm>;
    protected deployMultisigIsm(destination: ChainName, config: MultisigIsmConfig, logger: Logger): Promise<IMultisigIsm>;
    protected deployWeightedMultisigIsm(destination: ChainName, config: WeightedMultisigIsmConfig, logger: Logger): Promise<IMultisigIsm>;
    protected deployRoutingIsm(params: {
        destination: ChainName;
        config: RoutingIsmConfig;
        origin?: ChainName;
        mailbox?: Address;
        existingIsmAddress?: Address;
        logger: Logger;
    }): Promise<IRoutingIsm>;
    private deployIcaIsm;
    private deployAmountRoutingIsm;
    private deployOwnableRoutingIsm;
    protected deployAggregationIsm(params: {
        destination: ChainName;
        config: AggregationIsmConfig;
        origin?: ChainName;
        mailbox?: Address;
        logger: Logger;
    }): Promise<IAggregationIsm>;
    deployStaticAddressSet(chain: ChainName, factory: StaticThresholdAddressSetFactory | StaticAddressSetFactory, values: Address[], logger: Logger, threshold?: number): Promise<Address>;
    deployStaticWeightedValidatorSet(chain: ChainName, factory: StaticWeightedValidatorSetFactory, values: IStaticWeightedMultisigIsm.ValidatorInfoStruct[], thresholdWeight: number | undefined, logger: Logger): Promise<Address>;
}
export {};
//# sourceMappingURL=HyperlaneIsmFactory.d.ts.map