@zkp2p/contracts-v2 0.2.4 → 0.3.1-rc.0

package/_types/types/contracts/interfaces/index.d.ts

@@ -0,0 +1,27 @@
+export type { IAttestationVerifier } from "./IAttestationVerifier";
+export type { IChainlinkAggregatorV3 } from "./IChainlinkAggregatorV3";
+export type { IEscrow } from "./IEscrow";
+export type { IEscrowRegistry } from "./IEscrowRegistry";
+export type { IEscrowV2 } from "./IEscrowV2";
+export type { IIntentRiskHook } from "./IIntentRiskHook";
+export type { INullifierRegistry } from "./INullifierRegistry";
+export type { INullifierRegistryV2 } from "./INullifierRegistryV2";
+export type { IOracleAdapter } from "./IOracleAdapter";
+export type { IOrchestrator } from "./IOrchestrator";
+export type { IOrchestratorRegistry } from "./IOrchestratorRegistry";
+export type { IOrchestratorV2 } from "./IOrchestratorV2";
+export type { IOrchestratorV3 } from "./IOrchestratorV3";
+export type { IPaymentVerifier } from "./IPaymentVerifier";
+export type { IPaymentVerifierRegistry } from "./IPaymentVerifierRegistry";
+export type { IPostIntentHook } from "./IPostIntentHook";
+export type { IPostIntentHookRegistry } from "./IPostIntentHookRegistry";
+export type { IPostIntentHookV2 } from "./IPostIntentHookV2";
+export type { IPreIntentHook } from "./IPreIntentHook";
+export type { IProtocolViewer } from "./IProtocolViewer";
+export type { IProtocolViewerV2 } from "./IProtocolViewerV2";
+export type { IPyth } from "./IPyth";
+export type { IRateManager } from "./IRateManager";
+export type { IReferralFee } from "./IReferralFee";
+export type { IRelayerRegistry } from "./IRelayerRegistry";
+export type { IRiskManager } from "./IRiskManager";
+export type { IStakeVault } from "./IStakeVault";

package/_types/types/contracts/lib/BoundedCall.d.ts

@@ -0,0 +1,47 @@
+import type { BaseContract, BytesLike, Signer, utils } from "ethers";
+import type { EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
+export interface BoundedCallInterface extends utils.Interface {
+    functions: {};
+    events: {
+        "RiskHookCallbackFailed(bytes32,address,bytes4,bytes)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "RiskHookCallbackFailed"): EventFragment;
+}
+export interface RiskHookCallbackFailedEventObject {
+    intentHash: string;
+    riskHook: string;
+    callbackSelector: string;
+    revertData: string;
+}
+export type RiskHookCallbackFailedEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    string
+], RiskHookCallbackFailedEventObject>;
+export type RiskHookCallbackFailedEventFilter = TypedEventFilter<RiskHookCallbackFailedEvent>;
+export interface BoundedCall extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: BoundedCallInterface;
+    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: {};
+    callStatic: {};
+    filters: {
+        "RiskHookCallbackFailed(bytes32,address,bytes4,bytes)"(intentHash?: PromiseOrValue<BytesLike> | null, riskHook?: PromiseOrValue<string> | null, callbackSelector?: PromiseOrValue<BytesLike> | null, revertData?: null): RiskHookCallbackFailedEventFilter;
+        RiskHookCallbackFailed(intentHash?: PromiseOrValue<BytesLike> | null, riskHook?: PromiseOrValue<string> | null, callbackSelector?: PromiseOrValue<BytesLike> | null, revertData?: null): RiskHookCallbackFailedEventFilter;
+    };
+    estimateGas: {};
+    populateTransaction: {};
+}

package/_types/types/contracts/lib/FeeSettlementLib.d.ts

