@1inch/solidity-utils 6.8.0 → 6.8.1

package/dist/typechain-types/contracts/libraries/TransientLock.sol/TransientLockLib.js

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

package/dist/typechain-types/contracts/libraries/TransientLock.sol/TransientLockLib.js.map

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

package/dist/typechain-types/contracts/libraries/TransientLock.sol/index.d.ts

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

package/dist/typechain-types/contracts/libraries/TransientLock.sol/index.js

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

package/dist/typechain-types/contracts/libraries/TransientLock.sol/index.js.map

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

package/dist/typechain-types/contracts/libraries/index.d.ts

@@ -1,3 +1,7 @@
+import type * as transientSol from "./Transient.sol";
+export type { transientSol };
+import type * as transientLockSol from "./TransientLock.sol";
+export type { transientLockSol };
 export type { AddressArray } from "./AddressArray";
 export type { BySigTraits } from "./BySigTraits";
 export type { BytesMemory } from "./BytesMemory";

package/dist/typechain-types/contracts/mixins/Multicall.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 MulticallInterface extends Interface {
+    getFunction(nameOrSignature: "multicall"): FunctionFragment;
+    encodeFunctionData(functionFragment: "multicall", values: [BytesLike[]]): string;
+    decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
+}
+export interface Multicall extends BaseContract {
+    connect(runner?: ContractRunner | null): Multicall;
+    waitForDeployment(): Promise<this>;
+    interface: MulticallInterface;
+    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>;
+    multicall: TypedContractMethod<[data: BytesLike[]], [void], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "multicall"): TypedContractMethod<[data: BytesLike[]], [void], "nonpayable">;
+    filters: {};
+}

package/dist/typechain-types/contracts/mixins/Multicall.js

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

package/dist/typechain-types/contracts/mixins/Multicall.js.map

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

package/dist/typechain-types/contracts/mixins/ReentrancyGuard.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 ReentrancyGuardInterface extends Interface {
+}
+export interface ReentrancyGuard extends BaseContract {
+    connect(runner?: ContractRunner | null): ReentrancyGuard;
+    waitForDeployment(): Promise<this>;
+    interface: ReentrancyGuardInterface;
+    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: {};
+}

package/dist/typechain-types/contracts/mixins/ReentrancyGuard.js

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

package/dist/typechain-types/contracts/mixins/ReentrancyGuard.js.map

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

package/dist/typechain-types/contracts/mixins/Simulator.d.ts

