@zing-protocol/zing-sdk 0.0.1 → 0.0.2

package/dist/hooks/useZingInfiniteQueries.d.ts

@@ -0,0 +1,75 @@
+import type { ZingClient } from "../client/index.js";
+import type { SuiNetwork } from "../types.js";
+import type { UseInfiniteQueryOptions, InfiniteData } from "@tanstack/react-query";
+declare const zingInfiniteQueryMethodMap: (zingClient: ZingClient) => {
+    getMembers: (owner: string, cursor?: string, limit?: number) => Promise<{
+        data: {
+            member: string;
+            level: number;
+            expiredAt: string;
+        }[];
+        nextCursor: string | undefined;
+        hasNextPage: boolean;
+    }>;
+    getWorks: (walrusSystem: import("../index.js").WalrusSystemState, owner: string, workType?: import("../index.js").WorkType, cursor?: string, limit?: number) => Promise<{
+        data: {
+            id: {
+                id: string;
+            };
+            owner: string;
+            deleted: boolean;
+            created_at: string;
+            subscription_level: number | null;
+            blobs: {
+                id: {
+                    id: string;
+                };
+                registered_epoch: number;
+                blob_id: string;
+                size: string;
+                encoding_type: number;
+                certified_epoch: number | null;
+                storage: {
+                    id: {
+                        id: string;
+                    };
+                    start_epoch: number;
+                    end_epoch: number;
+                    storage_size: string;
+                };
+                deletable: boolean;
+            }[];
+            files: {
+                contents: {
+                    key: string;
+                    value: {
+                        blob_index: string;
+                        mime_type: string;
+                        size: string;
+                    };
+                }[];
+            };
+        }[];
+        nextCursor: string | undefined;
+        hasNextPage: boolean;
+    }>;
+};
+type ZingInfiniteQueryMethods = ReturnType<typeof zingInfiniteQueryMethodMap>;
+type ExtractParams<T> = T extends (...args: infer P) => any ? P : never;
+type InfiniteMethodParamsMap = {
+    [K in keyof ZingInfiniteQueryMethods]: ExtractParams<ZingInfiniteQueryMethods[K]>;
+};
+type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+type ExtractReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
+type UseZingInfiniteQueryParams<K extends keyof InfiniteMethodParamsMap> = {
+    method: K;
+    params: InfiniteMethodParamsMap[K];
+    limit?: number;
+};
+type ExtraInfiniteQueryOptions<TData = unknown> = Partial<Pick<UseInfiniteQueryOptions<TData, Error, InfiniteData<TData>, readonly unknown[], string | undefined>, "enabled" | "gcTime" | "staleTime" | "retry">>;
+export type InfiniteMethodReturnMap = {
+    [K in keyof ZingInfiniteQueryMethods]: UnwrapPromise<ExtractReturnType<ZingInfiniteQueryMethods[K]>>;
+};
+export declare function getZingInfiniteQueryKey<K extends keyof ZingInfiniteQueryMethods>(network: SuiNetwork, method: K, memo: string[]): readonly [string, K, string[]];
+export declare function useZingInfiniteQuery<K extends keyof InfiniteMethodParamsMap>(input: UseZingInfiniteQueryParams<K>, options?: ExtraInfiniteQueryOptions<InfiniteMethodReturnMap[K]>, memo?: string[]): import("@tanstack/react-query").UseInfiniteQueryResult<InfiniteData<InfiniteMethodReturnMap[K], unknown>, Error>;
+export {};

package/dist/hooks/useZingInfiniteQueries.js

@@ -0,0 +1,28 @@
+import { useZingClient } from "../components/zing-provider.js";
+import { useInfiniteQuery } from "@tanstack/react-query";
+const zingInfiniteQueryMethodMap = (zingClient) => ({
+    getMembers: zingClient.getMembers.bind(zingClient),
+    getWorks: zingClient.getWorks.bind(zingClient),
+});
+export function getZingInfiniteQueryKey(network, method, memo) {
+    return [network, method, memo];
+}
+export function useZingInfiniteQuery(input, options = {}, memo = []) {
+    const zingClient = useZingClient();
+    const methodMap = zingInfiniteQueryMethodMap(zingClient);
+    const { method, params, limit = 20 } = input;
+    return useInfiniteQuery({
+        queryKey: [zingClient.network, method, memo],
+        queryFn: async ({ pageParam }) => {
+            const fn = methodMap[method];
+            // Call the function with spread params, cursor, and limit
+            return fn(...params, pageParam, limit);
+        },
+        initialPageParam: undefined,
+        getNextPageParam: (lastPage) => {
+            const nextCursor = lastPage?.nextCursor;
+            return nextCursor ?? undefined; // Convert null to undefined
+        },
+        ...options,
+    });
+}

