@onepercentio/one-ui 0.6.2 → 0.6.3

package/dist/hooks/usePooling.js

@@ -1,47 +1,47 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("react");
-function usePooling(intervalMs = 1000, maxPoolingTime = 60000) {
-    const [intervalId, setIntervalId] = (0, react_1.useState)();
-    const [failed, setFailed] = (0, react_1.useState)(false);
-    (0, react_1.useEffect)(() => () => {
-        if (intervalId)
-            clearInterval(intervalId);
-    }, [intervalId]);
-    return {
-        failed,
-        setFailed,
-        isPooling: !!intervalId,
-        /**
-         *
-         * @param cb {@link PoolingAction} - Executes and returns if has finished (true) or not (false)
-         */
-        startPolling: (cb) => {
-            const maxPoolings = Math.ceil(maxPoolingTime / intervalMs);
-            let poolingCount = 0;
-            const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                poolingCount++;
-                const finished = yield cb();
-                if (finished)
-                    setIntervalId(undefined);
-                else if (poolingCount === maxPoolings) {
-                    setIntervalId(undefined);
-                    setFailed(true);
-                }
-            }), intervalMs);
-            setIntervalId(intervalId);
-            setFailed(false);
-        },
-    };
-}
-exports.default = usePooling;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+function usePooling(intervalMs = 1000, maxPoolingTime = 60000) {
+    const [intervalId, setIntervalId] = (0, react_1.useState)();
+    const [failed, setFailed] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => () => {
+        if (intervalId)
+            clearInterval(intervalId);
+    }, [intervalId]);
+    return {
+        failed,
+        setFailed,
+        isPooling: !!intervalId,
+        /**
+         *
+         * @param cb {@link PoolingAction} - Executes and returns if has finished (true) or not (false)
+         */
+        startPolling: (cb) => {
+            const maxPoolings = Math.ceil(maxPoolingTime / intervalMs);
+            let poolingCount = 0;
+            const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                poolingCount++;
+                const finished = yield cb();
+                if (finished)
+                    setIntervalId(undefined);
+                else if (poolingCount === maxPoolings) {
+                    setIntervalId(undefined);
+                    setFailed(true);
+                }
+            }), intervalMs);
+            setIntervalId(intervalId);
+            setFailed(false);
+        },
+    };
+}
+exports.default = usePooling;
 //# sourceMappingURL=usePooling.js.map

package/dist/hooks/usePooling.test.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/hooks/usePooling.test.js

