@recoillink/sdk 0.0.0-stage → 45.0.1

package/dist/ism/HyperlaneIsmFactory.js

@@ -0,0 +1,867 @@
+import { AmountRoutingIsm__factory, ArbL2ToL1Ism__factory, BlacklistIsm__factory, CCIPIsm__factory, AtomicInitDefaultFallbackRoutingIsm__factory, AtomicInitDomainRoutingIsm__factory, AtomicInitIncrementalDomainRoutingIsm__factory, DefaultIsm__factory, DelayedFlowRouterHookIsm__factory, DomainRoutingIsm__factory, IAggregationIsm__factory, IInterchainSecurityModule__factory, IMultisigIsm__factory, IncrementalDomainRoutingIsm__factory, NetFlowRateLimitedHookIsm__factory, OPStackIsm__factory, PausableIsm__factory, RateLimitedIsm__factory, StorageAggregationIsm__factory, StorageMerkleRootMultisigIsm__factory, StorageMessageIdMultisigIsm__factory, TestIsm__factory, TrustedRelayerIsm__factory, } from '@recoillink/core';
+import { addBufferToGasLimit, assert, eqAddress, isZeroishAddress, objFilter, rootLogger, } from '@recoillink/utils';
+import { HyperlaneApp } from '../app/HyperlaneApp.js';
+import { CCIPContractCache } from '../ccip/utils.js';
+import { appFromAddressesMapHelper } from '../contracts/contracts.js';
+import { HyperlaneDeployer } from '../deploy/HyperlaneDeployer.js';
+import { proxyFactoryFactories, } from '../deploy/contracts.js';
+import { ChainTechnicalStack } from '../metadata/chainMetadataTypes.js';
+import { fetchPackageVersion, isValidContractVersion, } from '../utils/contract.js';
+import { canonicalizeRemoteIsms } from '../utils/ism.js';
+import { getZKSyncArtifactByContractName } from '../utils/zksync.js';
+import { BaseIsmConfigSchema, DerivedPausableIsmConfigSchema, IsmConfigSchema, IsmType, ModuleType, } from './types.js';
+import { isIsmCompatible, routingModuleDelta } from './utils.js';
+const ismFactories = {
+    [IsmType.PAUSABLE]: new PausableIsm__factory(),
+    [IsmType.TRUSTED_RELAYER]: new TrustedRelayerIsm__factory(),
+    [IsmType.TEST_ISM]: new TestIsm__factory(),
+    [IsmType.OP_STACK]: new OPStackIsm__factory(),
+    [IsmType.ARB_L2_TO_L1]: new ArbL2ToL1Ism__factory(),
+    [IsmType.CCIP]: new CCIPIsm__factory(),
+    [IsmType.RATE_LIMITED]: new RateLimitedIsm__factory(),
+    [IsmType.BLACKLIST]: new BlacklistIsm__factory(),
+    [IsmType.MAILBOX_DEFAULT]: new DefaultIsm__factory(),
+    [IsmType.NET_FLOW_RATE_LIMITED]: new NetFlowRateLimitedHookIsm__factory(),
+    [IsmType.DELAYED_FLOW_ROUTER]: new DelayedFlowRouterHookIsm__factory(),
+};
+// First @recoillink/core version with setIsms/removeIsms on
+// DomainRoutingIsm. Routing ISMs at or above this version let the SDK
+// consolidate per-domain txs into chunked setIsms/removeIsms calls;
+// older ISMs fall back to the per-domain loop.
+const ROUTING_ISM_BATCH_MIN_VERSION = '12.0.0';
+const domainRoutingInitializationSize = (destination) => {
+    if (destination === 'tempo') {
+        return 30;
+    }
+    if (destination === 'mitosis') {
+        return 30;
+    }
+    if (destination === 'citrea') {
+        return 50;
+    }
+    if (destination === 'sei' ||
+        destination === 'xlayer' ||
+        destination === 'eni' ||
+        destination === 'megaeth' ||
+        destination === 'pulsechain') {
+        return 120;
+    }
+    return 300;
+};
+const domainRoutingSetGasBuffer = (destination) => {
+    // MegaETH underestimates incremental routing ISM set() gas by ~2x.
+    // Use a larger buffer only for per-domain enrollments on that chain.
+    if (destination === 'megaeth') {
+        return 150;
+    }
+    return 15;
+};
+/**
+ * Recursively rejects Sealevel-only ISMs (Composite, RoutingMessageIdMultisig)
+ * anywhere in an EVM ISM config tree, including nested under
+ * AGGREGATION/ROUTING/AMOUNT_ROUTING — called once up front so an invalid
+ * nested config is caught before any sibling module in the tree is deployed
+ * on-chain.
+ */
+export function assertNoSealevelOnlyIsm(config) {
+    if (typeof config === 'string') {
+        return;
+    }
+    assert(config.type !== IsmType.COMPOSITE &&
+        config.type !== IsmType.ROUTING_MESSAGE_ID_MULTISIG, `Cannot deploy ${config.type} via the EVM ISM factory — it is Sealevel-only.`);
+    switch (config.type) {
+        case IsmType.AGGREGATION:
+        case IsmType.STORAGE_AGGREGATION:
+            config.modules.forEach(assertNoSealevelOnlyIsm);
+            break;
+        case IsmType.ROUTING:
+        case IsmType.FALLBACK_ROUTING:
+        case IsmType.INCREMENTAL_ROUTING:
+            Object.values(config.domains).forEach(assertNoSealevelOnlyIsm);
+            break;
+        case IsmType.AMOUNT_ROUTING:
+            assertNoSealevelOnlyIsm(config.lowerIsm);
+            assertNoSealevelOnlyIsm(config.upperIsm);
+            break;
+        default:
+            break;
+    }
+}
+/**
+ * Asserts that every domain -> submodule mapping already configured on a
+ * routing ISM found already-initialized matches what this deploy expected to
+ * configure. Owner matching alone isn't sufficient: a resumed deploy whose
+ * nested submodules landed on different addresses than this attempt (e.g. a
+ * raw-CREATE nested routing ISM re-deployed with a new nonce-based address),
+ * or someone else's initialize() call, can leave a routing ISM correctly
+ * owned but wired to the wrong submodules.
+ */
+export async function assertSubmodulesMatchExpected(routingIsm, expectedDomains, expectedModules, destination) {
+    const existingDomains = (await routingIsm.domains()).map((domain) => domain.toNumber());
+    assert(existingDomains.length === expectedDomains.length, `Routing ISM at ${routingIsm.address} on ${destination} was front-run: it has ${existingDomains.length} domains configured, expected ${expectedDomains.length} — refusing to proceed`);
+    // Combined with the length check above, confirming every expected domain is
+    // present on-chain proves the two domain sets are exactly equal.
+    const existingDomainSet = new Set(existingDomains);
+    for (let i = 0; i < expectedDomains.length; i++) {
+        const domain = expectedDomains[i];
+        const expectedModule = expectedModules[i];
+        // module() reverts with a raw "No ISM found for origin" string for a
+        // domain that isn't configured (or, on DefaultFallbackRoutingIsm, silently
+        // falls back to the mailbox default ISM instead) — check set membership
+        // first so a missing domain always surfaces as this clear message.
+        assert(existingDomainSet.has(domain), `Routing ISM at ${routingIsm.address} on ${destination} was front-run: expected domain ${domain} is not configured on-chain — refusing to proceed`);
+        const actualModule = await routingIsm.module(domain);
+        assert(eqAddress(actualModule, expectedModule), `Routing ISM at ${routingIsm.address} on ${destination} was front-run: domain ${domain} routes to ${actualModule}, expected ${expectedModule} — refusing to proceed`);
+    }
+}
+class IsmDeployer extends HyperlaneDeployer {
+    cachingEnabled = false;
+    deployContracts(_chain, _config) {
+        throw new Error('Method not implemented.');
+    }
+}
+export class HyperlaneIsmFactory extends HyperlaneApp {
+    multiProvider;
+    ccipContractCache;
+    // The shape of this object is `ChainMap<Address | ChainMap<Address>`,
+    // although `any` is use here because that type breaks a lot of signatures.
+    // TODO: fix this in the next refactoring
+    deployedIsms = {};
+    deployer;
+    // Memoizes the result of `PACKAGE_VERSION() >= 12.0.0` per routing ISM,
+    // keyed by chain + address. PACKAGE_VERSION is immutable for a given
+    // deployed bytecode, so an instance-lifetime cache is safe. Stores the
+    // in-flight promise so concurrent callers share a single RPC.
+    supportsBatchCache = new Map();
+    constructor(contractsMap, multiProvider, ccipContractCache = new CCIPContractCache(), contractVerifier) {
+        super(contractsMap, multiProvider, rootLogger.child({ module: 'ismFactoryApp' }));
+        this.multiProvider = multiProvider;
+        this.ccipContractCache = ccipContractCache;
+        this.deployer = new IsmDeployer(multiProvider, ismFactories, {
+            contractVerifier,
+        });
+    }
+    static fromAddressesMap(addressesMap, multiProvider, ccipContractCache, contractVerifier) {
+        const helper = appFromAddressesMapHelper(addressesMap, proxyFactoryFactories, multiProvider);
+        return new HyperlaneIsmFactory(helper.contractsMap, multiProvider, ccipContractCache, contractVerifier);
+    }
+    async deploy(params) {
+        // Validate the full ISM tree at the public deployment boundary; recursion
+        // and pre-validated callers use deployInternal (structural only).
+        IsmConfigSchema.parse(params.config);
+        return this.deployInternal(params);
+    }
+    /**
+     * @internal Structural deploy primitive for recursion and pre-validated
+     * callers. Assumes the composition rules of the whole ISM tree have already
+     * been validated via IsmConfigSchema (e.g. by the public deploy() or
+     * EvmIsmModule.create/update). Do not call directly from application code.
+     *
+     * It cannot be `protected` — EvmIsmModule deploys sub-trees through it, and
+     * those are exactly the nodes IsmConfigSchema rejects on their own (a hybrid
+     * hook/ISM outside its mandatory aggregation, say) — so the shape of every
+     * node it is handed is re-validated here instead. Only the composition rules
+     * are taken on trust; a caller reaching this directly still cannot deploy a
+     * malformed config.
+     */
+    async deployInternal(params) {
+        const { destination, config, origin, mailbox, existingIsmAddress } = params;
+        BaseIsmConfigSchema.parse(config);
+        // Reject a nested Sealevel-only ISM before deploying any
+        // sibling module in the tree — a leaf-only check would let earlier
+        // siblings in e.g. an AGGREGATION deploy before this is caught.
+        assertNoSealevelOnlyIsm(config);
+        if (typeof config === 'string') {
+            // @ts-ignore
+            return IInterchainSecurityModule__factory.connect(config, this.multiProvider.getSignerOrProvider(destination));
+        }
+        const ismType = config.type;
+        const logger = this.logger.child({ destination, ismType });
+        logger.debug(`Deploying ISM of type ${ismType} to ${destination} ${origin ? `(for verifying ${origin})` : ''}`);
+        const { technicalStack } = this.multiProvider.getChainMetadata(destination);
+        // For static ISM types it checks whether the technical stack supports static contract deployment
+        assert(isIsmCompatible({ ismType, chainTechnicalStack: technicalStack }), `Technical stack ${technicalStack} is not compatible with ${ismType}`);
+        // Explicit check for unknown ISM types from newer registry versions
+        assert(ismType !== IsmType.UNKNOWN, `Cannot deploy unknown ISM type. Registry contains ISM type not supported by this SDK version.`);
+        let contract;
+        switch (ismType) {
+            case IsmType.MESSAGE_ID_MULTISIG:
+            case IsmType.MERKLE_ROOT_MULTISIG:
+            case IsmType.STORAGE_MESSAGE_ID_MULTISIG:
+            case IsmType.STORAGE_MERKLE_ROOT_MULTISIG:
+                contract = await this.deployMultisigIsm(destination, config, logger);
+                break;
+            case IsmType.WEIGHTED_MESSAGE_ID_MULTISIG:
+            case IsmType.WEIGHTED_MERKLE_ROOT_MULTISIG:
+                contract = await this.deployWeightedMultisigIsm(destination, config, logger);
+                break;
+            case IsmType.ROUTING:
+            case IsmType.FALLBACK_ROUTING:
+            case IsmType.INCREMENTAL_ROUTING:
+            case IsmType.AMOUNT_ROUTING:
+                contract = await this.deployRoutingIsm({
+                    destination,
+                    config,
+                    origin,
+                    mailbox,
+                    existingIsmAddress,
+                    logger,
+                });
+                break;
+            case IsmType.AGGREGATION:
+            case IsmType.STORAGE_AGGREGATION:
+                contract = await this.deployAggregationIsm({
+                    destination,
+                    config,
+                    origin,
+                    mailbox,
+                    logger,
+                });
+                break;
+            case IsmType.OP_STACK:
+                contract = await this.deployer.deployContract(destination, ismType, [
+                    config.nativeBridge,
+                ]);
+                break;
+            case IsmType.PAUSABLE: {
+                const derivedConfig = DerivedPausableIsmConfigSchema.safeParse(config);
+                // Address-bearing configs represent recovered artifacts. Normal
+                // pausable configs omit address and deploy a chain/route-local ISM.
+                const pausableIsm = derivedConfig.success
+                    ? PausableIsm__factory.connect(derivedConfig.data.address, this.multiProvider.getSignerOrProvider(destination))
+                    : await this.deployPausableIsm(destination, config);
+                if (derivedConfig.success) {
+                    await this.reconcileRecoveredPausableIsm(destination, pausableIsm, config);
+                }
+                contract = pausableIsm;
+                break;
+            }
+            case IsmType.TRUSTED_RELAYER:
+                assert(mailbox, `Mailbox address is required for deploying ${ismType}`);
+                contract = await this.deployer.deployContract(destination, IsmType.TRUSTED_RELAYER, [mailbox, config.relayer]);
+                break;
+            case IsmType.TEST_ISM:
+                contract = await this.deployer.deployContract(destination, IsmType.TEST_ISM, []);
+                break;
+            case IsmType.ARB_L2_TO_L1:
+                contract = await this.deployer.deployContract(destination, IsmType.ARB_L2_TO_L1, [config.bridge]);
+                break;
+            case IsmType.RATE_LIMITED: {
+                assert(mailbox, `Mailbox address is required for deploying ${ismType}`);
+                assert(config.recipient, `Recipient address is required for deploying ${ismType}`);
+                contract = await this.deployer.deployContract(destination, IsmType.RATE_LIMITED, [mailbox, config.maxCapacity, config.duration, config.recipient]);
+                if (config.owner) {
+                    const signer = this.multiProvider.getSigner(destination);
+                    const signerAddress = await signer.getAddress();
+                    if (!eqAddress(signerAddress, config.owner)) {
+                        const overrides = this.multiProvider.getTransactionOverrides(destination);
+                        const rateLimitedIsm = RateLimitedIsm__factory.connect(contract.address, signer);
+                        const tx = await rateLimitedIsm.transferOwnership(config.owner, overrides);
+                        await this.multiProvider.handleTx(destination, tx);
+                    }
+                }
+                break;
+            }
+            case IsmType.BLACKLIST:
+                contract = await this.deployBlacklistIsm(destination, config);
+                break;
+            case IsmType.MAILBOX_DEFAULT:
+                assert(mailbox, `Mailbox address is required for deploying ${ismType}`);
+                contract = await this.deployer.deployContract(destination, IsmType.MAILBOX_DEFAULT, [mailbox]);
+                break;
+            case IsmType.NET_FLOW_RATE_LIMITED: {
+                assert(mailbox, `Mailbox address is required for deploying ${ismType}`);
+                assert(config.warpRouter, `Warp router address is required for deploying ${ismType}`);
+                contract = await this.deployer.deployContract(destination, IsmType.NET_FLOW_RATE_LIMITED, [mailbox, config.warpRouter, config.thresholdBps, config.duration]);
+                if (config.owner) {
+                    const signerAddress = await this.multiProvider
+                        .getSigner(destination)
+                        .getAddress();
+                    if (!eqAddress(signerAddress, config.owner)) {
+                        const overrides = this.multiProvider.getTransactionOverrides(destination);
+                        const tx = await contract.transferOwnership(config.owner, overrides);
+                        await this.multiProvider.handleTx(destination, tx);
+                    }
+                }
+                break;
+            }
+            case IsmType.DELAYED_FLOW_ROUTER: {
+                assert(config.warpRouter, `Warp router address is required for deploying ${ismType}`);
+                contract = await this.deployer.deployContract(destination, IsmType.DELAYED_FLOW_ROUTER, [
+                    config.warpRouter,
+                    config.thresholdBps,
+                    config.maxDelay,
+                    config.duration,
+                ]);
+                const overrides = this.multiProvider.getTransactionOverrides(destination);
+                // Canonicalized (chain name -> lowercase bytes32) before anything is
+                // enrolled, so this path resolves the operator's keys exactly as the
+                // update and check paths do. Unknown keys and two keys naming the same
+                // chain are hard errors rather than skips: a dropped counterpart
+                // deploys a route that reports success and can never converge, since
+                // the config keeps asking for an enrollment the tooling omits.
+                const canonicalRemoteIsms = canonicalizeRemoteIsms(config.remoteIsms ?? {}, this.multiProvider, `${ismType} on ${destination}`);
+                const domainIds = [];
+                const routerAddresses = [];
+                for (const [chainName, router] of Object.entries(canonicalRemoteIsms)) {
+                    const domainId = this.multiProvider.getDomainId(chainName);
+                    domainIds.push(domainId);
+                    routerAddresses.push(router);
+                }
+                if (domainIds.length > 0) {
+                    const tx = await contract.enrollRemoteRouters(domainIds, routerAddresses, overrides);
+                    await this.multiProvider.handleTx(destination, tx);
+                }
+                // Ownership transfer is the LAST deployer-signed step — the enrollment
+                // above is owner-gated and requires the deployer to still be owner.
+                const signerAddress = await this.multiProvider
+                    .getSigner(destination)
+                    .getAddress();
+                if (!eqAddress(signerAddress, config.owner)) {
+                    const tx = await contract.transferOwnership(config.owner, overrides);
+                    await this.multiProvider.handleTx(destination, tx);
+                }
+                break;
+            }
+            case IsmType.CCIP:
+                contract = await this.deployCCIPIsm(destination, config);
+                break;
+            case IsmType.OFFCHAIN_LOOKUP:
+                throw new Error(`OFFCHAIN_LOOKUP ISM cannot be deployed — it must already be deployed. ` +
+                    `Pass its contract address as a string instead of a config object.`);
+            case IsmType.INTERCHAIN_ACCOUNT_ROUTING:
+                throw new Error('Interchain Account ISM is not supported in this context');
+            default:
+                throw new Error(`Unsupported ISM type ${ismType}`);
+        }
+        if (!this.deployedIsms[destination]) {
+            this.deployedIsms[destination] = {};
+        }
+        if (origin) {
+            // if we're deploying network-specific contracts (e.g. ISMs), store them as sub-entry
+            // under that network's key (`origin`)
+            if (!this.deployedIsms[destination][origin]) {
+                this.deployedIsms[destination][origin] = {};
+            }
+            this.deployedIsms[destination][origin][ismType] = contract;
+        }
+        else {
+            // otherwise store the entry directly
+            this.deployedIsms[destination][ismType] = contract;
+        }
+        return contract;
+    }
+    async reconcileRecoveredPausableIsm(destination, contract, config) {
+        const [moduleType, currentOwner, currentPaused, signer] = await Promise.all([
+            contract.moduleType(),
+            contract.owner(),
+            contract.paused(),
+            this.multiProvider.getSignerAddress(destination),
+        ]);
+        assert(moduleType === ModuleType.NULL, `Recovered pausable ISM ${contract.address} on ${destination} has module type ${moduleType}, expected ${ModuleType.NULL}`);
+        assert(currentPaused === config.paused, `Recovered pausable ISM ${contract.address} on ${destination} is ${currentPaused ? '' : 'not '}paused, but config expects ${config.paused ? '' : 'not '}paused`);
+        const owner = config.ownerOverrides?.[config.type] ?? config.owner;
+        assert(!isZeroishAddress(owner), `Recovered pausable ISM owner cannot be the zero address`);
+        if (eqAddress(currentOwner, owner))
+            return;
+        assert(eqAddress(currentOwner, signer), `Cannot reconcile recovered pausable ISM ${contract.address} on ${destination}: signer ${signer} is not owner ${currentOwner}`);
+        const overrides = this.multiProvider.getTransactionOverrides(destination);
+        await this.multiProvider.handleTx(destination, contract.transferOwnership(owner, overrides));
+    }
+    async deployCCIPIsm(destination, config) {
+        const ism = this.ccipContractCache.getIsm(config.originChain, destination);
+        if (!ism) {
+            this.logger.error(`CCIP ISM not found for ${config.originChain} -> ${destination}`);
+            throw new Error(`CCIP ISM not found for ${config.originChain} -> ${destination}`);
+        }
+        return CCIPIsm__factory.connect(ism, this.multiProvider.getSigner(destination));
+    }
+    async deployBlacklistIsm(destination, config) {
+        const { blacklistedIds } = config;
+        const signer = this.multiProvider.getSigner(destination);
+        const signerAddress = await signer.getAddress();
+        const overrides = this.multiProvider.getTransactionOverrides(destination);
+        const contract = await this.deployer.deployContract(destination, IsmType.BLACKLIST, [signerAddress]);
+        if (blacklistedIds.length > 0) {
+            const tx = await contract.blacklist(blacklistedIds, overrides);
+            await this.multiProvider.handleTx(destination, tx);
+        }
+        if (!eqAddress(signerAddress, config.owner)) {
+            const tx = await contract.transferOwnership(config.owner, overrides);
+            await this.multiProvider.handleTx(destination, tx);
+        }
+        return contract;
+    }
+    async deployPausableIsm(destination, config) {
+        const signer = this.multiProvider.getSigner(destination);
+        const signerAddress = await signer.getAddress();
+        const overrides = this.multiProvider.getTransactionOverrides(destination);
+        const contract = await this.deployer.deployContract(destination, IsmType.PAUSABLE, [signerAddress]);
+        // Apply owner-gated state before transferring ownership so fresh ISMs
+        // always match the requested config when this method returns.
+        if (config.paused) {
+            const tx = await contract.pause(overrides);
+            await this.multiProvider.handleTx(destination, tx);
+        }
+        if (!eqAddress(signerAddress, config.owner)) {
+            const tx = await contract.transferOwnership(config.owner, overrides);
+            await this.multiProvider.handleTx(destination, tx);
+        }
+        return contract;
+    }
+    async deployMultisigIsm(destination, config, logger) {
+        const signer = this.multiProvider.getSigner(destination);
+        const deployStatic = (factory) => this.deployStaticAddressSet(destination, factory, config.validators, logger, config.threshold);
+        const deployStorage = async (factory, artifact) => {
+            const contract = await this.multiProvider.handleDeploy(destination, factory, [config.validators, config.threshold], artifact);
+            return contract.address;
+        };
+        let address;
+        switch (config.type) {
+            case IsmType.MERKLE_ROOT_MULTISIG:
+                address = await deployStatic(this.getContracts(destination).staticMerkleRootMultisigIsmFactory);
+                break;
+            case IsmType.MESSAGE_ID_MULTISIG:
+                address = await deployStatic(this.getContracts(destination).staticMessageIdMultisigIsmFactory);
+                break;
+            // TODO: support using minimal proxy factories for storage multisig ISMs too.
+            // Doing so drops these two types out of AUTHENTICATING_ISM_TYPES: the
+            // factory's initialize(msg.sender, ...) leaves the proxy owned by its
+            // caller with setValidatorsAndThreshold callable, whereas this
+            // constructor deploy runs _disableInitializers() and leaves it ownerless.
+            case IsmType.STORAGE_MERKLE_ROOT_MULTISIG:
+                address = await deployStorage(new StorageMerkleRootMultisigIsm__factory(), await getZKSyncArtifactByContractName(config.type));
+                break;
+            case IsmType.STORAGE_MESSAGE_ID_MULTISIG:
+                address = await deployStorage(new StorageMessageIdMultisigIsm__factory(), await getZKSyncArtifactByContractName(config.type));
+                break;
+            default:
+                throw new Error(`Unsupported multisig ISM type: ${config.type}`);
+        }
+        return IMultisigIsm__factory.connect(address, signer);
+    }
+    async deployWeightedMultisigIsm(destination, config, logger) {
+        const signer = this.multiProvider.getSigner(destination);
+        const weightedmultisigIsmFactory = config.type === IsmType.WEIGHTED_MERKLE_ROOT_MULTISIG
+            ? this.getContracts(destination)
+                .staticMerkleRootWeightedMultisigIsmFactory
+            : this.getContracts(destination)
+                .staticMessageIdWeightedMultisigIsmFactory;
+        const address = await this.deployStaticWeightedValidatorSet(destination, weightedmultisigIsmFactory, config.validators, config.thresholdWeight, logger);
+        return IMultisigIsm__factory.connect(address, signer);
+    }
+    async deployRoutingIsm(params) {
+        const { config } = params;
+        if (config.type === IsmType.AMOUNT_ROUTING) {
+            return this.deployAmountRoutingIsm({
+                config: config,
+                destination: params.destination,
+                origin: params.origin,
+                mailbox: params.mailbox,
+            });
+        }
+        if (config.type === IsmType.INTERCHAIN_ACCOUNT_ROUTING) {
+            throw new Error(`${IsmType.INTERCHAIN_ACCOUNT_ROUTING} deployment not supported for now in the HyperlaneIsmFactory class`);
+        }
+        return this.deployOwnableRoutingIsm({
+            ...params,
+            // Can't pass params directly because ts will complain that the types do not match
+            config,
+        });
+    }
+    async deployAmountRoutingIsm(params) {
+        const { threshold, lowerIsm, upperIsm } = params.config;
+        const addresses = [];
+        for (const module of [lowerIsm, upperIsm]) {
+            const submodule = await this.deployInternal({
+                destination: params.destination,
+                config: module,
+                origin: params.origin,
+                mailbox: params.mailbox,
+            });
+            addresses.push(submodule.address);
+        }
+        const [lowerIsmAddress, upperIsmAddress] = addresses;
+        return this.multiProvider.handleDeploy(params.destination, new AmountRoutingIsm__factory(), [lowerIsmAddress, upperIsmAddress, threshold]);
+    }
+    async deployOwnableRoutingIsm(params) {
+        const { destination, config, mailbox, existingIsmAddress, logger } = params;
+        const overrides = this.multiProvider.getTransactionOverrides(destination);
+        const contracts = this.getContracts(destination);
+        const domainRoutingIsmFactory = config.type === IsmType.INCREMENTAL_ROUTING
+            ? contracts.incrementalDomainRoutingIsmFactory
+            : contracts.domainRoutingIsmFactory;
+        let routingIsm;
+        // filtering out domains which are not part of the multiprovider
+        config.domains = objFilter(config.domains, (domain, _) => {
+            const domainId = this.multiProvider.tryGetDomainId(domain);
+            if (domainId === null) {
+                logger.warn(`Domain ${domain} doesn't have chain metadata provided, skipping ...`);
+            }
+            return domainId !== null;
+        });
+        const safeConfigDomains = Object.keys(config.domains).map((domain) => this.multiProvider.getDomainId(domain));
+        const delta = existingIsmAddress
+            ? await routingModuleDelta(destination, existingIsmAddress, config, this.multiProvider, this.getContracts(destination), mailbox)
+            : {
+                domainsToUnenroll: [],
+                domainsToEnroll: safeConfigDomains,
+            };
+        const signer = this.multiProvider.getSigner(destination);
+        const provider = this.multiProvider.getProvider(destination);
+        let isOwner = false;
+        if (existingIsmAddress) {
+            const owner = await DomainRoutingIsm__factory.connect(existingIsmAddress, provider).owner();
+            isOwner = eqAddress(await signer.getAddress(), owner);
+        }
+        // reconfiguring existing routing ISM
+        if (existingIsmAddress && isOwner && !delta.mailbox) {
+            routingIsm = DomainRoutingIsm__factory.connect(existingIsmAddress, this.multiProvider.getSigner(destination));
+            const batchSize = domainRoutingInitializationSize(destination);
+            // deploying all the ISMs which have to be updated
+            const enrollAddresses = [];
+            for (const originDomain of delta.domainsToEnroll) {
+                const origin = this.multiProvider.getChainName(originDomain); // already filtered to only include domains in the multiprovider
+                logger.debug(`Reconfiguring preexisting routing ISM at for origin ${origin}...`);
+                const ism = await this.deployInternal({
+                    destination,
+                    config: config.domains[origin],
+                    origin,
+                    mailbox,
+                });
+                enrollAddresses.push(ism.address);
+            }
+            await this.enrollDomains({
+                routingIsm,
+                domains: delta.domainsToEnroll,
+                addresses: enrollAddresses,
+                batchSize,
+                overrides,
+                destination,
+                logger,
+            });
+            await this.unenrollDomains({
+                routingIsm,
+                domains: delta.domainsToUnenroll,
+                batchSize,
+                overrides,
+                destination,
+                logger,
+            });
+            // transfer ownership if needed
+            if (delta.owner) {
+                logger.debug(`Transferring ownership of routing ISM...`);
+                const tx = await routingIsm.transferOwnership(delta.owner, overrides);
+                await this.multiProvider.handleTx(destination, tx);
+            }
+        }
+        else {
+            const isms = {};
+            for (const origin of Object.keys(config.domains)) {
+                const ism = await this.deployInternal({
+                    destination,
+                    config: config.domains[origin],
+                    origin,
+                    mailbox,
+                });
+                isms[origin] = ism.address;
+            }
+            const submoduleAddresses = Object.values(isms);
+            const signerAddress = await signer.getAddress();
+            const batchSize = domainRoutingInitializationSize(destination);
+            const initialBatchSize = Math.min(batchSize, safeConfigDomains.length);
+            const initialDomains = safeConfigDomains.slice(0, initialBatchSize);
+            const initialAddresses = submoduleAddresses.slice(0, initialBatchSize);
+            // Set the final owner atomically when no further enrollments are needed.
+            // RPCs may still serve pre-deployment state when estimating a follow-up call.
+            const initialOwner = initialBatchSize === safeConfigDomains.length
+                ? config.owner
+                : signerAddress;
+            let receipt;
+            if (config.type === IsmType.FALLBACK_ROUTING) {
+                // deploying new fallback routing ISM
+                if (!mailbox) {
+                    throw new Error('Mailbox address is required for deploying fallback routing ISM');
+                }
+                logger.debug('Deploying fallback routing ISM ...');
+                routingIsm = await this.multiProvider.handleDeploy(destination, new AtomicInitDefaultFallbackRoutingIsm__factory(), [mailbox, initialOwner, initialDomains, initialAddresses], await getZKSyncArtifactByContractName('AtomicInitDefaultFallbackRoutingIsm'));
+                await this.enrollDomains({
+                    routingIsm,
+                    domains: safeConfigDomains.slice(initialBatchSize),
+                    addresses: submoduleAddresses.slice(initialBatchSize),
+                    batchSize,
+                    overrides,
+                    destination,
+                    logger,
+                });
+                if (!eqAddress(initialOwner, config.owner)) {
+                    const transferTxEstimatedGas = await routingIsm.estimateGas.transferOwnership(config.owner, overrides);
+                    const transferTx = await routingIsm.transferOwnership(config.owner, {
+                        gasLimit: addBufferToGasLimit(transferTxEstimatedGas, 15),
+                        ...overrides,
+                    });
+                    await this.multiProvider.handleTx(destination, transferTx);
+                }
+            }
+            else {
+                // deploying new domain routing ISM
+                const owner = config.owner;
+                // if zksync we can't use the proxy factories, so we need to deploy directly
+                const isZksync = this.multiProvider.getChainMetadata(destination).technicalStack ===
+                    ChainTechnicalStack.ZkSync;
+                if (isZksync) {
+                    assert(this.deployer, 'HyperlaneDeployer must be set to deploy routing ISM');
+                    const contractName = config.type === IsmType.INCREMENTAL_ROUTING
+                        ? 'AtomicInitIncrementalDomainRoutingIsm'
+                        : 'AtomicInitDomainRoutingIsm';
+                    const factory = config.type === IsmType.INCREMENTAL_ROUTING
+                        ? new AtomicInitIncrementalDomainRoutingIsm__factory()
+                        : new AtomicInitDomainRoutingIsm__factory();
+                    const routingIsm = await this.deployer.deployContractFromFactory(destination, factory, contractName, [owner, safeConfigDomains, submoduleAddresses]);
+                    return routingIsm;
+                }
+                const estimatedGas = await domainRoutingIsmFactory.estimateGas.deploy(initialOwner, initialDomains, initialAddresses, overrides);
+                this.logger.debug(`Deploying routing ISM with initial ${initialBatchSize} domains on ${destination}`);
+                // add gas buffer
+                const tx = await domainRoutingIsmFactory.deploy(initialOwner, initialDomains, initialAddresses, {
+                    gasLimit: addBufferToGasLimit(estimatedGas, 15),
+                    ...overrides,
+                });
+                // TODO: Should verify contract here
+                receipt = await this.multiProvider.handleTx(destination, tx);
+                // TODO: Break this out into a generalized function
+                const dispatchLogs = (receipt.logs ?? [])
+                    .map((log) => {
+                    try {
+                        return domainRoutingIsmFactory.interface.parseLog(log);
+                    }
+                    catch {
+                        return undefined;
+                    }
+                })
+                    .filter((log) => !!log && log.name === 'ModuleDeployed');
+                if (dispatchLogs.length === 0) {
+                    throw new Error('No ModuleDeployed event found');
+                }
+                const moduleAddress = dispatchLogs[0].args['module'];
+                const factory = config.type === IsmType.INCREMENTAL_ROUTING
+                    ? IncrementalDomainRoutingIsm__factory
+                    : DomainRoutingIsm__factory;
+                routingIsm = factory.connect(moduleAddress, this.multiProvider.getSigner(destination));
+                // Enroll remaining domains and addresses
+                // If all domains are enrolled already, this is a no-op
+                await this.enrollDomains({
+                    routingIsm,
+                    domains: safeConfigDomains.slice(initialBatchSize),
+                    addresses: submoduleAddresses.slice(initialBatchSize),
+                    batchSize,
+                    overrides,
+                    destination,
+                    logger,
+                });
+                // Multi-batch deployments retain the signer as owner until all
+                // enrollments are complete.
+                if (!eqAddress(initialOwner, config.owner)) {
+                    const transferTxEstimatedGas = await routingIsm.estimateGas.transferOwnership(config.owner, overrides);
+                    const transferTx = await routingIsm.transferOwnership(config.owner, {
+                        gasLimit: addBufferToGasLimit(transferTxEstimatedGas, 15),
+                        ...overrides,
+                    });
+                    await this.multiProvider.handleTx(destination, transferTx);
+                }
+            }
+        }
+        return routingIsm;
+    }
+    /**
+     * Resolves whether a routing ISM's deployed bytecode has the
+     * `setIsms`/`removeIsms` ops (introduced in `@recoillink/core`
+     * 12.0.0). Memoized per chain+address.
+     */
+    routingIsmSupportsBatch(destination, address) {
+        const key = `${destination}:${address.toLowerCase()}`;
+        const cached = this.supportsBatchCache.get(key);
+        if (cached)
+            return cached;
+        const resolved = fetchPackageVersion(this.multiProvider.getProvider(destination), address, this.logger)
+            .then((version) => isValidContractVersion(version, ROUTING_ISM_BATCH_MIN_VERSION))
+            .catch((error) => {
+            this.supportsBatchCache.delete(key);
+            throw error;
+        });
+        this.supportsBatchCache.set(key, resolved);
+        return resolved;
+    }
+    /**
+     * Enroll a set of (domain, ISM address) pairs on a routing ISM. Uses
+     * `setIsms` chunked by `batchSize` when the deployed ISM supports it;
+     * otherwise falls back to a per-domain `set` loop.
+     */
+    async enrollDomains(params) {
+        const { routingIsm, domains, addresses, batchSize, overrides, destination, logger, } = params;
+        assert(domains.length === addresses.length, 'Routing ISM domains and addresses must have equal lengths');
+        if (domains.length === 0)
+            return;
+        if (await this.routingIsmSupportsBatch(destination, routingIsm.address)) {
+            for (let i = 0; i < domains.length; i += batchSize) {
+                const chunk = domains.slice(i, i + batchSize).map((domain, j) => ({
+                    domain,
+                    ism: addresses[i + j],
+                }));
+                logger.debug(`setIsms enrolling ${chunk.length} domains on routing ISM ${routingIsm.address} (${destination})`);
+                const estimatedGas = await routingIsm.estimateGas.setIsms(chunk, overrides);
+                const tx = await routingIsm.setIsms(chunk, {
+                    gasLimit: addBufferToGasLimit(estimatedGas, domainRoutingSetGasBuffer(destination)),
+                    ...overrides,
+                });
+                await this.multiProvider.handleTx(destination, tx);
+            }
+            return;
+        }
+        for (let i = 0; i < domains.length; i++) {
+            const chainName = this.multiProvider.getChainName(domains[i]);
+            logger.debug(`Enrolling ${chainName} (${domains[i]}) ISM at ${addresses[i]} on routing ISM ${routingIsm.address}`);
+            const estimatedGas = await routingIsm.estimateGas.set(domains[i], addresses[i], overrides);
+            const tx = await routingIsm.set(domains[i], addresses[i], {
+                gasLimit: addBufferToGasLimit(estimatedGas, domainRoutingSetGasBuffer(destination)),
+                ...overrides,
+            });
+            await this.multiProvider.handleTx(destination, tx);
+        }
+    }
+    /**
+     * Unenroll a set of domains from a routing ISM. Uses `removeIsms`
+     * chunked by `batchSize` when supported; otherwise falls back to a
+     * per-domain `remove` loop.
+     */
+    async unenrollDomains(params) {
+        const { routingIsm, domains, batchSize, overrides, destination, logger } = params;
+        if (domains.length === 0)
+            return;
+        if (await this.routingIsmSupportsBatch(destination, routingIsm.address)) {
+            for (let i = 0; i < domains.length; i += batchSize) {
+                const chunk = domains.slice(i, i + batchSize);
+                logger.debug(`removeIsms unenrolling ${chunk.length} domains on routing ISM ${routingIsm.address} (${destination})`);
+                const estimatedGas = await routingIsm.estimateGas.removeIsms(chunk, overrides);
+                const tx = await routingIsm.removeIsms(chunk, {
+                    gasLimit: addBufferToGasLimit(estimatedGas, 15),
+                    ...overrides,
+                });
+                await this.multiProvider.handleTx(destination, tx);
+            }
+            return;
+        }
+        for (const domain of domains) {
+            logger.debug(`Unenrolling domain ${domain} from routing ISM ${routingIsm.address}`);
+            const estimatedGas = await routingIsm.estimateGas.remove(domain, overrides);
+            const tx = await routingIsm.remove(domain, {
+                gasLimit: addBufferToGasLimit(estimatedGas, 15),
+                ...overrides,
+            });
+            await this.multiProvider.handleTx(destination, tx);
+        }
+    }
+    async deployAggregationIsm(params) {
+        const { destination, config, origin, mailbox } = params;
+        const signer = this.multiProvider.getSigner(destination);
+        const addresses = [];
+        for (const module of config.modules) {
+            const submodule = await this.deployInternal({
+                destination,
+                config: module,
+                origin,
+                mailbox,
+            });
+            addresses.push(submodule.address);
+        }
+        let ismAddress;
+        if (config.type === IsmType.STORAGE_AGGREGATION) {
+            // TODO: support using minimal proxy factories for storage aggregation ISMs too
+            const factory = new StorageAggregationIsm__factory().connect(signer);
+            const ism = await this.multiProvider.handleDeploy(destination, factory, [
+                addresses,
+                config.threshold,
+            ]);
+            ismAddress = ism.address;
+        }
+        else {
+            const staticAggregationIsmFactory = this.getContracts(destination).staticAggregationIsmFactory;
+            ismAddress = await this.deployStaticAddressSet(destination, staticAggregationIsmFactory, addresses, params.logger, config.threshold);
+        }
+        return IAggregationIsm__factory.connect(ismAddress, signer);
+    }
+    async deployStaticAddressSet(chain, factory, values, logger, threshold = values.length) {
+        const sorted = [...values].sort();
+        const getAddressResult = await factory['getAddress(address[],uint8)'](sorted, threshold);
+        const address = (await this.previewFactoryDeployAddress(chain, factory, 'deploy(address[],uint8)', [sorted, threshold])) ?? getAddressResult;
+        if (!eqAddress(address, getAddressResult)) {
+            logger.debug(`Factory getAddress mismatch on ${chain}, using deploy simulation address ${address}`);
+        }
+        const code = await this.multiProvider.getProvider(chain).getCode(address);
+        if (code === '0x') {
+            logger.debug(`Deploying new ${threshold} of ${values.length} address set to ${chain}`);
+            const overrides = this.multiProvider.getTransactionOverrides(chain);
+            // estimate gas
+            const estimatedGas = await factory.estimateGas['deploy(address[],uint8)'](sorted, threshold, overrides);
+            // add gas buffer
+            const hash = await factory['deploy(address[],uint8)'](sorted, threshold, {
+                gasLimit: addBufferToGasLimit(estimatedGas, 15),
+                ...overrides,
+            });
+            await this.multiProvider.handleTx(chain, hash);
+            // TODO: add proxy verification artifact?
+        }
+        else {
+            logger.debug(`Recovered ${threshold} of ${values.length} address set on ${chain}: ${address}`);
+        }
+        return address;
+    }
+    async deployStaticWeightedValidatorSet(chain, factory, values, thresholdWeight = 66e8, logger) {
+        const sorted = [...values].sort();
+        const getAddressResult = await factory['getAddress((address,uint96)[],uint96)'](sorted, thresholdWeight);
+        const address = (await this.previewFactoryDeployAddress(chain, factory, 'deploy((address,uint96)[],uint96)', [sorted, thresholdWeight])) ?? getAddressResult;
+        if (!eqAddress(address, getAddressResult)) {
+            logger.debug(`Weighted factory getAddress mismatch on ${chain}, using deploy simulation address ${address}`);
+        }
+        const code = await this.multiProvider.getProvider(chain).getCode(address);
+        if (code === '0x') {
+            logger.debug(`Deploying new weighted set of ${values.length} validators with a threshold weight ${thresholdWeight} on ${chain} `);
+            const overrides = this.multiProvider.getTransactionOverrides(chain);
+            // estimate gas
+            const estimatedGas = await factory.estimateGas['deploy((address,uint96)[],uint96)'](sorted, thresholdWeight, overrides);
+            // add gas buffer
+            const hash = await factory['deploy((address,uint96)[],uint96)'](sorted, thresholdWeight, {
+                gasLimit: addBufferToGasLimit(estimatedGas, 15),
+                ...overrides,
+            });
+            await this.multiProvider.handleTx(chain, hash);
+            // TODO: add proxy verification artifact?
+        }
+        else {
+            logger.debug(`Recovered weighted set of ${values.length} validators on ${chain} with a threshold weight ${thresholdWeight}: ${address}`);
+        }
+        return address;
+    }
+    async previewFactoryDeployAddress(chain, factory, signature, args) {
+        try {
+            const data = factory.interface.encodeFunctionData(signature, args);
+            const result = await this.multiProvider.getProvider(chain).call({
+                to: factory.address,
+                data,
+            });
+            const decoded = factory.interface.decodeFunctionResult(signature, result);
+            if (Array.isArray(decoded) && typeof decoded[0] === 'string') {
+                return decoded[0];
+            }
+            if (typeof decoded === 'string') {
+                return decoded;
+            }
+            return undefined;
+        }
+        catch (e) {
+            this.logger.warn(`Failed to preview factory deploy address on ${chain} (factory=${factory.address}, fn=${signature}): ${e instanceof Error ? e.message : String(e)}`);
+            return undefined;
+        }
+    }
+}
+//# sourceMappingURL=HyperlaneIsmFactory.js.map