package/dist/hooks/useZingMutation.d.ts

@@ -0,0 +1,35 @@
+import { Transaction } from "@mysten/sui/transactions";
+import type { ZingClient } from "../client/index.js";
+import type { TransactionEffects } from "@mysten/sui/client";
+declare const zingMutationMethodMap: (zingClient: ZingClient) => {
+    subscribeToStudioTransaction: ({ sender, creatorAddress, subscriptionAmount, level, }: import("../client/types.js").SubscribeParams) => (tx: Transaction) => void;
+    purchaseStorageTierTransaction: ({ sender, objs, newTierIdx, balance, referrer, }: import("../client/types.js").PurchaseStorageTierParams) => (tx: Transaction) => void;
+    setMonthlySubscriptionFeeTransaction: ({ sender, monthlyFee, level, }: import("../client/types.js").SetMonthlySubscriptionFeeParams) => (tx: Transaction) => void;
+    updateArticleSubscriptionLevelTransaction: ({ sender, articleId, subscriptionLevel, }: {
+        sender: string;
+        articleId: string;
+        subscriptionLevel: null | number;
+    }) => (tx: Transaction) => void;
+    deleteArticleTransaction: ({ sender, articleId, }: {
+        sender: string;
+        articleId: string;
+    }) => (tx: Transaction) => void;
+    donateTransaction: ({ recipient, message, value, }: {
+        recipient: string;
+        message: string;
+        value: number;
+    }) => (tx: Transaction) => void;
+};
+type ZingMutationMethods = ReturnType<typeof zingMutationMethodMap>;
+type ExtractParams<T> = T extends (arg: infer P) => any ? P : never;
+type MethodParamsMap = {
+    [K in keyof ZingMutationMethods]: ExtractParams<ZingMutationMethods[K]>;
+};
+type UseZingMutationParams = {
+    [K in keyof ZingMutationMethods]: {
+        method: K;
+        params: MethodParamsMap[K];
+    };
+}[keyof ZingMutationMethods];
+export declare function useZingMutation(): import("@tanstack/react-query").UseMutationResult<TransactionEffects | null, Error, UseZingMutationParams, unknown>;
+export {};

package/dist/hooks/useZingMutation.js

@@ -0,0 +1,37 @@
+import { useSignAndExecuteTransaction } from "./useSignAndExecuteTransaction.js";
+import { useZingClient } from "../components/zing-provider.js";
+import { Transaction } from "@mysten/sui/transactions";
+import { useMutation } from "@tanstack/react-query";
+// Only allows Transaction methods
+const zingMutationMethodMap = (zingClient) => ({
+    subscribeToStudioTransaction: zingClient.subscribeToStudioTransaction.bind(zingClient),
+    purchaseStorageTierTransaction: zingClient.purchaseStorageTierTransaction.bind(zingClient),
+    setMonthlySubscriptionFeeTransaction: zingClient.setMonthlySubscriptionFeeTransaction.bind(zingClient),
+    updateArticleSubscriptionLevelTransaction: zingClient.updateArticleSubscriptionLevelTransaction.bind(zingClient),
+    deleteArticleTransaction: zingClient.deleteArticleTransaction.bind(zingClient),
+    donateTransaction: zingClient.donateTransaction.bind(zingClient),
+});
+export function useZingMutation() {
+    const zingClient = useZingClient();
+    const methodMap = zingMutationMethodMap(zingClient);
+    const { mutateAsync: signAndExecute } = useSignAndExecuteTransaction();
+    return useMutation({
+        mutationFn: async ({ method, params }) => {
+            const tx = new Transaction();
+            const builderFn = methodMap[method];
+            // builderFn receives a structured params object, not an array
+            const buildTx = builderFn(params);
+            buildTx(tx);
+            return signAndExecute({
+                transaction: tx,
+            });
+        },
+        onSuccess: async (effects) => {
+            if (effects?.transactionDigest) {
+                await zingClient.suiJsonRpcClient.waitForTransaction({
+                    digest: effects.transactionDigest,
+                });
+            }
+        },
+    });
+}