@@ -1,104 +1,104 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_hooks_1 = require("@testing-library/react-hooks");
-const test_utils_1 = require("react-dom/test-utils");
-const usePooling_1 = __importDefault(require("./usePooling"));
-const mockCb = () => Promise.resolve(true);
-beforeEach(() => {
-    jest.useFakeTimers();
-});
-afterEach(() => {
-    jest.useRealTimers();
-    jest.clearAllTimers();
-});
-function actAndSync(cb) {
-    (0, test_utils_1.act)(() => {
-        cb();
-        // This is to advance the timer for the setState
-        jest.advanceTimersByTime(100);
-    });
-}
-const renderHookAndSync = (cb) => {
-    const result = (0, react_hooks_1.renderHook)(cb);
-    jest.advanceTimersByTime(100);
-    return result;
-};
-it("Should mount", () => {
-    renderHookAndSync(() => (0, usePooling_1.default)());
-});
-it("Should be able to create an interval", () => {
-    expect(jest.getTimerCount()).toBe(0);
-    const { result: { current: { startPolling }, }, } = renderHookAndSync(() => (0, usePooling_1.default)());
-    actAndSync(() => startPolling(mockCb));
-    expect(jest.getTimerCount()).toBe(1);
-    /** Should clear the old interval */
-    actAndSync(() => startPolling(mockCb));
-    expect(jest.getTimerCount()).toBe(1);
-});
-it("Should indicate when the interval shall end", () => __awaiter(void 0, void 0, void 0, function* () {
-    let num = 0;
-    const cb = () => __awaiter(void 0, void 0, void 0, function* () {
-        num++;
-        return num === 3;
-    });
-    const { result, rerender } = renderHookAndSync(() => (0, usePooling_1.default)());
-    const { startPolling } = result.current;
-    expect(jest.getTimerCount()).toBe(0);
-    expect(result.current.isPooling).toBeFalsy();
-    actAndSync(() => startPolling(cb));
-    expect(jest.getTimerCount()).toBe(1);
-    expect(result.current.isPooling).toBeTruthy();
-    // First execution
-    (0, test_utils_1.act)(() => {
-        jest.advanceTimersByTime(1000);
-    });
-    expect(jest.getTimerCount()).toBe(1);
-    expect(result.current.isPooling).toBeTruthy();
-    //Second execution
-    (0, test_utils_1.act)(() => {
-        jest.advanceTimersByTime(1000);
-    });
-    expect(jest.getTimerCount()).toBe(1);
-    expect(result.current.isPooling).toBeTruthy();
-    //Last execution
-    (0, test_utils_1.act)(() => {
-        jest.advanceTimersByTime(1000);
-    });
-    //   expect(jest.getTimerCount()).toBe(0);
-    //   expect(result.current.isPooling).toBeFalsy();
-}));
-it.each([
-    [1000, 5000, 5],
-    [500, 10000, 20],
-    [1000, 2578, 3],
-])("Should end the pooling with error when the pooling of interval %s with max of %s exceeds max executions of %s", (poolingInterval, maxTime, expectedExecutionsCount) => {
-    const { result } = renderHookAndSync(() => (0, usePooling_1.default)(poolingInterval, maxTime));
-    const { startPolling } = result.current;
-    actAndSync(() => startPolling(() => __awaiter(void 0, void 0, void 0, function* () { return false; })));
-    for (let i = 1; i < expectedExecutionsCount; i++) {
-        (0, test_utils_1.act)(() => {
-            jest.advanceTimersByTime(poolingInterval);
-        });
-        if (i === expectedExecutionsCount) {
-            expect(result.current.isPooling).toBeFalsy();
-            expect(result.current.failed).toBeTruthy();
-        }
-        else {
-            expect(result.current.isPooling).toBeTruthy();
-            expect(result.current.failed).toBeFalsy();
-        }
-    }
-});
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_hooks_1 = require("@testing-library/react-hooks");
+const test_utils_1 = require("react-dom/test-utils");
+const usePooling_1 = __importDefault(require("./usePooling"));
+const mockCb = () => Promise.resolve(true);
+beforeEach(() => {
+    jest.useFakeTimers();
+});
+afterEach(() => {
+    jest.useRealTimers();
+    jest.clearAllTimers();
+});
+function actAndSync(cb) {
+    (0, test_utils_1.act)(() => {
+        cb();
+        // This is to advance the timer for the setState
+        jest.advanceTimersByTime(100);
+    });
+}
+const renderHookAndSync = (cb) => {
+    const result = (0, react_hooks_1.renderHook)(cb);
+    jest.advanceTimersByTime(100);
+    return result;
+};
+it("Should mount", () => {
+    renderHookAndSync(() => (0, usePooling_1.default)());
+});
+it("Should be able to create an interval", () => {
+    expect(jest.getTimerCount()).toBe(0);
+    const { result: { current: { startPolling }, }, } = renderHookAndSync(() => (0, usePooling_1.default)());
+    actAndSync(() => startPolling(mockCb));
+    expect(jest.getTimerCount()).toBe(1);
+    /** Should clear the old interval */
+    actAndSync(() => startPolling(mockCb));
+    expect(jest.getTimerCount()).toBe(1);
+});
+it("Should indicate when the interval shall end", () => __awaiter(void 0, void 0, void 0, function* () {
+    let num = 0;
+    const cb = () => __awaiter(void 0, void 0, void 0, function* () {
+        num++;
+        return num === 3;
+    });
+    const { result, rerender } = renderHookAndSync(() => (0, usePooling_1.default)());
+    const { startPolling } = result.current;
+    expect(jest.getTimerCount()).toBe(0);
+    expect(result.current.isPooling).toBeFalsy();
+    actAndSync(() => startPolling(cb));
+    expect(jest.getTimerCount()).toBe(1);
+    expect(result.current.isPooling).toBeTruthy();
+    // First execution
+    (0, test_utils_1.act)(() => {
+        jest.advanceTimersByTime(1000);
+    });
+    expect(jest.getTimerCount()).toBe(1);
+    expect(result.current.isPooling).toBeTruthy();
+    //Second execution
+    (0, test_utils_1.act)(() => {
+        jest.advanceTimersByTime(1000);
+    });
+    expect(jest.getTimerCount()).toBe(1);
+    expect(result.current.isPooling).toBeTruthy();
+    //Last execution
+    (0, test_utils_1.act)(() => {
+        jest.advanceTimersByTime(1000);
+    });
+    //   expect(jest.getTimerCount()).toBe(0);
+    //   expect(result.current.isPooling).toBeFalsy();
+}));
+it.each([
+    [1000, 5000, 5],
+    [500, 10000, 20],
+    [1000, 2578, 3],
+])("Should end the pooling with error when the pooling of interval %s with max of %s exceeds max executions of %s", (poolingInterval, maxTime, expectedExecutionsCount) => {
+    const { result } = renderHookAndSync(() => (0, usePooling_1.default)(poolingInterval, maxTime));
+    const { startPolling } = result.current;
+    actAndSync(() => startPolling(() => __awaiter(void 0, void 0, void 0, function* () { return false; })));
+    for (let i = 1; i < expectedExecutionsCount; i++) {
+        (0, test_utils_1.act)(() => {
+            jest.advanceTimersByTime(poolingInterval);
+        });
+        if (i === expectedExecutionsCount) {
+            expect(result.current.isPooling).toBeFalsy();
+            expect(result.current.failed).toBeTruthy();
+        }
+        else {
+            expect(result.current.isPooling).toBeTruthy();
+            expect(result.current.failed).toBeFalsy();
+        }
+    }
+});
 //# sourceMappingURL=usePooling.test.js.map