@@ -0,0 +1,47 @@
+import type { BaseContract, BigNumber, BytesLike, Signer, utils } from "ethers";
+import type { EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
+export interface FeeSettlementLibInterface extends utils.Interface {
+    functions: {};
+    events: {
+        "IntentFeeDistributed(bytes32,uint8,address,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "IntentFeeDistributed"): EventFragment;
+}
+export interface IntentFeeDistributedEventObject {
+    intentHash: string;
+    feeType: number;
+    recipient: string;
+    amount: BigNumber;
+}
+export type IntentFeeDistributedEvent = TypedEvent<[
+    string,
+    number,
+    string,
+    BigNumber
+], IntentFeeDistributedEventObject>;
+export type IntentFeeDistributedEventFilter = TypedEventFilter<IntentFeeDistributedEvent>;
+export interface FeeSettlementLib extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: FeeSettlementLibInterface;
+    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: {};
+    callStatic: {};
+    filters: {
+        "IntentFeeDistributed(bytes32,uint8,address,uint256)"(intentHash?: PromiseOrValue<BytesLike> | null, feeType?: null, recipient?: PromiseOrValue<string> | null, amount?: null): IntentFeeDistributedEventFilter;
+        IntentFeeDistributed(intentHash?: PromiseOrValue<BytesLike> | null, feeType?: null, recipient?: PromiseOrValue<string> | null, amount?: null): IntentFeeDistributedEventFilter;
+    };
+    estimateGas: {};
+    populateTransaction: {};
+}

package/_types/types/contracts/lib/RiskSettlementExecutor.d.ts

@@ -0,0 +1,53 @@
+import type { BaseContract, BigNumber, BytesLike, Signer, utils } from "ethers";
+import type { EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
+export interface RiskSettlementExecutorInterface extends utils.Interface {
+    functions: {};
+    events: {
+        "IntentRiskSettlementExecuted(bytes32,address,address,uint256,uint256,bool,bool)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "IntentRiskSettlementExecuted"): EventFragment;
+}
+export interface IntentRiskSettlementExecutedEventObject {
+    intentHash: string;
+    riskHook: string;
+    token: string;
+    grossAmount: BigNumber;
+    executableAmount: BigNumber;
+    fundsConsumed: boolean;
+    isManualRelease: boolean;
+}
+export type IntentRiskSettlementExecutedEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    boolean,
+    boolean
+], IntentRiskSettlementExecutedEventObject>;
+export type IntentRiskSettlementExecutedEventFilter = TypedEventFilter<IntentRiskSettlementExecutedEvent>;
+export interface RiskSettlementExecutor extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: RiskSettlementExecutorInterface;
+    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: {};
+    callStatic: {};
+    filters: {
+        "IntentRiskSettlementExecuted(bytes32,address,address,uint256,uint256,bool,bool)"(intentHash?: PromiseOrValue<BytesLike> | null, riskHook?: PromiseOrValue<string> | null, token?: PromiseOrValue<string> | null, grossAmount?: null, executableAmount?: null, fundsConsumed?: null, isManualRelease?: null): IntentRiskSettlementExecutedEventFilter;
+        IntentRiskSettlementExecuted(intentHash?: PromiseOrValue<BytesLike> | null, riskHook?: PromiseOrValue<string> | null, token?: PromiseOrValue<string> | null, grossAmount?: null, executableAmount?: null, fundsConsumed?: null, isManualRelease?: null): IntentRiskSettlementExecutedEventFilter;
+    };
+    estimateGas: {};
+    populateTransaction: {};
+}

package/_types/types/contracts/lib/index.d.ts

@@ -0,0 +1,3 @@
+export type { BoundedCall } from "./BoundedCall";
+export type { FeeSettlementLib } from "./FeeSettlementLib";
+export type { RiskSettlementExecutor } from "./RiskSettlementExecutor";

package/_types/types/contracts/oracles/ChainlinkOracleAdapter.d.ts

@@ -0,0 +1,76 @@
+import type { BaseContract, BigNumber, BytesLike, CallOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
+export interface ChainlinkOracleAdapterInterface extends utils.Interface {
+    functions: {
+        "getRate(bytes)": FunctionFragment;
+        "validateConfig(bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "getRate" | "validateConfig"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getRate", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "validateConfig", values: [PromiseOrValue<BytesLike>]): string;
+    decodeFunctionResult(functionFragment: "getRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "validateConfig", data: BytesLike): Result;
+    events: {};
+}
+export interface ChainlinkOracleAdapter extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: ChainlinkOracleAdapterInterface;
+    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: {
+        getRate(normalizedConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+            boolean,
+            BigNumber,
+            BigNumber
+        ] & {
+            valid: boolean;
+            rate: BigNumber;
+            updatedAt: BigNumber;
+        }>;
+        validateConfig(rawConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string] & {
+            normalizedConfig: string;
+        }>;
+    };
+    getRate(normalizedConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+        boolean,
+        BigNumber,
+        BigNumber
+    ] & {
+        valid: boolean;
+        rate: BigNumber;
+        updatedAt: BigNumber;
+    }>;
+    validateConfig(rawConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        getRate(normalizedConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+            boolean,
+            BigNumber,
+            BigNumber
+        ] & {
+            valid: boolean;
+            rate: BigNumber;
+            updatedAt: BigNumber;
+        }>;
+        validateConfig(rawConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {};
+    estimateGas: {
+        getRate(normalizedConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        validateConfig(rawConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        getRate(normalizedConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        validateConfig(rawConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/_types/types/contracts/oracles/PythOracleAdapter.d.ts

@@ -0,0 +1,84 @@
+import type { BaseContract, BigNumber, BytesLike, CallOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
+export interface PythOracleAdapterInterface extends utils.Interface {
+    functions: {
+        "getRate(bytes)": FunctionFragment;
+        "pyth()": FunctionFragment;
+        "validateConfig(bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "getRate" | "pyth" | "validateConfig"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getRate", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "pyth", values?: undefined): string;
+    encodeFunctionData(functionFragment: "validateConfig", values: [PromiseOrValue<BytesLike>]): string;
+    decodeFunctionResult(functionFragment: "getRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pyth", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "validateConfig", data: BytesLike): Result;
+    events: {};
+}
+export interface PythOracleAdapter extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: PythOracleAdapterInterface;
+    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: {
+        getRate(normalizedConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+            boolean,
+            BigNumber,
+            BigNumber
+        ] & {
+            valid: boolean;
+            rate: BigNumber;
+            updatedAt: BigNumber;
+        }>;
+        pyth(overrides?: CallOverrides): Promise<[string]>;
+        validateConfig(rawConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string] & {
+            normalizedConfig: string;
+        }>;
+    };
+    getRate(normalizedConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+        boolean,
+        BigNumber,
+        BigNumber
+    ] & {
+        valid: boolean;
+        rate: BigNumber;
+        updatedAt: BigNumber;
+    }>;
+    pyth(overrides?: CallOverrides): Promise<string>;
+    validateConfig(rawConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        getRate(normalizedConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+            boolean,
+            BigNumber,
+            BigNumber
+        ] & {
+            valid: boolean;
+            rate: BigNumber;
+            updatedAt: BigNumber;
+        }>;
+        pyth(overrides?: CallOverrides): Promise<string>;
+        validateConfig(rawConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {};
+    estimateGas: {
+        getRate(normalizedConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        pyth(overrides?: CallOverrides): Promise<BigNumber>;
+        validateConfig(rawConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        getRate(normalizedConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pyth(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        validateConfig(rawConfig: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/_types/types/contracts/oracles/index.d.ts

@@ -0,0 +1,2 @@
+export type { ChainlinkOracleAdapter } from "./ChainlinkOracleAdapter";
+export type { PythOracleAdapter } from "./PythOracleAdapter";

package/_types/types/contracts/registries/EscrowRegistry.d.ts

@@ -0,0 +1,206 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, 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, PromiseOrValue } from "../../common";
+export interface EscrowRegistryInterface extends utils.Interface {
+    functions: {
+        "acceptAllEscrows()": FunctionFragment;
+        "addEscrow(address)": FunctionFragment;
+        "escrows(uint256)": FunctionFragment;
+        "getWhitelistedEscrows()": FunctionFragment;
+        "isAcceptingAllEscrows()": FunctionFragment;
+        "isWhitelistedEscrow(address)": FunctionFragment;
+        "owner()": FunctionFragment;
+        "removeEscrow(address)": FunctionFragment;
+        "renounceOwnership()": FunctionFragment;
+        "setAcceptAllEscrows(bool)": FunctionFragment;
+        "transferOwnership(address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "acceptAllEscrows" | "addEscrow" | "escrows" | "getWhitelistedEscrows" | "isAcceptingAllEscrows" | "isWhitelistedEscrow" | "owner" | "removeEscrow" | "renounceOwnership" | "setAcceptAllEscrows" | "transferOwnership"): FunctionFragment;
+    encodeFunctionData(functionFragment: "acceptAllEscrows", values?: undefined): string;
+    encodeFunctionData(functionFragment: "addEscrow", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "escrows", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "getWhitelistedEscrows", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isAcceptingAllEscrows", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isWhitelistedEscrow", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "removeEscrow", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setAcceptAllEscrows", values: [PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [PromiseOrValue<string>]): string;
+    decodeFunctionResult(functionFragment: "acceptAllEscrows", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "addEscrow", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "escrows", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getWhitelistedEscrows", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isAcceptingAllEscrows", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isWhitelistedEscrow", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeEscrow", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setAcceptAllEscrows", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    events: {
+        "AcceptAllEscrowsUpdated(bool)": EventFragment;
+        "EscrowAdded(address)": EventFragment;
+        "EscrowRemoved(address)": EventFragment;
+        "OwnershipTransferred(address,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "AcceptAllEscrowsUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "EscrowAdded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "EscrowRemoved"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+}
+export interface AcceptAllEscrowsUpdatedEventObject {
+    acceptAll: boolean;
+}
+export type AcceptAllEscrowsUpdatedEvent = TypedEvent<[
+    boolean
+], AcceptAllEscrowsUpdatedEventObject>;
+export type AcceptAllEscrowsUpdatedEventFilter = TypedEventFilter<AcceptAllEscrowsUpdatedEvent>;
+export interface EscrowAddedEventObject {
+    escrow: string;
+}
+export type EscrowAddedEvent = TypedEvent<[string], EscrowAddedEventObject>;
+export type EscrowAddedEventFilter = TypedEventFilter<EscrowAddedEvent>;
+export interface EscrowRemovedEventObject {
+    escrow: string;
+}
+export type EscrowRemovedEvent = TypedEvent<[string], EscrowRemovedEventObject>;
+export type EscrowRemovedEventFilter = TypedEventFilter<EscrowRemovedEvent>;
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export interface EscrowRegistry extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: EscrowRegistryInterface;
+    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: {
+        acceptAllEscrows(overrides?: CallOverrides): Promise<[boolean]>;
+        addEscrow(_escrow: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        escrows(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        getWhitelistedEscrows(overrides?: CallOverrides): Promise<[string[]]>;
+        isAcceptingAllEscrows(overrides?: CallOverrides): Promise<[boolean]>;
+        isWhitelistedEscrow(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        removeEscrow(_escrow: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setAcceptAllEscrows(_acceptAll: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    acceptAllEscrows(overrides?: CallOverrides): Promise<boolean>;
+    addEscrow(_escrow: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    escrows(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    getWhitelistedEscrows(overrides?: CallOverrides): Promise<string[]>;
+    isAcceptingAllEscrows(overrides?: CallOverrides): Promise<boolean>;
+    isWhitelistedEscrow(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    removeEscrow(_escrow: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    renounceOwnership(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setAcceptAllEscrows(_acceptAll: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        acceptAllEscrows(overrides?: CallOverrides): Promise<boolean>;
+        addEscrow(_escrow: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        escrows(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        getWhitelistedEscrows(overrides?: CallOverrides): Promise<string[]>;
+        isAcceptingAllEscrows(overrides?: CallOverrides): Promise<boolean>;
+        isWhitelistedEscrow(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        removeEscrow(_escrow: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        renounceOwnership(overrides?: CallOverrides): Promise<void>;
+        setAcceptAllEscrows(_acceptAll: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "AcceptAllEscrowsUpdated(bool)"(acceptAll?: null): AcceptAllEscrowsUpdatedEventFilter;
+        AcceptAllEscrowsUpdated(acceptAll?: null): AcceptAllEscrowsUpdatedEventFilter;
+        "EscrowAdded(address)"(escrow?: PromiseOrValue<string> | null): EscrowAddedEventFilter;
+        EscrowAdded(escrow?: PromiseOrValue<string> | null): EscrowAddedEventFilter;
+        "EscrowRemoved(address)"(escrow?: PromiseOrValue<string> | null): EscrowRemovedEventFilter;
+        EscrowRemoved(escrow?: PromiseOrValue<string> | null): EscrowRemovedEventFilter;
+        "OwnershipTransferred(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+    };
+    estimateGas: {
+        acceptAllEscrows(overrides?: CallOverrides): Promise<BigNumber>;
+        addEscrow(_escrow: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        escrows(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        getWhitelistedEscrows(overrides?: CallOverrides): Promise<BigNumber>;
+        isAcceptingAllEscrows(overrides?: CallOverrides): Promise<BigNumber>;
+        isWhitelistedEscrow(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        removeEscrow(_escrow: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setAcceptAllEscrows(_acceptAll: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        acceptAllEscrows(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        addEscrow(_escrow: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        escrows(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getWhitelistedEscrows(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isAcceptingAllEscrows(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isWhitelistedEscrow(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        removeEscrow(_escrow: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setAcceptAllEscrows(_acceptAll: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}