package/dist/hooks/useZingQueries.d.ts

@@ -0,0 +1,127 @@
+import type { ZingClient } from "../client/index.js";
+import type { UseQueryOptions } from "@tanstack/react-query";
+declare const zingQueryMethodMap: (zingClient: ZingClient) => {
+    getIdentifierByAddress: (platform: import("../index.js").PlatformType, address: string) => Promise<string | null>;
+    getIdentifierInfoByIdentifier: (platform: import("../index.js").PlatformType, identifier: string) => Promise<{
+        owner: string;
+        updated_at: string;
+    } | null>;
+    getStudio: (owner: string) => Promise<{
+        id: {
+            id: string;
+        };
+        owner: string;
+        period: string[];
+        monthly_subscription_fee: {
+            contents: {
+                key: number;
+                value: string;
+            }[];
+        };
+        membership: {
+            id: {
+                id: string;
+            };
+            size: string;
+        };
+        works: {
+            id: {
+                id: string;
+            };
+            size: string;
+        };
+        encrypted_file_key: number[] | null;
+    } | null>;
+    getStorageSpace: (owner: string) => Promise<{
+        id: {
+            id: string;
+        };
+        owner: string;
+        tier: number | null;
+        storage_used: {
+            contents: {
+                key: number;
+                value: string;
+            }[];
+        };
+        credits: string;
+    } | null>;
+    getStorageTreasury: () => Promise<{
+        id: {
+            id: string;
+        };
+        tier_plan: {
+            contents: {
+                key: number;
+                value: {
+                    price: string;
+                    duration_days: number;
+                    storage_limit: string;
+                };
+            }[];
+        };
+        storages_by_epoch: {
+            contents: {
+                key: number;
+                value: {
+                    id: {
+                        id: string;
+                    };
+                    start_epoch: number;
+                    end_epoch: number;
+                    storage_size: string;
+                };
+            }[];
+        };
+        wal_treasury: {
+            id: {
+                id: string;
+            };
+            balance: {
+                value: string;
+            };
+        };
+    } | null>;
+    getMember: (owner: string, member: string) => Promise<{
+        level: number;
+        expired_at: string;
+    } | null>;
+    getBalance: (owner: string, coinSymbol: import("../index.js").CoinSymbol) => Promise<import("node_modules/@mysten/sui/dist/esm/grpc/proto/sui/rpc/v2/state_service.js").GetBalanceResponse>;
+};
+type ZingQueryMethods = ReturnType<typeof zingQueryMethodMap>;
+type ExtractParams<T> = T extends (...args: infer P) => any ? P : never;
+type MethodParamsMap = {
+    [K in keyof ZingQueryMethods]: ExtractParams<ZingQueryMethods[K]>;
+};
+type ExtractReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
+type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+type MethodReturnMap = {
+    [K in keyof ZingQueryMethods]: UnwrapPromise<ExtractReturnType<ZingQueryMethods[K]>>;
+};
+type ZingQueryConfig = {
+    [K in keyof ZingQueryMethods]: {
+        method: K;
+        params: MethodParamsMap[K];
+    } & Omit<UseQueryOptions<MethodReturnMap[K], Error, MethodReturnMap[K], readonly unknown[]>, "queryKey" | "queryFn">;
+}[keyof ZingQueryMethods];
+type UseZingQueriesOptions<T extends readonly ZingQueryConfig[], TCombinedResult = QueriesResults<T>> = {
+    queries: readonly [...T];
+    combine?: (results: QueriesResults<T>) => TCombinedResult;
+};
+type QueryResult<T> = T extends {
+    method: infer K;
+    params: any;
+} ? K extends keyof ZingQueryMethods ? {
+    data: MethodReturnMap[K] | undefined;
+    error: Error | null;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    status: "pending" | "error" | "success";
+    fetchStatus: "fetching" | "paused" | "idle";
+} : never : never;
+type QueriesResults<T extends readonly ZingQueryConfig[]> = {
+    [K in keyof T]: QueryResult<T[K]>;
+};
+export declare function useZingQueries<T extends readonly ZingQueryConfig[], TCombinedResult = QueriesResults<T>>(options: UseZingQueriesOptions<T, TCombinedResult>): TCombinedResult;
+export {};

