@zkp2p/contracts-v2 0.3.0 → 0.3.1-rc.1

package/_types/types/contracts/hooks/WhitelistPreIntentHookV2.d.ts

@@ -0,0 +1,311 @@
+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 declare namespace IReferralFee {
+    type ReferralFeeStruct = {
+        recipient: PromiseOrValue<string>;
+        fee: PromiseOrValue<BigNumberish>;
+    };
+    type ReferralFeeStructOutput = [string, BigNumber] & {
+        recipient: string;
+        fee: BigNumber;
+    };
+}
+export declare namespace IPreIntentHook {
+    type PreIntentContextStruct = {
+        taker: PromiseOrValue<string>;
+        escrow: PromiseOrValue<string>;
+        depositId: PromiseOrValue<BigNumberish>;
+        amount: PromiseOrValue<BigNumberish>;
+        to: PromiseOrValue<string>;
+        paymentMethod: PromiseOrValue<BytesLike>;
+        fiatCurrency: PromiseOrValue<BytesLike>;
+        conversionRate: PromiseOrValue<BigNumberish>;
+        referralFees: IReferralFee.ReferralFeeStruct[];
+        preIntentHookData: PromiseOrValue<BytesLike>;
+    };
+    type PreIntentContextStructOutput = [
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        string,
+        string,
+        string,
+        BigNumber,
+        IReferralFee.ReferralFeeStructOutput[],
+        string
+    ] & {
+        taker: string;
+        escrow: string;
+        depositId: BigNumber;
+        amount: BigNumber;
+        to: string;
+        paymentMethod: string;
+        fiatCurrency: string;
+        conversionRate: BigNumber;
+        referralFees: IReferralFee.ReferralFeeStructOutput[];
+        preIntentHookData: string;
+    };
+}
+export interface WhitelistPreIntentHookV2Interface extends utils.Interface {
+    functions: {
+        "MAX_GROUPS_PER_DEPOSIT()": FunctionFragment;
+        "addToWhitelist(address,uint256,address[])": FunctionFragment;
+        "attachGroups(address,uint256,uint256[])": FunctionFragment;
+        "detachGroups(address,uint256,uint256[])": FunctionFragment;
+        "getAttachedGroups(address,uint256)": FunctionFragment;
+        "groupRegistry()": FunctionFragment;
+        "isAllowedTaker(address,uint256,address)": FunctionFragment;
+        "isGroupAttached(address,uint256,uint256)": FunctionFragment;
+        "isWhitelisted(address,uint256,address)": FunctionFragment;
+        "orchestratorRegistry()": FunctionFragment;
+        "removeFromWhitelist(address,uint256,address[])": FunctionFragment;
+        "validateSignalIntent((address,address,uint256,uint256,address,bytes32,bytes32,uint256,(address,uint256)[],bytes))": FunctionFragment;
+        "whitelist(address,uint256,address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "MAX_GROUPS_PER_DEPOSIT" | "addToWhitelist" | "attachGroups" | "detachGroups" | "getAttachedGroups" | "groupRegistry" | "isAllowedTaker" | "isGroupAttached" | "isWhitelisted" | "orchestratorRegistry" | "removeFromWhitelist" | "validateSignalIntent" | "whitelist"): FunctionFragment;
+    encodeFunctionData(functionFragment: "MAX_GROUPS_PER_DEPOSIT", values?: undefined): string;
+    encodeFunctionData(functionFragment: "addToWhitelist", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>[]
+    ]): string;
+    encodeFunctionData(functionFragment: "attachGroups", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>[]
+    ]): string;
+    encodeFunctionData(functionFragment: "detachGroups", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>[]
+    ]): string;
+    encodeFunctionData(functionFragment: "getAttachedGroups", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "groupRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isAllowedTaker", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>
+    ]): string;
+    encodeFunctionData(functionFragment: "isGroupAttached", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "isWhitelisted", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>
+    ]): string;
+    encodeFunctionData(functionFragment: "orchestratorRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "removeFromWhitelist", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>[]
+    ]): string;
+    encodeFunctionData(functionFragment: "validateSignalIntent", values: [IPreIntentHook.PreIntentContextStruct]): string;
+    encodeFunctionData(functionFragment: "whitelist", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>
+    ]): string;
+    decodeFunctionResult(functionFragment: "MAX_GROUPS_PER_DEPOSIT", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "addToWhitelist", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "attachGroups", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "detachGroups", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAttachedGroups", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "groupRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isAllowedTaker", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isGroupAttached", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isWhitelisted", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "orchestratorRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeFromWhitelist", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "validateSignalIntent", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "whitelist", data: BytesLike): Result;
+    events: {
+        "GroupAttached(address,uint256,uint256)": EventFragment;
+        "GroupDetached(address,uint256,uint256)": EventFragment;
+        "TakerRemovedFromWhitelist(address,uint256,address)": EventFragment;
+        "TakerWhitelisted(address,uint256,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "GroupAttached"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "GroupDetached"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TakerRemovedFromWhitelist"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TakerWhitelisted"): EventFragment;
+}
+export interface GroupAttachedEventObject {
+    escrow: string;
+    depositId: BigNumber;
+    groupId: BigNumber;
+}
+export type GroupAttachedEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber
+], GroupAttachedEventObject>;
+export type GroupAttachedEventFilter = TypedEventFilter<GroupAttachedEvent>;
+export interface GroupDetachedEventObject {
+    escrow: string;
+    depositId: BigNumber;
+    groupId: BigNumber;
+}
+export type GroupDetachedEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber
+], GroupDetachedEventObject>;
+export type GroupDetachedEventFilter = TypedEventFilter<GroupDetachedEvent>;
+export interface TakerRemovedFromWhitelistEventObject {
+    escrow: string;
+    depositId: BigNumber;
+    taker: string;
+}
+export type TakerRemovedFromWhitelistEvent = TypedEvent<[
+    string,
+    BigNumber,
+    string
+], TakerRemovedFromWhitelistEventObject>;
+export type TakerRemovedFromWhitelistEventFilter = TypedEventFilter<TakerRemovedFromWhitelistEvent>;
+export interface TakerWhitelistedEventObject {
+    escrow: string;
+    depositId: BigNumber;
+    taker: string;
+}
+export type TakerWhitelistedEvent = TypedEvent<[
+    string,
+    BigNumber,
+    string
+], TakerWhitelistedEventObject>;
+export type TakerWhitelistedEventFilter = TypedEventFilter<TakerWhitelistedEvent>;
+export interface WhitelistPreIntentHookV2 extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: WhitelistPreIntentHookV2Interface;
+    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: {
+        MAX_GROUPS_PER_DEPOSIT(overrides?: CallOverrides): Promise<[BigNumber]>;
+        addToWhitelist(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _takers: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        attachGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        detachGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        getAttachedGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber[]]>;
+        groupRegistry(overrides?: CallOverrides): Promise<[string]>;
+        isAllowedTaker(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        isGroupAttached(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[boolean]>;
+        isWhitelisted(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        orchestratorRegistry(overrides?: CallOverrides): Promise<[string]>;
+        removeFromWhitelist(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _takers: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        validateSignalIntent(_ctx: IPreIntentHook.PreIntentContextStruct, overrides?: CallOverrides): Promise<[void]>;
+        whitelist(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, arg2: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+    };
+    MAX_GROUPS_PER_DEPOSIT(overrides?: CallOverrides): Promise<BigNumber>;
+    addToWhitelist(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _takers: PromiseOrValue<string>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    attachGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    detachGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    getAttachedGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber[]>;
+    groupRegistry(overrides?: CallOverrides): Promise<string>;
+    isAllowedTaker(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    isGroupAttached(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+    isWhitelisted(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    orchestratorRegistry(overrides?: CallOverrides): Promise<string>;
+    removeFromWhitelist(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _takers: PromiseOrValue<string>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    validateSignalIntent(_ctx: IPreIntentHook.PreIntentContextStruct, overrides?: CallOverrides): Promise<void>;
+    whitelist(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, arg2: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    callStatic: {
+        MAX_GROUPS_PER_DEPOSIT(overrides?: CallOverrides): Promise<BigNumber>;
+        addToWhitelist(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _takers: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
+        attachGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupIds: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
+        detachGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupIds: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
+        getAttachedGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber[]>;
+        groupRegistry(overrides?: CallOverrides): Promise<string>;
+        isAllowedTaker(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        isGroupAttached(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+        isWhitelisted(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        orchestratorRegistry(overrides?: CallOverrides): Promise<string>;
+        removeFromWhitelist(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _takers: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
+        validateSignalIntent(_ctx: IPreIntentHook.PreIntentContextStruct, overrides?: CallOverrides): Promise<void>;
+        whitelist(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, arg2: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    };
+    filters: {
+        "GroupAttached(address,uint256,uint256)"(escrow?: PromiseOrValue<string> | null, depositId?: PromiseOrValue<BigNumberish> | null, groupId?: PromiseOrValue<BigNumberish> | null): GroupAttachedEventFilter;
+        GroupAttached(escrow?: PromiseOrValue<string> | null, depositId?: PromiseOrValue<BigNumberish> | null, groupId?: PromiseOrValue<BigNumberish> | null): GroupAttachedEventFilter;
+        "GroupDetached(address,uint256,uint256)"(escrow?: PromiseOrValue<string> | null, depositId?: PromiseOrValue<BigNumberish> | null, groupId?: PromiseOrValue<BigNumberish> | null): GroupDetachedEventFilter;
+        GroupDetached(escrow?: PromiseOrValue<string> | null, depositId?: PromiseOrValue<BigNumberish> | null, groupId?: PromiseOrValue<BigNumberish> | null): GroupDetachedEventFilter;
+        "TakerRemovedFromWhitelist(address,uint256,address)"(escrow?: PromiseOrValue<string> | null, depositId?: PromiseOrValue<BigNumberish> | null, taker?: PromiseOrValue<string> | null): TakerRemovedFromWhitelistEventFilter;
+        TakerRemovedFromWhitelist(escrow?: PromiseOrValue<string> | null, depositId?: PromiseOrValue<BigNumberish> | null, taker?: PromiseOrValue<string> | null): TakerRemovedFromWhitelistEventFilter;
+        "TakerWhitelisted(address,uint256,address)"(escrow?: PromiseOrValue<string> | null, depositId?: PromiseOrValue<BigNumberish> | null, taker?: PromiseOrValue<string> | null): TakerWhitelistedEventFilter;
+        TakerWhitelisted(escrow?: PromiseOrValue<string> | null, depositId?: PromiseOrValue<BigNumberish> | null, taker?: PromiseOrValue<string> | null): TakerWhitelistedEventFilter;
+    };
+    estimateGas: {
+        MAX_GROUPS_PER_DEPOSIT(overrides?: CallOverrides): Promise<BigNumber>;
+        addToWhitelist(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _takers: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        attachGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        detachGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        getAttachedGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        groupRegistry(overrides?: CallOverrides): Promise<BigNumber>;
+        isAllowedTaker(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        isGroupAttached(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        isWhitelisted(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        orchestratorRegistry(overrides?: CallOverrides): Promise<BigNumber>;
+        removeFromWhitelist(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _takers: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        validateSignalIntent(_ctx: IPreIntentHook.PreIntentContextStruct, overrides?: CallOverrides): Promise<BigNumber>;
+        whitelist(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, arg2: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        MAX_GROUPS_PER_DEPOSIT(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        addToWhitelist(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _takers: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        attachGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        detachGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        getAttachedGroups(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        groupRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isAllowedTaker(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isGroupAttached(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isWhitelisted(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        orchestratorRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        removeFromWhitelist(_escrow: PromiseOrValue<string>, _depositId: PromiseOrValue<BigNumberish>, _takers: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        validateSignalIntent(_ctx: IPreIntentHook.PreIntentContextStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        whitelist(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, arg2: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

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

@@ -0,0 +1,5 @@
+export type { AcrossBridgeHook } from "./AcrossBridgeHook";
+export type { AcrossBridgeHookV2 } from "./AcrossBridgeHookV2";
+export type { SignatureGatingPreIntentHook } from "./SignatureGatingPreIntentHook";
+export type { WhitelistPreIntentHook } from "./WhitelistPreIntentHook";
+export type { WhitelistPreIntentHookV2 } from "./WhitelistPreIntentHookV2";

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

@@ -0,0 +1,26 @@
+import type * as external from "./external";
+export type { external };
+import type * as hooks from "./hooks";
+export type { hooks };
+import type * as interfaces from "./interfaces";
+export type { interfaces };
+import type * as lib from "./lib";
+export type { lib };
+import type * as oracles from "./oracles";
+export type { oracles };
+import type * as registries from "./registries";
+export type { registries };
+import type * as risk from "./risk";
+export type { risk };
+import type * as unifiedVerifier from "./unifiedVerifier";
+export type { unifiedVerifier };
+export type { Escrow } from "./Escrow";
+export type { EscrowV2 } from "./EscrowV2";
+export type { Orchestrator } from "./Orchestrator";
+export type { OrchestratorV2 } from "./OrchestratorV2";
+export type { OrchestratorV3 } from "./OrchestratorV3";
+export type { ProtocolViewer } from "./ProtocolViewer";
+export type { ProtocolViewerV2 } from "./ProtocolViewerV2";
+export type { RateManagerV1 } from "./RateManagerV1";
+export type { RiskManager } from "./RiskManager";
+export type { StakeVault } from "./StakeVault";

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

@@ -0,0 +1,208 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, 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 IAddressGroupRegistryInterface extends utils.Interface {
+    functions: {
+        "acceptGroupOwnership(uint256)": FunctionFragment;
+        "addMembers(uint256,address[])": FunctionFragment;
+        "cancelGroupOwnershipTransfer(uint256)": FunctionFragment;
+        "createGroup(string)": FunctionFragment;
+        "getGroup(uint256)": FunctionFragment;
+        "groupCount()": FunctionFragment;
+        "groupExists(uint256)": FunctionFragment;
+        "isMember(uint256,address)": FunctionFragment;
+        "removeMembers(uint256,address[])": FunctionFragment;
+        "setResolver(uint256,address)": FunctionFragment;
+        "transferGroupOwnership(uint256,address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "acceptGroupOwnership" | "addMembers" | "cancelGroupOwnershipTransfer" | "createGroup" | "getGroup" | "groupCount" | "groupExists" | "isMember" | "removeMembers" | "setResolver" | "transferGroupOwnership"): FunctionFragment;
+    encodeFunctionData(functionFragment: "acceptGroupOwnership", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "addMembers", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>[]]): string;
+    encodeFunctionData(functionFragment: "cancelGroupOwnershipTransfer", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "createGroup", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "getGroup", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "groupCount", values?: undefined): string;
+    encodeFunctionData(functionFragment: "groupExists", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "isMember", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "removeMembers", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>[]]): string;
+    encodeFunctionData(functionFragment: "setResolver", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "transferGroupOwnership", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
+    decodeFunctionResult(functionFragment: "acceptGroupOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "addMembers", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "cancelGroupOwnershipTransfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createGroup", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getGroup", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "groupCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "groupExists", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isMember", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeMembers", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setResolver", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferGroupOwnership", data: BytesLike): Result;
+    events: {};
+}
+export interface IAddressGroupRegistry extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IAddressGroupRegistryInterface;
+    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: {
+        acceptGroupOwnership(_groupId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        addMembers(_groupId: PromiseOrValue<BigNumberish>, _members: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        cancelGroupOwnershipTransfer(_groupId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        createGroup(_name: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        getGroup(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            string,
+            string,
+            string,
+            boolean
+        ] & {
+            owner: string;
+            pendingOwner: string;
+            resolver: string;
+            exists: boolean;
+        }>;
+        groupCount(overrides?: CallOverrides): Promise<[BigNumber]>;
+        groupExists(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[boolean]>;
+        isMember(_groupId: PromiseOrValue<BigNumberish>, _account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        removeMembers(_groupId: PromiseOrValue<BigNumberish>, _members: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setResolver(_groupId: PromiseOrValue<BigNumberish>, _resolver: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        transferGroupOwnership(_groupId: PromiseOrValue<BigNumberish>, _newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    acceptGroupOwnership(_groupId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    addMembers(_groupId: PromiseOrValue<BigNumberish>, _members: PromiseOrValue<string>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    cancelGroupOwnershipTransfer(_groupId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    createGroup(_name: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    getGroup(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+        string,
+        string,
+        string,
+        boolean
+    ] & {
+        owner: string;
+        pendingOwner: string;
+        resolver: string;
+        exists: boolean;
+    }>;
+    groupCount(overrides?: CallOverrides): Promise<BigNumber>;
+    groupExists(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+    isMember(_groupId: PromiseOrValue<BigNumberish>, _account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    removeMembers(_groupId: PromiseOrValue<BigNumberish>, _members: PromiseOrValue<string>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setResolver(_groupId: PromiseOrValue<BigNumberish>, _resolver: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    transferGroupOwnership(_groupId: PromiseOrValue<BigNumberish>, _newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        acceptGroupOwnership(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        addMembers(_groupId: PromiseOrValue<BigNumberish>, _members: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
+        cancelGroupOwnershipTransfer(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        createGroup(_name: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        getGroup(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            string,
+            string,
+            string,
+            boolean
+        ] & {
+            owner: string;
+            pendingOwner: string;
+            resolver: string;
+            exists: boolean;
+        }>;
+        groupCount(overrides?: CallOverrides): Promise<BigNumber>;
+        groupExists(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+        isMember(_groupId: PromiseOrValue<BigNumberish>, _account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        removeMembers(_groupId: PromiseOrValue<BigNumberish>, _members: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
+        setResolver(_groupId: PromiseOrValue<BigNumberish>, _resolver: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        transferGroupOwnership(_groupId: PromiseOrValue<BigNumberish>, _newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        acceptGroupOwnership(_groupId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        addMembers(_groupId: PromiseOrValue<BigNumberish>, _members: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        cancelGroupOwnershipTransfer(_groupId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        createGroup(_name: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        getGroup(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        groupCount(overrides?: CallOverrides): Promise<BigNumber>;
+        groupExists(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        isMember(_groupId: PromiseOrValue<BigNumberish>, _account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        removeMembers(_groupId: PromiseOrValue<BigNumberish>, _members: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setResolver(_groupId: PromiseOrValue<BigNumberish>, _resolver: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        transferGroupOwnership(_groupId: PromiseOrValue<BigNumberish>, _newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        acceptGroupOwnership(_groupId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        addMembers(_groupId: PromiseOrValue<BigNumberish>, _members: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        cancelGroupOwnershipTransfer(_groupId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        createGroup(_name: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        getGroup(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        groupCount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        groupExists(_groupId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isMember(_groupId: PromiseOrValue<BigNumberish>, _account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        removeMembers(_groupId: PromiseOrValue<BigNumberish>, _members: PromiseOrValue<string>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setResolver(_groupId: PromiseOrValue<BigNumberish>, _resolver: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        transferGroupOwnership(_groupId: PromiseOrValue<BigNumberish>, _newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

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

@@ -0,0 +1,48 @@
+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 IAttestationVerifierInterface extends utils.Interface {
+    functions: {
+        "verify(bytes32,bytes[],bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "verify"): FunctionFragment;
+    encodeFunctionData(functionFragment: "verify", values: [
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>[],
+        PromiseOrValue<BytesLike>
+    ]): string;
+    decodeFunctionResult(functionFragment: "verify", data: BytesLike): Result;
+    events: {};
+}
+export interface IAttestationVerifier extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IAttestationVerifierInterface;
+    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: {
+        verify(_digest: PromiseOrValue<BytesLike>, _sigs: PromiseOrValue<BytesLike>[], _data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean] & {
+            isValid: boolean;
+        }>;
+    };
+    verify(_digest: PromiseOrValue<BytesLike>, _sigs: PromiseOrValue<BytesLike>[], _data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    callStatic: {
+        verify(_digest: PromiseOrValue<BytesLike>, _sigs: PromiseOrValue<BytesLike>[], _data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    };
+    filters: {};
+    estimateGas: {
+        verify(_digest: PromiseOrValue<BytesLike>, _sigs: PromiseOrValue<BytesLike>[], _data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        verify(_digest: PromiseOrValue<BytesLike>, _sigs: PromiseOrValue<BytesLike>[], _data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}