@1inch/solidity-utils 6.7.1 → 6.8.1

package/dist/typechain-types/contracts/libraries/Transient.sol/TransientLib.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 TransientLibInterface extends Interface {
+}
+export interface TransientLib extends BaseContract {
+    connect(runner?: ContractRunner | null): TransientLib;
+    waitForDeployment(): Promise<this>;
+    interface: TransientLibInterface;
+    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/libraries/Transient.sol/TransientLib.js

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

package/dist/typechain-types/contracts/libraries/Transient.sol/TransientLib.js.map

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

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

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

package/dist/typechain-types/contracts/libraries/Transient.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/Transient.sol/index.js.map

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

package/dist/typechain-types/contracts/libraries/TransientLock.sol/TransientLockLib.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 TransientLockLibInterface extends Interface {
+}
+export interface TransientLockLib extends BaseContract {
+    connect(runner?: ContractRunner | null): TransientLockLib;
+    waitForDeployment(): Promise<this>;
+    interface: TransientLockLibInterface;
+    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/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":""}