@hyperlane-xyz/core 4.0.0 → 4.1.0

package/dist/@arbitrum/nitro-contracts/src/precompiles/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/@arbitrum/nitro-contracts/src/precompiles/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../types/@arbitrum/nitro-contracts/src/precompiles/index.ts"],"names":[],"mappings":""}

package/dist/@openzeppelin/contracts/vendor/arbitrum/IBridge.d.ts

@@ -0,0 +1,607 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../../../../common.js";
+export interface IBridgeInterface extends utils.Interface {
+    functions: {
+        "activeOutbox()": FunctionFragment;
+        "allowedDelayedInboxList(uint256)": FunctionFragment;
+        "allowedDelayedInboxes(address)": FunctionFragment;
+        "allowedOutboxList(uint256)": FunctionFragment;
+        "allowedOutboxes(address)": FunctionFragment;
+        "delayedInboxAccs(uint256)": FunctionFragment;
+        "delayedMessageCount()": FunctionFragment;
+        "enqueueDelayedMessage(uint8,address,bytes32)": FunctionFragment;
+        "enqueueSequencerMessage(bytes32,uint256,uint256,uint256)": FunctionFragment;
+        "executeCall(address,uint256,bytes)": FunctionFragment;
+        "initialize(address)": FunctionFragment;
+        "rollup()": FunctionFragment;
+        "sequencerInbox()": FunctionFragment;
+        "sequencerInboxAccs(uint256)": FunctionFragment;
+        "sequencerMessageCount()": FunctionFragment;
+        "sequencerReportedSubMessageCount()": FunctionFragment;
+        "setDelayedInbox(address,bool)": FunctionFragment;
+        "setOutbox(address,bool)": FunctionFragment;
+        "setSequencerInbox(address)": FunctionFragment;
+        "submitBatchSpendingReport(address,bytes32)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "activeOutbox" | "activeOutbox()" | "allowedDelayedInboxList" | "allowedDelayedInboxList(uint256)" | "allowedDelayedInboxes" | "allowedDelayedInboxes(address)" | "allowedOutboxList" | "allowedOutboxList(uint256)" | "allowedOutboxes" | "allowedOutboxes(address)" | "delayedInboxAccs" | "delayedInboxAccs(uint256)" | "delayedMessageCount" | "delayedMessageCount()" | "enqueueDelayedMessage" | "enqueueDelayedMessage(uint8,address,bytes32)" | "enqueueSequencerMessage" | "enqueueSequencerMessage(bytes32,uint256,uint256,uint256)" | "executeCall" | "executeCall(address,uint256,bytes)" | "initialize" | "initialize(address)" | "rollup" | "rollup()" | "sequencerInbox" | "sequencerInbox()" | "sequencerInboxAccs" | "sequencerInboxAccs(uint256)" | "sequencerMessageCount" | "sequencerMessageCount()" | "sequencerReportedSubMessageCount" | "sequencerReportedSubMessageCount()" | "setDelayedInbox" | "setDelayedInbox(address,bool)" | "setOutbox" | "setOutbox(address,bool)" | "setSequencerInbox" | "setSequencerInbox(address)" | "submitBatchSpendingReport" | "submitBatchSpendingReport(address,bytes32)"): FunctionFragment;
+    encodeFunctionData(functionFragment: "activeOutbox", values?: undefined): string;
+    encodeFunctionData(functionFragment: "activeOutbox()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "allowedDelayedInboxList", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "allowedDelayedInboxList(uint256)", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "allowedDelayedInboxes", values: [string]): string;
+    encodeFunctionData(functionFragment: "allowedDelayedInboxes(address)", values: [string]): string;
+    encodeFunctionData(functionFragment: "allowedOutboxList", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "allowedOutboxList(uint256)", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "allowedOutboxes", values: [string]): string;
+    encodeFunctionData(functionFragment: "allowedOutboxes(address)", values: [string]): string;
+    encodeFunctionData(functionFragment: "delayedInboxAccs", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "delayedInboxAccs(uint256)", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "delayedMessageCount", values?: undefined): string;
+    encodeFunctionData(functionFragment: "delayedMessageCount()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "enqueueDelayedMessage", values: [BigNumberish, string, BytesLike]): string;
+    encodeFunctionData(functionFragment: "enqueueDelayedMessage(uint8,address,bytes32)", values: [BigNumberish, string, BytesLike]): string;
+    encodeFunctionData(functionFragment: "enqueueSequencerMessage", values: [BytesLike, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "enqueueSequencerMessage(bytes32,uint256,uint256,uint256)", values: [BytesLike, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "executeCall", values: [string, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: "executeCall(address,uint256,bytes)", values: [string, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: "initialize", values: [string]): string;
+    encodeFunctionData(functionFragment: "initialize(address)", values: [string]): string;
+    encodeFunctionData(functionFragment: "rollup", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rollup()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "sequencerInbox", values?: undefined): string;
+    encodeFunctionData(functionFragment: "sequencerInbox()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "sequencerInboxAccs", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "sequencerInboxAccs(uint256)", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "sequencerMessageCount", values?: undefined): string;
+    encodeFunctionData(functionFragment: "sequencerMessageCount()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "sequencerReportedSubMessageCount", values?: undefined): string;
+    encodeFunctionData(functionFragment: "sequencerReportedSubMessageCount()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setDelayedInbox", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "setDelayedInbox(address,bool)", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "setOutbox", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "setOutbox(address,bool)", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "setSequencerInbox", values: [string]): string;
+    encodeFunctionData(functionFragment: "setSequencerInbox(address)", values: [string]): string;
+    encodeFunctionData(functionFragment: "submitBatchSpendingReport", values: [string, BytesLike]): string;
+    encodeFunctionData(functionFragment: "submitBatchSpendingReport(address,bytes32)", values: [string, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "activeOutbox", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "activeOutbox()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedDelayedInboxList", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedDelayedInboxList(uint256)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedDelayedInboxes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedDelayedInboxes(address)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedOutboxList", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedOutboxList(uint256)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedOutboxes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedOutboxes(address)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "delayedInboxAccs", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "delayedInboxAccs(uint256)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "delayedMessageCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "delayedMessageCount()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "enqueueDelayedMessage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "enqueueDelayedMessage(uint8,address,bytes32)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "enqueueSequencerMessage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "enqueueSequencerMessage(bytes32,uint256,uint256,uint256)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "executeCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "executeCall(address,uint256,bytes)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize(address)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rollup", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rollup()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sequencerInbox", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sequencerInbox()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sequencerInboxAccs", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sequencerInboxAccs(uint256)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sequencerMessageCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sequencerMessageCount()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sequencerReportedSubMessageCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sequencerReportedSubMessageCount()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setDelayedInbox", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setDelayedInbox(address,bool)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setOutbox", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setOutbox(address,bool)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setSequencerInbox", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setSequencerInbox(address)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "submitBatchSpendingReport", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "submitBatchSpendingReport(address,bytes32)", data: BytesLike): Result;
+    events: {
+        "BridgeCallTriggered(address,address,uint256,bytes)": EventFragment;
+        "InboxToggle(address,bool)": EventFragment;
+        "MessageDelivered(uint256,bytes32,address,uint8,address,bytes32,uint256,uint64)": EventFragment;
+        "OutboxToggle(address,bool)": EventFragment;
+        "SequencerInboxUpdated(address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "BridgeCallTriggered"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "BridgeCallTriggered(address,address,uint256,bytes)"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "InboxToggle"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "InboxToggle(address,bool)"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "MessageDelivered"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "MessageDelivered(uint256,bytes32,address,uint8,address,bytes32,uint256,uint64)"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OutboxToggle"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OutboxToggle(address,bool)"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "SequencerInboxUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "SequencerInboxUpdated(address)"): EventFragment;
+}
+export interface BridgeCallTriggeredEventObject {
+    outbox: string;
+    to: string;
+    value: BigNumber;
+    data: string;
+}
+export type BridgeCallTriggeredEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    string
+], BridgeCallTriggeredEventObject>;
+export type BridgeCallTriggeredEventFilter = TypedEventFilter<BridgeCallTriggeredEvent>;
+export interface InboxToggleEventObject {
+    inbox: string;
+    enabled: boolean;
+}
+export type InboxToggleEvent = TypedEvent<[
+    string,
+    boolean
+], InboxToggleEventObject>;
+export type InboxToggleEventFilter = TypedEventFilter<InboxToggleEvent>;
+export interface MessageDeliveredEventObject {
+    messageIndex: BigNumber;
+    beforeInboxAcc: string;
+    inbox: string;
+    kind: number;
+    sender: string;
+    messageDataHash: string;
+    baseFeeL1: BigNumber;
+    timestamp: BigNumber;
+}
+export type MessageDeliveredEvent = TypedEvent<[
+    BigNumber,
+    string,
+    string,
+    number,
+    string,
+    string,
+    BigNumber,
+    BigNumber
+], MessageDeliveredEventObject>;
+export type MessageDeliveredEventFilter = TypedEventFilter<MessageDeliveredEvent>;
+export interface OutboxToggleEventObject {
+    outbox: string;
+    enabled: boolean;
+}
+export type OutboxToggleEvent = TypedEvent<[
+    string,
+    boolean
+], OutboxToggleEventObject>;
+export type OutboxToggleEventFilter = TypedEventFilter<OutboxToggleEvent>;
+export interface SequencerInboxUpdatedEventObject {
+    newSequencerInbox: string;
+}
+export type SequencerInboxUpdatedEvent = TypedEvent<[
+    string
+], SequencerInboxUpdatedEventObject>;
+export type SequencerInboxUpdatedEventFilter = TypedEventFilter<SequencerInboxUpdatedEvent>;
+export interface IBridge extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IBridgeInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        activeOutbox(overrides?: CallOverrides): Promise<[string]>;
+        "activeOutbox()"(overrides?: CallOverrides): Promise<[string]>;
+        allowedDelayedInboxList(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "allowedDelayedInboxList(uint256)"(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        allowedDelayedInboxes(inbox: string, overrides?: CallOverrides): Promise<[boolean]>;
+        "allowedDelayedInboxes(address)"(inbox: string, overrides?: CallOverrides): Promise<[boolean]>;
+        allowedOutboxList(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "allowedOutboxList(uint256)"(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        allowedOutboxes(outbox: string, overrides?: CallOverrides): Promise<[boolean]>;
+        "allowedOutboxes(address)"(outbox: string, overrides?: CallOverrides): Promise<[boolean]>;
+        delayedInboxAccs(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        "delayedInboxAccs(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        delayedMessageCount(overrides?: CallOverrides): Promise<[BigNumber]>;
+        "delayedMessageCount()"(overrides?: CallOverrides): Promise<[BigNumber]>;
+        enqueueDelayedMessage(kind: BigNumberish, sender: string, messageDataHash: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "enqueueDelayedMessage(uint8,address,bytes32)"(kind: BigNumberish, sender: string, messageDataHash: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        enqueueSequencerMessage(dataHash: BytesLike, afterDelayedMessagesRead: BigNumberish, prevMessageCount: BigNumberish, newMessageCount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "enqueueSequencerMessage(bytes32,uint256,uint256,uint256)"(dataHash: BytesLike, afterDelayedMessagesRead: BigNumberish, prevMessageCount: BigNumberish, newMessageCount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        executeCall(to: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "executeCall(address,uint256,bytes)"(to: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        initialize(rollup_: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "initialize(address)"(rollup_: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        rollup(overrides?: CallOverrides): Promise<[string]>;
+        "rollup()"(overrides?: CallOverrides): Promise<[string]>;
+        sequencerInbox(overrides?: CallOverrides): Promise<[string]>;
+        "sequencerInbox()"(overrides?: CallOverrides): Promise<[string]>;
+        sequencerInboxAccs(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        "sequencerInboxAccs(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        sequencerMessageCount(overrides?: CallOverrides): Promise<[BigNumber]>;
+        "sequencerMessageCount()"(overrides?: CallOverrides): Promise<[BigNumber]>;
+        sequencerReportedSubMessageCount(overrides?: CallOverrides): Promise<[BigNumber]>;
+        "sequencerReportedSubMessageCount()"(overrides?: CallOverrides): Promise<[BigNumber]>;
+        setDelayedInbox(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "setDelayedInbox(address,bool)"(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setOutbox(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "setOutbox(address,bool)"(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setSequencerInbox(_sequencerInbox: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "setSequencerInbox(address)"(_sequencerInbox: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        submitBatchSpendingReport(batchPoster: string, dataHash: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "submitBatchSpendingReport(address,bytes32)"(batchPoster: string, dataHash: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    activeOutbox(overrides?: CallOverrides): Promise<string>;
+    "activeOutbox()"(overrides?: CallOverrides): Promise<string>;
+    allowedDelayedInboxList(arg0: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "allowedDelayedInboxList(uint256)"(arg0: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    allowedDelayedInboxes(inbox: string, overrides?: CallOverrides): Promise<boolean>;
+    "allowedDelayedInboxes(address)"(inbox: string, overrides?: CallOverrides): Promise<boolean>;
+    allowedOutboxList(arg0: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "allowedOutboxList(uint256)"(arg0: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    allowedOutboxes(outbox: string, overrides?: CallOverrides): Promise<boolean>;
+    "allowedOutboxes(address)"(outbox: string, overrides?: CallOverrides): Promise<boolean>;
+    delayedInboxAccs(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    "delayedInboxAccs(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    delayedMessageCount(overrides?: CallOverrides): Promise<BigNumber>;
+    "delayedMessageCount()"(overrides?: CallOverrides): Promise<BigNumber>;
+    enqueueDelayedMessage(kind: BigNumberish, sender: string, messageDataHash: BytesLike, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "enqueueDelayedMessage(uint8,address,bytes32)"(kind: BigNumberish, sender: string, messageDataHash: BytesLike, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    enqueueSequencerMessage(dataHash: BytesLike, afterDelayedMessagesRead: BigNumberish, prevMessageCount: BigNumberish, newMessageCount: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "enqueueSequencerMessage(bytes32,uint256,uint256,uint256)"(dataHash: BytesLike, afterDelayedMessagesRead: BigNumberish, prevMessageCount: BigNumberish, newMessageCount: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    executeCall(to: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "executeCall(address,uint256,bytes)"(to: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    initialize(rollup_: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "initialize(address)"(rollup_: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    rollup(overrides?: CallOverrides): Promise<string>;
+    "rollup()"(overrides?: CallOverrides): Promise<string>;
+    sequencerInbox(overrides?: CallOverrides): Promise<string>;
+    "sequencerInbox()"(overrides?: CallOverrides): Promise<string>;
+    sequencerInboxAccs(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    "sequencerInboxAccs(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    sequencerMessageCount(overrides?: CallOverrides): Promise<BigNumber>;
+    "sequencerMessageCount()"(overrides?: CallOverrides): Promise<BigNumber>;
+    sequencerReportedSubMessageCount(overrides?: CallOverrides): Promise<BigNumber>;
+    "sequencerReportedSubMessageCount()"(overrides?: CallOverrides): Promise<BigNumber>;
+    setDelayedInbox(inbox: string, enabled: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "setDelayedInbox(address,bool)"(inbox: string, enabled: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setOutbox(inbox: string, enabled: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "setOutbox(address,bool)"(inbox: string, enabled: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setSequencerInbox(_sequencerInbox: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "setSequencerInbox(address)"(_sequencerInbox: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    submitBatchSpendingReport(batchPoster: string, dataHash: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "submitBatchSpendingReport(address,bytes32)"(batchPoster: string, dataHash: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        activeOutbox(overrides?: CallOverrides): Promise<string>;
+        "activeOutbox()"(overrides?: CallOverrides): Promise<string>;
+        allowedDelayedInboxList(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        "allowedDelayedInboxList(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        allowedDelayedInboxes(inbox: string, overrides?: CallOverrides): Promise<boolean>;
+        "allowedDelayedInboxes(address)"(inbox: string, overrides?: CallOverrides): Promise<boolean>;
+        allowedOutboxList(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        "allowedOutboxList(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        allowedOutboxes(outbox: string, overrides?: CallOverrides): Promise<boolean>;
+        "allowedOutboxes(address)"(outbox: string, overrides?: CallOverrides): Promise<boolean>;
+        delayedInboxAccs(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        "delayedInboxAccs(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        delayedMessageCount(overrides?: CallOverrides): Promise<BigNumber>;
+        "delayedMessageCount()"(overrides?: CallOverrides): Promise<BigNumber>;
+        enqueueDelayedMessage(kind: BigNumberish, sender: string, messageDataHash: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        "enqueueDelayedMessage(uint8,address,bytes32)"(kind: BigNumberish, sender: string, messageDataHash: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        enqueueSequencerMessage(dataHash: BytesLike, afterDelayedMessagesRead: BigNumberish, prevMessageCount: BigNumberish, newMessageCount: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            string,
+            string,
+            string
+        ] & {
+            seqMessageIndex: BigNumber;
+            beforeAcc: string;
+            delayedAcc: string;
+            acc: string;
+        }>;
+        "enqueueSequencerMessage(bytes32,uint256,uint256,uint256)"(dataHash: BytesLike, afterDelayedMessagesRead: BigNumberish, prevMessageCount: BigNumberish, newMessageCount: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            string,
+            string,
+            string
+        ] & {
+            seqMessageIndex: BigNumber;
+            beforeAcc: string;
+            delayedAcc: string;
+            acc: string;
+        }>;
+        executeCall(to: string, value: BigNumberish, data: BytesLike, overrides?: CallOverrides): Promise<[boolean, string] & {
+            success: boolean;
+            returnData: string;
+        }>;
+        "executeCall(address,uint256,bytes)"(to: string, value: BigNumberish, data: BytesLike, overrides?: CallOverrides): Promise<[boolean, string] & {
+            success: boolean;
+            returnData: string;
+        }>;
+        initialize(rollup_: string, overrides?: CallOverrides): Promise<void>;
+        "initialize(address)"(rollup_: string, overrides?: CallOverrides): Promise<void>;
+        rollup(overrides?: CallOverrides): Promise<string>;
+        "rollup()"(overrides?: CallOverrides): Promise<string>;
+        sequencerInbox(overrides?: CallOverrides): Promise<string>;
+        "sequencerInbox()"(overrides?: CallOverrides): Promise<string>;
+        sequencerInboxAccs(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        "sequencerInboxAccs(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        sequencerMessageCount(overrides?: CallOverrides): Promise<BigNumber>;
+        "sequencerMessageCount()"(overrides?: CallOverrides): Promise<BigNumber>;
+        sequencerReportedSubMessageCount(overrides?: CallOverrides): Promise<BigNumber>;
+        "sequencerReportedSubMessageCount()"(overrides?: CallOverrides): Promise<BigNumber>;
+        setDelayedInbox(inbox: string, enabled: boolean, overrides?: CallOverrides): Promise<void>;
+        "setDelayedInbox(address,bool)"(inbox: string, enabled: boolean, overrides?: CallOverrides): Promise<void>;
+        setOutbox(inbox: string, enabled: boolean, overrides?: CallOverrides): Promise<void>;
+        "setOutbox(address,bool)"(inbox: string, enabled: boolean, overrides?: CallOverrides): Promise<void>;
+        setSequencerInbox(_sequencerInbox: string, overrides?: CallOverrides): Promise<void>;
+        "setSequencerInbox(address)"(_sequencerInbox: string, overrides?: CallOverrides): Promise<void>;
+        submitBatchSpendingReport(batchPoster: string, dataHash: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        "submitBatchSpendingReport(address,bytes32)"(batchPoster: string, dataHash: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    filters: {
+        "BridgeCallTriggered(address,address,uint256,bytes)"(outbox?: string | null, to?: string | null, value?: null, data?: null): BridgeCallTriggeredEventFilter;
+        BridgeCallTriggered(outbox?: string | null, to?: string | null, value?: null, data?: null): BridgeCallTriggeredEventFilter;
+        "InboxToggle(address,bool)"(inbox?: string | null, enabled?: null): InboxToggleEventFilter;
+        InboxToggle(inbox?: string | null, enabled?: null): InboxToggleEventFilter;
+        "MessageDelivered(uint256,bytes32,address,uint8,address,bytes32,uint256,uint64)"(messageIndex?: BigNumberish | null, beforeInboxAcc?: BytesLike | null, inbox?: null, kind?: null, sender?: null, messageDataHash?: null, baseFeeL1?: null, timestamp?: null): MessageDeliveredEventFilter;
+        MessageDelivered(messageIndex?: BigNumberish | null, beforeInboxAcc?: BytesLike | null, inbox?: null, kind?: null, sender?: null, messageDataHash?: null, baseFeeL1?: null, timestamp?: null): MessageDeliveredEventFilter;
+        "OutboxToggle(address,bool)"(outbox?: string | null, enabled?: null): OutboxToggleEventFilter;
+        OutboxToggle(outbox?: string | null, enabled?: null): OutboxToggleEventFilter;
+        "SequencerInboxUpdated(address)"(newSequencerInbox?: null): SequencerInboxUpdatedEventFilter;
+        SequencerInboxUpdated(newSequencerInbox?: null): SequencerInboxUpdatedEventFilter;
+    };
+    estimateGas: {
+        activeOutbox(overrides?: CallOverrides): Promise<BigNumber>;
+        "activeOutbox()"(overrides?: CallOverrides): Promise<BigNumber>;
+        allowedDelayedInboxList(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "allowedDelayedInboxList(uint256)"(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        allowedDelayedInboxes(inbox: string, overrides?: CallOverrides): Promise<BigNumber>;
+        "allowedDelayedInboxes(address)"(inbox: string, overrides?: CallOverrides): Promise<BigNumber>;
+        allowedOutboxList(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "allowedOutboxList(uint256)"(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        allowedOutboxes(outbox: string, overrides?: CallOverrides): Promise<BigNumber>;
+        "allowedOutboxes(address)"(outbox: string, overrides?: CallOverrides): Promise<BigNumber>;
+        delayedInboxAccs(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        "delayedInboxAccs(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        delayedMessageCount(overrides?: CallOverrides): Promise<BigNumber>;
+        "delayedMessageCount()"(overrides?: CallOverrides): Promise<BigNumber>;
+        enqueueDelayedMessage(kind: BigNumberish, sender: string, messageDataHash: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "enqueueDelayedMessage(uint8,address,bytes32)"(kind: BigNumberish, sender: string, messageDataHash: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        enqueueSequencerMessage(dataHash: BytesLike, afterDelayedMessagesRead: BigNumberish, prevMessageCount: BigNumberish, newMessageCount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "enqueueSequencerMessage(bytes32,uint256,uint256,uint256)"(dataHash: BytesLike, afterDelayedMessagesRead: BigNumberish, prevMessageCount: BigNumberish, newMessageCount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        executeCall(to: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "executeCall(address,uint256,bytes)"(to: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        initialize(rollup_: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "initialize(address)"(rollup_: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        rollup(overrides?: CallOverrides): Promise<BigNumber>;
+        "rollup()"(overrides?: CallOverrides): Promise<BigNumber>;
+        sequencerInbox(overrides?: CallOverrides): Promise<BigNumber>;
+        "sequencerInbox()"(overrides?: CallOverrides): Promise<BigNumber>;
+        sequencerInboxAccs(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        "sequencerInboxAccs(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        sequencerMessageCount(overrides?: CallOverrides): Promise<BigNumber>;
+        "sequencerMessageCount()"(overrides?: CallOverrides): Promise<BigNumber>;
+        sequencerReportedSubMessageCount(overrides?: CallOverrides): Promise<BigNumber>;
+        "sequencerReportedSubMessageCount()"(overrides?: CallOverrides): Promise<BigNumber>;
+        setDelayedInbox(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "setDelayedInbox(address,bool)"(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setOutbox(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "setOutbox(address,bool)"(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setSequencerInbox(_sequencerInbox: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "setSequencerInbox(address)"(_sequencerInbox: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        submitBatchSpendingReport(batchPoster: string, dataHash: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "submitBatchSpendingReport(address,bytes32)"(batchPoster: string, dataHash: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        activeOutbox(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "activeOutbox()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        allowedDelayedInboxList(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "allowedDelayedInboxList(uint256)"(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        allowedDelayedInboxes(inbox: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "allowedDelayedInboxes(address)"(inbox: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        allowedOutboxList(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "allowedOutboxList(uint256)"(arg0: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        allowedOutboxes(outbox: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "allowedOutboxes(address)"(outbox: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        delayedInboxAccs(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "delayedInboxAccs(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        delayedMessageCount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "delayedMessageCount()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        enqueueDelayedMessage(kind: BigNumberish, sender: string, messageDataHash: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "enqueueDelayedMessage(uint8,address,bytes32)"(kind: BigNumberish, sender: string, messageDataHash: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        enqueueSequencerMessage(dataHash: BytesLike, afterDelayedMessagesRead: BigNumberish, prevMessageCount: BigNumberish, newMessageCount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "enqueueSequencerMessage(bytes32,uint256,uint256,uint256)"(dataHash: BytesLike, afterDelayedMessagesRead: BigNumberish, prevMessageCount: BigNumberish, newMessageCount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        executeCall(to: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "executeCall(address,uint256,bytes)"(to: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        initialize(rollup_: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "initialize(address)"(rollup_: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        rollup(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "rollup()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        sequencerInbox(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "sequencerInbox()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        sequencerInboxAccs(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "sequencerInboxAccs(uint256)"(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        sequencerMessageCount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "sequencerMessageCount()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        sequencerReportedSubMessageCount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "sequencerReportedSubMessageCount()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setDelayedInbox(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "setDelayedInbox(address,bool)"(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setOutbox(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "setOutbox(address,bool)"(inbox: string, enabled: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setSequencerInbox(_sequencerInbox: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "setSequencerInbox(address)"(_sequencerInbox: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        submitBatchSpendingReport(batchPoster: string, dataHash: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "submitBatchSpendingReport(address,bytes32)"(batchPoster: string, dataHash: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}
+//# sourceMappingURL=IBridge.d.ts.map