@dappworks/kit 0.5.40 → 0.5.41

package/dist/utils.d.mts

@@ -0,0 +1,148 @@
+import DataLoader from 'dataloader';
+import { Table } from 'dexie';
+import BigNumber from 'bignumber.js';
+
+declare class DexieCache {
+    kv: Table<{
+        key: string;
+        value: {
+            value: any;
+            expiration: number;
+        };
+    }, any, {
+        key: string;
+        value: {
+            value: any;
+            expiration: number;
+        };
+    }>;
+    kv_get: DataLoader<string, {
+        value: any;
+        expiration: number;
+    }, string>;
+    kv_set: DataLoader<{
+        key: string;
+        value: any;
+        ttl: number;
+    }, {
+        key: string;
+        value: any;
+        ttl: number;
+    }, {
+        key: string;
+        value: any;
+        ttl: number;
+    }>;
+    options: {
+        ttl: number;
+        prefix: string;
+    };
+    get(_key: any): Promise<any>;
+    getRaw(_key: any): Promise<any>;
+    set(_key: any, value: any, options?: {
+        ttl?: number;
+    }): Promise<this>;
+    delete(key: any): Promise<void>;
+    clear(): Promise<void>;
+    wrap<T extends (...args: any[]) => Promise<any>, U = ReturnType<T>>(key: any, fn: T, args?: {
+        ttl?: number;
+        alowStale?: boolean;
+    }): Promise<Awaited<U>>;
+}
+declare const cache: DexieCache;
+
+declare const helper: {
+    env: {
+        isIopayMobile: () => boolean;
+        isBrowser: () => boolean;
+        onBrowser(func: any): void;
+    };
+    promise: {
+        sleep(ms: any): Promise<unknown>;
+        runAsync<T, U = Error>(promise: Promise<T>): Promise<[U | null, T | null]>;
+    };
+    object: {
+        crawlObject(object: any, options: any): any;
+        crawl(object: any, options: any): any;
+    };
+    json: {
+        isJsonString(str: string): boolean;
+        safeParse(val: any): any;
+    };
+    deepAssign(target: any, ...sources: any[]): any;
+    isObject(value: any): boolean;
+    deepMerge(obj: any, newObj: any): any;
+    img: {
+        parse(src: string | undefined): string;
+    };
+    string: {
+        copy(str: string): void;
+        fristUpper(str: string): string;
+        firstUpperCase(str: string): string;
+        toFixString(str: any, length: any): any;
+        truncate(fullStr: string, strLen: any, separator: any): string;
+        validAbi(abi: string): {
+            abi: any[];
+            address: string;
+        };
+        random(count: number): string;
+    };
+    download: {
+        downloadByBlob(name: string, blob: Blob): void;
+        downloadJSON(name: string, jsonObj: object): void;
+    };
+    number: {
+        countNonZeroNumbers: (str: string) => number;
+        numberWithCommas(num: number): string;
+        getBN: (value: number | string | BigNumber) => BigNumber;
+        toPrecisionFloor: (str: number | string, options?: {
+            decimals?: number;
+            format?: string;
+            toLocalString?: boolean;
+        }) => any;
+        warpBigNumber(value: string, decimals?: number, options?: {
+            format?: string;
+            fallback?: string;
+            min?: number;
+        }): {
+            value: string;
+            format: string;
+            originFormat: string;
+            decimals: string;
+        };
+        numberFormat(str: string | number, format?: string, options?: {
+            min?: number;
+            fallback?: string;
+        }): string;
+    };
+    address: {
+        convertAddress: (addressMode: "io" | "0x", address?: string) => string;
+        validateEthAddress: (address: string) => boolean;
+        validateIoAddress: (address: string) => boolean;
+        validateAddress: (address: string) => boolean;
+    };
+};
+
+declare const _: {
+    throttle: any;
+    debounce: any;
+    each: any;
+    flattenDeep: any;
+    omitBy: any;
+    isNil: any;
+    keyBy: any;
+    mergeWith: any;
+    cloneDeep: any;
+    groupBy: any;
+    get: any;
+    set: any;
+    remove: any;
+    merge: any;
+    isEqual: any;
+    uniqWith: any;
+    orderBy: any;
+    map: any;
+    zip: any;
+};
+
+export { _, cache, helper };

package/dist/utils.mjs

@@ -1,6 +1,6 @@
 export { cache } from './chunk-2N4HH4ZF.mjs';
 export { helper } from './chunk-R4N52NI2.mjs';
 export { _ } from './chunk-K7LFG5BA.mjs';
-import './chunk-R4SQKVDQ.mjs';
+import './chunk-6F7H4PAA.mjs';
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=utils.mjs.map

package/dist/wallet.d.mts