@@ -0,0 +1,35 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
+export interface SimulatorInterface extends Interface {
+    getFunction(nameOrSignature: "simulate"): FunctionFragment;
+    encodeFunctionData(functionFragment: "simulate", values: [AddressLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "simulate", data: BytesLike): Result;
+}
+export interface Simulator extends BaseContract {
+    connect(runner?: ContractRunner | null): Simulator;
+    waitForDeployment(): Promise<this>;
+    interface: SimulatorInterface;
+    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>;
+    simulate: TypedContractMethod<[
+        delegatee: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "simulate"): TypedContractMethod<[
+        delegatee: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    filters: {};
+}

package/dist/typechain-types/contracts/mixins/Simulator.js

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

package/dist/typechain-types/contracts/mixins/Simulator.js.map

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

package/dist/typechain-types/contracts/mixins/index.d.ts

@@ -1,5 +1,8 @@
 export type { BySig } from "./BySig";
 export type { EthReceiver } from "./EthReceiver";
+export type { Multicall } from "./Multicall";
 export type { OnlyWethReceiver } from "./OnlyWethReceiver";
 export type { PermitAndCall } from "./PermitAndCall";
+export type { ReentrancyGuard } from "./ReentrancyGuard";
 export type { SelfdestructEthSender } from "./SelfdestructEthSender";
+export type { Simulator } from "./Simulator";

package/dist/typechain-types/contracts/tests/mocks/CalldataMock.d.ts

@@ -0,0 +1,81 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface CalldataMockInterface extends Interface {
+    getFunction(nameOrSignature: "sliceToEnd" | "sliceToEndChecked" | "sliceWithBounds" | "sliceWithBoundsChecked"): FunctionFragment;
+    encodeFunctionData(functionFragment: "sliceToEnd", values: [BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "sliceToEndChecked", values: [BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "sliceWithBounds", values: [BytesLike, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "sliceWithBoundsChecked", values: [BytesLike, BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "sliceToEnd", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sliceToEndChecked", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sliceWithBounds", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sliceWithBoundsChecked", data: BytesLike): Result;
+}
+export interface CalldataMock extends BaseContract {
+    connect(runner?: ContractRunner | null): CalldataMock;
+    waitForDeployment(): Promise<this>;
+    interface: CalldataMockInterface;
+    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>;
+    sliceToEnd: TypedContractMethod<[
+        data: BytesLike,
+        begin: BigNumberish
+    ], [
+        string
+    ], "view">;
+    sliceToEndChecked: TypedContractMethod<[
+        data: BytesLike,
+        begin: BigNumberish
+    ], [
+        string
+    ], "view">;
+    sliceWithBounds: TypedContractMethod<[
+        data: BytesLike,
+        begin: BigNumberish,
+        end: BigNumberish
+    ], [
+        string
+    ], "view">;
+    sliceWithBoundsChecked: TypedContractMethod<[
+        data: BytesLike,
+        begin: BigNumberish,
+        end: BigNumberish
+    ], [
+        string
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "sliceToEnd"): TypedContractMethod<[
+        data: BytesLike,
+        begin: BigNumberish
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "sliceToEndChecked"): TypedContractMethod<[
+        data: BytesLike,
+        begin: BigNumberish
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "sliceWithBounds"): TypedContractMethod<[
+        data: BytesLike,
+        begin: BigNumberish,
+        end: BigNumberish
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "sliceWithBoundsChecked"): TypedContractMethod<[
+        data: BytesLike,
+        begin: BigNumberish,
+        end: BigNumberish
+    ], [
+        string
+    ], "view">;
+    filters: {};
+}

package/dist/typechain-types/contracts/tests/mocks/CalldataMock.js

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

package/dist/typechain-types/contracts/tests/mocks/CalldataMock.js.map

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

package/dist/typechain-types/contracts/tests/mocks/CalldataPtrMock.d.ts

@@ -0,0 +1,51 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface CalldataPtrMockInterface extends Interface {
+    getFunction(nameOrSignature: "from" | "getOffsetAndLength" | "roundTrip" | "toBytes"): FunctionFragment;
+    encodeFunctionData(functionFragment: "from", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "getOffsetAndLength", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "roundTrip", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "toBytes", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "from", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getOffsetAndLength", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "roundTrip", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "toBytes", data: BytesLike): Result;
+}
+export interface CalldataPtrMock extends BaseContract {
+    connect(runner?: ContractRunner | null): CalldataPtrMock;
+    waitForDeployment(): Promise<this>;
+    interface: CalldataPtrMockInterface;
+    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>;
+    from: TypedContractMethod<[data: BytesLike], [bigint], "view">;
+    getOffsetAndLength: TypedContractMethod<[
+        data: BytesLike
+    ], [
+        [bigint, bigint] & {
+            offset: bigint;
+            length: bigint;
+        }
+    ], "view">;
+    roundTrip: TypedContractMethod<[data: BytesLike], [string], "view">;
+    toBytes: TypedContractMethod<[ptr: BigNumberish], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "from"): TypedContractMethod<[data: BytesLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getOffsetAndLength"): TypedContractMethod<[
+        data: BytesLike
+    ], [
+        [bigint, bigint] & {
+            offset: bigint;
+            length: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "roundTrip"): TypedContractMethod<[data: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "toBytes"): TypedContractMethod<[ptr: BigNumberish], [string], "view">;
+    filters: {};
+}

package/dist/typechain-types/contracts/tests/mocks/CalldataPtrMock.js

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

package/dist/typechain-types/contracts/tests/mocks/CalldataPtrMock.js.map

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

package/dist/typechain-types/contracts/tests/mocks/MulticallMock.d.ts

@@ -0,0 +1,53 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface MulticallMockInterface extends Interface {
+    getFunction(nameOrSignature: "getValue" | "increment" | "lastSender" | "multicall" | "revertEmpty" | "revertWithMessage" | "setValue" | "value"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getValue", values?: undefined): string;
+    encodeFunctionData(functionFragment: "increment", values?: undefined): string;
+    encodeFunctionData(functionFragment: "lastSender", values?: undefined): string;
+    encodeFunctionData(functionFragment: "multicall", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "revertEmpty", values?: undefined): string;
+    encodeFunctionData(functionFragment: "revertWithMessage", values: [string]): string;
+    encodeFunctionData(functionFragment: "setValue", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "value", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "getValue", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increment", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lastSender", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "revertEmpty", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "revertWithMessage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setValue", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "value", data: BytesLike): Result;
+}
+export interface MulticallMock extends BaseContract {
+    connect(runner?: ContractRunner | null): MulticallMock;
+    waitForDeployment(): Promise<this>;
+    interface: MulticallMockInterface;
+    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>;
+    getValue: TypedContractMethod<[], [bigint], "view">;
+    increment: TypedContractMethod<[], [void], "nonpayable">;
+    lastSender: TypedContractMethod<[], [string], "view">;
+    multicall: TypedContractMethod<[data: BytesLike[]], [void], "nonpayable">;
+    revertEmpty: TypedContractMethod<[], [void], "view">;
+    revertWithMessage: TypedContractMethod<[message: string], [void], "view">;
+    setValue: TypedContractMethod<[_value: BigNumberish], [void], "nonpayable">;
+    value: TypedContractMethod<[], [bigint], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "getValue"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "increment"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "lastSender"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "multicall"): TypedContractMethod<[data: BytesLike[]], [void], "nonpayable">;
+    getFunction(nameOrSignature: "revertEmpty"): TypedContractMethod<[], [void], "view">;
+    getFunction(nameOrSignature: "revertWithMessage"): TypedContractMethod<[message: string], [void], "view">;
+    getFunction(nameOrSignature: "setValue"): TypedContractMethod<[_value: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "value"): TypedContractMethod<[], [bigint], "view">;
+    filters: {};
+}

package/dist/typechain-types/contracts/tests/mocks/MulticallMock.js

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

package/dist/typechain-types/contracts/tests/mocks/MulticallMock.js.map

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

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/IReentrancyAttacker.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 IReentrancyAttackerInterface extends Interface {
+    getFunction(nameOrSignature: "attack" | "attackCustomLock"): FunctionFragment;
+    encodeFunctionData(functionFragment: "attack", values?: undefined): string;
+    encodeFunctionData(functionFragment: "attackCustomLock", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "attack", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "attackCustomLock", data: BytesLike): Result;
+}
+export interface IReentrancyAttacker extends BaseContract {
+    connect(runner?: ContractRunner | null): IReentrancyAttacker;
+    waitForDeployment(): Promise<this>;
+    interface: IReentrancyAttackerInterface;
+    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>;
+    attack: TypedContractMethod<[], [void], "nonpayable">;
+    attackCustomLock: TypedContractMethod<[], [void], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "attack"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "attackCustomLock"): TypedContractMethod<[], [void], "nonpayable">;
+    filters: {};
+}

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/IReentrancyAttacker.js

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

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/IReentrancyAttacker.js.map

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

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/ReentrancyAttacker.d.ts

@@ -0,0 +1,41 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface ReentrancyAttackerInterface extends Interface {
+    getFunction(nameOrSignature: "attack" | "attackCustomLock" | "attacked" | "attackedCustomLock" | "guardTarget"): FunctionFragment;
+    encodeFunctionData(functionFragment: "attack", values?: undefined): string;
+    encodeFunctionData(functionFragment: "attackCustomLock", values?: undefined): string;
+    encodeFunctionData(functionFragment: "attacked", values?: undefined): string;
+    encodeFunctionData(functionFragment: "attackedCustomLock", values?: undefined): string;
+    encodeFunctionData(functionFragment: "guardTarget", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "attack", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "attackCustomLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "attacked", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "attackedCustomLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "guardTarget", data: BytesLike): Result;
+}
+export interface ReentrancyAttacker extends BaseContract {
+    connect(runner?: ContractRunner | null): ReentrancyAttacker;
+    waitForDeployment(): Promise<this>;
+    interface: ReentrancyAttackerInterface;
+    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>;
+    attack: TypedContractMethod<[], [void], "nonpayable">;
+    attackCustomLock: TypedContractMethod<[], [void], "nonpayable">;
+    attacked: TypedContractMethod<[], [boolean], "view">;
+    attackedCustomLock: TypedContractMethod<[], [boolean], "view">;
+    guardTarget: TypedContractMethod<[], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "attack"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "attackCustomLock"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "attacked"): TypedContractMethod<[], [boolean], "view">;
+    getFunction(nameOrSignature: "attackedCustomLock"): TypedContractMethod<[], [boolean], "view">;
+    getFunction(nameOrSignature: "guardTarget"): TypedContractMethod<[], [string], "view">;
+    filters: {};
+}

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/ReentrancyAttacker.js

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

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/ReentrancyAttacker.js.map

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

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/ReentrancyGuardMock.d.ts

@@ -0,0 +1,96 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface ReentrancyGuardMockInterface extends Interface {
+    getFunction(nameOrSignature: "callOnlyInProtectedContext" | "callOnlyInProtectedContextCustomLock" | "callOnlyInProtectedContextCustomLockWithoutGuard" | "callOnlyInProtectedContextWithoutGuard" | "checkInNonReentrantCall" | "counter" | "inNonReentrantCall" | "onlyInProtectedContext" | "onlyInProtectedContextCustomLock" | "protectedIncrement" | "protectedIncrementAndCall" | "protectedIncrementWithCustomLock" | "protectedIncrementWithCustomLockAndCall"): FunctionFragment;
+    encodeFunctionData(functionFragment: "callOnlyInProtectedContext", values?: undefined): string;
+    encodeFunctionData(functionFragment: "callOnlyInProtectedContextCustomLock", values?: undefined): string;
+    encodeFunctionData(functionFragment: "callOnlyInProtectedContextCustomLockWithoutGuard", values?: undefined): string;
+    encodeFunctionData(functionFragment: "callOnlyInProtectedContextWithoutGuard", values?: undefined): string;
+    encodeFunctionData(functionFragment: "checkInNonReentrantCall", values?: undefined): string;
+    encodeFunctionData(functionFragment: "counter", values?: undefined): string;
+    encodeFunctionData(functionFragment: "inNonReentrantCall", values?: undefined): string;
+    encodeFunctionData(functionFragment: "onlyInProtectedContext", values?: undefined): string;
+    encodeFunctionData(functionFragment: "onlyInProtectedContextCustomLock", values?: undefined): string;
+    encodeFunctionData(functionFragment: "protectedIncrement", values?: undefined): string;
+    encodeFunctionData(functionFragment: "protectedIncrementAndCall", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "protectedIncrementWithCustomLock", values?: undefined): string;
+    encodeFunctionData(functionFragment: "protectedIncrementWithCustomLockAndCall", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "callOnlyInProtectedContext", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "callOnlyInProtectedContextCustomLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "callOnlyInProtectedContextCustomLockWithoutGuard", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "callOnlyInProtectedContextWithoutGuard", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "checkInNonReentrantCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "counter", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "inNonReentrantCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "onlyInProtectedContext", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "onlyInProtectedContextCustomLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "protectedIncrement", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "protectedIncrementAndCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "protectedIncrementWithCustomLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "protectedIncrementWithCustomLockAndCall", data: BytesLike): Result;
+}
+export interface ReentrancyGuardMock extends BaseContract {
+    connect(runner?: ContractRunner | null): ReentrancyGuardMock;
+    waitForDeployment(): Promise<this>;
+    interface: ReentrancyGuardMockInterface;
+    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>;
+    callOnlyInProtectedContext: TypedContractMethod<[], [void], "nonpayable">;
+    callOnlyInProtectedContextCustomLock: TypedContractMethod<[
+    ], [
+        void
+    ], "nonpayable">;
+    callOnlyInProtectedContextCustomLockWithoutGuard: TypedContractMethod<[
+    ], [
+        void
+    ], "nonpayable">;
+    callOnlyInProtectedContextWithoutGuard: TypedContractMethod<[
+    ], [
+        void
+    ], "nonpayable">;
+    checkInNonReentrantCall: TypedContractMethod<[], [boolean], "nonpayable">;
+    counter: TypedContractMethod<[], [bigint], "view">;
+    inNonReentrantCall: TypedContractMethod<[], [boolean], "view">;
+    onlyInProtectedContext: TypedContractMethod<[], [void], "nonpayable">;
+    onlyInProtectedContextCustomLock: TypedContractMethod<[
+    ], [
+        void
+    ], "nonpayable">;
+    protectedIncrement: TypedContractMethod<[], [void], "nonpayable">;
+    protectedIncrementAndCall: TypedContractMethod<[
+        target: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    protectedIncrementWithCustomLock: TypedContractMethod<[
+    ], [
+        void
+    ], "nonpayable">;
+    protectedIncrementWithCustomLockAndCall: TypedContractMethod<[
+        target: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "callOnlyInProtectedContext"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "callOnlyInProtectedContextCustomLock"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "callOnlyInProtectedContextCustomLockWithoutGuard"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "callOnlyInProtectedContextWithoutGuard"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "checkInNonReentrantCall"): TypedContractMethod<[], [boolean], "nonpayable">;
+    getFunction(nameOrSignature: "counter"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "inNonReentrantCall"): TypedContractMethod<[], [boolean], "view">;
+    getFunction(nameOrSignature: "onlyInProtectedContext"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "onlyInProtectedContextCustomLock"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "protectedIncrement"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "protectedIncrementAndCall"): TypedContractMethod<[target: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "protectedIncrementWithCustomLock"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "protectedIncrementWithCustomLockAndCall"): TypedContractMethod<[target: AddressLike], [void], "nonpayable">;
+    filters: {};
+}

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/ReentrancyGuardMock.js

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

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/ReentrancyGuardMock.js.map

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

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/index.d.ts

@@ -0,0 +1,3 @@
+export type { IReentrancyAttacker } from "./IReentrancyAttacker";
+export type { ReentrancyAttacker } from "./ReentrancyAttacker";
+export type { ReentrancyGuardMock } from "./ReentrancyGuardMock";

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/index.js

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

package/dist/typechain-types/contracts/tests/mocks/ReentrancyGuardMock.sol/index.js.map

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