package/dist/hooks/useZingQueries.js

@@ -0,0 +1,37 @@
+import { useZingClient } from "../components/zing-provider.js";
+import { useQueries } from "@tanstack/react-query";
+// ---------------------------------------------
+// Method map (shared with useZingQuery)
+// ---------------------------------------------
+const zingQueryMethodMap = (zingClient) => ({
+    getIdentifierByAddress: zingClient.getIdentifierByAddress.bind(zingClient),
+    getIdentifierInfoByIdentifier: zingClient.getIdentifierInfoByIdentifier.bind(zingClient),
+    getStudio: zingClient.getStudio.bind(zingClient),
+    getStorageSpace: zingClient.getStorageSpace.bind(zingClient),
+    getStorageTreasury: zingClient.getStorageTreasury.bind(zingClient),
+    getMember: zingClient.getMember.bind(zingClient),
+    getBalance: zingClient.getBalance.bind(zingClient),
+});
+// ---------------------------------------------
+// Hook
+// ---------------------------------------------
+export function useZingQueries(options) {
+    const zingClient = useZingClient();
+    const methodMap = zingQueryMethodMap(zingClient);
+    const queryConfigs = options.queries.map((queryConfig) => {
+        const { method, params, ...queryOptions } = queryConfig;
+        return {
+            queryKey: [zingClient.network, method, params],
+            queryFn: async () => {
+                const fn = methodMap[method];
+                return fn(...params);
+            },
+            ...queryOptions,
+        };
+    });
+    const results = useQueries({
+        queries: queryConfigs,
+        combine: options.combine,
+    });
+    return results;
+}

package/dist/hooks/useZingQuery.d.ts

