@1inch/solidity-utils 2.1.0 → 2.1.2

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":""}

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

@@ -0,0 +1,90 @@
+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 AddressSetMockInterface extends utils.Interface {
+    functions: {
+        "add(address)": FunctionFragment;
+        "at(uint256)": FunctionFragment;
+        "contains(address)": FunctionFragment;
+        "length()": FunctionFragment;
+        "remove(address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "add" | "at" | "contains" | "length" | "remove"): FunctionFragment;
+    encodeFunctionData(functionFragment: "add", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "at", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "contains", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "length", values?: undefined): string;
+    encodeFunctionData(functionFragment: "remove", values: [PromiseOrValue<string>]): string;
+    decodeFunctionResult(functionFragment: "add", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "at", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "contains", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "length", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "remove", data: BytesLike): Result;
+    events: {};
+}
+export interface AddressSetMock extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: AddressSetMockInterface;
+    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: {
+        add(item: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        at(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        contains(item: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        length(overrides?: CallOverrides): Promise<[BigNumber]>;
+        remove(item: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    add(item: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    at(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    contains(item: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    length(overrides?: CallOverrides): Promise<BigNumber>;
+    remove(item: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        add(item: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        at(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        contains(item: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        length(overrides?: CallOverrides): Promise<BigNumber>;
+        remove(item: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    };
+    filters: {};
+    estimateGas: {
+        add(item: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        at(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        contains(item: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        length(overrides?: CallOverrides): Promise<BigNumber>;
+        remove(item: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        add(item: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        at(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        contains(item: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        length(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        remove(item: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

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

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

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

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