Add built files

dist/@openzeppelin/contracts-v3/access/Ownable.d.ts

@@ -0,0 +1,54 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface OwnableInterface extends Interface {
+    getFunction(nameOrSignature: "owner" | "renounceOwnership" | "transferOwnership"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+}
+export declare namespace OwnershipTransferredEvent {
+    type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike];
+    type OutputTuple = [previousOwner: string, newOwner: string];
+    interface OutputObject {
+        previousOwner: string;
+        newOwner: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface Ownable extends BaseContract {
+    connect(runner?: ContractRunner | null): Ownable;
+    waitForDeployment(): Promise<this>;
+    interface: OwnableInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    owner: TypedContractMethod<[], [string], "view">;
+    renounceOwnership: TypedContractMethod<[], [void], "nonpayable">;
+    transferOwnership: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "owner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "renounceOwnership"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "transferOwnership"): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+    getEvent(key: "OwnershipTransferred"): TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    filters: {
+        "OwnershipTransferred(address,address)": TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        OwnershipTransferred: TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    };
+}

dist/@openzeppelin/contracts-v3/access/index.d.ts

@@ -0,0 +1 @@
+export type { Ownable } from "./Ownable";

dist/@openzeppelin/contracts-v3/index.d.ts

@@ -0,0 +1,8 @@
+import type * as access from "./access";
+export type { access };
+import type * as proxy from "./proxy";
+export type { proxy };
+import type * as token from "./token";
+export type { token };
+import type * as utils from "./utils";
+export type { utils };

dist/@openzeppelin/contracts-v3/proxy/Proxy.d.ts

@@ -0,0 +1,20 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../common";
+export interface ProxyInterface extends Interface {
+}
+export interface Proxy extends BaseContract {
+    connect(runner?: ContractRunner | null): Proxy;
+    waitForDeployment(): Promise<this>;
+    interface: ProxyInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}

dist/@openzeppelin/contracts-v3/proxy/TransparentUpgradeableProxy.d.ts

@@ -0,0 +1,94 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface TransparentUpgradeableProxyInterface extends Interface {
+    getFunction(nameOrSignature: "admin" | "changeAdmin" | "implementation" | "upgradeTo" | "upgradeToAndCall"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "AdminChanged" | "Upgraded"): EventFragment;
+    encodeFunctionData(functionFragment: "admin", values?: undefined): string;
+    encodeFunctionData(functionFragment: "changeAdmin", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "upgradeTo", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "upgradeToAndCall", values: [AddressLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "admin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeAdmin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeToAndCall", data: BytesLike): Result;
+}
+export declare namespace AdminChangedEvent {
+    type InputTuple = [previousAdmin: AddressLike, newAdmin: AddressLike];
+    type OutputTuple = [previousAdmin: string, newAdmin: string];
+    interface OutputObject {
+        previousAdmin: string;
+        newAdmin: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UpgradedEvent {
+    type InputTuple = [implementation: AddressLike];
+    type OutputTuple = [implementation: string];
+    interface OutputObject {
+        implementation: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TransparentUpgradeableProxy extends BaseContract {
+    connect(runner?: ContractRunner | null): TransparentUpgradeableProxy;
+    waitForDeployment(): Promise<this>;
+    interface: TransparentUpgradeableProxyInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    admin: TypedContractMethod<[], [string], "nonpayable">;
+    changeAdmin: TypedContractMethod<[
+        newAdmin: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    implementation: TypedContractMethod<[], [string], "nonpayable">;
+    upgradeTo: TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    upgradeToAndCall: TypedContractMethod<[
+        newImplementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "admin"): TypedContractMethod<[], [string], "nonpayable">;
+    getFunction(nameOrSignature: "changeAdmin"): TypedContractMethod<[newAdmin: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "implementation"): TypedContractMethod<[], [string], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeTo"): TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeToAndCall"): TypedContractMethod<[
+        newImplementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getEvent(key: "AdminChanged"): TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+    getEvent(key: "Upgraded"): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    filters: {
+        "AdminChanged(address,address)": TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        AdminChanged: TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        "Upgraded(address)": TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    };
+}

dist/@openzeppelin/contracts-v3/proxy/UpgradeableProxy.d.ts

@@ -0,0 +1,36 @@
+import type { BaseContract, FunctionFragment, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "../../../common";
+export interface UpgradeableProxyInterface extends Interface {
+    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
+}
+export declare namespace UpgradedEvent {
+    type InputTuple = [implementation: AddressLike];
+    type OutputTuple = [implementation: string];
+    interface OutputObject {
+        implementation: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface UpgradeableProxy extends BaseContract {
+    connect(runner?: ContractRunner | null): UpgradeableProxy;
+    waitForDeployment(): Promise<this>;
+    interface: UpgradeableProxyInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getEvent(key: "Upgraded"): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    filters: {
+        "Upgraded(address)": TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    };
+}

dist/@openzeppelin/contracts-v3/proxy/index.d.ts

@@ -0,0 +1,3 @@
+export type { Proxy } from "./Proxy";
+export type { TransparentUpgradeableProxy } from "./TransparentUpgradeableProxy";
+export type { UpgradeableProxy } from "./UpgradeableProxy";

dist/@openzeppelin/contracts-v3/token/ERC20/ERC20.d.ts

@@ -0,0 +1,169 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface ERC20Interface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "decimals" | "decreaseAllowance" | "increaseAllowance" | "name" | "symbol" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decreaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "increaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ERC20 extends BaseContract {
+    connect(runner?: ContractRunner | null): ERC20;
+    waitForDeployment(): Promise<this>;
+    interface: ERC20Interface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    decreaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    increaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "decreaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "increaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/@openzeppelin/contracts-v3/token/ERC20/ERC20Burnable.d.ts

@@ -0,0 +1,187 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface ERC20BurnableInterface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "burn" | "burnFrom" | "decimals" | "decreaseAllowance" | "increaseAllowance" | "name" | "symbol" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "burn", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "burnFrom", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decreaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "increaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burnFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ERC20Burnable extends BaseContract {
+    connect(runner?: ContractRunner | null): ERC20Burnable;
+    waitForDeployment(): Promise<this>;
+    interface: ERC20BurnableInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    burn: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    burnFrom: TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    decreaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    increaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "burn"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "burnFrom"): TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "decreaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "increaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/@openzeppelin/contracts-v3/token/ERC20/IERC20.d.ts

@@ -0,0 +1,129 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface IERC20Interface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IERC20 extends BaseContract {
+    connect(runner?: ContractRunner | null): IERC20;
+    waitForDeployment(): Promise<this>;
+    interface: IERC20Interface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/@openzeppelin/contracts-v3/token/ERC20/index.d.ts

@@ -0,0 +1,3 @@
+export type { ERC20 } from "./ERC20";
+export type { ERC20Burnable } from "./ERC20Burnable";
+export type { IERC20 } from "./IERC20";

dist/@openzeppelin/contracts-v3/token/index.d.ts

@@ -0,0 +1,2 @@
+import type * as erc20 from "./ERC20";
+export type { erc20 };

dist/@openzeppelin/contracts-v3/utils/Pausable.d.ts

@@ -0,0 +1,55 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface PausableInterface extends Interface {
+    getFunction(nameOrSignature: "paused"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Paused" | "Unpaused"): EventFragment;
+    encodeFunctionData(functionFragment: "paused", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
+}
+export declare namespace PausedEvent {
+    type InputTuple = [account: AddressLike];
+    type OutputTuple = [account: string];
+    interface OutputObject {
+        account: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UnpausedEvent {
+    type InputTuple = [account: AddressLike];
+    type OutputTuple = [account: string];
+    interface OutputObject {
+        account: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface Pausable extends BaseContract {
+    connect(runner?: ContractRunner | null): Pausable;
+    waitForDeployment(): Promise<this>;
+    interface: PausableInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    paused: TypedContractMethod<[], [boolean], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "paused"): TypedContractMethod<[], [boolean], "view">;
+    getEvent(key: "Paused"): TypedContractEvent<PausedEvent.InputTuple, PausedEvent.OutputTuple, PausedEvent.OutputObject>;
+    getEvent(key: "Unpaused"): TypedContractEvent<UnpausedEvent.InputTuple, UnpausedEvent.OutputTuple, UnpausedEvent.OutputObject>;
+    filters: {
+        "Paused(address)": TypedContractEvent<PausedEvent.InputTuple, PausedEvent.OutputTuple, PausedEvent.OutputObject>;
+        Paused: TypedContractEvent<PausedEvent.InputTuple, PausedEvent.OutputTuple, PausedEvent.OutputObject>;
+        "Unpaused(address)": TypedContractEvent<UnpausedEvent.InputTuple, UnpausedEvent.OutputTuple, UnpausedEvent.OutputObject>;
+        Unpaused: TypedContractEvent<UnpausedEvent.InputTuple, UnpausedEvent.OutputTuple, UnpausedEvent.OutputObject>;
+    };
+}

dist/@openzeppelin/contracts-v3/utils/index.d.ts

@@ -0,0 +1 @@
+export type { Pausable } from "./Pausable";

dist/@openzeppelin/contracts/index.d.ts

@@ -0,0 +1,4 @@
+import type * as interfaces from "./interfaces";
+export type { interfaces };
+import type * as token from "./token";
+export type { token };

dist/@openzeppelin/contracts/interfaces/draft-IERC6093.sol/IERC1155Errors.d.ts

@@ -0,0 +1,20 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../../common";
+export interface IERC1155ErrorsInterface extends Interface {
+}
+export interface IERC1155Errors extends BaseContract {
+    connect(runner?: ContractRunner | null): IERC1155Errors;
+    waitForDeployment(): Promise<this>;
+    interface: IERC1155ErrorsInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}

dist/@openzeppelin/contracts/interfaces/draft-IERC6093.sol/IERC20Errors.d.ts

@@ -0,0 +1,20 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../../common";
+export interface IERC20ErrorsInterface extends Interface {
+}
+export interface IERC20Errors extends BaseContract {
+    connect(runner?: ContractRunner | null): IERC20Errors;
+    waitForDeployment(): Promise<this>;
+    interface: IERC20ErrorsInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}

dist/@openzeppelin/contracts/interfaces/draft-IERC6093.sol/IERC721Errors.d.ts

@@ -0,0 +1,20 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../../common";
+export interface IERC721ErrorsInterface extends Interface {
+}
+export interface IERC721Errors extends BaseContract {
+    connect(runner?: ContractRunner | null): IERC721Errors;
+    waitForDeployment(): Promise<this>;
+    interface: IERC721ErrorsInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}

dist/@openzeppelin/contracts/interfaces/draft-IERC6093.sol/index.d.ts

@@ -0,0 +1,3 @@
+export type { IERC1155Errors } from "./IERC1155Errors";
+export type { IERC20Errors } from "./IERC20Errors";
+export type { IERC721Errors } from "./IERC721Errors";

dist/@openzeppelin/contracts/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+import type * as draftIerc6093Sol from "./draft-IERC6093.sol";
+export type { draftIerc6093Sol };

dist/@openzeppelin/contracts/token/ERC20/ERC20.d.ts

@@ -0,0 +1,141 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface ERC20Interface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "decimals" | "name" | "symbol" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ERC20 extends BaseContract {
+    connect(runner?: ContractRunner | null): ERC20;
+    waitForDeployment(): Promise<this>;
+    interface: ERC20Interface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    name: TypedContractMethod<[], [string], "view">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/@openzeppelin/contracts/token/ERC20/IERC20.d.ts

@@ -0,0 +1,129 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface IERC20Interface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IERC20 extends BaseContract {
+    connect(runner?: ContractRunner | null): IERC20;
+    waitForDeployment(): Promise<this>;
+    interface: IERC20Interface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.d.ts

@@ -0,0 +1,141 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../../common";
+export interface IERC20MetadataInterface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "decimals" | "name" | "symbol" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IERC20Metadata extends BaseContract {
+    connect(runner?: ContractRunner | null): IERC20Metadata;
+    waitForDeployment(): Promise<this>;
+    interface: IERC20MetadataInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    name: TypedContractMethod<[], [string], "view">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/@openzeppelin/contracts/token/ERC20/extensions/index.d.ts

@@ -0,0 +1 @@
+export type { IERC20Metadata } from "./IERC20Metadata";

dist/@openzeppelin/contracts/token/ERC20/index.d.ts

@@ -0,0 +1,4 @@
+import type * as extensions from "./extensions";
+export type { extensions };
+export type { ERC20 } from "./ERC20";
+export type { IERC20 } from "./IERC20";

dist/@openzeppelin/contracts/token/index.d.ts

@@ -0,0 +1,2 @@
+import type * as erc20 from "./ERC20";
+export type { erc20 };

dist/@openzeppelin/index.d.ts

@@ -0,0 +1,4 @@
+import type * as contracts from "./contracts";
+export type { contracts };
+import type * as contractsV3 from "./contracts-v3";
+export type { contractsV3 };

dist/common.d.ts

@@ -0,0 +1,50 @@
+import type { FunctionFragment, Typed, EventFragment, ContractTransaction, ContractTransactionResponse, DeferredTopicFilter, EventLog, TransactionRequest, LogDescription } from "ethers";
+export interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent> extends DeferredTopicFilter {
+}
+export interface TypedContractEvent<InputTuple extends Array<any> = any, OutputTuple extends Array<any> = any, OutputObject = any> {
+    (...args: Partial<InputTuple>): TypedDeferredTopicFilter<TypedContractEvent<InputTuple, OutputTuple, OutputObject>>;
+    name: string;
+    fragment: EventFragment;
+    getFragment(...args: Partial<InputTuple>): EventFragment;
+}
+type __TypechainAOutputTuple<T> = T extends TypedContractEvent<infer _U, infer W> ? W : never;
+type __TypechainOutputObject<T> = T extends TypedContractEvent<infer _U, infer _W, infer V> ? V : never;
+export interface TypedEventLog<TCEvent extends TypedContractEvent> extends Omit<EventLog, "args"> {
+    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+export interface TypedLogDescription<TCEvent extends TypedContractEvent> extends Omit<LogDescription, "args"> {
+    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+export type TypedListener<TCEvent extends TypedContractEvent> = (...listenerArg: [
+    ...__TypechainAOutputTuple<TCEvent>,
+    TypedEventLog<TCEvent>,
+    ...undefined[]
+]) => void;
+export type MinEthersFactory<C, ARGS> = {
+    deploy(...a: ARGS[]): Promise<C>;
+};
+export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<infer C, any> ? C : never;
+export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any> ? Parameters<F["deploy"]> : never;
+export type StateMutability = "nonpayable" | "payable" | "view";
+export type BaseOverrides = Omit<TransactionRequest, "to" | "data">;
+export type NonPayableOverrides = Omit<BaseOverrides, "value" | "blockTag" | "enableCcipRead">;
+export type PayableOverrides = Omit<BaseOverrides, "blockTag" | "enableCcipRead">;
+export type ViewOverrides = Omit<TransactionRequest, "to" | "data">;
+export type Overrides<S extends StateMutability> = S extends "nonpayable" ? NonPayableOverrides : S extends "payable" ? PayableOverrides : ViewOverrides;
+export type PostfixOverrides<A extends Array<any>, S extends StateMutability> = A | [...A, Overrides<S>];
+export type ContractMethodArgs<A extends Array<any>, S extends StateMutability> = PostfixOverrides<{
+    [I in keyof A]-?: A[I] | Typed;
+}, S>;
+export type DefaultReturnType<R> = R extends Array<any> ? R[0] : R;
+export interface TypedContractMethod<A extends Array<any> = Array<any>, R = any, S extends StateMutability = "payable"> {
+    (...args: ContractMethodArgs<A, S>): S extends "view" ? Promise<DefaultReturnType<R>> : Promise<ContractTransactionResponse>;
+    name: string;
+    fragment: FunctionFragment;
+    getFragment(...args: ContractMethodArgs<A, S>): FunctionFragment;
+    populateTransaction(...args: ContractMethodArgs<A, S>): Promise<ContractTransaction>;
+    staticCall(...args: ContractMethodArgs<A, "view">): Promise<DefaultReturnType<R>>;
+    send(...args: ContractMethodArgs<A, S>): Promise<ContractTransactionResponse>;
+    estimateGas(...args: ContractMethodArgs<A, S>): Promise<bigint>;
+    staticCallResult(...args: ContractMethodArgs<A, "view">): Promise<R>;
+}
+export {};

dist/contracts/Classic/CTornado.d.ts

@@ -0,0 +1,218 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export interface CTornadoInterface extends Interface {
+    getFunction(nameOrSignature: "FIELD_SIZE" | "ROOT_HISTORY_SIZE" | "ZERO_VALUE" | "claimComp" | "commitments" | "comp" | "currentRootIndex" | "denomination" | "deposit" | "filledSubtrees" | "getLastRoot" | "governance" | "hashLeftRight" | "hasher" | "isKnownRoot" | "isSpent" | "isSpentArray" | "levels" | "nextIndex" | "nullifierHashes" | "roots" | "token" | "verifier" | "withdraw" | "zeros"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Deposit" | "Withdrawal"): EventFragment;
+    encodeFunctionData(functionFragment: "FIELD_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ROOT_HISTORY_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ZERO_VALUE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "claimComp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "commitments", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "comp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "currentRootIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "denomination", values?: undefined): string;
+    encodeFunctionData(functionFragment: "deposit", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "filledSubtrees", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getLastRoot", values?: undefined): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "hashLeftRight", values: [AddressLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "hasher", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isKnownRoot", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "isSpent", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "isSpentArray", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "levels", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nextIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nullifierHashes", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "roots", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "token", values?: undefined): string;
+    encodeFunctionData(functionFragment: "verifier", values?: undefined): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "zeros", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "FIELD_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ROOT_HISTORY_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ZERO_VALUE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimComp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "commitments", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "comp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "currentRootIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "denomination", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "filledSubtrees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLastRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hashLeftRight", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hasher", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isKnownRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isSpent", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isSpentArray", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "levels", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nextIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nullifierHashes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "roots", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifier", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "zeros", data: BytesLike): Result;
+}
+export declare namespace DepositEvent {
+    type InputTuple = [
+        commitment: BytesLike,
+        leafIndex: BigNumberish,
+        timestamp: BigNumberish
+    ];
+    type OutputTuple = [
+        commitment: string,
+        leafIndex: bigint,
+        timestamp: bigint
+    ];
+    interface OutputObject {
+        commitment: string;
+        leafIndex: bigint;
+        timestamp: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace WithdrawalEvent {
+    type InputTuple = [
+        to: AddressLike,
+        nullifierHash: BytesLike,
+        relayer: AddressLike,
+        fee: BigNumberish
+    ];
+    type OutputTuple = [
+        to: string,
+        nullifierHash: string,
+        relayer: string,
+        fee: bigint
+    ];
+    interface OutputObject {
+        to: string;
+        nullifierHash: string;
+        relayer: string;
+        fee: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface CTornado extends BaseContract {
+    connect(runner?: ContractRunner | null): CTornado;
+    waitForDeployment(): Promise<this>;
+    interface: CTornadoInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    FIELD_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ROOT_HISTORY_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ZERO_VALUE: TypedContractMethod<[], [bigint], "view">;
+    claimComp: TypedContractMethod<[], [void], "nonpayable">;
+    commitments: TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    comp: TypedContractMethod<[], [string], "view">;
+    currentRootIndex: TypedContractMethod<[], [bigint], "view">;
+    denomination: TypedContractMethod<[], [bigint], "view">;
+    deposit: TypedContractMethod<[_commitment: BytesLike], [void], "payable">;
+    filledSubtrees: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getLastRoot: TypedContractMethod<[], [string], "view">;
+    governance: TypedContractMethod<[], [string], "view">;
+    hashLeftRight: TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    hasher: TypedContractMethod<[], [string], "view">;
+    isKnownRoot: TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    isSpent: TypedContractMethod<[_nullifierHash: BytesLike], [boolean], "view">;
+    isSpentArray: TypedContractMethod<[
+        _nullifierHashes: BytesLike[]
+    ], [
+        boolean[]
+    ], "view">;
+    levels: TypedContractMethod<[], [bigint], "view">;
+    nextIndex: TypedContractMethod<[], [bigint], "view">;
+    nullifierHashes: TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    roots: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    token: TypedContractMethod<[], [string], "view">;
+    verifier: TypedContractMethod<[], [string], "view">;
+    withdraw: TypedContractMethod<[
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    zeros: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "FIELD_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ROOT_HISTORY_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ZERO_VALUE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "claimComp"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "commitments"): TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "comp"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "currentRootIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "denomination"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[_commitment: BytesLike], [void], "payable">;
+    getFunction(nameOrSignature: "filledSubtrees"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "getLastRoot"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "hashLeftRight"): TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "hasher"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "isKnownRoot"): TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "isSpent"): TypedContractMethod<[_nullifierHash: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "isSpentArray"): TypedContractMethod<[_nullifierHashes: BytesLike[]], [boolean[]], "view">;
+    getFunction(nameOrSignature: "levels"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nextIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nullifierHashes"): TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "roots"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "token"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "verifier"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "zeros"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getEvent(key: "Deposit"): TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+    getEvent(key: "Withdrawal"): TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+    filters: {
+        "Deposit(bytes32,uint32,uint256)": TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+        Deposit: TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+        "Withdrawal(address,bytes32,address,uint256)": TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+        Withdrawal: TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+    };
+}

dist/contracts/Classic/ERC20Tornado.d.ts

@@ -0,0 +1,206 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export interface ERC20TornadoInterface extends Interface {
+    getFunction(nameOrSignature: "FIELD_SIZE" | "ROOT_HISTORY_SIZE" | "ZERO_VALUE" | "commitments" | "currentRootIndex" | "denomination" | "deposit" | "filledSubtrees" | "getLastRoot" | "hashLeftRight" | "hasher" | "isKnownRoot" | "isSpent" | "isSpentArray" | "levels" | "nextIndex" | "nullifierHashes" | "roots" | "token" | "verifier" | "withdraw" | "zeros"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Deposit" | "Withdrawal"): EventFragment;
+    encodeFunctionData(functionFragment: "FIELD_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ROOT_HISTORY_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ZERO_VALUE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "commitments", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "currentRootIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "denomination", values?: undefined): string;
+    encodeFunctionData(functionFragment: "deposit", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "filledSubtrees", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getLastRoot", values?: undefined): string;
+    encodeFunctionData(functionFragment: "hashLeftRight", values: [AddressLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "hasher", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isKnownRoot", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "isSpent", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "isSpentArray", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "levels", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nextIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nullifierHashes", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "roots", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "token", values?: undefined): string;
+    encodeFunctionData(functionFragment: "verifier", values?: undefined): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "zeros", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "FIELD_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ROOT_HISTORY_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ZERO_VALUE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "commitments", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "currentRootIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "denomination", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "filledSubtrees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLastRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hashLeftRight", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hasher", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isKnownRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isSpent", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isSpentArray", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "levels", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nextIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nullifierHashes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "roots", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifier", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "zeros", data: BytesLike): Result;
+}
+export declare namespace DepositEvent {
+    type InputTuple = [
+        commitment: BytesLike,
+        leafIndex: BigNumberish,
+        timestamp: BigNumberish
+    ];
+    type OutputTuple = [
+        commitment: string,
+        leafIndex: bigint,
+        timestamp: bigint
+    ];
+    interface OutputObject {
+        commitment: string;
+        leafIndex: bigint;
+        timestamp: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace WithdrawalEvent {
+    type InputTuple = [
+        to: AddressLike,
+        nullifierHash: BytesLike,
+        relayer: AddressLike,
+        fee: BigNumberish
+    ];
+    type OutputTuple = [
+        to: string,
+        nullifierHash: string,
+        relayer: string,
+        fee: bigint
+    ];
+    interface OutputObject {
+        to: string;
+        nullifierHash: string;
+        relayer: string;
+        fee: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ERC20Tornado extends BaseContract {
+    connect(runner?: ContractRunner | null): ERC20Tornado;
+    waitForDeployment(): Promise<this>;
+    interface: ERC20TornadoInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    FIELD_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ROOT_HISTORY_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ZERO_VALUE: TypedContractMethod<[], [bigint], "view">;
+    commitments: TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    currentRootIndex: TypedContractMethod<[], [bigint], "view">;
+    denomination: TypedContractMethod<[], [bigint], "view">;
+    deposit: TypedContractMethod<[_commitment: BytesLike], [void], "payable">;
+    filledSubtrees: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getLastRoot: TypedContractMethod<[], [string], "view">;
+    hashLeftRight: TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    hasher: TypedContractMethod<[], [string], "view">;
+    isKnownRoot: TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    isSpent: TypedContractMethod<[_nullifierHash: BytesLike], [boolean], "view">;
+    isSpentArray: TypedContractMethod<[
+        _nullifierHashes: BytesLike[]
+    ], [
+        boolean[]
+    ], "view">;
+    levels: TypedContractMethod<[], [bigint], "view">;
+    nextIndex: TypedContractMethod<[], [bigint], "view">;
+    nullifierHashes: TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    roots: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    token: TypedContractMethod<[], [string], "view">;
+    verifier: TypedContractMethod<[], [string], "view">;
+    withdraw: TypedContractMethod<[
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    zeros: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "FIELD_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ROOT_HISTORY_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ZERO_VALUE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "commitments"): TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "currentRootIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "denomination"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[_commitment: BytesLike], [void], "payable">;
+    getFunction(nameOrSignature: "filledSubtrees"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "getLastRoot"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "hashLeftRight"): TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "hasher"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "isKnownRoot"): TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "isSpent"): TypedContractMethod<[_nullifierHash: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "isSpentArray"): TypedContractMethod<[_nullifierHashes: BytesLike[]], [boolean[]], "view">;
+    getFunction(nameOrSignature: "levels"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nextIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nullifierHashes"): TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "roots"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "token"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "verifier"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "zeros"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getEvent(key: "Deposit"): TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+    getEvent(key: "Withdrawal"): TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+    filters: {
+        "Deposit(bytes32,uint32,uint256)": TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+        Deposit: TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+        "Withdrawal(address,bytes32,address,uint256)": TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+        Withdrawal: TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+    };
+}

dist/contracts/Classic/ETHTornado.d.ts

@@ -0,0 +1,202 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export interface ETHTornadoInterface extends Interface {
+    getFunction(nameOrSignature: "FIELD_SIZE" | "ROOT_HISTORY_SIZE" | "ZERO_VALUE" | "commitments" | "currentRootIndex" | "denomination" | "deposit" | "filledSubtrees" | "getLastRoot" | "hashLeftRight" | "hasher" | "isKnownRoot" | "isSpent" | "isSpentArray" | "levels" | "nextIndex" | "nullifierHashes" | "roots" | "verifier" | "withdraw" | "zeros"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Deposit" | "Withdrawal"): EventFragment;
+    encodeFunctionData(functionFragment: "FIELD_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ROOT_HISTORY_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ZERO_VALUE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "commitments", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "currentRootIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "denomination", values?: undefined): string;
+    encodeFunctionData(functionFragment: "deposit", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "filledSubtrees", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getLastRoot", values?: undefined): string;
+    encodeFunctionData(functionFragment: "hashLeftRight", values: [AddressLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "hasher", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isKnownRoot", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "isSpent", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "isSpentArray", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "levels", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nextIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nullifierHashes", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "roots", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "verifier", values?: undefined): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "zeros", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "FIELD_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ROOT_HISTORY_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ZERO_VALUE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "commitments", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "currentRootIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "denomination", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "filledSubtrees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLastRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hashLeftRight", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hasher", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isKnownRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isSpent", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isSpentArray", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "levels", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nextIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nullifierHashes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "roots", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifier", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "zeros", data: BytesLike): Result;
+}
+export declare namespace DepositEvent {
+    type InputTuple = [
+        commitment: BytesLike,
+        leafIndex: BigNumberish,
+        timestamp: BigNumberish
+    ];
+    type OutputTuple = [
+        commitment: string,
+        leafIndex: bigint,
+        timestamp: bigint
+    ];
+    interface OutputObject {
+        commitment: string;
+        leafIndex: bigint;
+        timestamp: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace WithdrawalEvent {
+    type InputTuple = [
+        to: AddressLike,
+        nullifierHash: BytesLike,
+        relayer: AddressLike,
+        fee: BigNumberish
+    ];
+    type OutputTuple = [
+        to: string,
+        nullifierHash: string,
+        relayer: string,
+        fee: bigint
+    ];
+    interface OutputObject {
+        to: string;
+        nullifierHash: string;
+        relayer: string;
+        fee: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ETHTornado extends BaseContract {
+    connect(runner?: ContractRunner | null): ETHTornado;
+    waitForDeployment(): Promise<this>;
+    interface: ETHTornadoInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    FIELD_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ROOT_HISTORY_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ZERO_VALUE: TypedContractMethod<[], [bigint], "view">;
+    commitments: TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    currentRootIndex: TypedContractMethod<[], [bigint], "view">;
+    denomination: TypedContractMethod<[], [bigint], "view">;
+    deposit: TypedContractMethod<[_commitment: BytesLike], [void], "payable">;
+    filledSubtrees: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getLastRoot: TypedContractMethod<[], [string], "view">;
+    hashLeftRight: TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    hasher: TypedContractMethod<[], [string], "view">;
+    isKnownRoot: TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    isSpent: TypedContractMethod<[_nullifierHash: BytesLike], [boolean], "view">;
+    isSpentArray: TypedContractMethod<[
+        _nullifierHashes: BytesLike[]
+    ], [
+        boolean[]
+    ], "view">;
+    levels: TypedContractMethod<[], [bigint], "view">;
+    nextIndex: TypedContractMethod<[], [bigint], "view">;
+    nullifierHashes: TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    roots: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    verifier: TypedContractMethod<[], [string], "view">;
+    withdraw: TypedContractMethod<[
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    zeros: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "FIELD_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ROOT_HISTORY_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ZERO_VALUE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "commitments"): TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "currentRootIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "denomination"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[_commitment: BytesLike], [void], "payable">;
+    getFunction(nameOrSignature: "filledSubtrees"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "getLastRoot"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "hashLeftRight"): TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "hasher"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "isKnownRoot"): TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "isSpent"): TypedContractMethod<[_nullifierHash: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "isSpentArray"): TypedContractMethod<[_nullifierHashes: BytesLike[]], [boolean[]], "view">;
+    getFunction(nameOrSignature: "levels"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nextIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nullifierHashes"): TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "roots"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "verifier"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "zeros"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getEvent(key: "Deposit"): TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+    getEvent(key: "Withdrawal"): TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+    filters: {
+        "Deposit(bytes32,uint32,uint256)": TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+        Deposit: TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+        "Withdrawal(address,bytes32,address,uint256)": TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+        Withdrawal: TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+    };
+}

dist/contracts/Classic/Echoer.d.ts

@@ -0,0 +1,42 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export interface EchoerInterface extends Interface {
+    getFunction(nameOrSignature: "echo"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Echo"): EventFragment;
+    encodeFunctionData(functionFragment: "echo", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "echo", data: BytesLike): Result;
+}
+export declare namespace EchoEvent {
+    type InputTuple = [who: AddressLike, data: BytesLike];
+    type OutputTuple = [who: string, data: string];
+    interface OutputObject {
+        who: string;
+        data: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface Echoer extends BaseContract {
+    connect(runner?: ContractRunner | null): Echoer;
+    waitForDeployment(): Promise<this>;
+    interface: EchoerInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    echo: TypedContractMethod<[_data: BytesLike], [void], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "echo"): TypedContractMethod<[_data: BytesLike], [void], "nonpayable">;
+    getEvent(key: "Echo"): TypedContractEvent<EchoEvent.InputTuple, EchoEvent.OutputTuple, EchoEvent.OutputObject>;
+    filters: {
+        "Echo(address,bytes)": TypedContractEvent<EchoEvent.InputTuple, EchoEvent.OutputTuple, EchoEvent.OutputObject>;
+        Echo: TypedContractEvent<EchoEvent.InputTuple, EchoEvent.OutputTuple, EchoEvent.OutputObject>;
+    };
+}

dist/contracts/Classic/MerkleTreeWithHistory.sol/IHasher.d.ts

@@ -0,0 +1,41 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface IHasherInterface extends Interface {
+    getFunction(nameOrSignature: "MiMCSponge"): FunctionFragment;
+    encodeFunctionData(functionFragment: "MiMCSponge", values: [BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "MiMCSponge", data: BytesLike): Result;
+}
+export interface IHasher extends BaseContract {
+    connect(runner?: ContractRunner | null): IHasher;
+    waitForDeployment(): Promise<this>;
+    interface: IHasherInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    MiMCSponge: TypedContractMethod<[
+        in_xL: BigNumberish,
+        in_xR: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            xL: bigint;
+            xR: bigint;
+        }
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "MiMCSponge"): TypedContractMethod<[
+        in_xL: BigNumberish,
+        in_xR: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            xL: bigint;
+            xR: bigint;
+        }
+    ], "view">;
+    filters: {};
+}

dist/contracts/Classic/MerkleTreeWithHistory.sol/MerkleTreeWithHistory.d.ts

@@ -0,0 +1,85 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface MerkleTreeWithHistoryInterface extends Interface {
+    getFunction(nameOrSignature: "FIELD_SIZE" | "ROOT_HISTORY_SIZE" | "ZERO_VALUE" | "currentRootIndex" | "filledSubtrees" | "getLastRoot" | "hashLeftRight" | "hasher" | "isKnownRoot" | "levels" | "nextIndex" | "roots" | "zeros"): FunctionFragment;
+    encodeFunctionData(functionFragment: "FIELD_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ROOT_HISTORY_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ZERO_VALUE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "currentRootIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "filledSubtrees", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getLastRoot", values?: undefined): string;
+    encodeFunctionData(functionFragment: "hashLeftRight", values: [AddressLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "hasher", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isKnownRoot", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "levels", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nextIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "roots", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "zeros", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "FIELD_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ROOT_HISTORY_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ZERO_VALUE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "currentRootIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "filledSubtrees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLastRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hashLeftRight", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hasher", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isKnownRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "levels", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nextIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "roots", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "zeros", data: BytesLike): Result;
+}
+export interface MerkleTreeWithHistory extends BaseContract {
+    connect(runner?: ContractRunner | null): MerkleTreeWithHistory;
+    waitForDeployment(): Promise<this>;
+    interface: MerkleTreeWithHistoryInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    FIELD_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ROOT_HISTORY_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ZERO_VALUE: TypedContractMethod<[], [bigint], "view">;
+    currentRootIndex: TypedContractMethod<[], [bigint], "view">;
+    filledSubtrees: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getLastRoot: TypedContractMethod<[], [string], "view">;
+    hashLeftRight: TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    hasher: TypedContractMethod<[], [string], "view">;
+    isKnownRoot: TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    levels: TypedContractMethod<[], [bigint], "view">;
+    nextIndex: TypedContractMethod<[], [bigint], "view">;
+    roots: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    zeros: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "FIELD_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ROOT_HISTORY_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ZERO_VALUE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "currentRootIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "filledSubtrees"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "getLastRoot"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "hashLeftRight"): TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "hasher"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "isKnownRoot"): TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "levels"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nextIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "roots"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "zeros"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    filters: {};
+}

dist/contracts/Classic/MerkleTreeWithHistory.sol/index.d.ts

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

dist/contracts/Classic/Mocks/BadRecipient.d.ts

@@ -0,0 +1,20 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../common";
+export interface BadRecipientInterface extends Interface {
+}
+export interface BadRecipient extends BaseContract {
+    connect(runner?: ContractRunner | null): BadRecipient;
+    waitForDeployment(): Promise<this>;
+    interface: BadRecipientInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}

dist/contracts/Classic/Mocks/ERC20Mock.d.ts

@@ -0,0 +1,155 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface ERC20MockInterface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "decimals" | "mint" | "name" | "symbol" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "mint", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ERC20Mock extends BaseContract {
+    connect(runner?: ContractRunner | null): ERC20Mock;
+    waitForDeployment(): Promise<this>;
+    interface: ERC20MockInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    mint: TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "mint"): TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/contracts/Classic/Mocks/IDeployer.d.ts

@@ -0,0 +1,35 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface IDeployerInterface extends Interface {
+    getFunction(nameOrSignature: "deploy"): FunctionFragment;
+    encodeFunctionData(functionFragment: "deploy", values: [BytesLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "deploy", data: BytesLike): Result;
+}
+export interface IDeployer extends BaseContract {
+    connect(runner?: ContractRunner | null): IDeployer;
+    waitForDeployment(): Promise<this>;
+    interface: IDeployerInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    deploy: TypedContractMethod<[
+        _initCode: BytesLike,
+        _salt: BytesLike
+    ], [
+        string
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "deploy"): TypedContractMethod<[
+        _initCode: BytesLike,
+        _salt: BytesLike
+    ], [
+        string
+    ], "nonpayable">;
+    filters: {};
+}

dist/contracts/Classic/Mocks/IUSDT.sol/ERC20Basic.d.ts

@@ -0,0 +1,69 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface ERC20BasicInterface extends Interface {
+    getFunction(nameOrSignature: "_totalSupply" | "balanceOf" | "totalSupply" | "transfer"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "_totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "_totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ERC20Basic extends BaseContract {
+    connect(runner?: ContractRunner | null): ERC20Basic;
+    waitForDeployment(): Promise<this>;
+    interface: ERC20BasicInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    _totalSupply: TypedContractMethod<[], [bigint], "nonpayable">;
+    balanceOf: TypedContractMethod<[who: AddressLike], [bigint], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "_totalSupply"): TypedContractMethod<[], [bigint], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[who: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/contracts/Classic/Mocks/IUSDT.sol/IUSDT.d.ts

@@ -0,0 +1,133 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface IUSDTInterface extends Interface {
+    getFunction(nameOrSignature: "_totalSupply" | "allowance" | "approve" | "balanceOf" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "_totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "_totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IUSDT extends BaseContract {
+    connect(runner?: ContractRunner | null): IUSDT;
+    waitForDeployment(): Promise<this>;
+    interface: IUSDTInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    _totalSupply: TypedContractMethod<[], [bigint], "nonpayable">;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[who: AddressLike], [bigint], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "_totalSupply"): TypedContractMethod<[], [bigint], "nonpayable">;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[who: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/contracts/Classic/Mocks/IUSDT.sol/index.d.ts

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

dist/contracts/Classic/Mocks/MerkleTreeWithHistoryMock.d.ts

@@ -0,0 +1,89 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface MerkleTreeWithHistoryMockInterface extends Interface {
+    getFunction(nameOrSignature: "FIELD_SIZE" | "ROOT_HISTORY_SIZE" | "ZERO_VALUE" | "currentRootIndex" | "filledSubtrees" | "getLastRoot" | "hashLeftRight" | "hasher" | "insert" | "isKnownRoot" | "levels" | "nextIndex" | "roots" | "zeros"): FunctionFragment;
+    encodeFunctionData(functionFragment: "FIELD_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ROOT_HISTORY_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ZERO_VALUE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "currentRootIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "filledSubtrees", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getLastRoot", values?: undefined): string;
+    encodeFunctionData(functionFragment: "hashLeftRight", values: [AddressLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "hasher", values?: undefined): string;
+    encodeFunctionData(functionFragment: "insert", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "isKnownRoot", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "levels", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nextIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "roots", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "zeros", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "FIELD_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ROOT_HISTORY_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ZERO_VALUE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "currentRootIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "filledSubtrees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLastRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hashLeftRight", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hasher", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "insert", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isKnownRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "levels", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nextIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "roots", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "zeros", data: BytesLike): Result;
+}
+export interface MerkleTreeWithHistoryMock extends BaseContract {
+    connect(runner?: ContractRunner | null): MerkleTreeWithHistoryMock;
+    waitForDeployment(): Promise<this>;
+    interface: MerkleTreeWithHistoryMockInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    FIELD_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ROOT_HISTORY_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ZERO_VALUE: TypedContractMethod<[], [bigint], "view">;
+    currentRootIndex: TypedContractMethod<[], [bigint], "view">;
+    filledSubtrees: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getLastRoot: TypedContractMethod<[], [string], "view">;
+    hashLeftRight: TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    hasher: TypedContractMethod<[], [string], "view">;
+    insert: TypedContractMethod<[_leaf: BytesLike], [void], "nonpayable">;
+    isKnownRoot: TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    levels: TypedContractMethod<[], [bigint], "view">;
+    nextIndex: TypedContractMethod<[], [bigint], "view">;
+    roots: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    zeros: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "FIELD_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ROOT_HISTORY_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ZERO_VALUE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "currentRootIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "filledSubtrees"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "getLastRoot"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "hashLeftRight"): TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "hasher"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "insert"): TypedContractMethod<[_leaf: BytesLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "isKnownRoot"): TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "levels"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nextIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "roots"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "zeros"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    filters: {};
+}

dist/contracts/Classic/Mocks/index.d.ts

@@ -0,0 +1,6 @@
+import type * as iusdtSol from "./IUSDT.sol";
+export type { iusdtSol };
+export type { BadRecipient } from "./BadRecipient";
+export type { ERC20Mock } from "./ERC20Mock";
+export type { IDeployer } from "./IDeployer";
+export type { MerkleTreeWithHistoryMock } from "./MerkleTreeWithHistoryMock";

dist/contracts/Classic/Tornado.sol/IVerifier.d.ts

@@ -0,0 +1,35 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface IVerifierInterface extends Interface {
+    getFunction(nameOrSignature: "verifyProof"): FunctionFragment;
+    encodeFunctionData(functionFragment: "verifyProof", values: [BytesLike, BigNumberish[]]): string;
+    decodeFunctionResult(functionFragment: "verifyProof", data: BytesLike): Result;
+}
+export interface IVerifier extends BaseContract {
+    connect(runner?: ContractRunner | null): IVerifier;
+    waitForDeployment(): Promise<this>;
+    interface: IVerifierInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    verifyProof: TypedContractMethod<[
+        _proof: BytesLike,
+        _input: BigNumberish[]
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "verifyProof"): TypedContractMethod<[
+        _proof: BytesLike,
+        _input: BigNumberish[]
+    ], [
+        boolean
+    ], "nonpayable">;
+    filters: {};
+}

dist/contracts/Classic/Tornado.sol/Tornado.d.ts

@@ -0,0 +1,202 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface TornadoInterface extends Interface {
+    getFunction(nameOrSignature: "FIELD_SIZE" | "ROOT_HISTORY_SIZE" | "ZERO_VALUE" | "commitments" | "currentRootIndex" | "denomination" | "deposit" | "filledSubtrees" | "getLastRoot" | "hashLeftRight" | "hasher" | "isKnownRoot" | "isSpent" | "isSpentArray" | "levels" | "nextIndex" | "nullifierHashes" | "roots" | "verifier" | "withdraw" | "zeros"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Deposit" | "Withdrawal"): EventFragment;
+    encodeFunctionData(functionFragment: "FIELD_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ROOT_HISTORY_SIZE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ZERO_VALUE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "commitments", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "currentRootIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "denomination", values?: undefined): string;
+    encodeFunctionData(functionFragment: "deposit", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "filledSubtrees", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getLastRoot", values?: undefined): string;
+    encodeFunctionData(functionFragment: "hashLeftRight", values: [AddressLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "hasher", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isKnownRoot", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "isSpent", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "isSpentArray", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "levels", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nextIndex", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nullifierHashes", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "roots", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "verifier", values?: undefined): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "zeros", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "FIELD_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ROOT_HISTORY_SIZE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ZERO_VALUE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "commitments", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "currentRootIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "denomination", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "filledSubtrees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLastRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hashLeftRight", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hasher", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isKnownRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isSpent", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isSpentArray", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "levels", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nextIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nullifierHashes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "roots", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifier", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "zeros", data: BytesLike): Result;
+}
+export declare namespace DepositEvent {
+    type InputTuple = [
+        commitment: BytesLike,
+        leafIndex: BigNumberish,
+        timestamp: BigNumberish
+    ];
+    type OutputTuple = [
+        commitment: string,
+        leafIndex: bigint,
+        timestamp: bigint
+    ];
+    interface OutputObject {
+        commitment: string;
+        leafIndex: bigint;
+        timestamp: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace WithdrawalEvent {
+    type InputTuple = [
+        to: AddressLike,
+        nullifierHash: BytesLike,
+        relayer: AddressLike,
+        fee: BigNumberish
+    ];
+    type OutputTuple = [
+        to: string,
+        nullifierHash: string,
+        relayer: string,
+        fee: bigint
+    ];
+    interface OutputObject {
+        to: string;
+        nullifierHash: string;
+        relayer: string;
+        fee: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface Tornado extends BaseContract {
+    connect(runner?: ContractRunner | null): Tornado;
+    waitForDeployment(): Promise<this>;
+    interface: TornadoInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    FIELD_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ROOT_HISTORY_SIZE: TypedContractMethod<[], [bigint], "view">;
+    ZERO_VALUE: TypedContractMethod<[], [bigint], "view">;
+    commitments: TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    currentRootIndex: TypedContractMethod<[], [bigint], "view">;
+    denomination: TypedContractMethod<[], [bigint], "view">;
+    deposit: TypedContractMethod<[_commitment: BytesLike], [void], "payable">;
+    filledSubtrees: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getLastRoot: TypedContractMethod<[], [string], "view">;
+    hashLeftRight: TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    hasher: TypedContractMethod<[], [string], "view">;
+    isKnownRoot: TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    isSpent: TypedContractMethod<[_nullifierHash: BytesLike], [boolean], "view">;
+    isSpentArray: TypedContractMethod<[
+        _nullifierHashes: BytesLike[]
+    ], [
+        boolean[]
+    ], "view">;
+    levels: TypedContractMethod<[], [bigint], "view">;
+    nextIndex: TypedContractMethod<[], [bigint], "view">;
+    nullifierHashes: TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    roots: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    verifier: TypedContractMethod<[], [string], "view">;
+    withdraw: TypedContractMethod<[
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    zeros: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "FIELD_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ROOT_HISTORY_SIZE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "ZERO_VALUE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "commitments"): TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "currentRootIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "denomination"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[_commitment: BytesLike], [void], "payable">;
+    getFunction(nameOrSignature: "filledSubtrees"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "getLastRoot"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "hashLeftRight"): TypedContractMethod<[
+        _hasher: AddressLike,
+        _left: BytesLike,
+        _right: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "hasher"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "isKnownRoot"): TypedContractMethod<[_root: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "isSpent"): TypedContractMethod<[_nullifierHash: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "isSpentArray"): TypedContractMethod<[_nullifierHashes: BytesLike[]], [boolean[]], "view">;
+    getFunction(nameOrSignature: "levels"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nextIndex"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nullifierHashes"): TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "roots"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "verifier"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "zeros"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getEvent(key: "Deposit"): TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+    getEvent(key: "Withdrawal"): TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+    filters: {
+        "Deposit(bytes32,uint32,uint256)": TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+        Deposit: TypedContractEvent<DepositEvent.InputTuple, DepositEvent.OutputTuple, DepositEvent.OutputObject>;
+        "Withdrawal(address,bytes32,address,uint256)": TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+        Withdrawal: TypedContractEvent<WithdrawalEvent.InputTuple, WithdrawalEvent.OutputTuple, WithdrawalEvent.OutputObject>;
+    };
+}

dist/contracts/Classic/Tornado.sol/index.d.ts

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

dist/contracts/Classic/TornadoProxyLight.sol/ITornadoInstance.d.ts

@@ -0,0 +1,65 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface ITornadoInstanceInterface extends Interface {
+    getFunction(nameOrSignature: "denomination" | "deposit" | "token" | "withdraw"): FunctionFragment;
+    encodeFunctionData(functionFragment: "denomination", values?: undefined): string;
+    encodeFunctionData(functionFragment: "deposit", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "token", values?: undefined): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    decodeFunctionResult(functionFragment: "denomination", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+}
+export interface ITornadoInstance extends BaseContract {
+    connect(runner?: ContractRunner | null): ITornadoInstance;
+    waitForDeployment(): Promise<this>;
+    interface: ITornadoInstanceInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    denomination: TypedContractMethod<[], [bigint], "view">;
+    deposit: TypedContractMethod<[commitment: BytesLike], [void], "payable">;
+    token: TypedContractMethod<[], [string], "view">;
+    withdraw: TypedContractMethod<[
+        proof: BytesLike,
+        root: BytesLike,
+        nullifierHash: BytesLike,
+        recipient: AddressLike,
+        relayer: AddressLike,
+        fee: BigNumberish,
+        refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "denomination"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[commitment: BytesLike], [void], "payable">;
+    getFunction(nameOrSignature: "token"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[
+        proof: BytesLike,
+        root: BytesLike,
+        nullifierHash: BytesLike,
+        recipient: AddressLike,
+        relayer: AddressLike,
+        fee: BigNumberish,
+        refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    filters: {};
+}

dist/contracts/Classic/TornadoProxyLight.sol/TornadoProxyLight.d.ts

@@ -0,0 +1,97 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface TornadoProxyLightInterface extends Interface {
+    getFunction(nameOrSignature: "backupNotes" | "deposit" | "withdraw"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "EncryptedNote"): EventFragment;
+    encodeFunctionData(functionFragment: "backupNotes", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "deposit", values: [AddressLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [
+        AddressLike,
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    decodeFunctionResult(functionFragment: "backupNotes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+}
+export declare namespace EncryptedNoteEvent {
+    type InputTuple = [sender: AddressLike, encryptedNote: BytesLike];
+    type OutputTuple = [sender: string, encryptedNote: string];
+    interface OutputObject {
+        sender: string;
+        encryptedNote: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TornadoProxyLight extends BaseContract {
+    connect(runner?: ContractRunner | null): TornadoProxyLight;
+    waitForDeployment(): Promise<this>;
+    interface: TornadoProxyLightInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    backupNotes: TypedContractMethod<[
+        _encryptedNotes: BytesLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    deposit: TypedContractMethod<[
+        _tornado: AddressLike,
+        _commitment: BytesLike,
+        _encryptedNote: BytesLike
+    ], [
+        void
+    ], "payable">;
+    withdraw: TypedContractMethod<[
+        _tornado: AddressLike,
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "backupNotes"): TypedContractMethod<[_encryptedNotes: BytesLike[]], [void], "nonpayable">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[
+        _tornado: AddressLike,
+        _commitment: BytesLike,
+        _encryptedNote: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[
+        _tornado: AddressLike,
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getEvent(key: "EncryptedNote"): TypedContractEvent<EncryptedNoteEvent.InputTuple, EncryptedNoteEvent.OutputTuple, EncryptedNoteEvent.OutputObject>;
+    filters: {
+        "EncryptedNote(address,bytes)": TypedContractEvent<EncryptedNoteEvent.InputTuple, EncryptedNoteEvent.OutputTuple, EncryptedNoteEvent.OutputObject>;
+        EncryptedNote: TypedContractEvent<EncryptedNoteEvent.InputTuple, EncryptedNoteEvent.OutputTuple, EncryptedNoteEvent.OutputObject>;
+    };
+}

dist/contracts/Classic/TornadoProxyLight.sol/index.d.ts

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

dist/contracts/Classic/Verifier.d.ts

@@ -0,0 +1,35 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
+export interface VerifierInterface extends Interface {
+    getFunction(nameOrSignature: "verifyProof"): FunctionFragment;
+    encodeFunctionData(functionFragment: "verifyProof", values: [BytesLike, BigNumberish[]]): string;
+    decodeFunctionResult(functionFragment: "verifyProof", data: BytesLike): Result;
+}
+export interface Verifier extends BaseContract {
+    connect(runner?: ContractRunner | null): Verifier;
+    waitForDeployment(): Promise<this>;
+    interface: VerifierInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    verifyProof: TypedContractMethod<[
+        proof: BytesLike,
+        input: BigNumberish[]
+    ], [
+        boolean
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "verifyProof"): TypedContractMethod<[
+        proof: BytesLike,
+        input: BigNumberish[]
+    ], [
+        boolean
+    ], "view">;
+    filters: {};
+}

dist/contracts/Classic/index.d.ts

@@ -0,0 +1,15 @@
+import type * as merkleTreeWithHistorySol from "./MerkleTreeWithHistory.sol";
+export type { merkleTreeWithHistorySol };
+import type * as mocks from "./Mocks";
+export type { mocks };
+import type * as tornadoSol from "./Tornado.sol";
+export type { tornadoSol };
+import type * as tornadoProxyLightSol from "./TornadoProxyLight.sol";
+export type { tornadoProxyLightSol };
+import type * as interfaces from "./interfaces";
+export type { interfaces };
+export type { ERC20Tornado } from "./ERC20Tornado";
+export type { ETHTornado } from "./ETHTornado";
+export type { Echoer } from "./Echoer";
+export type { Verifier } from "./Verifier";
+export type { CTornado } from "./CTornado";

dist/contracts/Classic/interfaces/IERC20.d.ts

@@ -0,0 +1,127 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface IERC20Interface extends Interface {
+    getFunction(nameOrSignature: "DOMAIN_SEPARATOR" | "allowance" | "approve" | "balanceOf" | "nonces" | "permit" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    encodeFunctionData(functionFragment: "DOMAIN_SEPARATOR", values?: undefined): string;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "nonces", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "permit", values: [
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "DOMAIN_SEPARATOR", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export interface IERC20 extends BaseContract {
+    connect(runner?: ContractRunner | null): IERC20;
+    waitForDeployment(): Promise<this>;
+    interface: IERC20Interface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    DOMAIN_SEPARATOR: TypedContractMethod<[], [string], "view">;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    nonces: TypedContractMethod<[owner: AddressLike], [bigint], "view">;
+    permit: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "DOMAIN_SEPARATOR"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "nonces"): TypedContractMethod<[owner: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "permit"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    filters: {};
+}

dist/contracts/Classic/interfaces/index.d.ts

@@ -0,0 +1 @@
+export type { IERC20 } from "./IERC20";

dist/contracts/Governance/AdminUpgradeableProxy.d.ts

@@ -0,0 +1,94 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export interface AdminUpgradeableProxyInterface extends Interface {
+    getFunction(nameOrSignature: "admin" | "changeAdmin" | "implementation" | "upgradeTo" | "upgradeToAndCall"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "AdminChanged" | "Upgraded"): EventFragment;
+    encodeFunctionData(functionFragment: "admin", values?: undefined): string;
+    encodeFunctionData(functionFragment: "changeAdmin", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "upgradeTo", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "upgradeToAndCall", values: [AddressLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "admin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeAdmin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeToAndCall", data: BytesLike): Result;
+}
+export declare namespace AdminChangedEvent {
+    type InputTuple = [previousAdmin: AddressLike, newAdmin: AddressLike];
+    type OutputTuple = [previousAdmin: string, newAdmin: string];
+    interface OutputObject {
+        previousAdmin: string;
+        newAdmin: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UpgradedEvent {
+    type InputTuple = [implementation: AddressLike];
+    type OutputTuple = [implementation: string];
+    interface OutputObject {
+        implementation: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface AdminUpgradeableProxy extends BaseContract {
+    connect(runner?: ContractRunner | null): AdminUpgradeableProxy;
+    waitForDeployment(): Promise<this>;
+    interface: AdminUpgradeableProxyInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    admin: TypedContractMethod<[], [string], "nonpayable">;
+    changeAdmin: TypedContractMethod<[
+        newAdmin: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    implementation: TypedContractMethod<[], [string], "nonpayable">;
+    upgradeTo: TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    upgradeToAndCall: TypedContractMethod<[
+        newImplementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "admin"): TypedContractMethod<[], [string], "nonpayable">;
+    getFunction(nameOrSignature: "changeAdmin"): TypedContractMethod<[newAdmin: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "implementation"): TypedContractMethod<[], [string], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeTo"): TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeToAndCall"): TypedContractMethod<[
+        newImplementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getEvent(key: "AdminChanged"): TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+    getEvent(key: "Upgraded"): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    filters: {
+        "AdminChanged(address,address)": TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        AdminChanged: TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        "Upgraded(address)": TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/Aggregator/Aggregator.d.ts

@@ -0,0 +1,158 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export type RelayerStruct = {
+    owner: AddressLike;
+    balance: BigNumberish;
+    isRegistered: boolean;
+    records: string[];
+};
+export type RelayerStructOutput = [
+    owner: string,
+    balance: bigint,
+    isRegistered: boolean,
+    records: string[]
+] & {
+    owner: string;
+    balance: bigint;
+    isRegistered: boolean;
+    records: string[];
+};
+export declare namespace GovernanceAggregator {
+    type ProposalStruct = {
+        proposer: AddressLike;
+        target: AddressLike;
+        startTime: BigNumberish;
+        endTime: BigNumberish;
+        forVotes: BigNumberish;
+        againstVotes: BigNumberish;
+        executed: boolean;
+        extended: boolean;
+        state: BigNumberish;
+    };
+    type ProposalStructOutput = [
+        proposer: string,
+        target: string,
+        startTime: bigint,
+        endTime: bigint,
+        forVotes: bigint,
+        againstVotes: bigint,
+        executed: boolean,
+        extended: boolean,
+        state: bigint
+    ] & {
+        proposer: string;
+        target: string;
+        startTime: bigint;
+        endTime: bigint;
+        forVotes: bigint;
+        againstVotes: bigint;
+        executed: boolean;
+        extended: boolean;
+        state: bigint;
+    };
+}
+export interface AggregatorInterface extends Interface {
+    getFunction(nameOrSignature: "ENSRegistry" | "RelayerRegistry" | "getAllProposals" | "getGovernanceBalances" | "getUserData" | "relayersData"): FunctionFragment;
+    encodeFunctionData(functionFragment: "ENSRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "RelayerRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getAllProposals", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getGovernanceBalances", values: [AddressLike, AddressLike[]]): string;
+    encodeFunctionData(functionFragment: "getUserData", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "relayersData", values: [BytesLike[], string[]]): string;
+    decodeFunctionResult(functionFragment: "ENSRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "RelayerRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAllProposals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getGovernanceBalances", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getUserData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "relayersData", data: BytesLike): Result;
+}
+export interface Aggregator extends BaseContract {
+    connect(runner?: ContractRunner | null): Aggregator;
+    waitForDeployment(): Promise<this>;
+    interface: AggregatorInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    ENSRegistry: TypedContractMethod<[], [string], "view">;
+    RelayerRegistry: TypedContractMethod<[], [string], "view">;
+    getAllProposals: TypedContractMethod<[
+        governance: AddressLike
+    ], [
+        GovernanceAggregator.ProposalStructOutput[]
+    ], "view">;
+    getGovernanceBalances: TypedContractMethod<[
+        governance: AddressLike,
+        accs: AddressLike[]
+    ], [
+        bigint[]
+    ], "view">;
+    getUserData: TypedContractMethod<[
+        governance: AddressLike,
+        account: AddressLike
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            string
+        ] & {
+            balance: bigint;
+            latestProposalId: bigint;
+            latestProposalIdState: bigint;
+            timelock: bigint;
+            delegatee: string;
+        }
+    ], "view">;
+    relayersData: TypedContractMethod<[
+        _relayers: BytesLike[],
+        _subdomains: string[]
+    ], [
+        RelayerStructOutput[]
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "ENSRegistry"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "RelayerRegistry"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getAllProposals"): TypedContractMethod<[
+        governance: AddressLike
+    ], [
+        GovernanceAggregator.ProposalStructOutput[]
+    ], "view">;
+    getFunction(nameOrSignature: "getGovernanceBalances"): TypedContractMethod<[
+        governance: AddressLike,
+        accs: AddressLike[]
+    ], [
+        bigint[]
+    ], "view">;
+    getFunction(nameOrSignature: "getUserData"): TypedContractMethod<[
+        governance: AddressLike,
+        account: AddressLike
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            string
+        ] & {
+            balance: bigint;
+            latestProposalId: bigint;
+            latestProposalIdState: bigint;
+            timelock: bigint;
+            delegatee: string;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "relayersData"): TypedContractMethod<[
+        _relayers: BytesLike[],
+        _subdomains: string[]
+    ], [
+        RelayerStructOutput[]
+    ], "view">;
+    filters: {};
+}

dist/contracts/Governance/Aggregator/GovernanceAggregator.d.ts

@@ -0,0 +1,119 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export declare namespace GovernanceAggregator {
+    type ProposalStruct = {
+        proposer: AddressLike;
+        target: AddressLike;
+        startTime: BigNumberish;
+        endTime: BigNumberish;
+        forVotes: BigNumberish;
+        againstVotes: BigNumberish;
+        executed: boolean;
+        extended: boolean;
+        state: BigNumberish;
+    };
+    type ProposalStructOutput = [
+        proposer: string,
+        target: string,
+        startTime: bigint,
+        endTime: bigint,
+        forVotes: bigint,
+        againstVotes: bigint,
+        executed: boolean,
+        extended: boolean,
+        state: bigint
+    ] & {
+        proposer: string;
+        target: string;
+        startTime: bigint;
+        endTime: bigint;
+        forVotes: bigint;
+        againstVotes: bigint;
+        executed: boolean;
+        extended: boolean;
+        state: bigint;
+    };
+}
+export interface GovernanceAggregatorInterface extends Interface {
+    getFunction(nameOrSignature: "getAllProposals" | "getGovernanceBalances" | "getUserData"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getAllProposals", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getGovernanceBalances", values: [AddressLike, AddressLike[]]): string;
+    encodeFunctionData(functionFragment: "getUserData", values: [AddressLike, AddressLike]): string;
+    decodeFunctionResult(functionFragment: "getAllProposals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getGovernanceBalances", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getUserData", data: BytesLike): Result;
+}
+export interface GovernanceAggregator extends BaseContract {
+    connect(runner?: ContractRunner | null): GovernanceAggregator;
+    waitForDeployment(): Promise<this>;
+    interface: GovernanceAggregatorInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getAllProposals: TypedContractMethod<[
+        governance: AddressLike
+    ], [
+        GovernanceAggregator.ProposalStructOutput[]
+    ], "view">;
+    getGovernanceBalances: TypedContractMethod<[
+        governance: AddressLike,
+        accs: AddressLike[]
+    ], [
+        bigint[]
+    ], "view">;
+    getUserData: TypedContractMethod<[
+        governance: AddressLike,
+        account: AddressLike
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            string
+        ] & {
+            balance: bigint;
+            latestProposalId: bigint;
+            latestProposalIdState: bigint;
+            timelock: bigint;
+            delegatee: string;
+        }
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "getAllProposals"): TypedContractMethod<[
+        governance: AddressLike
+    ], [
+        GovernanceAggregator.ProposalStructOutput[]
+    ], "view">;
+    getFunction(nameOrSignature: "getGovernanceBalances"): TypedContractMethod<[
+        governance: AddressLike,
+        accs: AddressLike[]
+    ], [
+        bigint[]
+    ], "view">;
+    getFunction(nameOrSignature: "getUserData"): TypedContractMethod<[
+        governance: AddressLike,
+        account: AddressLike
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            string
+        ] & {
+            balance: bigint;
+            latestProposalId: bigint;
+            latestProposalIdState: bigint;
+            timelock: bigint;
+            delegatee: string;
+        }
+    ], "view">;
+    filters: {};
+}

dist/contracts/Governance/Aggregator/RelayerAggregator.sol/IENSRegistry.d.ts

@@ -0,0 +1,252 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface IENSRegistryInterface extends Interface {
+    getFunction(nameOrSignature: "isApprovedForAll" | "owner" | "recordExists" | "resolver" | "setApprovalForAll" | "setOwner" | "setRecord" | "setResolver" | "setSubnodeOwner" | "setSubnodeRecord" | "setTTL" | "ttl"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "ApprovalForAll" | "NewOwner" | "NewResolver" | "NewTTL" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "isApprovedForAll", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "owner", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "recordExists", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "resolver", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "setApprovalForAll", values: [AddressLike, boolean]): string;
+    encodeFunctionData(functionFragment: "setOwner", values: [BytesLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "setRecord", values: [BytesLike, AddressLike, AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setResolver", values: [BytesLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "setSubnodeOwner", values: [BytesLike, BytesLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "setSubnodeRecord", values: [BytesLike, BytesLike, AddressLike, AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setTTL", values: [BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "ttl", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "isApprovedForAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recordExists", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resolver", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setApprovalForAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setRecord", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setResolver", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setSubnodeOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setSubnodeRecord", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTTL", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ttl", data: BytesLike): Result;
+}
+export declare namespace ApprovalForAllEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        operator: AddressLike,
+        approved: boolean
+    ];
+    type OutputTuple = [
+        owner: string,
+        operator: string,
+        approved: boolean
+    ];
+    interface OutputObject {
+        owner: string;
+        operator: string;
+        approved: boolean;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace NewOwnerEvent {
+    type InputTuple = [
+        node: BytesLike,
+        label: BytesLike,
+        owner: AddressLike
+    ];
+    type OutputTuple = [node: string, label: string, owner: string];
+    interface OutputObject {
+        node: string;
+        label: string;
+        owner: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace NewResolverEvent {
+    type InputTuple = [node: BytesLike, resolver: AddressLike];
+    type OutputTuple = [node: string, resolver: string];
+    interface OutputObject {
+        node: string;
+        resolver: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace NewTTLEvent {
+    type InputTuple = [node: BytesLike, ttl: BigNumberish];
+    type OutputTuple = [node: string, ttl: bigint];
+    interface OutputObject {
+        node: string;
+        ttl: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [node: BytesLike, owner: AddressLike];
+    type OutputTuple = [node: string, owner: string];
+    interface OutputObject {
+        node: string;
+        owner: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IENSRegistry extends BaseContract {
+    connect(runner?: ContractRunner | null): IENSRegistry;
+    waitForDeployment(): Promise<this>;
+    interface: IENSRegistryInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    isApprovedForAll: TypedContractMethod<[
+        owner: AddressLike,
+        operator: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    owner: TypedContractMethod<[node: BytesLike], [string], "view">;
+    recordExists: TypedContractMethod<[node: BytesLike], [boolean], "view">;
+    resolver: TypedContractMethod<[node: BytesLike], [string], "view">;
+    setApprovalForAll: TypedContractMethod<[
+        operator: AddressLike,
+        approved: boolean
+    ], [
+        void
+    ], "nonpayable">;
+    setOwner: TypedContractMethod<[
+        node: BytesLike,
+        owner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setRecord: TypedContractMethod<[
+        node: BytesLike,
+        owner: AddressLike,
+        resolver: AddressLike,
+        ttl: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setResolver: TypedContractMethod<[
+        node: BytesLike,
+        resolver: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setSubnodeOwner: TypedContractMethod<[
+        node: BytesLike,
+        label: BytesLike,
+        owner: AddressLike
+    ], [
+        string
+    ], "nonpayable">;
+    setSubnodeRecord: TypedContractMethod<[
+        node: BytesLike,
+        label: BytesLike,
+        owner: AddressLike,
+        resolver: AddressLike,
+        ttl: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setTTL: TypedContractMethod<[
+        node: BytesLike,
+        ttl: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    ttl: TypedContractMethod<[node: BytesLike], [bigint], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "isApprovedForAll"): TypedContractMethod<[
+        owner: AddressLike,
+        operator: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "owner"): TypedContractMethod<[node: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "recordExists"): TypedContractMethod<[node: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "resolver"): TypedContractMethod<[node: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "setApprovalForAll"): TypedContractMethod<[
+        operator: AddressLike,
+        approved: boolean
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setOwner"): TypedContractMethod<[
+        node: BytesLike,
+        owner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setRecord"): TypedContractMethod<[
+        node: BytesLike,
+        owner: AddressLike,
+        resolver: AddressLike,
+        ttl: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setResolver"): TypedContractMethod<[
+        node: BytesLike,
+        resolver: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setSubnodeOwner"): TypedContractMethod<[
+        node: BytesLike,
+        label: BytesLike,
+        owner: AddressLike
+    ], [
+        string
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setSubnodeRecord"): TypedContractMethod<[
+        node: BytesLike,
+        label: BytesLike,
+        owner: AddressLike,
+        resolver: AddressLike,
+        ttl: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setTTL"): TypedContractMethod<[
+        node: BytesLike,
+        ttl: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "ttl"): TypedContractMethod<[node: BytesLike], [bigint], "view">;
+    getEvent(key: "ApprovalForAll"): TypedContractEvent<ApprovalForAllEvent.InputTuple, ApprovalForAllEvent.OutputTuple, ApprovalForAllEvent.OutputObject>;
+    getEvent(key: "NewOwner"): TypedContractEvent<NewOwnerEvent.InputTuple, NewOwnerEvent.OutputTuple, NewOwnerEvent.OutputObject>;
+    getEvent(key: "NewResolver"): TypedContractEvent<NewResolverEvent.InputTuple, NewResolverEvent.OutputTuple, NewResolverEvent.OutputObject>;
+    getEvent(key: "NewTTL"): TypedContractEvent<NewTTLEvent.InputTuple, NewTTLEvent.OutputTuple, NewTTLEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "ApprovalForAll(address,address,bool)": TypedContractEvent<ApprovalForAllEvent.InputTuple, ApprovalForAllEvent.OutputTuple, ApprovalForAllEvent.OutputObject>;
+        ApprovalForAll: TypedContractEvent<ApprovalForAllEvent.InputTuple, ApprovalForAllEvent.OutputTuple, ApprovalForAllEvent.OutputObject>;
+        "NewOwner(bytes32,bytes32,address)": TypedContractEvent<NewOwnerEvent.InputTuple, NewOwnerEvent.OutputTuple, NewOwnerEvent.OutputObject>;
+        NewOwner: TypedContractEvent<NewOwnerEvent.InputTuple, NewOwnerEvent.OutputTuple, NewOwnerEvent.OutputObject>;
+        "NewResolver(bytes32,address)": TypedContractEvent<NewResolverEvent.InputTuple, NewResolverEvent.OutputTuple, NewResolverEvent.OutputObject>;
+        NewResolver: TypedContractEvent<NewResolverEvent.InputTuple, NewResolverEvent.OutputTuple, NewResolverEvent.OutputObject>;
+        "NewTTL(bytes32,uint64)": TypedContractEvent<NewTTLEvent.InputTuple, NewTTLEvent.OutputTuple, NewTTLEvent.OutputObject>;
+        NewTTL: TypedContractEvent<NewTTLEvent.InputTuple, NewTTLEvent.OutputTuple, NewTTLEvent.OutputObject>;
+        "Transfer(bytes32,address)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/Aggregator/RelayerAggregator.sol/IENSResolver.d.ts

@@ -0,0 +1,29 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface IENSResolverInterface extends Interface {
+    getFunction(nameOrSignature: "addr" | "text"): FunctionFragment;
+    encodeFunctionData(functionFragment: "addr", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "text", values: [BytesLike, string]): string;
+    decodeFunctionResult(functionFragment: "addr", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "text", data: BytesLike): Result;
+}
+export interface IENSResolver extends BaseContract {
+    connect(runner?: ContractRunner | null): IENSResolver;
+    waitForDeployment(): Promise<this>;
+    interface: IENSResolverInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    addr: TypedContractMethod<[node: BytesLike], [string], "view">;
+    text: TypedContractMethod<[node: BytesLike, key: string], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "addr"): TypedContractMethod<[node: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "text"): TypedContractMethod<[node: BytesLike, key: string], [string], "view">;
+    filters: {};
+}

dist/contracts/Governance/Aggregator/RelayerAggregator.sol/IRelayerRegistry.d.ts

@@ -0,0 +1,43 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface IRelayerRegistryInterface extends Interface {
+    getFunction(nameOrSignature: "getRelayerBalance" | "isRelayerRegistered"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getRelayerBalance", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "isRelayerRegistered", values: [AddressLike, AddressLike]): string;
+    decodeFunctionResult(functionFragment: "getRelayerBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isRelayerRegistered", data: BytesLike): Result;
+}
+export interface IRelayerRegistry extends BaseContract {
+    connect(runner?: ContractRunner | null): IRelayerRegistry;
+    waitForDeployment(): Promise<this>;
+    interface: IRelayerRegistryInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getRelayerBalance: TypedContractMethod<[
+        relayer: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    isRelayerRegistered: TypedContractMethod<[
+        relayer: AddressLike,
+        toResolve: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "getRelayerBalance"): TypedContractMethod<[relayer: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "isRelayerRegistered"): TypedContractMethod<[
+        relayer: AddressLike,
+        toResolve: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    filters: {};
+}

dist/contracts/Governance/Aggregator/RelayerAggregator.sol/RelayerAggregator.d.ts

@@ -0,0 +1,60 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export type RelayerStruct = {
+    owner: AddressLike;
+    balance: BigNumberish;
+    isRegistered: boolean;
+    records: string[];
+};
+export type RelayerStructOutput = [
+    owner: string,
+    balance: bigint,
+    isRegistered: boolean,
+    records: string[]
+] & {
+    owner: string;
+    balance: bigint;
+    isRegistered: boolean;
+    records: string[];
+};
+export interface RelayerAggregatorInterface extends Interface {
+    getFunction(nameOrSignature: "ENSRegistry" | "RelayerRegistry" | "relayersData"): FunctionFragment;
+    encodeFunctionData(functionFragment: "ENSRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "RelayerRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "relayersData", values: [BytesLike[], string[]]): string;
+    decodeFunctionResult(functionFragment: "ENSRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "RelayerRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "relayersData", data: BytesLike): Result;
+}
+export interface RelayerAggregator extends BaseContract {
+    connect(runner?: ContractRunner | null): RelayerAggregator;
+    waitForDeployment(): Promise<this>;
+    interface: RelayerAggregatorInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    ENSRegistry: TypedContractMethod<[], [string], "view">;
+    RelayerRegistry: TypedContractMethod<[], [string], "view">;
+    relayersData: TypedContractMethod<[
+        _relayers: BytesLike[],
+        _subdomains: string[]
+    ], [
+        RelayerStructOutput[]
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "ENSRegistry"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "RelayerRegistry"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "relayersData"): TypedContractMethod<[
+        _relayers: BytesLike[],
+        _subdomains: string[]
+    ], [
+        RelayerStructOutput[]
+    ], "view">;
+    filters: {};
+}

dist/contracts/Governance/Aggregator/RelayerAggregator.sol/index.d.ts

@@ -0,0 +1,4 @@
+export type { IENSRegistry } from "./IENSRegistry";
+export type { IENSResolver } from "./IENSResolver";
+export type { IRelayerRegistry } from "./IRelayerRegistry";
+export type { RelayerAggregator } from "./RelayerAggregator";

dist/contracts/Governance/Aggregator/index.d.ts

@@ -0,0 +1,4 @@
+import type * as relayerAggregatorSol from "./RelayerAggregator.sol";
+export type { relayerAggregatorSol };
+export type { Aggregator } from "./Aggregator";
+export type { GovernanceAggregator } from "./GovernanceAggregator";

dist/contracts/Governance/Deployer.sol/Deployer.d.ts

@@ -0,0 +1,56 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface DeployerInterface extends Interface {
+    getFunction(nameOrSignature: "deploy" | "deployer"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Deployed"): EventFragment;
+    encodeFunctionData(functionFragment: "deploy", values: [BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "deployer", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "deploy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deployer", data: BytesLike): Result;
+}
+export declare namespace DeployedEvent {
+    type InputTuple = [sender: AddressLike, addr: AddressLike];
+    type OutputTuple = [sender: string, addr: string];
+    interface OutputObject {
+        sender: string;
+        addr: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface Deployer extends BaseContract {
+    connect(runner?: ContractRunner | null): Deployer;
+    waitForDeployment(): Promise<this>;
+    interface: DeployerInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    deploy: TypedContractMethod<[
+        _initCode: BytesLike,
+        _salt: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    deployer: TypedContractMethod<[], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "deploy"): TypedContractMethod<[
+        _initCode: BytesLike,
+        _salt: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "deployer"): TypedContractMethod<[], [string], "view">;
+    getEvent(key: "Deployed"): TypedContractEvent<DeployedEvent.InputTuple, DeployedEvent.OutputTuple, DeployedEvent.OutputObject>;
+    filters: {
+        "Deployed(address,address)": TypedContractEvent<DeployedEvent.InputTuple, DeployedEvent.OutputTuple, DeployedEvent.OutputObject>;
+        Deployed: TypedContractEvent<DeployedEvent.InputTuple, DeployedEvent.OutputTuple, DeployedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/Deployer.sol/IDeployer.d.ts

@@ -0,0 +1,35 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface IDeployerInterface extends Interface {
+    getFunction(nameOrSignature: "deploy"): FunctionFragment;
+    encodeFunctionData(functionFragment: "deploy", values: [BytesLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "deploy", data: BytesLike): Result;
+}
+export interface IDeployer extends BaseContract {
+    connect(runner?: ContractRunner | null): IDeployer;
+    waitForDeployment(): Promise<this>;
+    interface: IDeployerInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    deploy: TypedContractMethod<[
+        _initCode: BytesLike,
+        _salt: BytesLike
+    ], [
+        string
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "deploy"): TypedContractMethod<[
+        _initCode: BytesLike,
+        _salt: BytesLike
+    ], [
+        string
+    ], "nonpayable">;
+    filters: {};
+}

dist/contracts/Governance/Deployer.sol/index.d.ts

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

dist/contracts/Governance/FeeManager.d.ts

@@ -0,0 +1,173 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export declare namespace FeeManager {
+    type DeviationStruct = {
+        instance: AddressLike;
+        deviation: BigNumberish;
+    };
+    type DeviationStructOutput = [instance: string, deviation: bigint] & {
+        instance: string;
+        deviation: bigint;
+    };
+}
+export interface FeeManagerInterface extends Interface {
+    getFunction(nameOrSignature: "PROTOCOL_FEE_DIVIDER" | "calculatePoolFee" | "feeDeviations" | "governance" | "instanceFee" | "instanceFeeUpdated" | "instanceFeeWithUpdate" | "registry" | "setPeriodForTWAPOracle" | "setUniswapTornPoolSwappingFee" | "setUpdateFeeTimeLimit" | "torn" | "uniswapTimePeriod" | "uniswapTornPoolSwappingFee" | "updateAllFees" | "updateFee" | "updateFeeTimeLimit" | "updateFees"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "FeeUpdated" | "UniswapTornPoolSwappingFeeChanged"): EventFragment;
+    encodeFunctionData(functionFragment: "PROTOCOL_FEE_DIVIDER", values?: undefined): string;
+    encodeFunctionData(functionFragment: "calculatePoolFee", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "feeDeviations", values?: undefined): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "instanceFee", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "instanceFeeUpdated", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "instanceFeeWithUpdate", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "registry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setPeriodForTWAPOracle", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setUniswapTornPoolSwappingFee", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setUpdateFeeTimeLimit", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "torn", values?: undefined): string;
+    encodeFunctionData(functionFragment: "uniswapTimePeriod", values?: undefined): string;
+    encodeFunctionData(functionFragment: "uniswapTornPoolSwappingFee", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateAllFees", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateFee", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "updateFeeTimeLimit", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateFees", values: [AddressLike[]]): string;
+    decodeFunctionResult(functionFragment: "PROTOCOL_FEE_DIVIDER", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculatePoolFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "feeDeviations", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "instanceFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "instanceFeeUpdated", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "instanceFeeWithUpdate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "registry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPeriodForTWAPOracle", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setUniswapTornPoolSwappingFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setUpdateFeeTimeLimit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "torn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "uniswapTimePeriod", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "uniswapTornPoolSwappingFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateAllFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateFeeTimeLimit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateFees", data: BytesLike): Result;
+}
+export declare namespace FeeUpdatedEvent {
+    type InputTuple = [instance: AddressLike, newFee: BigNumberish];
+    type OutputTuple = [instance: string, newFee: bigint];
+    interface OutputObject {
+        instance: string;
+        newFee: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UniswapTornPoolSwappingFeeChangedEvent {
+    type InputTuple = [newFee: BigNumberish];
+    type OutputTuple = [newFee: bigint];
+    interface OutputObject {
+        newFee: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface FeeManager extends BaseContract {
+    connect(runner?: ContractRunner | null): FeeManager;
+    waitForDeployment(): Promise<this>;
+    interface: FeeManagerInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    PROTOCOL_FEE_DIVIDER: TypedContractMethod<[], [bigint], "view">;
+    calculatePoolFee: TypedContractMethod<[
+        _instance: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    feeDeviations: TypedContractMethod<[
+    ], [
+        FeeManager.DeviationStructOutput[]
+    ], "view">;
+    governance: TypedContractMethod<[], [string], "view">;
+    instanceFee: TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    instanceFeeUpdated: TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    instanceFeeWithUpdate: TypedContractMethod<[
+        _instance: AddressLike
+    ], [
+        bigint
+    ], "nonpayable">;
+    registry: TypedContractMethod<[], [string], "view">;
+    setPeriodForTWAPOracle: TypedContractMethod<[
+        newPeriod: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setUniswapTornPoolSwappingFee: TypedContractMethod<[
+        _uniswapTornPoolSwappingFee: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setUpdateFeeTimeLimit: TypedContractMethod<[
+        newLimit: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    torn: TypedContractMethod<[], [string], "view">;
+    uniswapTimePeriod: TypedContractMethod<[], [bigint], "view">;
+    uniswapTornPoolSwappingFee: TypedContractMethod<[], [bigint], "view">;
+    updateAllFees: TypedContractMethod<[], [void], "nonpayable">;
+    updateFee: TypedContractMethod<[
+        _instance: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    updateFeeTimeLimit: TypedContractMethod<[], [bigint], "view">;
+    updateFees: TypedContractMethod<[
+        _instances: AddressLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "PROTOCOL_FEE_DIVIDER"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "calculatePoolFee"): TypedContractMethod<[_instance: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "feeDeviations"): TypedContractMethod<[], [FeeManager.DeviationStructOutput[]], "view">;
+    getFunction(nameOrSignature: "governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "instanceFee"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "instanceFeeUpdated"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "instanceFeeWithUpdate"): TypedContractMethod<[_instance: AddressLike], [bigint], "nonpayable">;
+    getFunction(nameOrSignature: "registry"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "setPeriodForTWAPOracle"): TypedContractMethod<[newPeriod: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setUniswapTornPoolSwappingFee"): TypedContractMethod<[
+        _uniswapTornPoolSwappingFee: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setUpdateFeeTimeLimit"): TypedContractMethod<[newLimit: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "torn"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "uniswapTimePeriod"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "uniswapTornPoolSwappingFee"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "updateAllFees"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "updateFee"): TypedContractMethod<[_instance: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "updateFeeTimeLimit"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "updateFees"): TypedContractMethod<[_instances: AddressLike[]], [void], "nonpayable">;
+    getEvent(key: "FeeUpdated"): TypedContractEvent<FeeUpdatedEvent.InputTuple, FeeUpdatedEvent.OutputTuple, FeeUpdatedEvent.OutputObject>;
+    getEvent(key: "UniswapTornPoolSwappingFeeChanged"): TypedContractEvent<UniswapTornPoolSwappingFeeChangedEvent.InputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputObject>;
+    filters: {
+        "FeeUpdated(address,uint256)": TypedContractEvent<FeeUpdatedEvent.InputTuple, FeeUpdatedEvent.OutputTuple, FeeUpdatedEvent.OutputObject>;
+        FeeUpdated: TypedContractEvent<FeeUpdatedEvent.InputTuple, FeeUpdatedEvent.OutputTuple, FeeUpdatedEvent.OutputObject>;
+        "UniswapTornPoolSwappingFeeChanged(uint24)": TypedContractEvent<UniswapTornPoolSwappingFeeChangedEvent.InputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputObject>;
+        UniswapTornPoolSwappingFeeChanged: TypedContractEvent<UniswapTornPoolSwappingFeeChangedEvent.InputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/GasCompensationVault.d.ts

@@ -0,0 +1,47 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
+export interface GasCompensationVaultInterface extends Interface {
+    getFunction(nameOrSignature: "GovernanceAddress" | "compensateGas" | "withdrawToGovernance"): FunctionFragment;
+    encodeFunctionData(functionFragment: "GovernanceAddress", values?: undefined): string;
+    encodeFunctionData(functionFragment: "compensateGas", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "withdrawToGovernance", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "GovernanceAddress", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "compensateGas", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawToGovernance", data: BytesLike): Result;
+}
+export interface GasCompensationVault extends BaseContract {
+    connect(runner?: ContractRunner | null): GasCompensationVault;
+    waitForDeployment(): Promise<this>;
+    interface: GasCompensationVaultInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    GovernanceAddress: TypedContractMethod<[], [string], "view">;
+    compensateGas: TypedContractMethod<[
+        recipient: AddressLike,
+        gasAmount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    withdrawToGovernance: TypedContractMethod<[
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "GovernanceAddress"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "compensateGas"): TypedContractMethod<[
+        recipient: AddressLike,
+        gasAmount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "withdrawToGovernance"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    filters: {};
+}

dist/contracts/Governance/InstanceRegistry.sol/ITornadoRouter.d.ts

@@ -0,0 +1,37 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface ITornadoRouterInterface extends Interface {
+    getFunction(nameOrSignature: "approveExactToken"): FunctionFragment;
+    encodeFunctionData(functionFragment: "approveExactToken", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "approveExactToken", data: BytesLike): Result;
+}
+export interface ITornadoRouter extends BaseContract {
+    connect(runner?: ContractRunner | null): ITornadoRouter;
+    waitForDeployment(): Promise<this>;
+    interface: ITornadoRouterInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    approveExactToken: TypedContractMethod<[
+        _token: AddressLike,
+        _spender: AddressLike,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "approveExactToken"): TypedContractMethod<[
+        _token: AddressLike,
+        _spender: AddressLike,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    filters: {};
+}

dist/contracts/Governance/InstanceRegistry.sol/InstanceRegistry.d.ts

@@ -0,0 +1,204 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export declare namespace InstanceRegistry {
+    type InstanceStruct = {
+        isERC20: boolean;
+        token: AddressLike;
+        state: BigNumberish;
+        uniswapPoolSwappingFee: BigNumberish;
+        protocolFeePercentage: BigNumberish;
+    };
+    type InstanceStructOutput = [
+        isERC20: boolean,
+        token: string,
+        state: bigint,
+        uniswapPoolSwappingFee: bigint,
+        protocolFeePercentage: bigint
+    ] & {
+        isERC20: boolean;
+        token: string;
+        state: bigint;
+        uniswapPoolSwappingFee: bigint;
+        protocolFeePercentage: bigint;
+    };
+    type TornadoStruct = {
+        addr: AddressLike;
+        instance: InstanceRegistry.InstanceStruct;
+    };
+    type TornadoStructOutput = [
+        addr: string,
+        instance: InstanceRegistry.InstanceStructOutput
+    ] & {
+        addr: string;
+        instance: InstanceRegistry.InstanceStructOutput;
+    };
+}
+export interface InstanceRegistryInterface extends Interface {
+    getFunction(nameOrSignature: "getAllInstanceAddresses" | "getAllInstances" | "getPoolToken" | "governance" | "initialize" | "instanceIds" | "instances" | "removeInstance" | "router" | "setProtocolFee" | "setTornadoRouter" | "updateInstance"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "InstanceStateUpdated" | "RouterRegistered"): EventFragment;
+    encodeFunctionData(functionFragment: "getAllInstanceAddresses", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getAllInstances", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getPoolToken", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "initialize", values: [InstanceRegistry.TornadoStruct[], AddressLike]): string;
+    encodeFunctionData(functionFragment: "instanceIds", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "instances", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "removeInstance", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "router", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setProtocolFee", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setTornadoRouter", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "updateInstance", values: [InstanceRegistry.TornadoStruct]): string;
+    decodeFunctionResult(functionFragment: "getAllInstanceAddresses", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAllInstances", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPoolToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "instanceIds", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "instances", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeInstance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "router", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setProtocolFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTornadoRouter", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateInstance", data: BytesLike): Result;
+}
+export declare namespace InstanceStateUpdatedEvent {
+    type InputTuple = [instance: AddressLike, state: BigNumberish];
+    type OutputTuple = [instance: string, state: bigint];
+    interface OutputObject {
+        instance: string;
+        state: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RouterRegisteredEvent {
+    type InputTuple = [tornadoRouter: AddressLike];
+    type OutputTuple = [tornadoRouter: string];
+    interface OutputObject {
+        tornadoRouter: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface InstanceRegistry extends BaseContract {
+    connect(runner?: ContractRunner | null): InstanceRegistry;
+    waitForDeployment(): Promise<this>;
+    interface: InstanceRegistryInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getAllInstanceAddresses: TypedContractMethod<[], [string[]], "view">;
+    getAllInstances: TypedContractMethod<[
+    ], [
+        InstanceRegistry.TornadoStructOutput[]
+    ], "view">;
+    getPoolToken: TypedContractMethod<[instance: AddressLike], [string], "view">;
+    governance: TypedContractMethod<[], [string], "view">;
+    initialize: TypedContractMethod<[
+        _instances: InstanceRegistry.TornadoStruct[],
+        _router: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    instanceIds: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    instances: TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        [
+            boolean,
+            string,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            isERC20: boolean;
+            token: string;
+            state: bigint;
+            uniswapPoolSwappingFee: bigint;
+            protocolFeePercentage: bigint;
+        }
+    ], "view">;
+    removeInstance: TypedContractMethod<[
+        _instanceId: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    router: TypedContractMethod<[], [string], "view">;
+    setProtocolFee: TypedContractMethod<[
+        instance: AddressLike,
+        newFee: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setTornadoRouter: TypedContractMethod<[
+        routerAddress: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    updateInstance: TypedContractMethod<[
+        _tornado: InstanceRegistry.TornadoStruct
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "getAllInstanceAddresses"): TypedContractMethod<[], [string[]], "view">;
+    getFunction(nameOrSignature: "getAllInstances"): TypedContractMethod<[], [InstanceRegistry.TornadoStructOutput[]], "view">;
+    getFunction(nameOrSignature: "getPoolToken"): TypedContractMethod<[instance: AddressLike], [string], "view">;
+    getFunction(nameOrSignature: "governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "initialize"): TypedContractMethod<[
+        _instances: InstanceRegistry.TornadoStruct[],
+        _router: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "instanceIds"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "instances"): TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        [
+            boolean,
+            string,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            isERC20: boolean;
+            token: string;
+            state: bigint;
+            uniswapPoolSwappingFee: bigint;
+            protocolFeePercentage: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "removeInstance"): TypedContractMethod<[_instanceId: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "router"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "setProtocolFee"): TypedContractMethod<[
+        instance: AddressLike,
+        newFee: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setTornadoRouter"): TypedContractMethod<[routerAddress: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "updateInstance"): TypedContractMethod<[
+        _tornado: InstanceRegistry.TornadoStruct
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "InstanceStateUpdated"): TypedContractEvent<InstanceStateUpdatedEvent.InputTuple, InstanceStateUpdatedEvent.OutputTuple, InstanceStateUpdatedEvent.OutputObject>;
+    getEvent(key: "RouterRegistered"): TypedContractEvent<RouterRegisteredEvent.InputTuple, RouterRegisteredEvent.OutputTuple, RouterRegisteredEvent.OutputObject>;
+    filters: {
+        "InstanceStateUpdated(address,uint8)": TypedContractEvent<InstanceStateUpdatedEvent.InputTuple, InstanceStateUpdatedEvent.OutputTuple, InstanceStateUpdatedEvent.OutputObject>;
+        InstanceStateUpdated: TypedContractEvent<InstanceStateUpdatedEvent.InputTuple, InstanceStateUpdatedEvent.OutputTuple, InstanceStateUpdatedEvent.OutputObject>;
+        "RouterRegistered(address)": TypedContractEvent<RouterRegisteredEvent.InputTuple, RouterRegisteredEvent.OutputTuple, RouterRegisteredEvent.OutputObject>;
+        RouterRegistered: TypedContractEvent<RouterRegisteredEvent.InputTuple, RouterRegisteredEvent.OutputTuple, RouterRegisteredEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/InstanceRegistry.sol/index.d.ts

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

dist/contracts/Governance/LoopbackProxy.d.ts

@@ -0,0 +1,94 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export interface LoopbackProxyInterface extends Interface {
+    getFunction(nameOrSignature: "admin" | "changeAdmin" | "implementation" | "upgradeTo" | "upgradeToAndCall"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "AdminChanged" | "Upgraded"): EventFragment;
+    encodeFunctionData(functionFragment: "admin", values?: undefined): string;
+    encodeFunctionData(functionFragment: "changeAdmin", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "upgradeTo", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "upgradeToAndCall", values: [AddressLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "admin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeAdmin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeToAndCall", data: BytesLike): Result;
+}
+export declare namespace AdminChangedEvent {
+    type InputTuple = [previousAdmin: AddressLike, newAdmin: AddressLike];
+    type OutputTuple = [previousAdmin: string, newAdmin: string];
+    interface OutputObject {
+        previousAdmin: string;
+        newAdmin: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UpgradedEvent {
+    type InputTuple = [implementation: AddressLike];
+    type OutputTuple = [implementation: string];
+    interface OutputObject {
+        implementation: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface LoopbackProxy extends BaseContract {
+    connect(runner?: ContractRunner | null): LoopbackProxy;
+    waitForDeployment(): Promise<this>;
+    interface: LoopbackProxyInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    admin: TypedContractMethod<[], [string], "nonpayable">;
+    changeAdmin: TypedContractMethod<[
+        newAdmin: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    implementation: TypedContractMethod<[], [string], "nonpayable">;
+    upgradeTo: TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    upgradeToAndCall: TypedContractMethod<[
+        newImplementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "admin"): TypedContractMethod<[], [string], "nonpayable">;
+    getFunction(nameOrSignature: "changeAdmin"): TypedContractMethod<[newAdmin: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "implementation"): TypedContractMethod<[], [string], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeTo"): TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeToAndCall"): TypedContractMethod<[
+        newImplementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getEvent(key: "AdminChanged"): TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+    getEvent(key: "Upgraded"): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    filters: {
+        "AdminChanged(address,address)": TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        AdminChanged: TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        "Upgraded(address)": TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/RelayerRegistry.sol/IENS.d.ts

@@ -0,0 +1,25 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface IENSInterface extends Interface {
+    getFunction(nameOrSignature: "owner"): FunctionFragment;
+    encodeFunctionData(functionFragment: "owner", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+}
+export interface IENS extends BaseContract {
+    connect(runner?: ContractRunner | null): IENS;
+    waitForDeployment(): Promise<this>;
+    interface: IENSInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    owner: TypedContractMethod<[node: BytesLike], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "owner"): TypedContractMethod<[node: BytesLike], [string], "view">;
+    filters: {};
+}

dist/contracts/Governance/RelayerRegistry.sol/IFeeManager.d.ts

@@ -0,0 +1,29 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface IFeeManagerInterface extends Interface {
+    getFunction(nameOrSignature: "instanceFeeWithUpdate"): FunctionFragment;
+    encodeFunctionData(functionFragment: "instanceFeeWithUpdate", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "instanceFeeWithUpdate", data: BytesLike): Result;
+}
+export interface IFeeManager extends BaseContract {
+    connect(runner?: ContractRunner | null): IFeeManager;
+    waitForDeployment(): Promise<this>;
+    interface: IFeeManagerInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    instanceFeeWithUpdate: TypedContractMethod<[
+        _instance: AddressLike
+    ], [
+        bigint
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "instanceFeeWithUpdate"): TypedContractMethod<[_instance: AddressLike], [bigint], "nonpayable">;
+    filters: {};
+}

dist/contracts/Governance/RelayerRegistry.sol/RelayerRegistry.d.ts

@@ -0,0 +1,410 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface RelayerRegistryInterface extends Interface {
+    getFunction(nameOrSignature: "burn" | "ens" | "feeManager" | "getRelayerBalance" | "getRelayerEnsHash" | "governance" | "initialize" | "isRelayer" | "isRelayerRegistered" | "minStakeAmount" | "nullifyBalance" | "register" | "registerPermit" | "registerWorker" | "relayers" | "setMinStakeAmount" | "setTornadoRouter" | "stakeToRelayer" | "stakeToRelayerPermit" | "staking" | "torn" | "tornadoRouter" | "unregisterWorker" | "workers"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "MinimumStakeAmount" | "RelayerBalanceNullified" | "RelayerRegistered" | "RouterRegistered" | "StakeAddedToRelayer" | "StakeBurned" | "WorkerRegistered" | "WorkerUnregistered"): EventFragment;
+    encodeFunctionData(functionFragment: "burn", values: [AddressLike, AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "ens", values?: undefined): string;
+    encodeFunctionData(functionFragment: "feeManager", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getRelayerBalance", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getRelayerEnsHash", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "initialize", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "isRelayer", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "isRelayerRegistered", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "minStakeAmount", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nullifyBalance", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "register", values: [string, BigNumberish, AddressLike[]]): string;
+    encodeFunctionData(functionFragment: "registerPermit", values: [
+        string,
+        BigNumberish,
+        AddressLike[],
+        AddressLike,
+        BigNumberish,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "registerWorker", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "relayers", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setMinStakeAmount", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setTornadoRouter", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "stakeToRelayer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "stakeToRelayerPermit", values: [
+        AddressLike,
+        BigNumberish,
+        AddressLike,
+        BigNumberish,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "staking", values?: undefined): string;
+    encodeFunctionData(functionFragment: "torn", values?: undefined): string;
+    encodeFunctionData(functionFragment: "tornadoRouter", values?: undefined): string;
+    encodeFunctionData(functionFragment: "unregisterWorker", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "workers", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "feeManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRelayerBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRelayerEnsHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isRelayer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isRelayerRegistered", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "minStakeAmount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nullifyBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "register", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "registerPermit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "registerWorker", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "relayers", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setMinStakeAmount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTornadoRouter", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeToRelayer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeToRelayerPermit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "staking", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "torn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tornadoRouter", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unregisterWorker", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "workers", data: BytesLike): Result;
+}
+export declare namespace MinimumStakeAmountEvent {
+    type InputTuple = [minStakeAmount: BigNumberish];
+    type OutputTuple = [minStakeAmount: bigint];
+    interface OutputObject {
+        minStakeAmount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RelayerBalanceNullifiedEvent {
+    type InputTuple = [relayer: AddressLike];
+    type OutputTuple = [relayer: string];
+    interface OutputObject {
+        relayer: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RelayerRegisteredEvent {
+    type InputTuple = [
+        relayer: BytesLike,
+        ensName: string,
+        relayerAddress: AddressLike,
+        stakedAmount: BigNumberish
+    ];
+    type OutputTuple = [
+        relayer: string,
+        ensName: string,
+        relayerAddress: string,
+        stakedAmount: bigint
+    ];
+    interface OutputObject {
+        relayer: string;
+        ensName: string;
+        relayerAddress: string;
+        stakedAmount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RouterRegisteredEvent {
+    type InputTuple = [tornadoRouter: AddressLike];
+    type OutputTuple = [tornadoRouter: string];
+    interface OutputObject {
+        tornadoRouter: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace StakeAddedToRelayerEvent {
+    type InputTuple = [
+        relayer: AddressLike,
+        amountStakeAdded: BigNumberish
+    ];
+    type OutputTuple = [relayer: string, amountStakeAdded: bigint];
+    interface OutputObject {
+        relayer: string;
+        amountStakeAdded: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace StakeBurnedEvent {
+    type InputTuple = [relayer: AddressLike, amountBurned: BigNumberish];
+    type OutputTuple = [relayer: string, amountBurned: bigint];
+    interface OutputObject {
+        relayer: string;
+        amountBurned: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace WorkerRegisteredEvent {
+    type InputTuple = [relayer: AddressLike, worker: AddressLike];
+    type OutputTuple = [relayer: string, worker: string];
+    interface OutputObject {
+        relayer: string;
+        worker: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace WorkerUnregisteredEvent {
+    type InputTuple = [relayer: AddressLike, worker: AddressLike];
+    type OutputTuple = [relayer: string, worker: string];
+    interface OutputObject {
+        relayer: string;
+        worker: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface RelayerRegistry extends BaseContract {
+    connect(runner?: ContractRunner | null): RelayerRegistry;
+    waitForDeployment(): Promise<this>;
+    interface: RelayerRegistryInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    burn: TypedContractMethod<[
+        sender: AddressLike,
+        relayer: AddressLike,
+        pool: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    ens: TypedContractMethod<[], [string], "view">;
+    feeManager: TypedContractMethod<[], [string], "view">;
+    getRelayerBalance: TypedContractMethod<[
+        relayer: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getRelayerEnsHash: TypedContractMethod<[
+        relayer: AddressLike
+    ], [
+        string
+    ], "view">;
+    governance: TypedContractMethod<[], [string], "view">;
+    initialize: TypedContractMethod<[
+        _tornadoRouter: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    isRelayer: TypedContractMethod<[toResolve: AddressLike], [boolean], "view">;
+    isRelayerRegistered: TypedContractMethod<[
+        relayer: AddressLike,
+        toResolve: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    minStakeAmount: TypedContractMethod<[], [bigint], "view">;
+    nullifyBalance: TypedContractMethod<[
+        relayer: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    register: TypedContractMethod<[
+        ensName: string,
+        stake: BigNumberish,
+        workersToRegister: AddressLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    registerPermit: TypedContractMethod<[
+        ensName: string,
+        stake: BigNumberish,
+        workersToRegister: AddressLike[],
+        relayer: AddressLike,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    registerWorker: TypedContractMethod<[
+        relayer: AddressLike,
+        worker: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    relayers: TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        [bigint, string] & {
+            balance: bigint;
+            ensHash: string;
+        }
+    ], "view">;
+    setMinStakeAmount: TypedContractMethod<[
+        minAmount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setTornadoRouter: TypedContractMethod<[
+        tornadoRouterAddress: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    stakeToRelayer: TypedContractMethod<[
+        relayer: AddressLike,
+        stake: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    stakeToRelayerPermit: TypedContractMethod<[
+        relayer: AddressLike,
+        stake: BigNumberish,
+        staker: AddressLike,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    staking: TypedContractMethod<[], [string], "view">;
+    torn: TypedContractMethod<[], [string], "view">;
+    tornadoRouter: TypedContractMethod<[], [string], "view">;
+    unregisterWorker: TypedContractMethod<[
+        worker: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    workers: TypedContractMethod<[arg0: AddressLike], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "burn"): TypedContractMethod<[
+        sender: AddressLike,
+        relayer: AddressLike,
+        pool: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "ens"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "feeManager"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getRelayerBalance"): TypedContractMethod<[relayer: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getRelayerEnsHash"): TypedContractMethod<[relayer: AddressLike], [string], "view">;
+    getFunction(nameOrSignature: "governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "initialize"): TypedContractMethod<[_tornadoRouter: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "isRelayer"): TypedContractMethod<[toResolve: AddressLike], [boolean], "view">;
+    getFunction(nameOrSignature: "isRelayerRegistered"): TypedContractMethod<[
+        relayer: AddressLike,
+        toResolve: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "minStakeAmount"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "nullifyBalance"): TypedContractMethod<[relayer: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "register"): TypedContractMethod<[
+        ensName: string,
+        stake: BigNumberish,
+        workersToRegister: AddressLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "registerPermit"): TypedContractMethod<[
+        ensName: string,
+        stake: BigNumberish,
+        workersToRegister: AddressLike[],
+        relayer: AddressLike,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "registerWorker"): TypedContractMethod<[
+        relayer: AddressLike,
+        worker: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "relayers"): TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        [bigint, string] & {
+            balance: bigint;
+            ensHash: string;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "setMinStakeAmount"): TypedContractMethod<[minAmount: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setTornadoRouter"): TypedContractMethod<[
+        tornadoRouterAddress: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "stakeToRelayer"): TypedContractMethod<[
+        relayer: AddressLike,
+        stake: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "stakeToRelayerPermit"): TypedContractMethod<[
+        relayer: AddressLike,
+        stake: BigNumberish,
+        staker: AddressLike,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "staking"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "torn"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "tornadoRouter"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "unregisterWorker"): TypedContractMethod<[worker: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "workers"): TypedContractMethod<[arg0: AddressLike], [string], "view">;
+    getEvent(key: "MinimumStakeAmount"): TypedContractEvent<MinimumStakeAmountEvent.InputTuple, MinimumStakeAmountEvent.OutputTuple, MinimumStakeAmountEvent.OutputObject>;
+    getEvent(key: "RelayerBalanceNullified"): TypedContractEvent<RelayerBalanceNullifiedEvent.InputTuple, RelayerBalanceNullifiedEvent.OutputTuple, RelayerBalanceNullifiedEvent.OutputObject>;
+    getEvent(key: "RelayerRegistered"): TypedContractEvent<RelayerRegisteredEvent.InputTuple, RelayerRegisteredEvent.OutputTuple, RelayerRegisteredEvent.OutputObject>;
+    getEvent(key: "RouterRegistered"): TypedContractEvent<RouterRegisteredEvent.InputTuple, RouterRegisteredEvent.OutputTuple, RouterRegisteredEvent.OutputObject>;
+    getEvent(key: "StakeAddedToRelayer"): TypedContractEvent<StakeAddedToRelayerEvent.InputTuple, StakeAddedToRelayerEvent.OutputTuple, StakeAddedToRelayerEvent.OutputObject>;
+    getEvent(key: "StakeBurned"): TypedContractEvent<StakeBurnedEvent.InputTuple, StakeBurnedEvent.OutputTuple, StakeBurnedEvent.OutputObject>;
+    getEvent(key: "WorkerRegistered"): TypedContractEvent<WorkerRegisteredEvent.InputTuple, WorkerRegisteredEvent.OutputTuple, WorkerRegisteredEvent.OutputObject>;
+    getEvent(key: "WorkerUnregistered"): TypedContractEvent<WorkerUnregisteredEvent.InputTuple, WorkerUnregisteredEvent.OutputTuple, WorkerUnregisteredEvent.OutputObject>;
+    filters: {
+        "MinimumStakeAmount(uint256)": TypedContractEvent<MinimumStakeAmountEvent.InputTuple, MinimumStakeAmountEvent.OutputTuple, MinimumStakeAmountEvent.OutputObject>;
+        MinimumStakeAmount: TypedContractEvent<MinimumStakeAmountEvent.InputTuple, MinimumStakeAmountEvent.OutputTuple, MinimumStakeAmountEvent.OutputObject>;
+        "RelayerBalanceNullified(address)": TypedContractEvent<RelayerBalanceNullifiedEvent.InputTuple, RelayerBalanceNullifiedEvent.OutputTuple, RelayerBalanceNullifiedEvent.OutputObject>;
+        RelayerBalanceNullified: TypedContractEvent<RelayerBalanceNullifiedEvent.InputTuple, RelayerBalanceNullifiedEvent.OutputTuple, RelayerBalanceNullifiedEvent.OutputObject>;
+        "RelayerRegistered(bytes32,string,address,uint256)": TypedContractEvent<RelayerRegisteredEvent.InputTuple, RelayerRegisteredEvent.OutputTuple, RelayerRegisteredEvent.OutputObject>;
+        RelayerRegistered: TypedContractEvent<RelayerRegisteredEvent.InputTuple, RelayerRegisteredEvent.OutputTuple, RelayerRegisteredEvent.OutputObject>;
+        "RouterRegistered(address)": TypedContractEvent<RouterRegisteredEvent.InputTuple, RouterRegisteredEvent.OutputTuple, RouterRegisteredEvent.OutputObject>;
+        RouterRegistered: TypedContractEvent<RouterRegisteredEvent.InputTuple, RouterRegisteredEvent.OutputTuple, RouterRegisteredEvent.OutputObject>;
+        "StakeAddedToRelayer(address,uint256)": TypedContractEvent<StakeAddedToRelayerEvent.InputTuple, StakeAddedToRelayerEvent.OutputTuple, StakeAddedToRelayerEvent.OutputObject>;
+        StakeAddedToRelayer: TypedContractEvent<StakeAddedToRelayerEvent.InputTuple, StakeAddedToRelayerEvent.OutputTuple, StakeAddedToRelayerEvent.OutputObject>;
+        "StakeBurned(address,uint256)": TypedContractEvent<StakeBurnedEvent.InputTuple, StakeBurnedEvent.OutputTuple, StakeBurnedEvent.OutputObject>;
+        StakeBurned: TypedContractEvent<StakeBurnedEvent.InputTuple, StakeBurnedEvent.OutputTuple, StakeBurnedEvent.OutputObject>;
+        "WorkerRegistered(address,address)": TypedContractEvent<WorkerRegisteredEvent.InputTuple, WorkerRegisteredEvent.OutputTuple, WorkerRegisteredEvent.OutputObject>;
+        WorkerRegistered: TypedContractEvent<WorkerRegisteredEvent.InputTuple, WorkerRegisteredEvent.OutputTuple, WorkerRegisteredEvent.OutputObject>;
+        "WorkerUnregistered(address,address)": TypedContractEvent<WorkerUnregisteredEvent.InputTuple, WorkerUnregisteredEvent.OutputTuple, WorkerUnregisteredEvent.OutputObject>;
+        WorkerUnregistered: TypedContractEvent<WorkerUnregisteredEvent.InputTuple, WorkerUnregisteredEvent.OutputTuple, WorkerUnregisteredEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/RelayerRegistry.sol/index.d.ts

@@ -0,0 +1,3 @@
+export type { IENS } from "./IENS";
+export type { IFeeManager } from "./IFeeManager";
+export type { RelayerRegistry } from "./RelayerRegistry";

dist/contracts/Governance/TORN/Airdrop.d.ts

@@ -0,0 +1,39 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export declare namespace Airdrop {
+    type RecipientStruct = {
+        to: AddressLike;
+        amount: BigNumberish;
+    };
+    type RecipientStructOutput = [to: string, amount: bigint] & {
+        to: string;
+        amount: bigint;
+    };
+}
+export interface AirdropInterface extends Interface {
+    getFunction(nameOrSignature: "bulkResolve" | "resolve"): FunctionFragment;
+    encodeFunctionData(functionFragment: "bulkResolve", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "resolve", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "bulkResolve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resolve", data: BytesLike): Result;
+}
+export interface Airdrop extends BaseContract {
+    connect(runner?: ContractRunner | null): Airdrop;
+    waitForDeployment(): Promise<this>;
+    interface: AirdropInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    bulkResolve: TypedContractMethod<[domains: BytesLike[]], [string[]], "view">;
+    resolve: TypedContractMethod<[node: BytesLike], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "bulkResolve"): TypedContractMethod<[domains: BytesLike[]], [string[]], "view">;
+    getFunction(nameOrSignature: "resolve"): TypedContractMethod<[node: BytesLike], [string], "view">;
+    filters: {};
+}

dist/contracts/Governance/TORN/ENS.sol/ENS.d.ts

@@ -0,0 +1,25 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface ENSInterface extends Interface {
+    getFunction(nameOrSignature: "resolver"): FunctionFragment;
+    encodeFunctionData(functionFragment: "resolver", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "resolver", data: BytesLike): Result;
+}
+export interface ENS extends BaseContract {
+    connect(runner?: ContractRunner | null): ENS;
+    waitForDeployment(): Promise<this>;
+    interface: ENSInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    resolver: TypedContractMethod<[node: BytesLike], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "resolver"): TypedContractMethod<[node: BytesLike], [string], "view">;
+    filters: {};
+}

dist/contracts/Governance/TORN/ENS.sol/EnsResolve.d.ts

@@ -0,0 +1,29 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface EnsResolveInterface extends Interface {
+    getFunction(nameOrSignature: "bulkResolve" | "resolve"): FunctionFragment;
+    encodeFunctionData(functionFragment: "bulkResolve", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "resolve", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "bulkResolve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resolve", data: BytesLike): Result;
+}
+export interface EnsResolve extends BaseContract {
+    connect(runner?: ContractRunner | null): EnsResolve;
+    waitForDeployment(): Promise<this>;
+    interface: EnsResolveInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    bulkResolve: TypedContractMethod<[domains: BytesLike[]], [string[]], "view">;
+    resolve: TypedContractMethod<[node: BytesLike], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "bulkResolve"): TypedContractMethod<[domains: BytesLike[]], [string[]], "view">;
+    getFunction(nameOrSignature: "resolve"): TypedContractMethod<[node: BytesLike], [string], "view">;
+    filters: {};
+}

dist/contracts/Governance/TORN/ENS.sol/Resolver.d.ts

@@ -0,0 +1,25 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface ResolverInterface extends Interface {
+    getFunction(nameOrSignature: "addr"): FunctionFragment;
+    encodeFunctionData(functionFragment: "addr", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "addr", data: BytesLike): Result;
+}
+export interface Resolver extends BaseContract {
+    connect(runner?: ContractRunner | null): Resolver;
+    waitForDeployment(): Promise<this>;
+    interface: ResolverInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    addr: TypedContractMethod<[node: BytesLike], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "addr"): TypedContractMethod<[node: BytesLike], [string], "view">;
+    filters: {};
+}

dist/contracts/Governance/TORN/ENS.sol/index.d.ts

@@ -0,0 +1,3 @@
+export type { ENS } from "./ENS";
+export type { EnsResolve } from "./EnsResolve";
+export type { Resolver } from "./Resolver";

dist/contracts/Governance/TORN/ERC20Permit.d.ts

@@ -0,0 +1,213 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface ERC20PermitInterface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "blockTimestamp" | "chainID" | "decimals" | "decreaseAllowance" | "increaseAllowance" | "name" | "nonces" | "permit" | "symbol" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "blockTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "chainID", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decreaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "increaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nonces", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "permit", values: [
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "blockTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "chainID", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ERC20Permit extends BaseContract {
+    connect(runner?: ContractRunner | null): ERC20Permit;
+    waitForDeployment(): Promise<this>;
+    interface: ERC20PermitInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    blockTimestamp: TypedContractMethod<[], [bigint], "view">;
+    chainID: TypedContractMethod<[], [bigint], "view">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    decreaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    increaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    nonces: TypedContractMethod<[owner: AddressLike], [bigint], "view">;
+    permit: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike,
+        amount: BigNumberish,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "blockTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "chainID"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "decreaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "increaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "nonces"): TypedContractMethod<[owner: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "permit"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike,
+        amount: BigNumberish,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/TORN/TORN.d.ts

@@ -0,0 +1,357 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export declare namespace TORN {
+    type RecipientStruct = {
+        to: AddressLike;
+        amount: BigNumberish;
+    };
+    type RecipientStructOutput = [to: string, amount: bigint] & {
+        to: string;
+        amount: bigint;
+    };
+}
+export interface TORNInterface extends Interface {
+    getFunction(nameOrSignature: "addToAllowedList" | "allowance" | "allowedTransferee" | "approve" | "balanceOf" | "blockTimestamp" | "burn" | "burnFrom" | "canUnpauseAfter" | "chainID" | "changeTransferability" | "decimals" | "decreaseAllowance" | "governance" | "increaseAllowance" | "name" | "nonces" | "paused" | "permit" | "removeFromAllowedList" | "rescueTokens" | "symbol" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Allowed" | "Approval" | "Disallowed" | "Paused" | "Transfer" | "Unpaused"): EventFragment;
+    encodeFunctionData(functionFragment: "addToAllowedList", values: [AddressLike[]]): string;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "allowedTransferee", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "blockTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "burn", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "burnFrom", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "canUnpauseAfter", values?: undefined): string;
+    encodeFunctionData(functionFragment: "chainID", values?: undefined): string;
+    encodeFunctionData(functionFragment: "changeTransferability", values: [boolean]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decreaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "increaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nonces", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "paused", values?: undefined): string;
+    encodeFunctionData(functionFragment: "permit", values: [
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "removeFromAllowedList", values: [AddressLike[]]): string;
+    encodeFunctionData(functionFragment: "rescueTokens", values: [AddressLike, AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "addToAllowedList", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedTransferee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "blockTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burnFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "canUnpauseAfter", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "chainID", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeTransferability", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeFromAllowedList", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rescueTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace AllowedEvent {
+    type InputTuple = [target: AddressLike];
+    type OutputTuple = [target: string];
+    interface OutputObject {
+        target: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace DisallowedEvent {
+    type InputTuple = [target: AddressLike];
+    type OutputTuple = [target: string];
+    interface OutputObject {
+        target: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace PausedEvent {
+    type InputTuple = [account: AddressLike];
+    type OutputTuple = [account: string];
+    interface OutputObject {
+        account: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UnpausedEvent {
+    type InputTuple = [account: AddressLike];
+    type OutputTuple = [account: string];
+    interface OutputObject {
+        account: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TORN extends BaseContract {
+    connect(runner?: ContractRunner | null): TORN;
+    waitForDeployment(): Promise<this>;
+    interface: TORNInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    addToAllowedList: TypedContractMethod<[
+        target: AddressLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    allowedTransferee: TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    blockTimestamp: TypedContractMethod<[], [bigint], "view">;
+    burn: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    burnFrom: TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    canUnpauseAfter: TypedContractMethod<[], [bigint], "view">;
+    chainID: TypedContractMethod<[], [bigint], "view">;
+    changeTransferability: TypedContractMethod<[
+        decision: boolean
+    ], [
+        void
+    ], "nonpayable">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    decreaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    governance: TypedContractMethod<[], [string], "view">;
+    increaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    nonces: TypedContractMethod<[owner: AddressLike], [bigint], "view">;
+    paused: TypedContractMethod<[], [boolean], "view">;
+    permit: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike,
+        amount: BigNumberish,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    removeFromAllowedList: TypedContractMethod<[
+        target: AddressLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    rescueTokens: TypedContractMethod<[
+        _token: AddressLike,
+        _to: AddressLike,
+        _balance: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "addToAllowedList"): TypedContractMethod<[target: AddressLike[]], [void], "nonpayable">;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "allowedTransferee"): TypedContractMethod<[arg0: AddressLike], [boolean], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "blockTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "burn"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "burnFrom"): TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "canUnpauseAfter"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "chainID"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "changeTransferability"): TypedContractMethod<[decision: boolean], [void], "nonpayable">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "decreaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "increaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "nonces"): TypedContractMethod<[owner: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "paused"): TypedContractMethod<[], [boolean], "view">;
+    getFunction(nameOrSignature: "permit"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike,
+        amount: BigNumberish,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "removeFromAllowedList"): TypedContractMethod<[target: AddressLike[]], [void], "nonpayable">;
+    getFunction(nameOrSignature: "rescueTokens"): TypedContractMethod<[
+        _token: AddressLike,
+        _to: AddressLike,
+        _balance: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Allowed"): TypedContractEvent<AllowedEvent.InputTuple, AllowedEvent.OutputTuple, AllowedEvent.OutputObject>;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Disallowed"): TypedContractEvent<DisallowedEvent.InputTuple, DisallowedEvent.OutputTuple, DisallowedEvent.OutputObject>;
+    getEvent(key: "Paused"): TypedContractEvent<PausedEvent.InputTuple, PausedEvent.OutputTuple, PausedEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    getEvent(key: "Unpaused"): TypedContractEvent<UnpausedEvent.InputTuple, UnpausedEvent.OutputTuple, UnpausedEvent.OutputObject>;
+    filters: {
+        "Allowed(address)": TypedContractEvent<AllowedEvent.InputTuple, AllowedEvent.OutputTuple, AllowedEvent.OutputObject>;
+        Allowed: TypedContractEvent<AllowedEvent.InputTuple, AllowedEvent.OutputTuple, AllowedEvent.OutputObject>;
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Disallowed(address)": TypedContractEvent<DisallowedEvent.InputTuple, DisallowedEvent.OutputTuple, DisallowedEvent.OutputObject>;
+        Disallowed: TypedContractEvent<DisallowedEvent.InputTuple, DisallowedEvent.OutputTuple, DisallowedEvent.OutputObject>;
+        "Paused(address)": TypedContractEvent<PausedEvent.InputTuple, PausedEvent.OutputTuple, PausedEvent.OutputObject>;
+        Paused: TypedContractEvent<PausedEvent.InputTuple, PausedEvent.OutputTuple, PausedEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        "Unpaused(address)": TypedContractEvent<UnpausedEvent.InputTuple, UnpausedEvent.OutputTuple, UnpausedEvent.OutputObject>;
+        Unpaused: TypedContractEvent<UnpausedEvent.InputTuple, UnpausedEvent.OutputTuple, UnpausedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/TORN/Vesting.d.ts

@@ -0,0 +1,77 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface VestingInterface extends Interface {
+    getFunction(nameOrSignature: "SECONDS_PER_MONTH" | "beneficiary" | "blockTimestamp" | "cliffInMonths" | "durationInMonths" | "release" | "released" | "startTimestamp" | "token" | "vestedAmount"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Released"): EventFragment;
+    encodeFunctionData(functionFragment: "SECONDS_PER_MONTH", values?: undefined): string;
+    encodeFunctionData(functionFragment: "beneficiary", values?: undefined): string;
+    encodeFunctionData(functionFragment: "blockTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "cliffInMonths", values?: undefined): string;
+    encodeFunctionData(functionFragment: "durationInMonths", values?: undefined): string;
+    encodeFunctionData(functionFragment: "release", values?: undefined): string;
+    encodeFunctionData(functionFragment: "released", values?: undefined): string;
+    encodeFunctionData(functionFragment: "startTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "token", values?: undefined): string;
+    encodeFunctionData(functionFragment: "vestedAmount", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "SECONDS_PER_MONTH", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "beneficiary", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "blockTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "cliffInMonths", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "durationInMonths", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "release", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "released", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "startTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "vestedAmount", data: BytesLike): Result;
+}
+export declare namespace ReleasedEvent {
+    type InputTuple = [amount: BigNumberish];
+    type OutputTuple = [amount: bigint];
+    interface OutputObject {
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface Vesting extends BaseContract {
+    connect(runner?: ContractRunner | null): Vesting;
+    waitForDeployment(): Promise<this>;
+    interface: VestingInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    SECONDS_PER_MONTH: TypedContractMethod<[], [bigint], "view">;
+    beneficiary: TypedContractMethod<[], [string], "view">;
+    blockTimestamp: TypedContractMethod<[], [bigint], "view">;
+    cliffInMonths: TypedContractMethod<[], [bigint], "view">;
+    durationInMonths: TypedContractMethod<[], [bigint], "view">;
+    release: TypedContractMethod<[], [void], "nonpayable">;
+    released: TypedContractMethod<[], [bigint], "view">;
+    startTimestamp: TypedContractMethod<[], [bigint], "view">;
+    token: TypedContractMethod<[], [string], "view">;
+    vestedAmount: TypedContractMethod<[], [bigint], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "SECONDS_PER_MONTH"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "beneficiary"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "blockTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "cliffInMonths"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "durationInMonths"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "release"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "released"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "startTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "token"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "vestedAmount"): TypedContractMethod<[], [bigint], "view">;
+    getEvent(key: "Released"): TypedContractEvent<ReleasedEvent.InputTuple, ReleasedEvent.OutputTuple, ReleasedEvent.OutputObject>;
+    filters: {
+        "Released(uint256)": TypedContractEvent<ReleasedEvent.InputTuple, ReleasedEvent.OutputTuple, ReleasedEvent.OutputObject>;
+        Released: TypedContractEvent<ReleasedEvent.InputTuple, ReleasedEvent.OutputTuple, ReleasedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/TORN/Voucher.d.ts

@@ -0,0 +1,219 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export declare namespace Voucher {
+    type RecipientStruct = {
+        to: AddressLike;
+        amount: BigNumberish;
+    };
+    type RecipientStructOutput = [to: string, amount: bigint] & {
+        to: string;
+        amount: bigint;
+    };
+}
+export interface VoucherInterface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "allowedTransferee" | "approve" | "balanceOf" | "blockTimestamp" | "bulkResolve" | "decimals" | "decreaseAllowance" | "expiresAt" | "governance" | "increaseAllowance" | "name" | "redeem" | "rescueExpiredTokens" | "resolve" | "symbol" | "torn" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "allowedTransferee", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "blockTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "bulkResolve", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decreaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "expiresAt", values?: undefined): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "increaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "redeem", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rescueExpiredTokens", values?: undefined): string;
+    encodeFunctionData(functionFragment: "resolve", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "torn", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedTransferee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "blockTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "bulkResolve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "expiresAt", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rescueExpiredTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resolve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "torn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface Voucher extends BaseContract {
+    connect(runner?: ContractRunner | null): Voucher;
+    waitForDeployment(): Promise<this>;
+    interface: VoucherInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    allowedTransferee: TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    blockTimestamp: TypedContractMethod<[], [bigint], "view">;
+    bulkResolve: TypedContractMethod<[domains: BytesLike[]], [string[]], "view">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    decreaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    expiresAt: TypedContractMethod<[], [bigint], "view">;
+    governance: TypedContractMethod<[], [string], "view">;
+    increaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    redeem: TypedContractMethod<[], [void], "nonpayable">;
+    rescueExpiredTokens: TypedContractMethod<[], [void], "nonpayable">;
+    resolve: TypedContractMethod<[node: BytesLike], [string], "view">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    torn: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "allowedTransferee"): TypedContractMethod<[arg0: AddressLike], [boolean], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "blockTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "bulkResolve"): TypedContractMethod<[domains: BytesLike[]], [string[]], "view">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "decreaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "expiresAt"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "increaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "redeem"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "rescueExpiredTokens"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "resolve"): TypedContractMethod<[node: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "torn"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/TORN/index.d.ts

@@ -0,0 +1,9 @@
+import type * as ensSol from "./ENS.sol";
+export type { ensSol };
+import type * as mocks from "./mocks";
+export type { mocks };
+export type { Airdrop } from "./Airdrop";
+export type { ERC20Permit } from "./ERC20Permit";
+export type { TORN } from "./TORN";
+export type { Vesting } from "./Vesting";
+export type { Voucher } from "./Voucher";

dist/contracts/Governance/TORN/mocks/AirdropMock.d.ts

@@ -0,0 +1,39 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export declare namespace Airdrop {
+    type RecipientStruct = {
+        to: AddressLike;
+        amount: BigNumberish;
+    };
+    type RecipientStructOutput = [to: string, amount: bigint] & {
+        to: string;
+        amount: bigint;
+    };
+}
+export interface AirdropMockInterface extends Interface {
+    getFunction(nameOrSignature: "bulkResolve" | "resolve"): FunctionFragment;
+    encodeFunctionData(functionFragment: "bulkResolve", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "resolve", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "bulkResolve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resolve", data: BytesLike): Result;
+}
+export interface AirdropMock extends BaseContract {
+    connect(runner?: ContractRunner | null): AirdropMock;
+    waitForDeployment(): Promise<this>;
+    interface: AirdropMockInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    bulkResolve: TypedContractMethod<[domains: BytesLike[]], [string[]], "view">;
+    resolve: TypedContractMethod<[addr: BytesLike], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "bulkResolve"): TypedContractMethod<[domains: BytesLike[]], [string[]], "view">;
+    getFunction(nameOrSignature: "resolve"): TypedContractMethod<[addr: BytesLike], [string], "view">;
+    filters: {};
+}

dist/contracts/Governance/TORN/mocks/ENSMock.d.ts

@@ -0,0 +1,51 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface ENSMockInterface extends Interface {
+    getFunction(nameOrSignature: "addr" | "multicall" | "registry" | "resolver" | "setAddr"): FunctionFragment;
+    encodeFunctionData(functionFragment: "addr", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "multicall", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "registry", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "resolver", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "setAddr", values: [BytesLike, AddressLike]): string;
+    decodeFunctionResult(functionFragment: "addr", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "registry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resolver", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setAddr", data: BytesLike): Result;
+}
+export interface ENSMock extends BaseContract {
+    connect(runner?: ContractRunner | null): ENSMock;
+    waitForDeployment(): Promise<this>;
+    interface: ENSMockInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    addr: TypedContractMethod<[_node: BytesLike], [string], "view">;
+    multicall: TypedContractMethod<[data: BytesLike[]], [string[]], "nonpayable">;
+    registry: TypedContractMethod<[arg0: BytesLike], [string], "view">;
+    resolver: TypedContractMethod<[arg0: BytesLike], [string], "view">;
+    setAddr: TypedContractMethod<[
+        _node: BytesLike,
+        _addr: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "addr"): TypedContractMethod<[_node: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "multicall"): TypedContractMethod<[data: BytesLike[]], [string[]], "nonpayable">;
+    getFunction(nameOrSignature: "registry"): TypedContractMethod<[arg0: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "resolver"): TypedContractMethod<[arg0: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "setAddr"): TypedContractMethod<[
+        _node: BytesLike,
+        _addr: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    filters: {};
+}

dist/contracts/Governance/TORN/mocks/TORNMock.d.ts

@@ -0,0 +1,381 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export declare namespace TORN {
+    type RecipientStruct = {
+        to: AddressLike;
+        amount: BigNumberish;
+    };
+    type RecipientStructOutput = [to: string, amount: bigint] & {
+        to: string;
+        amount: bigint;
+    };
+}
+export interface TORNMockInterface extends Interface {
+    getFunction(nameOrSignature: "addToAllowedList" | "allowance" | "allowedTransferee" | "approve" | "balanceOf" | "blockTimestamp" | "burn" | "burnFrom" | "canUnpauseAfter" | "chainID" | "chainId" | "changeTransferability" | "decimals" | "decreaseAllowance" | "fakeTimestamp" | "governance" | "increaseAllowance" | "name" | "nonces" | "paused" | "permit" | "removeFromAllowedList" | "rescueTokens" | "setChainId" | "setFakeTimestamp" | "symbol" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Allowed" | "Approval" | "Disallowed" | "Paused" | "Transfer" | "Unpaused"): EventFragment;
+    encodeFunctionData(functionFragment: "addToAllowedList", values: [AddressLike[]]): string;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "allowedTransferee", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "blockTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "burn", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "burnFrom", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "canUnpauseAfter", values?: undefined): string;
+    encodeFunctionData(functionFragment: "chainID", values?: undefined): string;
+    encodeFunctionData(functionFragment: "chainId", values?: undefined): string;
+    encodeFunctionData(functionFragment: "changeTransferability", values: [boolean]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decreaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "fakeTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "increaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nonces", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "paused", values?: undefined): string;
+    encodeFunctionData(functionFragment: "permit", values: [
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "removeFromAllowedList", values: [AddressLike[]]): string;
+    encodeFunctionData(functionFragment: "rescueTokens", values: [AddressLike, AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setChainId", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setFakeTimestamp", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "addToAllowedList", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedTransferee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "blockTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burnFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "canUnpauseAfter", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "chainID", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "chainId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeTransferability", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "fakeTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeFromAllowedList", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rescueTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setChainId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setFakeTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace AllowedEvent {
+    type InputTuple = [target: AddressLike];
+    type OutputTuple = [target: string];
+    interface OutputObject {
+        target: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace DisallowedEvent {
+    type InputTuple = [target: AddressLike];
+    type OutputTuple = [target: string];
+    interface OutputObject {
+        target: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace PausedEvent {
+    type InputTuple = [account: AddressLike];
+    type OutputTuple = [account: string];
+    interface OutputObject {
+        account: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UnpausedEvent {
+    type InputTuple = [account: AddressLike];
+    type OutputTuple = [account: string];
+    interface OutputObject {
+        account: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TORNMock extends BaseContract {
+    connect(runner?: ContractRunner | null): TORNMock;
+    waitForDeployment(): Promise<this>;
+    interface: TORNMockInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    addToAllowedList: TypedContractMethod<[
+        target: AddressLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    allowedTransferee: TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    blockTimestamp: TypedContractMethod<[], [bigint], "view">;
+    burn: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    burnFrom: TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    canUnpauseAfter: TypedContractMethod<[], [bigint], "view">;
+    chainID: TypedContractMethod<[], [bigint], "view">;
+    chainId: TypedContractMethod<[], [bigint], "view">;
+    changeTransferability: TypedContractMethod<[
+        decision: boolean
+    ], [
+        void
+    ], "nonpayable">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    decreaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    fakeTimestamp: TypedContractMethod<[], [bigint], "view">;
+    governance: TypedContractMethod<[], [string], "view">;
+    increaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    nonces: TypedContractMethod<[owner: AddressLike], [bigint], "view">;
+    paused: TypedContractMethod<[], [boolean], "view">;
+    permit: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike,
+        amount: BigNumberish,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    removeFromAllowedList: TypedContractMethod<[
+        target: AddressLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    rescueTokens: TypedContractMethod<[
+        _token: AddressLike,
+        _to: AddressLike,
+        _balance: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setChainId: TypedContractMethod<[
+        _chainId: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setFakeTimestamp: TypedContractMethod<[
+        _fakeTimestamp: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "addToAllowedList"): TypedContractMethod<[target: AddressLike[]], [void], "nonpayable">;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "allowedTransferee"): TypedContractMethod<[arg0: AddressLike], [boolean], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "blockTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "burn"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "burnFrom"): TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "canUnpauseAfter"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "chainID"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "chainId"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "changeTransferability"): TypedContractMethod<[decision: boolean], [void], "nonpayable">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "decreaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "fakeTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "increaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "nonces"): TypedContractMethod<[owner: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "paused"): TypedContractMethod<[], [boolean], "view">;
+    getFunction(nameOrSignature: "permit"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike,
+        amount: BigNumberish,
+        deadline: BigNumberish,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "removeFromAllowedList"): TypedContractMethod<[target: AddressLike[]], [void], "nonpayable">;
+    getFunction(nameOrSignature: "rescueTokens"): TypedContractMethod<[
+        _token: AddressLike,
+        _to: AddressLike,
+        _balance: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setChainId"): TypedContractMethod<[_chainId: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setFakeTimestamp"): TypedContractMethod<[_fakeTimestamp: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Allowed"): TypedContractEvent<AllowedEvent.InputTuple, AllowedEvent.OutputTuple, AllowedEvent.OutputObject>;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Disallowed"): TypedContractEvent<DisallowedEvent.InputTuple, DisallowedEvent.OutputTuple, DisallowedEvent.OutputObject>;
+    getEvent(key: "Paused"): TypedContractEvent<PausedEvent.InputTuple, PausedEvent.OutputTuple, PausedEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    getEvent(key: "Unpaused"): TypedContractEvent<UnpausedEvent.InputTuple, UnpausedEvent.OutputTuple, UnpausedEvent.OutputObject>;
+    filters: {
+        "Allowed(address)": TypedContractEvent<AllowedEvent.InputTuple, AllowedEvent.OutputTuple, AllowedEvent.OutputObject>;
+        Allowed: TypedContractEvent<AllowedEvent.InputTuple, AllowedEvent.OutputTuple, AllowedEvent.OutputObject>;
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Disallowed(address)": TypedContractEvent<DisallowedEvent.InputTuple, DisallowedEvent.OutputTuple, DisallowedEvent.OutputObject>;
+        Disallowed: TypedContractEvent<DisallowedEvent.InputTuple, DisallowedEvent.OutputTuple, DisallowedEvent.OutputObject>;
+        "Paused(address)": TypedContractEvent<PausedEvent.InputTuple, PausedEvent.OutputTuple, PausedEvent.OutputObject>;
+        Paused: TypedContractEvent<PausedEvent.InputTuple, PausedEvent.OutputTuple, PausedEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        "Unpaused(address)": TypedContractEvent<UnpausedEvent.InputTuple, UnpausedEvent.OutputTuple, UnpausedEvent.OutputObject>;
+        Unpaused: TypedContractEvent<UnpausedEvent.InputTuple, UnpausedEvent.OutputTuple, UnpausedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/TORN/mocks/Timestamp.d.ts

@@ -0,0 +1,37 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface TimestampInterface extends Interface {
+    getFunction(nameOrSignature: "blockTimestamp" | "fakeTimestamp" | "setFakeTimestamp"): FunctionFragment;
+    encodeFunctionData(functionFragment: "blockTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "fakeTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setFakeTimestamp", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "blockTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "fakeTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setFakeTimestamp", data: BytesLike): Result;
+}
+export interface Timestamp extends BaseContract {
+    connect(runner?: ContractRunner | null): Timestamp;
+    waitForDeployment(): Promise<this>;
+    interface: TimestampInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    blockTimestamp: TypedContractMethod<[], [bigint], "view">;
+    fakeTimestamp: TypedContractMethod<[], [bigint], "view">;
+    setFakeTimestamp: TypedContractMethod<[
+        _fakeTimestamp: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "blockTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "fakeTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "setFakeTimestamp"): TypedContractMethod<[_fakeTimestamp: BigNumberish], [void], "nonpayable">;
+    filters: {};
+}

dist/contracts/Governance/TORN/mocks/VestingMock.d.ts

@@ -0,0 +1,89 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface VestingMockInterface extends Interface {
+    getFunction(nameOrSignature: "SECONDS_PER_MONTH" | "beneficiary" | "blockTimestamp" | "cliffInMonths" | "durationInMonths" | "fakeTimestamp" | "release" | "released" | "setFakeTimestamp" | "startTimestamp" | "token" | "vestedAmount"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Released"): EventFragment;
+    encodeFunctionData(functionFragment: "SECONDS_PER_MONTH", values?: undefined): string;
+    encodeFunctionData(functionFragment: "beneficiary", values?: undefined): string;
+    encodeFunctionData(functionFragment: "blockTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "cliffInMonths", values?: undefined): string;
+    encodeFunctionData(functionFragment: "durationInMonths", values?: undefined): string;
+    encodeFunctionData(functionFragment: "fakeTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "release", values?: undefined): string;
+    encodeFunctionData(functionFragment: "released", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setFakeTimestamp", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "startTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "token", values?: undefined): string;
+    encodeFunctionData(functionFragment: "vestedAmount", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "SECONDS_PER_MONTH", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "beneficiary", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "blockTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "cliffInMonths", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "durationInMonths", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "fakeTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "release", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "released", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setFakeTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "startTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "vestedAmount", data: BytesLike): Result;
+}
+export declare namespace ReleasedEvent {
+    type InputTuple = [amount: BigNumberish];
+    type OutputTuple = [amount: bigint];
+    interface OutputObject {
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface VestingMock extends BaseContract {
+    connect(runner?: ContractRunner | null): VestingMock;
+    waitForDeployment(): Promise<this>;
+    interface: VestingMockInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    SECONDS_PER_MONTH: TypedContractMethod<[], [bigint], "view">;
+    beneficiary: TypedContractMethod<[], [string], "view">;
+    blockTimestamp: TypedContractMethod<[], [bigint], "view">;
+    cliffInMonths: TypedContractMethod<[], [bigint], "view">;
+    durationInMonths: TypedContractMethod<[], [bigint], "view">;
+    fakeTimestamp: TypedContractMethod<[], [bigint], "view">;
+    release: TypedContractMethod<[], [void], "nonpayable">;
+    released: TypedContractMethod<[], [bigint], "view">;
+    setFakeTimestamp: TypedContractMethod<[
+        _fakeTimestamp: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    startTimestamp: TypedContractMethod<[], [bigint], "view">;
+    token: TypedContractMethod<[], [string], "view">;
+    vestedAmount: TypedContractMethod<[], [bigint], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "SECONDS_PER_MONTH"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "beneficiary"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "blockTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "cliffInMonths"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "durationInMonths"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "fakeTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "release"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "released"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "setFakeTimestamp"): TypedContractMethod<[_fakeTimestamp: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "startTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "token"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "vestedAmount"): TypedContractMethod<[], [bigint], "view">;
+    getEvent(key: "Released"): TypedContractEvent<ReleasedEvent.InputTuple, ReleasedEvent.OutputTuple, ReleasedEvent.OutputObject>;
+    filters: {
+        "Released(uint256)": TypedContractEvent<ReleasedEvent.InputTuple, ReleasedEvent.OutputTuple, ReleasedEvent.OutputObject>;
+        Released: TypedContractEvent<ReleasedEvent.InputTuple, ReleasedEvent.OutputTuple, ReleasedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/TORN/mocks/VoucherMock.d.ts

@@ -0,0 +1,231 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export declare namespace Voucher {
+    type RecipientStruct = {
+        to: AddressLike;
+        amount: BigNumberish;
+    };
+    type RecipientStructOutput = [to: string, amount: bigint] & {
+        to: string;
+        amount: bigint;
+    };
+}
+export interface VoucherMockInterface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "allowedTransferee" | "approve" | "balanceOf" | "blockTimestamp" | "bulkResolve" | "decimals" | "decreaseAllowance" | "expiresAt" | "fakeTimestamp" | "governance" | "increaseAllowance" | "name" | "redeem" | "rescueExpiredTokens" | "resolve" | "setFakeTimestamp" | "symbol" | "torn" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "allowedTransferee", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "blockTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "bulkResolve", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decreaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "expiresAt", values?: undefined): string;
+    encodeFunctionData(functionFragment: "fakeTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "increaseAllowance", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "redeem", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rescueExpiredTokens", values?: undefined): string;
+    encodeFunctionData(functionFragment: "resolve", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "setFakeTimestamp", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "torn", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedTransferee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "blockTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "bulkResolve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "expiresAt", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "fakeTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rescueExpiredTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resolve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setFakeTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "torn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface VoucherMock extends BaseContract {
+    connect(runner?: ContractRunner | null): VoucherMock;
+    waitForDeployment(): Promise<this>;
+    interface: VoucherMockInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    allowedTransferee: TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    blockTimestamp: TypedContractMethod<[], [bigint], "view">;
+    bulkResolve: TypedContractMethod<[domains: BytesLike[]], [string[]], "view">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    decreaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    expiresAt: TypedContractMethod<[], [bigint], "view">;
+    fakeTimestamp: TypedContractMethod<[], [bigint], "view">;
+    governance: TypedContractMethod<[], [string], "view">;
+    increaseAllowance: TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    redeem: TypedContractMethod<[], [void], "nonpayable">;
+    rescueExpiredTokens: TypedContractMethod<[], [void], "nonpayable">;
+    resolve: TypedContractMethod<[addr: BytesLike], [string], "view">;
+    setFakeTimestamp: TypedContractMethod<[
+        _fakeTimestamp: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    torn: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "allowedTransferee"): TypedContractMethod<[arg0: AddressLike], [boolean], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "blockTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "bulkResolve"): TypedContractMethod<[domains: BytesLike[]], [string[]], "view">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "decreaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        subtractedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "expiresAt"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "fakeTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "increaseAllowance"): TypedContractMethod<[
+        spender: AddressLike,
+        addedValue: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "redeem"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "rescueExpiredTokens"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "resolve"): TypedContractMethod<[addr: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "setFakeTimestamp"): TypedContractMethod<[_fakeTimestamp: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "torn"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/TORN/mocks/index.d.ts

@@ -0,0 +1,6 @@
+export type { AirdropMock } from "./AirdropMock";
+export type { ENSMock } from "./ENSMock";
+export type { TORNMock } from "./TORNMock";
+export type { Timestamp } from "./Timestamp";
+export type { VestingMock } from "./VestingMock";
+export type { VoucherMock } from "./VoucherMock";

dist/contracts/Governance/Testnet/TestnetAdminProxy.d.ts

@@ -0,0 +1,146 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface TestnetAdminProxyInterface extends Interface {
+    getFunction(nameOrSignature: "admin" | "callToOwner" | "changeAdmin" | "changeOwner" | "delegateToOwner" | "getCurrentOwner" | "implementation" | "upgradeTo" | "upgradeToAndCall" | "upgradeToOwner"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "AdminChanged" | "Upgraded"): EventFragment;
+    encodeFunctionData(functionFragment: "admin", values?: undefined): string;
+    encodeFunctionData(functionFragment: "callToOwner", values: [AddressLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "changeAdmin", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "changeOwner", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "delegateToOwner", values: [AddressLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "getCurrentOwner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "upgradeTo", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "upgradeToAndCall", values: [AddressLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "upgradeToOwner", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "admin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "callToOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeAdmin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "delegateToOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeToAndCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeToOwner", data: BytesLike): Result;
+}
+export declare namespace AdminChangedEvent {
+    type InputTuple = [previousAdmin: AddressLike, newAdmin: AddressLike];
+    type OutputTuple = [previousAdmin: string, newAdmin: string];
+    interface OutputObject {
+        previousAdmin: string;
+        newAdmin: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UpgradedEvent {
+    type InputTuple = [implementation: AddressLike];
+    type OutputTuple = [implementation: string];
+    interface OutputObject {
+        implementation: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TestnetAdminProxy extends BaseContract {
+    connect(runner?: ContractRunner | null): TestnetAdminProxy;
+    waitForDeployment(): Promise<this>;
+    interface: TestnetAdminProxyInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    admin: TypedContractMethod<[], [string], "nonpayable">;
+    callToOwner: TypedContractMethod<[
+        target: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    changeAdmin: TypedContractMethod<[
+        newAdmin: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    changeOwner: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    delegateToOwner: TypedContractMethod<[
+        target: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getCurrentOwner: TypedContractMethod<[], [string], "view">;
+    implementation: TypedContractMethod<[], [string], "nonpayable">;
+    upgradeTo: TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    upgradeToAndCall: TypedContractMethod<[
+        newImplementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    upgradeToOwner: TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "admin"): TypedContractMethod<[], [string], "nonpayable">;
+    getFunction(nameOrSignature: "callToOwner"): TypedContractMethod<[
+        target: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "changeAdmin"): TypedContractMethod<[newAdmin: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "changeOwner"): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "delegateToOwner"): TypedContractMethod<[
+        target: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "getCurrentOwner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "implementation"): TypedContractMethod<[], [string], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeTo"): TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeToAndCall"): TypedContractMethod<[
+        newImplementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "upgradeToOwner"): TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "AdminChanged"): TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+    getEvent(key: "Upgraded"): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    filters: {
+        "AdminChanged(address,address)": TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        AdminChanged: TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        "Upgraded(address)": TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/Testnet/TestnetFeeManager.d.ts

@@ -0,0 +1,201 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export declare namespace FeeManager {
+    type DeviationStruct = {
+        instance: AddressLike;
+        deviation: BigNumberish;
+    };
+    type DeviationStructOutput = [instance: string, deviation: bigint] & {
+        instance: string;
+        deviation: bigint;
+    };
+}
+export interface TestnetFeeManagerInterface extends Interface {
+    getFunction(nameOrSignature: "PROTOCOL_FEE_DIVIDER" | "calculatePoolFee" | "feeDeviations" | "getTokenPriceRatio" | "governance" | "instanceFee" | "instanceFeeUpdated" | "instanceFeeWithUpdate" | "registry" | "setPeriodForTWAPOracle" | "setTokenPrice" | "setUniswapTornPoolSwappingFee" | "setUpdateFeeTimeLimit" | "torn" | "uniswapTimePeriod" | "uniswapTornPoolSwappingFee" | "updateAllFees" | "updateFee" | "updateFeeTimeLimit" | "updateFees"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "FeeUpdated" | "UniswapTornPoolSwappingFeeChanged"): EventFragment;
+    encodeFunctionData(functionFragment: "PROTOCOL_FEE_DIVIDER", values?: undefined): string;
+    encodeFunctionData(functionFragment: "calculatePoolFee", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "feeDeviations", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getTokenPriceRatio", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "instanceFee", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "instanceFeeUpdated", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "instanceFeeWithUpdate", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "registry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setPeriodForTWAPOracle", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setTokenPrice", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setUniswapTornPoolSwappingFee", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setUpdateFeeTimeLimit", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "torn", values?: undefined): string;
+    encodeFunctionData(functionFragment: "uniswapTimePeriod", values?: undefined): string;
+    encodeFunctionData(functionFragment: "uniswapTornPoolSwappingFee", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateAllFees", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateFee", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "updateFeeTimeLimit", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateFees", values: [AddressLike[]]): string;
+    decodeFunctionResult(functionFragment: "PROTOCOL_FEE_DIVIDER", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculatePoolFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "feeDeviations", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTokenPriceRatio", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "instanceFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "instanceFeeUpdated", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "instanceFeeWithUpdate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "registry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPeriodForTWAPOracle", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTokenPrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setUniswapTornPoolSwappingFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setUpdateFeeTimeLimit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "torn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "uniswapTimePeriod", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "uniswapTornPoolSwappingFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateAllFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateFeeTimeLimit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateFees", data: BytesLike): Result;
+}
+export declare namespace FeeUpdatedEvent {
+    type InputTuple = [instance: AddressLike, newFee: BigNumberish];
+    type OutputTuple = [instance: string, newFee: bigint];
+    interface OutputObject {
+        instance: string;
+        newFee: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UniswapTornPoolSwappingFeeChangedEvent {
+    type InputTuple = [newFee: BigNumberish];
+    type OutputTuple = [newFee: bigint];
+    interface OutputObject {
+        newFee: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TestnetFeeManager extends BaseContract {
+    connect(runner?: ContractRunner | null): TestnetFeeManager;
+    waitForDeployment(): Promise<this>;
+    interface: TestnetFeeManagerInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    PROTOCOL_FEE_DIVIDER: TypedContractMethod<[], [bigint], "view">;
+    calculatePoolFee: TypedContractMethod<[
+        _instance: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    feeDeviations: TypedContractMethod<[
+    ], [
+        FeeManager.DeviationStructOutput[]
+    ], "view">;
+    getTokenPriceRatio: TypedContractMethod<[
+        _token: AddressLike,
+        _uniswapPoolSwappingFee: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    governance: TypedContractMethod<[], [string], "view">;
+    instanceFee: TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    instanceFeeUpdated: TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    instanceFeeWithUpdate: TypedContractMethod<[
+        _instance: AddressLike
+    ], [
+        bigint
+    ], "nonpayable">;
+    registry: TypedContractMethod<[], [string], "view">;
+    setPeriodForTWAPOracle: TypedContractMethod<[
+        newPeriod: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setTokenPrice: TypedContractMethod<[
+        _token: AddressLike,
+        _price: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setUniswapTornPoolSwappingFee: TypedContractMethod<[
+        _uniswapTornPoolSwappingFee: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setUpdateFeeTimeLimit: TypedContractMethod<[
+        newLimit: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    torn: TypedContractMethod<[], [string], "view">;
+    uniswapTimePeriod: TypedContractMethod<[], [bigint], "view">;
+    uniswapTornPoolSwappingFee: TypedContractMethod<[], [bigint], "view">;
+    updateAllFees: TypedContractMethod<[], [void], "nonpayable">;
+    updateFee: TypedContractMethod<[
+        _instance: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    updateFeeTimeLimit: TypedContractMethod<[], [bigint], "view">;
+    updateFees: TypedContractMethod<[
+        _instances: AddressLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "PROTOCOL_FEE_DIVIDER"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "calculatePoolFee"): TypedContractMethod<[_instance: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "feeDeviations"): TypedContractMethod<[], [FeeManager.DeviationStructOutput[]], "view">;
+    getFunction(nameOrSignature: "getTokenPriceRatio"): TypedContractMethod<[
+        _token: AddressLike,
+        _uniswapPoolSwappingFee: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "instanceFee"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "instanceFeeUpdated"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "instanceFeeWithUpdate"): TypedContractMethod<[_instance: AddressLike], [bigint], "nonpayable">;
+    getFunction(nameOrSignature: "registry"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "setPeriodForTWAPOracle"): TypedContractMethod<[newPeriod: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setTokenPrice"): TypedContractMethod<[
+        _token: AddressLike,
+        _price: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setUniswapTornPoolSwappingFee"): TypedContractMethod<[
+        _uniswapTornPoolSwappingFee: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setUpdateFeeTimeLimit"): TypedContractMethod<[newLimit: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "torn"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "uniswapTimePeriod"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "uniswapTornPoolSwappingFee"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "updateAllFees"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "updateFee"): TypedContractMethod<[_instance: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "updateFeeTimeLimit"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "updateFees"): TypedContractMethod<[_instances: AddressLike[]], [void], "nonpayable">;
+    getEvent(key: "FeeUpdated"): TypedContractEvent<FeeUpdatedEvent.InputTuple, FeeUpdatedEvent.OutputTuple, FeeUpdatedEvent.OutputObject>;
+    getEvent(key: "UniswapTornPoolSwappingFeeChanged"): TypedContractEvent<UniswapTornPoolSwappingFeeChangedEvent.InputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputObject>;
+    filters: {
+        "FeeUpdated(address,uint256)": TypedContractEvent<FeeUpdatedEvent.InputTuple, FeeUpdatedEvent.OutputTuple, FeeUpdatedEvent.OutputObject>;
+        FeeUpdated: TypedContractEvent<FeeUpdatedEvent.InputTuple, FeeUpdatedEvent.OutputTuple, FeeUpdatedEvent.OutputObject>;
+        "UniswapTornPoolSwappingFeeChanged(uint24)": TypedContractEvent<UniswapTornPoolSwappingFeeChangedEvent.InputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputObject>;
+        UniswapTornPoolSwappingFeeChanged: TypedContractEvent<UniswapTornPoolSwappingFeeChangedEvent.InputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputTuple, UniswapTornPoolSwappingFeeChangedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/Testnet/TestnetGovernanceProxy.d.ts

@@ -0,0 +1,146 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface TestnetGovernanceProxyInterface extends Interface {
+    getFunction(nameOrSignature: "admin" | "callToOwner" | "changeAdmin" | "changeOwner" | "delegateToOwner" | "getCurrentOwner" | "implementation" | "upgradeTo" | "upgradeToAndCall" | "upgradeToOwner"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "AdminChanged" | "Upgraded"): EventFragment;
+    encodeFunctionData(functionFragment: "admin", values?: undefined): string;
+    encodeFunctionData(functionFragment: "callToOwner", values: [AddressLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "changeAdmin", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "changeOwner", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "delegateToOwner", values: [AddressLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "getCurrentOwner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "upgradeTo", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "upgradeToAndCall", values: [AddressLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "upgradeToOwner", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "admin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "callToOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeAdmin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "delegateToOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeToAndCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeToOwner", data: BytesLike): Result;
+}
+export declare namespace AdminChangedEvent {
+    type InputTuple = [previousAdmin: AddressLike, newAdmin: AddressLike];
+    type OutputTuple = [previousAdmin: string, newAdmin: string];
+    interface OutputObject {
+        previousAdmin: string;
+        newAdmin: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UpgradedEvent {
+    type InputTuple = [implementation: AddressLike];
+    type OutputTuple = [implementation: string];
+    interface OutputObject {
+        implementation: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TestnetGovernanceProxy extends BaseContract {
+    connect(runner?: ContractRunner | null): TestnetGovernanceProxy;
+    waitForDeployment(): Promise<this>;
+    interface: TestnetGovernanceProxyInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    admin: TypedContractMethod<[], [string], "nonpayable">;
+    callToOwner: TypedContractMethod<[
+        target: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    changeAdmin: TypedContractMethod<[
+        newAdmin: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    changeOwner: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    delegateToOwner: TypedContractMethod<[
+        target: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getCurrentOwner: TypedContractMethod<[], [string], "view">;
+    implementation: TypedContractMethod<[], [string], "nonpayable">;
+    upgradeTo: TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    upgradeToAndCall: TypedContractMethod<[
+        newImplementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    upgradeToOwner: TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "admin"): TypedContractMethod<[], [string], "nonpayable">;
+    getFunction(nameOrSignature: "callToOwner"): TypedContractMethod<[
+        target: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "changeAdmin"): TypedContractMethod<[newAdmin: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "changeOwner"): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "delegateToOwner"): TypedContractMethod<[
+        target: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "getCurrentOwner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "implementation"): TypedContractMethod<[], [string], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeTo"): TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeToAndCall"): TypedContractMethod<[
+        newImplementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "upgradeToOwner"): TypedContractMethod<[
+        newImplementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "AdminChanged"): TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+    getEvent(key: "Upgraded"): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    filters: {
+        "AdminChanged(address,address)": TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        AdminChanged: TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        "Upgraded(address)": TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/Testnet/index.d.ts

@@ -0,0 +1,3 @@
+export type { TestnetAdminProxy } from "./TestnetAdminProxy";
+export type { TestnetFeeManager } from "./TestnetFeeManager";
+export type { TestnetGovernanceProxy } from "./TestnetGovernanceProxy";

dist/contracts/Governance/TornadoRouter.d.ts

@@ -0,0 +1,141 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export interface TornadoRouterInterface extends Interface {
+    getFunction(nameOrSignature: "approveExactToken" | "backupNotes" | "deposit" | "governance" | "instanceRegistry" | "relayerRegistry" | "rescueTokens" | "withdraw"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "EncryptedNote"): EventFragment;
+    encodeFunctionData(functionFragment: "approveExactToken", values: [AddressLike, AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "backupNotes", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "deposit", values: [AddressLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "instanceRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "relayerRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rescueTokens", values: [AddressLike, AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [
+        AddressLike,
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    decodeFunctionResult(functionFragment: "approveExactToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "backupNotes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "instanceRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "relayerRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rescueTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+}
+export declare namespace EncryptedNoteEvent {
+    type InputTuple = [sender: AddressLike, encryptedNote: BytesLike];
+    type OutputTuple = [sender: string, encryptedNote: string];
+    interface OutputObject {
+        sender: string;
+        encryptedNote: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TornadoRouter extends BaseContract {
+    connect(runner?: ContractRunner | null): TornadoRouter;
+    waitForDeployment(): Promise<this>;
+    interface: TornadoRouterInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    approveExactToken: TypedContractMethod<[
+        _token: AddressLike,
+        _spender: AddressLike,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    backupNotes: TypedContractMethod<[
+        _encryptedNotes: BytesLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    deposit: TypedContractMethod<[
+        _tornado: AddressLike,
+        _commitment: BytesLike,
+        _encryptedNote: BytesLike
+    ], [
+        void
+    ], "payable">;
+    governance: TypedContractMethod<[], [string], "view">;
+    instanceRegistry: TypedContractMethod<[], [string], "view">;
+    relayerRegistry: TypedContractMethod<[], [string], "view">;
+    rescueTokens: TypedContractMethod<[
+        _token: AddressLike,
+        _to: AddressLike,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    withdraw: TypedContractMethod<[
+        _tornado: AddressLike,
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "approveExactToken"): TypedContractMethod<[
+        _token: AddressLike,
+        _spender: AddressLike,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "backupNotes"): TypedContractMethod<[_encryptedNotes: BytesLike[]], [void], "nonpayable">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[
+        _tornado: AddressLike,
+        _commitment: BytesLike,
+        _encryptedNote: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "instanceRegistry"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "relayerRegistry"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "rescueTokens"): TypedContractMethod<[
+        _token: AddressLike,
+        _to: AddressLike,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[
+        _tornado: AddressLike,
+        _proof: BytesLike,
+        _root: BytesLike,
+        _nullifierHash: BytesLike,
+        _recipient: AddressLike,
+        _relayer: AddressLike,
+        _fee: BigNumberish,
+        _refund: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getEvent(key: "EncryptedNote"): TypedContractEvent<EncryptedNoteEvent.InputTuple, EncryptedNoteEvent.OutputTuple, EncryptedNoteEvent.OutputObject>;
+    filters: {
+        "EncryptedNote(address,bytes)": TypedContractEvent<EncryptedNoteEvent.InputTuple, EncryptedNoteEvent.OutputTuple, EncryptedNoteEvent.OutputObject>;
+        EncryptedNote: TypedContractEvent<EncryptedNoteEvent.InputTuple, EncryptedNoteEvent.OutputTuple, EncryptedNoteEvent.OutputObject>;
+    };
+}

dist/contracts/Governance/TornadoStakingRewards.sol/ITornadoGovernance.d.ts

@@ -0,0 +1,29 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface ITornadoGovernanceInterface extends Interface {
+    getFunction(nameOrSignature: "lockedBalance" | "userVault"): FunctionFragment;
+    encodeFunctionData(functionFragment: "lockedBalance", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "userVault", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "lockedBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "userVault", data: BytesLike): Result;
+}
+export interface ITornadoGovernance extends BaseContract {
+    connect(runner?: ContractRunner | null): ITornadoGovernance;
+    waitForDeployment(): Promise<this>;
+    interface: ITornadoGovernanceInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    lockedBalance: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    userVault: TypedContractMethod<[], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "lockedBalance"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "userVault"): TypedContractMethod<[], [string], "view">;
+    filters: {};
+}

dist/contracts/Governance/TornadoStakingRewards.sol/ITornadoVault.d.ts

@@ -0,0 +1,35 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface ITornadoVaultInterface extends Interface {
+    getFunction(nameOrSignature: "withdrawTorn"): FunctionFragment;
+    encodeFunctionData(functionFragment: "withdrawTorn", values: [AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "withdrawTorn", data: BytesLike): Result;
+}
+export interface ITornadoVault extends BaseContract {
+    connect(runner?: ContractRunner | null): ITornadoVault;
+    waitForDeployment(): Promise<this>;
+    interface: ITornadoVaultInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    withdrawTorn: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "withdrawTorn"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    filters: {};
+}

dist/contracts/Governance/TornadoStakingRewards.sol/TornadoStakingRewards.d.ts

@@ -0,0 +1,127 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface TornadoStakingRewardsInterface extends Interface {
+    getFunction(nameOrSignature: "Governance" | "accumulatedRewardPerTorn" | "accumulatedRewardRateOnLastUpdate" | "accumulatedRewards" | "addBurnRewards" | "checkReward" | "getReward" | "ratioConstant" | "relayerRegistry" | "torn" | "updateRewardsOnLockedBalanceChange" | "withdrawTorn"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardsClaimed" | "RewardsUpdated"): EventFragment;
+    encodeFunctionData(functionFragment: "Governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "accumulatedRewardPerTorn", values?: undefined): string;
+    encodeFunctionData(functionFragment: "accumulatedRewardRateOnLastUpdate", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "accumulatedRewards", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "addBurnRewards", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "checkReward", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getReward", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ratioConstant", values?: undefined): string;
+    encodeFunctionData(functionFragment: "relayerRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "torn", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateRewardsOnLockedBalanceChange", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "withdrawTorn", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "Governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "accumulatedRewardPerTorn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "accumulatedRewardRateOnLastUpdate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "accumulatedRewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "addBurnRewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "checkReward", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getReward", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ratioConstant", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "relayerRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "torn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateRewardsOnLockedBalanceChange", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawTorn", data: BytesLike): Result;
+}
+export declare namespace RewardsClaimedEvent {
+    type InputTuple = [account: AddressLike, rewardsClaimed: BigNumberish];
+    type OutputTuple = [account: string, rewardsClaimed: bigint];
+    interface OutputObject {
+        account: string;
+        rewardsClaimed: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RewardsUpdatedEvent {
+    type InputTuple = [account: AddressLike, rewards: BigNumberish];
+    type OutputTuple = [account: string, rewards: bigint];
+    interface OutputObject {
+        account: string;
+        rewards: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TornadoStakingRewards extends BaseContract {
+    connect(runner?: ContractRunner | null): TornadoStakingRewards;
+    waitForDeployment(): Promise<this>;
+    interface: TornadoStakingRewardsInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    Governance: TypedContractMethod<[], [string], "view">;
+    accumulatedRewardPerTorn: TypedContractMethod<[], [bigint], "view">;
+    accumulatedRewardRateOnLastUpdate: TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    accumulatedRewards: TypedContractMethod<[
+        arg0: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    addBurnRewards: TypedContractMethod<[
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    checkReward: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getReward: TypedContractMethod<[], [void], "nonpayable">;
+    ratioConstant: TypedContractMethod<[], [bigint], "view">;
+    relayerRegistry: TypedContractMethod<[], [string], "view">;
+    torn: TypedContractMethod<[], [string], "view">;
+    updateRewardsOnLockedBalanceChange: TypedContractMethod<[
+        account: AddressLike,
+        amountLockedBeforehand: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    withdrawTorn: TypedContractMethod<[
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "Governance"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "accumulatedRewardPerTorn"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "accumulatedRewardRateOnLastUpdate"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "accumulatedRewards"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "addBurnRewards"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "checkReward"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getReward"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "ratioConstant"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "relayerRegistry"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "torn"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "updateRewardsOnLockedBalanceChange"): TypedContractMethod<[
+        account: AddressLike,
+        amountLockedBeforehand: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "withdrawTorn"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getEvent(key: "RewardsClaimed"): TypedContractEvent<RewardsClaimedEvent.InputTuple, RewardsClaimedEvent.OutputTuple, RewardsClaimedEvent.OutputObject>;
+    getEvent(key: "RewardsUpdated"): TypedContractEvent<RewardsUpdatedEvent.InputTuple, RewardsUpdatedEvent.OutputTuple, RewardsUpdatedEvent.OutputObject>;
+    filters: {
+        "RewardsClaimed(address,uint256)": TypedContractEvent<RewardsClaimedEvent.InputTuple, RewardsClaimedEvent.OutputTuple, RewardsClaimedEvent.OutputObject>;
+        RewardsClaimed: TypedContractEvent<RewardsClaimedEvent.InputTuple, RewardsClaimedEvent.OutputTuple, RewardsClaimedEvent.OutputObject>;
+        "RewardsUpdated(address,uint256)": TypedContractEvent<RewardsUpdatedEvent.InputTuple, RewardsUpdatedEvent.OutputTuple, RewardsUpdatedEvent.OutputObject>;
+        RewardsUpdated: TypedContractEvent<RewardsUpdatedEvent.InputTuple, RewardsUpdatedEvent.OutputTuple, RewardsUpdatedEvent.OutputObject>;
+    };
+}