package/dist/hooks/useRebound.d.ts

@@ -1,9 +1,9 @@
-/// <reference types="react" />
-/**
- * This hook adds a prop that you can toggle and returns to initial
- * state after a defined time (usefull for notification)
- */
-export default function useRebound<T extends any>(initialValue: T, timeoutSec?: number): {
-    current: T;
-    setState: import("react").Dispatch<import("react").SetStateAction<T>>;
-};
+/// <reference types="react" />
+/**
+ * This hook adds a prop that you can toggle and returns to initial
+ * state after a defined time (usefull for notification)
+ */
+export default function useRebound<T extends any>(initialValue: T, timeoutSec?: number): {
+    current: T;
+    setState: import("react").Dispatch<import("react").SetStateAction<T>>;
+};

package/dist/hooks/useRebound.js

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("react");
-/**
- * This hook adds a prop that you can toggle and returns to initial
- * state after a defined time (usefull for notification)
- */
-function useRebound(initialValue, timeoutSec = 1) {
-    const [state, setState] = (0, react_1.useState)(initialValue);
-    (0, react_1.useEffect)(() => {
-        if (state !== initialValue) {
-            const timeout = setTimeout(() => {
-                setState(initialValue);
-            }, timeoutSec * 1000);
-            return () => clearTimeout(timeout);
-        }
-    }, [state]);
-    return {
-        current: state,
-        setState
-    };
-}
-exports.default = useRebound;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/**
+ * This hook adds a prop that you can toggle and returns to initial
+ * state after a defined time (usefull for notification)
+ */
+function useRebound(initialValue, timeoutSec = 1) {
+    const [state, setState] = (0, react_1.useState)(initialValue);
+    (0, react_1.useEffect)(() => {
+        if (state !== initialValue) {
+            const timeout = setTimeout(() => {
+                setState(initialValue);
+            }, timeoutSec * 1000);
+            return () => clearTimeout(timeout);
+        }
+    }, [state]);
+    return {
+        current: state,
+        setState
+    };
+}
+exports.default = useRebound;
 //# sourceMappingURL=useRebound.js.map

package/dist/hooks/useShortIntl.d.ts