@@ -0,0 +1,196 @@
+import React from 'react';
+import { Chain } from 'viem/chains';
+import { a as PromiseHookData, S as StorageState } from './StorageState-cfd942cb.js';
+import { S as Store } from './root-218afa4f.js';
+import { WalletClient, PublicClient, HttpTransport, TransactionReceipt } from 'viem';
+import EventEmitter from 'events';
+import { SwitchChainMutateAsync } from 'wagmi/query';
+import * as wagmi from 'wagmi';
+import { Config } from 'wagmi';
+import { Chain as Chain$1 } from '@rainbow-me/rainbowkit';
+import * as _rainbow_me_rainbowkit_dist_config_getDefaultConfig from '@rainbow-me/rainbowkit/dist/config/getDefaultConfig';
+import 'mobx';
+import 'typed-emitter';
+
+declare const WalletProvider: (({ children, theme, appName, supportedChains, compatibleMode, rainbowKitProps, projectId }: {
+    children: React.ReactNode;
+    theme?: "dark" | "light";
+    appName?: string;
+    supportedChains?: Chain[];
+    compatibleMode?: boolean;
+    debug?: boolean;
+    rainbowKitProps?: any;
+    projectId?: string;
+}) => React.JSX.Element) & {
+    displayName: string;
+};
+
+type NetworkObject = {
+    name: string;
+    chainId: number;
+    rpcUrl: string;
+    logoUrl: string;
+    explorerUrl: string;
+    explorerName: string;
+    nativeCoin: string;
+    type: 'mainnet' | 'testnet';
+};
+type WalletTransactionHistoryType = {
+    chainId: number;
+    tx?: string;
+    msg: string;
+    timestamp: number;
+    type: string;
+    status: 'loading' | 'success' | 'fail';
+};
+type AddressMode = 'io' | '0x';
+declare const iotex: Chain;
+declare const iotexTestnet: Chain;
+
+declare class WalletStore implements Store {
+    sid: string;
+    autoObservable: boolean;
+    account: `0x${string}`;
+    isSuccessDialogOpen: boolean;
+    get isInSafeApp(): boolean;
+    isLedger: boolean;
+    isConnect: boolean;
+    walletClient: WalletClient;
+    event: EventEmitter<[never]>;
+    switchChain: SwitchChainMutateAsync<Config, unknown> | undefined;
+    updateTicker: number;
+    addressMode: AddressMode;
+    isIoTeXChain: boolean;
+    setAddressMode(mode: AddressMode): void;
+    get accountFormat(): string;
+    get connectAccountEllipsisFormat(): string;
+    get accountEllipsisFormat(): string;
+    get supportedChains(): Chain$1[];
+    chain: Chain$1 | undefined;
+    openConnectModal: any;
+    disconnect: any;
+    balance: PromiseHookData<() => Promise<{
+        value: string;
+        format: string;
+        originFormat: string;
+        decimals: string;
+    }>, Promise<{
+        value: string;
+        format: string;
+        originFormat: string;
+        decimals: string;
+    }>>;
+    constructor(args?: Partial<WalletStore>);
+    use(): void;
+    private useWalletClientWithCompatibleMode;
+    useWalletClientWithoutCompatibleMode(): void;
+    get publicClient(): PublicClient<HttpTransport, Chain$1, any, any>;
+    set(args: Partial<WalletStore>): void;
+    toJSON(): {
+        account: `0x${string}`;
+    };
+    prepare(chainId?: number): Promise<WalletStore>;
+    waitForTransactionReceipt({ hash }: {
+        hash: any;
+    }): Promise<TransactionReceipt>;
+    static SendTx(...args: Parameters<WalletStore['sendTx']>): Promise<TransactionReceipt>;
+    static SendRawTx(...args: Parameters<WalletStore['sendRawTx']>): Promise<TransactionReceipt>;
+    sendTx({ chainId, tx, autoAlert, loadingText, successText, historyItem, showSuccessDialog, onSuccess, onError, }: {
+        chainId: number | string;
+        tx: any;
+        autoAlert?: boolean;
+        loadingText?: string;
+        successText?: string;
+        showSuccessDialog?: boolean;
+        historyItem?: Pick<WalletTransactionHistoryType, 'msg' | 'type'>;
+        onSuccess?: ({ receipt }: {
+            receipt: TransactionReceipt;
+        }) => Promise<void>;
+        onError?: (error: any) => void;
+    }): Promise<TransactionReceipt>;
+    sendRawTx({ chainId, address, data, value, autoAlert, onSended, onSuccess, onError, historyItem, loadingText, showSuccessDialog, }: {
+        loadingText?: string;
+        chainId: number | string;
+        address: string;
+        data: string | null;
+        value?: string;
+        autoRefresh?: boolean;
+        autoAlert?: boolean;
+        historyItem?: Pick<WalletTransactionHistoryType, 'msg' | 'type'>;
+        showTransactionSubmitDialog?: boolean;
+        showSuccessDialog?: boolean;
+        onSended?: ({ res }: {
+            res: TransactionReceipt;
+        }) => void;
+        onSuccess?: ({ res }: {
+            res: TransactionReceipt;
+        }) => void;
+        onError?: (error: any) => void;
+    }): Promise<TransactionReceipt | undefined>;
+    signMessage(message: string): Promise<string>;
+}
+
+declare class WalletRpcStore implements Store {
+    sid: string;
+    autoObservable: boolean;
+    curRpc: StorageState<unknown>;
+    isAutoSelectRpc: StorageState<unknown>;
+    customRpc: string;
+    rpcList: StorageState<unknown>;
+    showCustomRpc: boolean;
+    get currentRpc(): any;
+    addCustomRpc(): string;
+    addToMetamask(url: any): Promise<void>;
+    switchOrAddChain(chainId: number): Promise<unknown>;
+    addToMetamaskById(id: number): Promise<unknown>;
+    refresh(): void;
+    latencyColor(latency: number): "text-red-500" | "text-green-500" | "text-yellow-500";
+    testRpcFunction(url: string): Promise<{
+        url: string;
+        lentency: number;
+        height: number;
+    }>;
+    testRpc(): void;
+    removeRpc(name: string): void;
+    scoreIcon(score: number): React.JSX.Element;
+    get wallet(): WalletStore;
+    autoSelectRpc(): Promise<void>;
+}
+declare class WalletHistoryStore implements Store {
+    sid: string;
+    isRender: boolean;
+    autoObservable: boolean;
+    set(params: Partial<WalletHistoryStore>): void;
+    private history;
+    get historyList(): WalletTransactionHistoryType[];
+    recordHistory(item: WalletTransactionHistoryType): void;
+    updateHistoryStatusByTx(tx: string | null, status: 'loading' | 'success' | 'fail'): void;
+    clearHistory(): void;
+}
+
+declare class WalletConfigStore implements Store {
+    sid: string;
+    autoObservable: boolean;
+    appName: string;
+    projectId: string;
+    supportedChains: Chain$1[];
+    defaultChainId: number;
+    updateTicker: number;
+    walletUpdateTick: number;
+    isConnect: boolean;
+    isInSafeApp: boolean;
+    compatibleMode: boolean;
+    constructor(args: Partial<WalletConfigStore>);
+    set(params: Partial<WalletConfigStore>): void;
+    get reconnectOnMount(): boolean;
+    get rainbowKitConfig(): wagmi.Config<_rainbow_me_rainbowkit_dist_config_getDefaultConfig._chains, _rainbow_me_rainbowkit_dist_config_getDefaultConfig._transports, wagmi.CreateConnectorFn<unknown, Record<string, unknown>, Record<string, unknown>>[]>;
+}
+
+declare const RpcList: (() => React.JSX.Element) & {
+    displayName: string;
+};
+
+declare const ConnectLedger: () => Promise<void>;
+declare const DisconnectLedger: () => void;
+
+export { AddressMode, ConnectLedger, DisconnectLedger, NetworkObject, RpcList, WalletConfigStore, WalletHistoryStore, WalletProvider, WalletRpcStore, WalletStore, WalletTransactionHistoryType, iotex, iotexTestnet };