@@ -0,0 +1,147 @@
+import type { ZingClient } from "../client/index.js";
+import type { SuiNetwork } from "../types.js";
+import type { UseQueryOptions } from "@tanstack/react-query";
+declare const zingQueryMethodMap: (zingClient: ZingClient) => {
+    getIdentifierByAddress: (platform: import("../index.js").PlatformType, address: string) => Promise<string | null>;
+    getIdentifierInfoByIdentifier: (platform: import("../index.js").PlatformType, identifier: string) => Promise<{
+        owner: string;
+        updated_at: string;
+    } | null>;
+    getStudio: (owner: string) => Promise<{
+        id: {
+            id: string;
+        };
+        owner: string;
+        period: string[];
+        monthly_subscription_fee: {
+            contents: {
+                key: number;
+                value: string;
+            }[];
+        };
+        membership: {
+            id: {
+                id: string;
+            };
+            size: string;
+        };
+        works: {
+            id: {
+                id: string;
+            };
+            size: string;
+        };
+        encrypted_file_key: number[] | null;
+    } | null>;
+    getStorageSpace: (owner: string) => Promise<{
+        id: {
+            id: string;
+        };
+        owner: string;
+        tier: number | null;
+        storage_used: {
+            contents: {
+                key: number;
+                value: string;
+            }[];
+        };
+        credits: string;
+    } | null>;
+    getStorageTreasury: () => Promise<{
+        id: {
+            id: string;
+        };
+        tier_plan: {
+            contents: {
+                key: number;
+                value: {
+                    price: string;
+                    duration_days: number;
+                    storage_limit: string;
+                };
+            }[];
+        };
+        storages_by_epoch: {
+            contents: {
+                key: number;
+                value: {
+                    id: {
+                        id: string;
+                    };
+                    start_epoch: number;
+                    end_epoch: number;
+                    storage_size: string;
+                };
+            }[];
+        };
+        wal_treasury: {
+            id: {
+                id: string;
+            };
+            balance: {
+                value: string;
+            };
+        };
+    } | null>;
+    getMember: (owner: string, member: string) => Promise<{
+        level: number;
+        expired_at: string;
+    } | null>;
+    getBalance: (owner: string, coinSymbol: import("../index.js").CoinSymbol) => Promise<import("node_modules/@mysten/sui/dist/esm/grpc/proto/sui/rpc/v2/state_service.js").GetBalanceResponse>;
+    getWork: (walrusSystem: import("../index.js").WalrusSystemState, workId: string, workType?: import("../index.js").WorkType) => Promise<{
+        id: {
+            id: string;
+        };
+        owner: string;
+        deleted: boolean;
+        created_at: string;
+        subscription_level: number | null;
+        blobs: {
+            id: {
+                id: string;
+            };
+            registered_epoch: number;
+            blob_id: string;
+            size: string;
+            encoding_type: number;
+            certified_epoch: number | null;
+            storage: {
+                id: {
+                    id: string;
+                };
+                start_epoch: number;
+                end_epoch: number;
+                storage_size: string;
+            };
+            deletable: boolean;
+        }[];
+        files: {
+            contents: {
+                key: string;
+                value: {
+                    blob_index: string;
+                    mime_type: string;
+                    size: string;
+                };
+            }[];
+        };
+    } | null>;
+};
+type ZingQueryMethods = ReturnType<typeof zingQueryMethodMap>;
+type ExtractParams<T> = T extends (...args: infer P) => any ? P : never;
+type MethodParamsMap = {
+    [K in keyof ZingQueryMethods]: ExtractParams<ZingQueryMethods[K]>;
+};
+type ExtractReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
+type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+type MethodReturnMap = {
+    [K in keyof ZingQueryMethods]: UnwrapPromise<ExtractReturnType<ZingQueryMethods[K]>>;
+};
+type UseZingQueryParams<K extends keyof ZingQueryMethods = keyof ZingQueryMethods> = {
+    method: K;
+    params: MethodParamsMap[K];
+};
+type ExtraQueryOptions<TData> = Omit<UseQueryOptions<TData, Error, TData, readonly unknown[]>, "queryKey" | "queryFn">;
+export declare function getZingQueryKey<K extends keyof ZingQueryMethods>(network: SuiNetwork, method: K, memo: string[]): readonly [string, K, string[]];
+export declare function useZingQuery<K extends keyof ZingQueryMethods>(input: UseZingQueryParams<K>, options?: ExtraQueryOptions<MethodReturnMap[K]>, memo?: string[]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<MethodReturnMap[K]>, Error>;
+export {};

package/dist/hooks/useZingQuery.js

@@ -0,0 +1,34 @@
+import { useZingClient } from "../components/zing-provider.js";
+import { useQuery } from "@tanstack/react-query";
+// ---------------------------------------------
+// Method map
+// ---------------------------------------------
+const zingQueryMethodMap = (zingClient) => ({
+    getIdentifierByAddress: zingClient.getIdentifierByAddress.bind(zingClient),
+    getIdentifierInfoByIdentifier: zingClient.getIdentifierInfoByIdentifier.bind(zingClient),
+    getStudio: zingClient.getStudio.bind(zingClient),
+    getStorageSpace: zingClient.getStorageSpace.bind(zingClient),
+    getStorageTreasury: zingClient.getStorageTreasury.bind(zingClient),
+    getMember: zingClient.getMember.bind(zingClient),
+    getBalance: zingClient.getBalance.bind(zingClient),
+    getWork: zingClient.getWork.bind(zingClient),
+});
+export function getZingQueryKey(network, method, memo) {
+    return [network, method, memo];
+}
+export function useZingQuery(input, options = {}, memo = []) {
+    const zingClient = useZingClient();
+    const methodMap = zingQueryMethodMap(zingClient);
+    const { method, params } = input;
+    return useQuery({
+        queryKey: [zingClient.network, method, memo],
+        gcTime: options.gcTime,
+        staleTime: options.staleTime,
+        enabled: options.enabled,
+        retry: options.retry,
+        queryFn: async () => {
+            const fn = methodMap[method];
+            return fn(...params);
+        },
+    });
+}

package/{src/index.ts → dist/index.d.ts}

@@ -8,8 +8,7 @@ export * from "./bcs.js";
 export * from "./_generated/index.js";
 export * from "./components/index.js";
 export type * from "./types.js";
-
 export type InfiniteQueryResult<TData> = {
-  pages: TData[];
-  pageParams: number[];
+    pages: TData[];
+    pageParams: number[];
 };

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./const.js";
+export * from "./lib/utils/index.js";
+export * from "./config/index.js";
+export * from "./getters.js";
+export * from "./mutations/index.js";
+export * from "./hooks/index.js";
+export * from "./bcs.js";
+export * from "./_generated/index.js";
+export * from "./components/index.js";

package/dist/lib/utils/colorful-logger.d.ts

@@ -0,0 +1,2 @@
+import type { ColorType } from "./types.js";
+export declare const colorfulLog: (message: string, type: ColorType) => void;

package/dist/lib/utils/colorful-logger.js

@@ -0,0 +1,23 @@
+import { COLORS } from "./const.js";
+export const colorfulLog = (message, type) => {
+    let color;
+    switch (type) {
+        case "success":
+            color = COLORS.FgGreen;
+            break;
+        case "info":
+            color = COLORS.FgBlue;
+            break;
+        case "error":
+            color = COLORS.FgRed;
+            break;
+        case "warning":
+            color = COLORS.FgYellow;
+            break;
+        default:
+            color = COLORS[type];
+            break;
+    }
+    console.info(color, message);
+    console.info(COLORS["Reset"]);
+};

package/dist/lib/utils/const.d.ts

@@ -0,0 +1,25 @@
+export declare const COLORS: {
+    readonly Reset: "\u001B[0m";
+    readonly Bright: "\u001B[1m";
+    readonly Dim: "\u001B[2m";
+    readonly Underscore: "\u001B[4m";
+    readonly Blink: "\u001B[5m";
+    readonly Reverse: "\u001B[7m";
+    readonly Hidden: "\u001B[8m";
+    readonly FgBlack: "\u001B[30m";
+    readonly FgRed: "\u001B[31m";
+    readonly FgGreen: "\u001B[32m";
+    readonly FgYellow: "\u001B[33m";
+    readonly FgBlue: "\u001B[34m";
+    readonly FgMagenta: "\u001B[35m";
+    readonly FgCyan: "\u001B[36m";
+    readonly FgWhite: "\u001B[37m";
+    readonly BgBlack: "\u001B[40m";
+    readonly BgRed: "\u001B[41m";
+    readonly BgGreen: "\u001B[42m";
+    readonly BgYellow: "\u001B[43m";
+    readonly BgBlue: "\u001B[44m";
+    readonly BgMagenta: "\u001B[45m";
+    readonly BgCyan: "\u001B[46m";
+    readonly BgWhite: "\u001B[47m";
+};

package/dist/lib/utils/const.js

@@ -0,0 +1,25 @@
+export const COLORS = {
+    Reset: "\x1b[0m",
+    Bright: "\x1b[1m",
+    Dim: "\x1b[2m",
+    Underscore: "\x1b[4m",
+    Blink: "\x1b[5m",
+    Reverse: "\x1b[7m",
+    Hidden: "\x1b[8m",
+    FgBlack: "\x1b[30m",
+    FgRed: "\x1b[31m",
+    FgGreen: "\x1b[32m",
+    FgYellow: "\x1b[33m",
+    FgBlue: "\x1b[34m",
+    FgMagenta: "\x1b[35m",
+    FgCyan: "\x1b[36m",
+    FgWhite: "\x1b[37m",
+    BgBlack: "\x1b[40m",
+    BgRed: "\x1b[41m",
+    BgGreen: "\x1b[42m",
+    BgYellow: "\x1b[43m",
+    BgBlue: "\x1b[44m",
+    BgMagenta: "\x1b[45m",
+    BgCyan: "\x1b[46m",
+    BgWhite: "\x1b[47m",
+};

package/dist/lib/utils/helpers.d.ts

@@ -0,0 +1,10 @@
+import type { ExcludeValuesFromBaseArrayType } from "./types.js";
+export declare const excludeValuesFromBaseArray: <B extends string[], E extends (string | number)[]>(baseArray: B, excludeArray: E) => ExcludeValuesFromBaseArrayType<B, E>;
+export declare const sleep: (time: number) => Promise<unknown>;
+export declare const formatDate: (date: Date) => string;
+export declare const formatBalance: (balance: string | number | bigint, decimal: number, digits?: number) => string;
+export declare const formatTimeAgo: (date: Date) => string;
+export declare function formatDaysAuto(days: number): string;
+export declare const formatBytes: (bytes: number) => string;
+export declare const getDaysRemaining: (comp: number) => number;
+export declare const bytesToGB: (bytes: number) => number;