@@ -1,15 +1,15 @@
-import { IntlFormatters, IntlShape } from "react-intl";
-import { BigNumber } from "bignumber.js";
-export default function useShortIntl(): IntlShape & {
-    txt: (id: OnepercentUtility.IntlIds, params?: Parameters<IntlFormatters["formatMessage"]>[1]) => ReturnType<IntlFormatters["formatMessage"]>;
-    formatToDoubleDecimal(number: number, options?: Parameters<IntlFormatters["formatNumber"]>[1]): string;
-    formatBigNumber(number: BigNumber, options?: Parameters<IntlFormatters["formatNumber"]>[1]): string;
-};
-declare type StrMap = {
-    [s: string]: string;
-};
-declare type IsolatedMessages<A extends string, M extends StrMap, P extends string> = {
-    [s1 in `${P}.${keyof M extends string ? keyof M : ""}`]: M[keyof M];
-};
-export declare function isolateMessages<A extends string, M extends StrMap>(preffix: A, strings: M): IsolatedMessages<A, M, A>;
-export {};
+import { IntlFormatters, IntlShape } from "react-intl";
+import { BigNumber } from "bignumber.js";
+export default function useShortIntl(): IntlShape & {
+    txt: (id: OnepercentUtility.IntlIds, params?: Parameters<IntlFormatters["formatMessage"]>[1]) => ReturnType<IntlFormatters["formatMessage"]>;
+    formatToDoubleDecimal(number: number, options?: Parameters<IntlFormatters["formatNumber"]>[1]): string;
+    formatBigNumber(number: BigNumber, options?: Parameters<IntlFormatters["formatNumber"]>[1]): string;
+};
+declare type StrMap = {
+    [s: string]: string;
+};
+declare type IsolatedMessages<A extends string, M extends StrMap, P extends string> = {
+    [s1 in `${P}.${keyof M extends string ? keyof M : ""}`]: M[keyof M];
+};
+export declare function isolateMessages<A extends string, M extends StrMap>(preffix: A, strings: M): IsolatedMessages<A, M, A>;
+export {};

package/dist/hooks/useShortIntl.js

@@ -1,38 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isolateMessages = void 0;
-const react_intl_1 = require("react-intl");
-function useShortIntl() {
-    const intl = (0, react_intl_1.useIntl)();
-    const { formatMessage, formatNumber } = intl;
-    return Object.assign(Object.assign({}, intl), { txt: (id, params) => {
-            return formatMessage({ id }, params);
-        }, formatToDoubleDecimal(val, options = {}) {
-            return formatNumber(val, Object.assign({ minimumFractionDigits: 2, maximumFractionDigits: 2 }, options));
-        },
-        formatBigNumber(bigNumber, options) {
-            const { decimalSeparator } = intl
-                .formatNumberToParts(1000.1)
-                .reduce((r, a) => {
-                if (a.type === "decimal")
-                    return Object.assign(Object.assign({}, r), { decimalSeparator: a.value });
-                if (a.type === "group")
-                    return Object.assign(Object.assign({}, r), { thousandSeparator: a.value });
-                return r;
-            }, {});
-            const integerPart = bigNumber.integerValue(1);
-            const integer = intl.formatNumber(integerPart.toNumber(), options);
-            const decimals = bigNumber
-                .minus(integerPart)
-                .decimalPlaces((options === null || options === void 0 ? void 0 : options.maximumFractionDigits) || bigNumber.decimalPlaces(), 5)
-                .toString()
-                .replace("0.", "");
-            return `${integer}${decimals !== "0" ? `${decimalSeparator}${decimals}` : ""}`;
-        } });
-}
-exports.default = useShortIntl;
-function isolateMessages(preffix, strings) {
-    return Object.entries(strings).reduce((r, [k, v]) => (Object.assign(Object.assign({}, r), { [`${preffix}.${k}`]: v })), {});
-}
-exports.isolateMessages = isolateMessages;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isolateMessages = void 0;
+const react_intl_1 = require("react-intl");
+function useShortIntl() {
+    const intl = (0, react_intl_1.useIntl)();
+    const { formatMessage, formatNumber } = intl;
+    return Object.assign(Object.assign({}, intl), { txt: (id, params) => {
+            return formatMessage({ id }, params);
+        }, formatToDoubleDecimal(val, options = {}) {
+            return formatNumber(val, Object.assign({ minimumFractionDigits: 2, maximumFractionDigits: 2 }, options));
+        },
+        formatBigNumber(bigNumber, options) {
+            const { decimalSeparator } = intl
+                .formatNumberToParts(1000.1)
+                .reduce((r, a) => {
+                if (a.type === "decimal")
+                    return Object.assign(Object.assign({}, r), { decimalSeparator: a.value });
+                if (a.type === "group")
+                    return Object.assign(Object.assign({}, r), { thousandSeparator: a.value });
+                return r;
+            }, {});
+            const integerPart = bigNumber.integerValue(1);
+            const integer = intl.formatNumber(integerPart.toNumber(), options);
+            const decimals = bigNumber
+                .minus(integerPart)
+                .decimalPlaces((options === null || options === void 0 ? void 0 : options.maximumFractionDigits) || bigNumber.decimalPlaces(), 5)
+                .toString()
+                .replace("0.", "");
+            return `${integer}${decimals !== "0" ? `${decimalSeparator}${decimals}` : ""}`;
+        } });
+}
+exports.default = useShortIntl;
+function isolateMessages(preffix, strings) {
+    return Object.entries(strings).reduce((r, [k, v]) => (Object.assign(Object.assign({}, r), { [`${preffix}.${k}`]: v })), {});
+}
+exports.isolateMessages = isolateMessages;
 //# sourceMappingURL=useShortIntl.js.map