package/dist/wallet.mjs

@@ -1,16 +1,16 @@
-import { WalletConfigStore, WalletStore, WalletRpcStore } from './chunk-2WRRZVUW.mjs';
-export { ConnectLedger, DisconnectLedger, WalletConfigStore, WalletHistoryStore, WalletRpcStore, WalletStore } from './chunk-2WRRZVUW.mjs';
-import './chunk-B7RV4C5E.mjs';
-import './chunk-O3FWAAEG.mjs';
+import { WalletConfigStore, WalletStore, WalletRpcStore } from './chunk-4F33QAJ4.mjs';
+export { ConnectLedger, DisconnectLedger, WalletConfigStore, WalletHistoryStore, WalletRpcStore, WalletStore } from './chunk-4F33QAJ4.mjs';
+import './chunk-SL5OV6OR.mjs';
+import './chunk-3XIPR2M3.mjs';
 import './chunk-2N4HH4ZF.mjs';
-import './chunk-PZ3VSAOC.mjs';
+import './chunk-C5BPNLKH.mjs';
 import { ToastPlugin } from './chunk-IMOLRP7I.mjs';
 import './chunk-GKAU4P5I.mjs';
-import { RootStore } from './chunk-XSGTWROT.mjs';
+import { RootStore } from './chunk-IDKGZ5T4.mjs';
 import './chunk-R4N52NI2.mjs';
 import './chunk-ONVPCAMQ.mjs';
 import './chunk-K7LFG5BA.mjs';
-import { __spreadValues } from './chunk-R4SQKVDQ.mjs';
+import { __spreadValues } from './chunk-6F7H4PAA.mjs';
 import { RainbowKitProvider, darkTheme, lightTheme } from '@rainbow-me/rainbowkit';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import React2, { useEffect } from 'react';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dappworks/kit",
-  "version": "0.5.40",
+  "version": "0.5.41",
   "description": "",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
@@ -111,7 +111,7 @@
   "scripts": {
     "dev": "npm run build -- --watch",
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsup --format esm",
+    "build": "tsup --format esm --dts",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {