@1inch/solidity-utils 2.4.0 → 3.0.0

package/dist/src/typechain-types/contracts/mocks/TokenMock.d.ts

@@ -0,0 +1,228 @@
+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 TokenMockInterface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "burn" | "decimals" | "decreaseAllowance" | "increaseAllowance" | "mint" | "name" | "owner" | "renounceOwnership" | "symbol" | "totalSupply" | "transfer" | "transferFrom" | "transferOwnership"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "OwnershipTransferred" | "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: [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: "mint", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", 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;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [AddressLike]): 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: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", 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;
+    decodeFunctionResult(functionFragment: "transferOwnership", 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 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 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 TokenMock extends BaseContract {
+    connect(runner?: ContractRunner | null): TokenMock;
+    waitForDeployment(): Promise<this>;
+    interface: TokenMockInterface;
+    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<[
+        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">;
+    mint: TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    owner: TypedContractMethod<[], [string], "view">;
+    renounceOwnership: TypedContractMethod<[], [void], "nonpayable">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        to: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferOwnership: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], "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<[
+        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: "mint"): TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "owner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "renounceOwnership"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        to: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferOwnership"): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "OwnershipTransferred"): TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.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>;
+        "OwnershipTransferred(address,address)": TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        OwnershipTransferred: TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

package/dist/src/typechain-types/contracts/mocks/TokenMock.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TokenMock.js.map

package/dist/src/typechain-types/contracts/mocks/TokenMock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenMock.js","sourceRoot":"","sources":["../../../../../typechain-types/contracts/mocks/TokenMock.ts"],"names":[],"mappings":""}

package/dist/src/typechain-types/contracts/mocks/index.d.ts

@@ -0,0 +1,3 @@
+export type { ERC20PermitMock } from "./ERC20PermitMock";
+export type { TokenCustomDecimalsMock } from "./TokenCustomDecimalsMock";
+export type { TokenMock } from "./TokenMock";

package/dist/src/typechain-types/contracts/mocks/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/src/typechain-types/contracts/mocks/index.js.map

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

package/dist/src/typechain-types/contracts/tests/ECDSATest.d.ts

