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

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

@@ -0,0 +1,76 @@
+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 declare namespace IPaymentVerifier {
+    type VerifyPaymentDataStruct = {
+        intentHash: PromiseOrValue<BytesLike>;
+        paymentProof: PromiseOrValue<BytesLike>;
+        data: PromiseOrValue<BytesLike>;
+    };
+    type VerifyPaymentDataStructOutput = [string, string, string] & {
+        intentHash: string;
+        paymentProof: string;
+        data: string;
+    };
+    type PaymentVerificationResultStruct = {
+        success: PromiseOrValue<boolean>;
+        intentHash: PromiseOrValue<BytesLike>;
+        releaseAmount: PromiseOrValue<BigNumberish>;
+    };
+    type PaymentVerificationResultStructOutput = [
+        boolean,
+        string,
+        BigNumber
+    ] & {
+        success: boolean;
+        intentHash: string;
+        releaseAmount: BigNumber;
+    };
+}
+export interface IPaymentVerifierInterface extends utils.Interface {
+    functions: {
+        "verifyPayment((bytes32,bytes,bytes))": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "verifyPayment"): FunctionFragment;
+    encodeFunctionData(functionFragment: "verifyPayment", values: [IPaymentVerifier.VerifyPaymentDataStruct]): string;
+    decodeFunctionResult(functionFragment: "verifyPayment", data: BytesLike): Result;
+    events: {};
+}
+export interface IPaymentVerifier extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IPaymentVerifierInterface;
+    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: {
+        verifyPayment(_verifyPaymentData: IPaymentVerifier.VerifyPaymentDataStruct, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    verifyPayment(_verifyPaymentData: IPaymentVerifier.VerifyPaymentDataStruct, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        verifyPayment(_verifyPaymentData: IPaymentVerifier.VerifyPaymentDataStruct, overrides?: CallOverrides): Promise<IPaymentVerifier.PaymentVerificationResultStructOutput>;
+    };
+    filters: {};
+    estimateGas: {
+        verifyPayment(_verifyPaymentData: IPaymentVerifier.VerifyPaymentDataStruct, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        verifyPayment(_verifyPaymentData: IPaymentVerifier.VerifyPaymentDataStruct, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

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

@@ -0,0 +1,74 @@
+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 IPaymentVerifierRegistryInterface extends utils.Interface {
+    functions: {
+        "getCurrencies(bytes32)": FunctionFragment;
+        "getPaymentMethods()": FunctionFragment;
+        "getVerifier(bytes32)": FunctionFragment;
+        "isCurrency(bytes32,bytes32)": FunctionFragment;
+        "isPaymentMethod(bytes32)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "getCurrencies" | "getPaymentMethods" | "getVerifier" | "isCurrency" | "isPaymentMethod"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getCurrencies", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "getPaymentMethods", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getVerifier", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "isCurrency", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "isPaymentMethod", values: [PromiseOrValue<BytesLike>]): string;
+    decodeFunctionResult(functionFragment: "getCurrencies", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPaymentMethods", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getVerifier", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isCurrency", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isPaymentMethod", data: BytesLike): Result;
+    events: {};
+}
+export interface IPaymentVerifierRegistry extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IPaymentVerifierRegistryInterface;
+    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: {
+        getCurrencies(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string[]]>;
+        getPaymentMethods(overrides?: CallOverrides): Promise<[string[]]>;
+        getVerifier(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string]>;
+        isCurrency(_paymentMethod: PromiseOrValue<BytesLike>, _currencyCode: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
+        isPaymentMethod(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
+    };
+    getCurrencies(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string[]>;
+    getPaymentMethods(overrides?: CallOverrides): Promise<string[]>;
+    getVerifier(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    isCurrency(_paymentMethod: PromiseOrValue<BytesLike>, _currencyCode: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    isPaymentMethod(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    callStatic: {
+        getCurrencies(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string[]>;
+        getPaymentMethods(overrides?: CallOverrides): Promise<string[]>;
+        getVerifier(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+        isCurrency(_paymentMethod: PromiseOrValue<BytesLike>, _currencyCode: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        isPaymentMethod(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    };
+    filters: {};
+    estimateGas: {
+        getCurrencies(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        getPaymentMethods(overrides?: CallOverrides): Promise<BigNumber>;
+        getVerifier(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        isCurrency(_paymentMethod: PromiseOrValue<BytesLike>, _currencyCode: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        isPaymentMethod(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        getCurrencies(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getPaymentMethods(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getVerifier(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isCurrency(_paymentMethod: PromiseOrValue<BytesLike>, _currencyCode: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isPaymentMethod(_paymentMethod: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

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

@@ -0,0 +1,103 @@
+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 declare namespace IOrchestrator {
+    type IntentStruct = {
+        owner: PromiseOrValue<string>;
+        to: PromiseOrValue<string>;
+        escrow: PromiseOrValue<string>;
+        depositId: PromiseOrValue<BigNumberish>;
+        amount: PromiseOrValue<BigNumberish>;
+        timestamp: PromiseOrValue<BigNumberish>;
+        paymentMethod: PromiseOrValue<BytesLike>;
+        fiatCurrency: PromiseOrValue<BytesLike>;
+        conversionRate: PromiseOrValue<BigNumberish>;
+        payeeId: PromiseOrValue<BytesLike>;
+        referrer: PromiseOrValue<string>;
+        referrerFee: PromiseOrValue<BigNumberish>;
+        postIntentHook: PromiseOrValue<string>;
+        data: PromiseOrValue<BytesLike>;
+    };
+    type IntentStructOutput = [
+        string,
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        string,
+        string,
+        BigNumber,
+        string,
+        string,
+        BigNumber,
+        string,
+        string
+    ] & {
+        owner: string;
+        to: string;
+        escrow: string;
+        depositId: BigNumber;
+        amount: BigNumber;
+        timestamp: BigNumber;
+        paymentMethod: string;
+        fiatCurrency: string;
+        conversionRate: BigNumber;
+        payeeId: string;
+        referrer: string;
+        referrerFee: BigNumber;
+        postIntentHook: string;
+        data: string;
+    };
+}
+export interface IPostIntentHookInterface extends utils.Interface {
+    functions: {
+        "execute((address,address,address,uint256,uint256,uint256,bytes32,bytes32,uint256,bytes32,address,uint256,address,bytes),uint256,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "execute"): FunctionFragment;
+    encodeFunctionData(functionFragment: "execute", values: [
+        IOrchestrator.IntentStruct,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result;
+    events: {};
+}
+export interface IPostIntentHook extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IPostIntentHookInterface;
+    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: {
+        execute(_intent: IOrchestrator.IntentStruct, _amountNetFees: PromiseOrValue<BigNumberish>, _fulfillIntentData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    execute(_intent: IOrchestrator.IntentStruct, _amountNetFees: PromiseOrValue<BigNumberish>, _fulfillIntentData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        execute(_intent: IOrchestrator.IntentStruct, _amountNetFees: PromiseOrValue<BigNumberish>, _fulfillIntentData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        execute(_intent: IOrchestrator.IntentStruct, _amountNetFees: PromiseOrValue<BigNumberish>, _fulfillIntentData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        execute(_intent: IOrchestrator.IntentStruct, _amountNetFees: PromiseOrValue<BigNumberish>, _fulfillIntentData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

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

@@ -0,0 +1,50 @@
+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 IPostIntentHookRegistryInterface extends utils.Interface {
+    functions: {
+        "getWhitelistedHooks()": FunctionFragment;
+        "isWhitelistedHook(address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "getWhitelistedHooks" | "isWhitelistedHook"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getWhitelistedHooks", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isWhitelistedHook", values: [PromiseOrValue<string>]): string;
+    decodeFunctionResult(functionFragment: "getWhitelistedHooks", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isWhitelistedHook", data: BytesLike): Result;
+    events: {};
+}
+export interface IPostIntentHookRegistry extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IPostIntentHookRegistryInterface;
+    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: {
+        getWhitelistedHooks(overrides?: CallOverrides): Promise<[string[]]>;
+        isWhitelistedHook(_hook: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+    };
+    getWhitelistedHooks(overrides?: CallOverrides): Promise<string[]>;
+    isWhitelistedHook(_hook: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    callStatic: {
+        getWhitelistedHooks(overrides?: CallOverrides): Promise<string[]>;
+        isWhitelistedHook(_hook: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    };
+    filters: {};
+    estimateGas: {
+        getWhitelistedHooks(overrides?: CallOverrides): Promise<BigNumber>;
+        isWhitelistedHook(_hook: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        getWhitelistedHooks(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isWhitelistedHook(_hook: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

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

@@ -0,0 +1,110 @@
+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 declare namespace IPostIntentHookV2 {
+    type HookIntentContextStruct = {
+        owner: PromiseOrValue<string>;
+        to: PromiseOrValue<string>;
+        escrow: PromiseOrValue<string>;
+        depositId: PromiseOrValue<BigNumberish>;
+        amount: PromiseOrValue<BigNumberish>;
+        timestamp: PromiseOrValue<BigNumberish>;
+        paymentMethod: PromiseOrValue<BytesLike>;
+        fiatCurrency: PromiseOrValue<BytesLike>;
+        conversionRate: PromiseOrValue<BigNumberish>;
+        payeeId: PromiseOrValue<BytesLike>;
+        signalHookData: PromiseOrValue<BytesLike>;
+    };
+    type HookIntentContextStructOutput = [
+        string,
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        string,
+        string,
+        BigNumber,
+        string,
+        string
+    ] & {
+        owner: string;
+        to: string;
+        escrow: string;
+        depositId: BigNumber;
+        amount: BigNumber;
+        timestamp: BigNumber;
+        paymentMethod: string;
+        fiatCurrency: string;
+        conversionRate: BigNumber;
+        payeeId: string;
+        signalHookData: string;
+    };
+    type HookExecutionContextStruct = {
+        intentHash: PromiseOrValue<BytesLike>;
+        token: PromiseOrValue<string>;
+        executableAmount: PromiseOrValue<BigNumberish>;
+        intent: IPostIntentHookV2.HookIntentContextStruct;
+    };
+    type HookExecutionContextStructOutput = [
+        string,
+        string,
+        BigNumber,
+        IPostIntentHookV2.HookIntentContextStructOutput
+    ] & {
+        intentHash: string;
+        token: string;
+        executableAmount: BigNumber;
+        intent: IPostIntentHookV2.HookIntentContextStructOutput;
+    };
+}
+export interface IPostIntentHookV2Interface extends utils.Interface {
+    functions: {
+        "execute((bytes32,address,uint256,(address,address,address,uint256,uint256,uint256,bytes32,bytes32,uint256,bytes32,bytes)),bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "execute"): FunctionFragment;
+    encodeFunctionData(functionFragment: "execute", values: [
+        IPostIntentHookV2.HookExecutionContextStruct,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result;
+    events: {};
+}
+export interface IPostIntentHookV2 extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IPostIntentHookV2Interface;
+    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: {
+        execute(_ctx: IPostIntentHookV2.HookExecutionContextStruct, _fulfillHookData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    execute(_ctx: IPostIntentHookV2.HookExecutionContextStruct, _fulfillHookData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        execute(_ctx: IPostIntentHookV2.HookExecutionContextStruct, _fulfillHookData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        execute(_ctx: IPostIntentHookV2.HookExecutionContextStruct, _fulfillHookData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        execute(_ctx: IPostIntentHookV2.HookExecutionContextStruct, _fulfillHookData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

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

@@ -0,0 +1,97 @@
+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 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 IPreIntentHookInterface extends utils.Interface {
+    functions: {
+        "validateSignalIntent((address,address,uint256,uint256,address,bytes32,bytes32,uint256,(address,uint256)[],bytes))": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "validateSignalIntent"): FunctionFragment;
+    encodeFunctionData(functionFragment: "validateSignalIntent", values: [IPreIntentHook.PreIntentContextStruct]): string;
+    decodeFunctionResult(functionFragment: "validateSignalIntent", data: BytesLike): Result;
+    events: {};
+}
+export interface IPreIntentHook extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IPreIntentHookInterface;
+    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: {
+        validateSignalIntent(_ctx: IPreIntentHook.PreIntentContextStruct, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    validateSignalIntent(_ctx: IPreIntentHook.PreIntentContextStruct, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        validateSignalIntent(_ctx: IPreIntentHook.PreIntentContextStruct, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        validateSignalIntent(_ctx: IPreIntentHook.PreIntentContextStruct, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        validateSignalIntent(_ctx: IPreIntentHook.PreIntentContextStruct, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}