@1inch/solidity-utils 2.1.1 → 2.1.2

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,213 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
+export interface ECDSATestInterface extends utils.Interface {
+    functions: {
+        "isValidSignature(address,bytes32,bytes)": FunctionFragment;
+        "isValidSignature65(address,bytes32,bytes32,bytes32)": FunctionFragment;
+        "isValidSignature_r_vs(address,bytes32,bytes32,bytes32)": FunctionFragment;
+        "isValidSignature_v_r_s(address,bytes32,uint8,bytes32,bytes32)": FunctionFragment;
+        "recover(bytes32,bytes)": FunctionFragment;
+        "recoverOrIsValidSignature(address,bytes32,bytes)": FunctionFragment;
+        "recoverOrIsValidSignature65(address,bytes32,bytes32,bytes32)": FunctionFragment;
+        "recoverOrIsValidSignature_r_vs(address,bytes32,bytes32,bytes32)": FunctionFragment;
+        "recoverOrIsValidSignature_v_r_s(address,bytes32,uint8,bytes32,bytes32)": FunctionFragment;
+        "recover_r_vs(bytes32,bytes32,bytes32)": FunctionFragment;
+        "recover_v_r_s(bytes32,uint8,bytes32,bytes32)": FunctionFragment;
+        "toEthSignedMessageHash(bytes32)": FunctionFragment;
+        "toTypedDataHash(bytes32,bytes32)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "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: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "isValidSignature65", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "isValidSignature_r_vs", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "isValidSignature_v_r_s", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "recover", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "recoverOrIsValidSignature", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "recoverOrIsValidSignature65", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "recoverOrIsValidSignature_r_vs", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "recoverOrIsValidSignature_v_r_s", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "recover_r_vs", values: [
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "recover_v_r_s", values: [
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "toEthSignedMessageHash", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "toTypedDataHash", values: [PromiseOrValue<BytesLike>, PromiseOrValue<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;
+    events: {};
+}
+export interface ECDSATest extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: ECDSATestInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        isValidSignature(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean] & {
+            success: boolean;
+        }>;
+        isValidSignature65(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean] & {
+            success: boolean;
+        }>;
+        isValidSignature_r_vs(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean] & {
+            success: boolean;
+        }>;
+        isValidSignature_v_r_s(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean] & {
+            success: boolean;
+        }>;
+        recover(hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string] & {
+            signer: string;
+        }>;
+        recoverOrIsValidSignature(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean] & {
+            success: boolean;
+        }>;
+        recoverOrIsValidSignature65(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean] & {
+            success: boolean;
+        }>;
+        recoverOrIsValidSignature_r_vs(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean] & {
+            success: boolean;
+        }>;
+        recoverOrIsValidSignature_v_r_s(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean] & {
+            success: boolean;
+        }>;
+        recover_r_vs(hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string] & {
+            signer: string;
+        }>;
+        recover_v_r_s(hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string] & {
+            signer: string;
+        }>;
+        toEthSignedMessageHash(hash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string] & {
+            res: string;
+        }>;
+        toTypedDataHash(domainSeparator: PromiseOrValue<BytesLike>, structHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string] & {
+            res: string;
+        }>;
+    };
+    isValidSignature(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    isValidSignature65(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    isValidSignature_r_vs(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    isValidSignature_v_r_s(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    recover(hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    recoverOrIsValidSignature(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    recoverOrIsValidSignature65(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    recoverOrIsValidSignature_r_vs(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    recoverOrIsValidSignature_v_r_s(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    recover_r_vs(hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    recover_v_r_s(hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    toEthSignedMessageHash(hash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    toTypedDataHash(domainSeparator: PromiseOrValue<BytesLike>, structHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        isValidSignature(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        isValidSignature65(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        isValidSignature_r_vs(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        isValidSignature_v_r_s(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        recover(hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+        recoverOrIsValidSignature(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        recoverOrIsValidSignature65(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        recoverOrIsValidSignature_r_vs(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        recoverOrIsValidSignature_v_r_s(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        recover_r_vs(hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+        recover_v_r_s(hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+        toEthSignedMessageHash(hash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+        toTypedDataHash(domainSeparator: PromiseOrValue<BytesLike>, structHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {};
+    estimateGas: {
+        isValidSignature(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        isValidSignature65(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        isValidSignature_r_vs(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        isValidSignature_v_r_s(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        recover(hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        recoverOrIsValidSignature(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        recoverOrIsValidSignature65(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        recoverOrIsValidSignature_r_vs(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        recoverOrIsValidSignature_v_r_s(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        recover_r_vs(hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        recover_v_r_s(hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        toEthSignedMessageHash(hash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        toTypedDataHash(domainSeparator: PromiseOrValue<BytesLike>, structHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        isValidSignature(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isValidSignature65(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isValidSignature_r_vs(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isValidSignature_v_r_s(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recover(hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recoverOrIsValidSignature(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recoverOrIsValidSignature65(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recoverOrIsValidSignature_r_vs(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recoverOrIsValidSignature_v_r_s(signer: PromiseOrValue<string>, hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recover_r_vs(hash: PromiseOrValue<BytesLike>, r: PromiseOrValue<BytesLike>, vs: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recover_v_r_s(hash: PromiseOrValue<BytesLike>, v: PromiseOrValue<BigNumberish>, r: PromiseOrValue<BytesLike>, s: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        toEthSignedMessageHash(hash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        toTypedDataHash(domainSeparator: PromiseOrValue<BytesLike>, structHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

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,138 @@
+import type { BaseContract, BigNumber, BytesLike, CallOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../../common";
+export interface RevertReasonParserTestInterface extends utils.Interface {
+    functions: {
+        "assertion()": FunctionFragment;
+        "emptyRevert()": FunctionFragment;
+        "emptyStringRevert()": FunctionFragment;
+        "longStringRevert()": FunctionFragment;
+        "nonEmptyRevert()": FunctionFragment;
+        "testAssertion()": FunctionFragment;
+        "testEmptyRevert()": FunctionFragment;
+        "testEmptyStringRevert()": FunctionFragment;
+        "testLongStringRevert()": FunctionFragment;
+        "testNonEmptyRevert()": FunctionFragment;
+        "testParseWithThrow()": FunctionFragment;
+        "testWithThrow()": FunctionFragment;
+        "withoutAssertion()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "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;
+    events: {};
+}
+export interface RevertReasonParserTest extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: RevertReasonParserTestInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        assertion(overrides?: CallOverrides): Promise<[void]>;
+        emptyRevert(overrides?: CallOverrides): Promise<[void]>;
+        emptyStringRevert(overrides?: CallOverrides): Promise<[void]>;
+        longStringRevert(overrides?: CallOverrides): Promise<[void]>;
+        nonEmptyRevert(overrides?: CallOverrides): Promise<[void]>;
+        testAssertion(overrides?: CallOverrides): Promise<[void]>;
+        testEmptyRevert(overrides?: CallOverrides): Promise<[void]>;
+        testEmptyStringRevert(overrides?: CallOverrides): Promise<[void]>;
+        testLongStringRevert(overrides?: CallOverrides): Promise<[void]>;
+        testNonEmptyRevert(overrides?: CallOverrides): Promise<[void]>;
+        testParseWithThrow(overrides?: CallOverrides): Promise<[void]>;
+        testWithThrow(overrides?: CallOverrides): Promise<[void]>;
+        withoutAssertion(overrides?: CallOverrides): Promise<[void]>;
+    };
+    assertion(overrides?: CallOverrides): Promise<void>;
+    emptyRevert(overrides?: CallOverrides): Promise<void>;
+    emptyStringRevert(overrides?: CallOverrides): Promise<void>;
+    longStringRevert(overrides?: CallOverrides): Promise<void>;
+    nonEmptyRevert(overrides?: CallOverrides): Promise<void>;
+    testAssertion(overrides?: CallOverrides): Promise<void>;
+    testEmptyRevert(overrides?: CallOverrides): Promise<void>;
+    testEmptyStringRevert(overrides?: CallOverrides): Promise<void>;
+    testLongStringRevert(overrides?: CallOverrides): Promise<void>;
+    testNonEmptyRevert(overrides?: CallOverrides): Promise<void>;
+    testParseWithThrow(overrides?: CallOverrides): Promise<void>;
+    testWithThrow(overrides?: CallOverrides): Promise<void>;
+    withoutAssertion(overrides?: CallOverrides): Promise<void>;
+    callStatic: {
+        assertion(overrides?: CallOverrides): Promise<void>;
+        emptyRevert(overrides?: CallOverrides): Promise<void>;
+        emptyStringRevert(overrides?: CallOverrides): Promise<void>;
+        longStringRevert(overrides?: CallOverrides): Promise<void>;
+        nonEmptyRevert(overrides?: CallOverrides): Promise<void>;
+        testAssertion(overrides?: CallOverrides): Promise<void>;
+        testEmptyRevert(overrides?: CallOverrides): Promise<void>;
+        testEmptyStringRevert(overrides?: CallOverrides): Promise<void>;
+        testLongStringRevert(overrides?: CallOverrides): Promise<void>;
+        testNonEmptyRevert(overrides?: CallOverrides): Promise<void>;
+        testParseWithThrow(overrides?: CallOverrides): Promise<void>;
+        testWithThrow(overrides?: CallOverrides): Promise<void>;
+        withoutAssertion(overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        assertion(overrides?: CallOverrides): Promise<BigNumber>;
+        emptyRevert(overrides?: CallOverrides): Promise<BigNumber>;
+        emptyStringRevert(overrides?: CallOverrides): Promise<BigNumber>;
+        longStringRevert(overrides?: CallOverrides): Promise<BigNumber>;
+        nonEmptyRevert(overrides?: CallOverrides): Promise<BigNumber>;
+        testAssertion(overrides?: CallOverrides): Promise<BigNumber>;
+        testEmptyRevert(overrides?: CallOverrides): Promise<BigNumber>;
+        testEmptyStringRevert(overrides?: CallOverrides): Promise<BigNumber>;
+        testLongStringRevert(overrides?: CallOverrides): Promise<BigNumber>;
+        testNonEmptyRevert(overrides?: CallOverrides): Promise<BigNumber>;
+        testParseWithThrow(overrides?: CallOverrides): Promise<BigNumber>;
+        testWithThrow(overrides?: CallOverrides): Promise<BigNumber>;
+        withoutAssertion(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        assertion(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        emptyRevert(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        emptyStringRevert(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        longStringRevert(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        nonEmptyRevert(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        testAssertion(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        testEmptyRevert(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        testEmptyStringRevert(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        testLongStringRevert(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        testNonEmptyRevert(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        testParseWithThrow(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        testWithThrow(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        withoutAssertion(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

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,66 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
+export interface StringUtilTestInterface extends utils.Interface {
+    functions: {
+        "toHex(uint256,uint256)": FunctionFragment;
+        "toHexBytes(bytes,uint256)": FunctionFragment;
+        "toHexNaive(uint256,uint256)": FunctionFragment;
+        "toHexNaiveBytes(bytes,uint256)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "toHex" | "toHexBytes" | "toHexNaive" | "toHexNaiveBytes"): FunctionFragment;
+    encodeFunctionData(functionFragment: "toHex", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "toHexBytes", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "toHexNaive", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "toHexNaiveBytes", values: [PromiseOrValue<BytesLike>, PromiseOrValue<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;
+    events: {};
+}
+export interface StringUtilTest extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: StringUtilTestInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        toHex(value: PromiseOrValue<BigNumberish>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        toHexBytes(data: PromiseOrValue<BytesLike>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        toHexNaive(value: PromiseOrValue<BigNumberish>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        toHexNaiveBytes(data: PromiseOrValue<BytesLike>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+    };
+    toHex(value: PromiseOrValue<BigNumberish>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    toHexBytes(data: PromiseOrValue<BytesLike>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    toHexNaive(value: PromiseOrValue<BigNumberish>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    toHexNaiveBytes(data: PromiseOrValue<BytesLike>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        toHex(value: PromiseOrValue<BigNumberish>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        toHexBytes(data: PromiseOrValue<BytesLike>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        toHexNaive(value: PromiseOrValue<BigNumberish>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        toHexNaiveBytes(data: PromiseOrValue<BytesLike>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {};
+    estimateGas: {
+        toHex(value: PromiseOrValue<BigNumberish>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        toHexBytes(data: PromiseOrValue<BytesLike>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        toHexNaive(value: PromiseOrValue<BigNumberish>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        toHexNaiveBytes(data: PromiseOrValue<BytesLike>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        toHex(value: PromiseOrValue<BigNumberish>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        toHexBytes(data: PromiseOrValue<BytesLike>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        toHexNaive(value: PromiseOrValue<BigNumberish>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        toHexNaiveBytes(data: PromiseOrValue<BytesLike>, expectedGasCost: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type * as mocks from "./mocks";
+export type { mocks };
+export type { ECDSATest } from "./ECDSATest";
+export type { RevertReasonParserTest } from "./RevertReasonParserTest";
+export type { StringUtilTest } from "./StringUtilTest";

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

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

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

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

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

@@ -0,0 +1,108 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../../common";
+export interface AddressArrayMockInterface extends utils.Interface {
+    functions: {
+        "at(uint256)": FunctionFragment;
+        "get()": FunctionFragment;
+        "length()": FunctionFragment;
+        "pop()": FunctionFragment;
+        "push(address)": FunctionFragment;
+        "set(uint256,address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "at" | "get" | "length" | "pop" | "push" | "set"): FunctionFragment;
+    encodeFunctionData(functionFragment: "at", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "get", values?: undefined): string;
+    encodeFunctionData(functionFragment: "length", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pop", values?: undefined): string;
+    encodeFunctionData(functionFragment: "push", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "set", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
+    decodeFunctionResult(functionFragment: "at", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "get", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "length", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pop", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "push", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "set", data: BytesLike): Result;
+    events: {};
+}
+export interface AddressArrayMock extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: AddressArrayMockInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        at(i: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        get(overrides?: CallOverrides): Promise<[string[]] & {
+            arr: string[];
+        }>;
+        length(overrides?: CallOverrides): Promise<[BigNumber]>;
+        pop(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        push(account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        set(index: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    at(i: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    get(overrides?: CallOverrides): Promise<string[]>;
+    length(overrides?: CallOverrides): Promise<BigNumber>;
+    pop(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    push(account: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    set(index: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        at(i: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        get(overrides?: CallOverrides): Promise<string[]>;
+        length(overrides?: CallOverrides): Promise<BigNumber>;
+        pop(overrides?: CallOverrides): Promise<void>;
+        push(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        set(index: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        at(i: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        get(overrides?: CallOverrides): Promise<BigNumber>;
+        length(overrides?: CallOverrides): Promise<BigNumber>;
+        pop(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        push(account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        set(index: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        at(i: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        get(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        length(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pop(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        push(account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        set(index: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/src/typechain-types/contracts/tests/mocks/AddressArrayMock.js

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

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

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