@@ -0,0 +1,235 @@
+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 ECDSATestInterface extends Interface {
+    getFunction(nameOrSignature: "isValidSignature" | "isValidSignature65" | "isValidSignature_r_vs" | "isValidSignature_v_r_s" | "recover" | "recoverOrIsValidSignature" | "recoverOrIsValidSignature65" | "recoverOrIsValidSignature_r_vs" | "recoverOrIsValidSignature_v_r_s" | "recover_r_vs" | "recover_v_r_s" | "toEthSignedMessageHash" | "toTypedDataHash"): FunctionFragment;
+    encodeFunctionData(functionFragment: "isValidSignature", values: [AddressLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "isValidSignature65", values: [AddressLike, BytesLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "isValidSignature_r_vs", values: [AddressLike, BytesLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "isValidSignature_v_r_s", values: [AddressLike, BytesLike, BigNumberish, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "recover", values: [BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "recoverOrIsValidSignature", values: [AddressLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "recoverOrIsValidSignature65", values: [AddressLike, BytesLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "recoverOrIsValidSignature_r_vs", values: [AddressLike, BytesLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "recoverOrIsValidSignature_v_r_s", values: [AddressLike, BytesLike, BigNumberish, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "recover_r_vs", values: [BytesLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "recover_v_r_s", values: [BytesLike, BigNumberish, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "toEthSignedMessageHash", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "toTypedDataHash", values: [BytesLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "isValidSignature", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isValidSignature65", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isValidSignature_r_vs", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isValidSignature_v_r_s", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recover", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recoverOrIsValidSignature", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recoverOrIsValidSignature65", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recoverOrIsValidSignature_r_vs", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recoverOrIsValidSignature_v_r_s", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recover_r_vs", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recover_v_r_s", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "toEthSignedMessageHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "toTypedDataHash", data: BytesLike): Result;
+}
+export interface ECDSATest extends BaseContract {
+    connect(runner?: ContractRunner | null): ECDSATest;
+    waitForDeployment(): Promise<this>;
+    interface: ECDSATestInterface;
+    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>;
+    isValidSignature: TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        signature: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    isValidSignature65: TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        r: BytesLike,
+        vs: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    isValidSignature_r_vs: TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        r: BytesLike,
+        vs: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    isValidSignature_v_r_s: TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    recover: TypedContractMethod<[
+        hash: BytesLike,
+        signature: BytesLike
+    ], [
+        string
+    ], "view">;
+    recoverOrIsValidSignature: TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        signature: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    recoverOrIsValidSignature65: TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        r: BytesLike,
+        vs: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    recoverOrIsValidSignature_r_vs: TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        r: BytesLike,
+        vs: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    recoverOrIsValidSignature_v_r_s: TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    recover_r_vs: TypedContractMethod<[
+        hash: BytesLike,
+        r: BytesLike,
+        vs: BytesLike
+    ], [
+        string
+    ], "view">;
+    recover_v_r_s: TypedContractMethod<[
+        hash: BytesLike,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        string
+    ], "view">;
+    toEthSignedMessageHash: TypedContractMethod<[
+        hash: BytesLike
+    ], [
+        string
+    ], "view">;
+    toTypedDataHash: TypedContractMethod<[
+        domainSeparator: BytesLike,
+        structHash: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "isValidSignature"): TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        signature: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "isValidSignature65"): TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        r: BytesLike,
+        vs: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "isValidSignature_r_vs"): TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        r: BytesLike,
+        vs: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "isValidSignature_v_r_s"): TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "recover"): TypedContractMethod<[
+        hash: BytesLike,
+        signature: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "recoverOrIsValidSignature"): TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        signature: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "recoverOrIsValidSignature65"): TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        r: BytesLike,
+        vs: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "recoverOrIsValidSignature_r_vs"): TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        r: BytesLike,
+        vs: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "recoverOrIsValidSignature_v_r_s"): TypedContractMethod<[
+        signer: AddressLike,
+        hash: BytesLike,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "recover_r_vs"): TypedContractMethod<[
+        hash: BytesLike,
+        r: BytesLike,
+        vs: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "recover_v_r_s"): TypedContractMethod<[
+        hash: BytesLike,
+        v: BigNumberish,
+        r: BytesLike,
+        s: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "toEthSignedMessageHash"): TypedContractMethod<[hash: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "toTypedDataHash"): TypedContractMethod<[
+        domainSeparator: BytesLike,
+        structHash: BytesLike
+    ], [
+        string
+    ], "view">;
+    filters: {};
+}

package/dist/src/typechain-types/contracts/tests/ECDSATest.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ECDSATest.js.map

package/dist/src/typechain-types/contracts/tests/ECDSATest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ECDSATest.js","sourceRoot":"","sources":["../../../../../typechain-types/contracts/tests/ECDSATest.ts"],"names":[],"mappings":""}

package/dist/src/typechain-types/contracts/tests/RevertReasonParserTest.d.ts

@@ -0,0 +1,73 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
+export interface RevertReasonParserTestInterface extends Interface {
+    getFunction(nameOrSignature: "assertion" | "emptyRevert" | "emptyStringRevert" | "longStringRevert" | "nonEmptyRevert" | "testAssertion" | "testEmptyRevert" | "testEmptyStringRevert" | "testLongStringRevert" | "testNonEmptyRevert" | "testParseWithThrow" | "testWithThrow" | "withoutAssertion"): FunctionFragment;
+    encodeFunctionData(functionFragment: "assertion", values?: undefined): string;
+    encodeFunctionData(functionFragment: "emptyRevert", values?: undefined): string;
+    encodeFunctionData(functionFragment: "emptyStringRevert", values?: undefined): string;
+    encodeFunctionData(functionFragment: "longStringRevert", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nonEmptyRevert", values?: undefined): string;
+    encodeFunctionData(functionFragment: "testAssertion", values?: undefined): string;
+    encodeFunctionData(functionFragment: "testEmptyRevert", values?: undefined): string;
+    encodeFunctionData(functionFragment: "testEmptyStringRevert", values?: undefined): string;
+    encodeFunctionData(functionFragment: "testLongStringRevert", values?: undefined): string;
+    encodeFunctionData(functionFragment: "testNonEmptyRevert", values?: undefined): string;
+    encodeFunctionData(functionFragment: "testParseWithThrow", values?: undefined): string;
+    encodeFunctionData(functionFragment: "testWithThrow", values?: undefined): string;
+    encodeFunctionData(functionFragment: "withoutAssertion", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "assertion", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emptyRevert", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emptyStringRevert", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "longStringRevert", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nonEmptyRevert", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "testAssertion", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "testEmptyRevert", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "testEmptyStringRevert", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "testLongStringRevert", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "testNonEmptyRevert", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "testParseWithThrow", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "testWithThrow", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withoutAssertion", data: BytesLike): Result;
+}
+export interface RevertReasonParserTest extends BaseContract {
+    connect(runner?: ContractRunner | null): RevertReasonParserTest;
+    waitForDeployment(): Promise<this>;
+    interface: RevertReasonParserTestInterface;
+    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>;
+    assertion: TypedContractMethod<[], [void], "view">;
+    emptyRevert: TypedContractMethod<[], [void], "view">;
+    emptyStringRevert: TypedContractMethod<[], [void], "view">;
+    longStringRevert: TypedContractMethod<[], [void], "view">;
+    nonEmptyRevert: TypedContractMethod<[], [void], "view">;
+    testAssertion: TypedContractMethod<[], [void], "view">;
+    testEmptyRevert: TypedContractMethod<[], [void], "view">;
+    testEmptyStringRevert: TypedContractMethod<[], [void], "view">;
+    testLongStringRevert: TypedContractMethod<[], [void], "view">;
+    testNonEmptyRevert: TypedContractMethod<[], [void], "view">;
+    testParseWithThrow: TypedContractMethod<[], [void], "view">;
+    testWithThrow: TypedContractMethod<[], [void], "view">;
+    withoutAssertion: TypedContractMethod<[], [void], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "assertion"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "emptyRevert"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "emptyStringRevert"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "longStringRevert"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "nonEmptyRevert"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "testAssertion"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "testEmptyRevert"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "testEmptyStringRevert"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "testLongStringRevert"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "testNonEmptyRevert"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "testParseWithThrow"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "testWithThrow"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "withoutAssertion"): TypedContractMethod<[], [void], "view">;
+    filters: {};
+}

package/dist/src/typechain-types/contracts/tests/RevertReasonParserTest.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=RevertReasonParserTest.js.map

package/dist/src/typechain-types/contracts/tests/RevertReasonParserTest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RevertReasonParserTest.js","sourceRoot":"","sources":["../../../../../typechain-types/contracts/tests/RevertReasonParserTest.ts"],"names":[],"mappings":""}

package/dist/src/typechain-types/contracts/tests/StringUtilTest.d.ts

@@ -0,0 +1,77 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
+export interface StringUtilTestInterface extends Interface {
+    getFunction(nameOrSignature: "toHex" | "toHexBytes" | "toHexNaive" | "toHexNaiveBytes"): FunctionFragment;
+    encodeFunctionData(functionFragment: "toHex", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "toHexBytes", values: [BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "toHexNaive", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "toHexNaiveBytes", values: [BytesLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "toHex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "toHexBytes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "toHexNaive", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "toHexNaiveBytes", data: BytesLike): Result;
+}
+export interface StringUtilTest extends BaseContract {
+    connect(runner?: ContractRunner | null): StringUtilTest;
+    waitForDeployment(): Promise<this>;
+    interface: StringUtilTestInterface;
+    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>;
+    toHex: TypedContractMethod<[
+        value: BigNumberish,
+        expectedGasCost: BigNumberish
+    ], [
+        string
+    ], "view">;
+    toHexBytes: TypedContractMethod<[
+        data: BytesLike,
+        expectedGasCost: BigNumberish
+    ], [
+        string
+    ], "view">;
+    toHexNaive: TypedContractMethod<[
+        value: BigNumberish,
+        expectedGasCost: BigNumberish
+    ], [
+        string
+    ], "view">;
+    toHexNaiveBytes: TypedContractMethod<[
+        data: BytesLike,
+        expectedGasCost: BigNumberish
+    ], [
+        string
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "toHex"): TypedContractMethod<[
+        value: BigNumberish,
+        expectedGasCost: BigNumberish
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "toHexBytes"): TypedContractMethod<[
+        data: BytesLike,
+        expectedGasCost: BigNumberish
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "toHexNaive"): TypedContractMethod<[
+        value: BigNumberish,
+        expectedGasCost: BigNumberish
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "toHexNaiveBytes"): TypedContractMethod<[
+        data: BytesLike,
+        expectedGasCost: BigNumberish
+    ], [
+        string
+    ], "view">;
+    filters: {};
+}