package/dist/models/GenericContract.d.ts

@@ -1,66 +1,74 @@
-import { Contract, ContractOptions, EventData, PastEventOptions } from "web3-eth-contract";
-export declare type AllABIs = OnepercentUtility.ApplicationABIs;
-declare type ExtractMethods<A extends AllABIs[number]> = A extends {
-    type: "function";
-} ? A["name"] : never;
-declare type ExtractEvents<A extends AllABIs[number]> = A extends {
-    type: "event";
-} ? A["name"] : never;
-declare type MapTypeToJS<L> = L extends "string" ? string : L extends "address" ? string : L extends "uint256" ? string : L extends "bool" ? boolean : unknown;
-declare type ExtractFromObj<R extends (AllABIs[number] & {
-    type: "function";
-})> = {
-    [K in R["outputs"][number]["name"]]: MapTypeToJS<(R["outputs"][number] & {
-        name: K;
-    })["type"]>;
-};
-declare type ExtractMethodDefinition<A extends AllABIs, N extends (AllABIs[number] & {
-    type: "function";
-})["name"], R = A[number] & {
-    type: "function";
-    name: N;
-}> = (...args: TuplifyUnion<(A[number] & {
-    type: "function";
-    name: N;
-})["inputs"][number]["name"]>) => {
-    call: () => Promise<R extends {
-        outputs: {
-            length: 1;
-        };
-    } ? MapTypeToJS<R["outputs"][0]["type"]> : R extends {
-        outputs: any;
-    } ? ExtractFromObj<R> : void>;
-    send: (prop: {
-        from: string;
-    }) => Promise<void>;
-};
-declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-declare type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
-declare type Push<T extends any[], V> = [...T, V];
-declare type TuplifyUnion<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<TuplifyUnion<Exclude<T, L>>, MapTypeToJS<L>>;
-export default class GenericContract<A extends AllABIs = AllABIs, E extends string = ExtractEvents<A[number]> | "allEvents"> extends Contract {
-    events: Exclude<E, "allEvents">;
-    constructor(jsonInterface: A, address?: string, options?: ContractOptions);
-    methods: {
-        [k in ExtractMethods<A[number]>]: ExtractMethodDefinition<A, k>;
-    };
-    getPastEvents(event: E): Promise<GenericEventData<A>[]>;
-    getPastEvents(event: E, options: PastEventOptions, callback: (error: Error, event: EventData) => void): Promise<GenericEventData<A>[]>;
-    getPastEvents(event: E, options: PastEventOptions): Promise<GenericEventData<A>[]>;
-    getPastEvents(event: E, callback: (error: Error, event: EventData) => void): Promise<GenericEventData<A>[]>;
-}
-export declare type GenericEventData<E extends AllABIs> = EventData & GenericEvent<E>;
-declare type ABIEvent = AllABIs[number] & {
-    type: "event";
-};
-declare type GenericEvent<ABI extends AllABIs, E extends string = ExtractEvents<ABI[number]>> = {
-    event: E;
-    returnValues: ExtractReturnValues<ABIEvent & {
-        name: E;
-    }>;
-};
-declare type ExtractReturnValues<E extends ABIEvent> = ExtractInputType<E["inputs"][number]>;
-declare type ExtractInputType<I extends ABIEvent["inputs"][number]> = {
-    [k in I["name"]]: MapTypeToJS<I["internalType"]>;
-};
-export {};
+import { Contract, ContractOptions, EventData, PastEventOptions } from "web3-eth-contract";
+export declare type AllABIs = OnepercentUtility.ApplicationABIs;
+declare type ExtractMethods<A extends AllABIs[number]> = A extends {
+    type: "function";
+} ? A["name"] : never;
+declare type ExtractEvents<A extends AllABIs[number]> = A extends {
+    type: "event";
+} ? A["name"] : never;
+declare type MapTypeToJS<L> = L extends "string" ? string : L extends "address" ? string : L extends "uint256" ? string : L extends "uint8" ? string : L extends "bool" ? boolean : unknown;
+declare type ExtractFromObj<R extends (AllABIs[number] & {
+    type: "function";
+})> = {
+    [K in R["outputs"][number]["name"]]: MapTypeToJS<(R["outputs"][number] & {
+        name: K;
+    })["type"]>;
+};
+declare type ExtractMethodDefinition<A extends AllABIs, N extends (AllABIs[number] & {
+    type: "function";
+})["name"], R = A[number] & {
+    type: "function";
+    name: N;
+}> = (...args: TuplifyUnion<(A[number] & {
+    type: "function";
+    name: N;
+})["inputs"][number], (A[number] & {
+    type: "function";
+    name: N;
+})["inputs"][number]["name"]>) => {
+    call: () => Promise<R extends {
+        outputs: {
+            length: 1;
+        };
+    } ? MapTypeToJS<R["outputs"][0]["type"]> : R extends {
+        outputs: any;
+    } ? ExtractFromObj<R> : void>;
+    send: (prop: {
+        from: string;
+        maxPriorityFeePerGas?: number;
+        gas?: number;
+        gasPrice?: string;
+    }) => Promise<void>;
+};
+declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
+declare type Push<T extends any[], V> = [...T, V];
+declare type TuplifyUnion<FUNCS, T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<TuplifyUnion<FUNCS, Exclude<T, L>>, MapTypeToJS<(FUNCS & {
+    name: L;
+})['internalType']>>;
+export default class GenericContract<A extends AllABIs = AllABIs, E extends string = ExtractEvents<A[number]> | "allEvents"> extends Contract {
+    events: Exclude<E, "allEvents">;
+    constructor(jsonInterface: A, address?: string, options?: ContractOptions);
+    methods: {
+        [k in ExtractMethods<A[number]>]: ExtractMethodDefinition<A, k>;
+    };
+    getPastEvents(event: E): Promise<GenericEventData<A>[]>;
+    getPastEvents(event: E, options: PastEventOptions, callback: (error: Error, event: EventData) => void): Promise<GenericEventData<A>[]>;
+    getPastEvents(event: E, options: PastEventOptions): Promise<GenericEventData<A>[]>;
+    getPastEvents(event: E, callback: (error: Error, event: EventData) => void): Promise<GenericEventData<A>[]>;
+}
+export declare type GenericEventData<E extends AllABIs> = EventData & GenericEvent<E>;
+declare type ABIEvent = AllABIs[number] & {
+    type: "event";
+};
+declare type GenericEvent<ABI extends AllABIs, E extends string = ExtractEvents<ABI[number]>> = {
+    event: E;
+    returnValues: ExtractReturnValues<ABIEvent & {
+        name: E;
+    }>;
+};
+declare type ExtractReturnValues<E extends ABIEvent> = ExtractInputType<E["inputs"][number]>;
+declare type ExtractInputType<I extends ABIEvent["inputs"][number]> = {
+    [k in I["name"]]: MapTypeToJS<I["internalType"]>;
+};
+export {};