@luno-kit/react 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,256 @@
+import React, { ReactNode } from 'react';
+import { Config, Account, Connector, AccountBalance, Chain, Signer } from '@luno-kit/core';
+export * from '@luno-kit/core';
+import { LegacyClient, SubstrateRuntimeVersion } from 'dedot';
+import { HexString } from 'dedot/utils';
+import { Callback, IEventRecord, ISubmittableExtrinsic } from 'dedot/types';
+import { MutateOptions, UseQueryResult } from '@tanstack/react-query';
+import { DispatchError, DispatchInfo } from 'dedot/codecs';
+
+interface LunoProviderProps {
+    config: Config;
+    children: ReactNode;
+}
+declare const LunoProvider: React.FC<LunoProviderProps>;
+
+declare enum ConnectionStatus {
+    Disconnected = "disconnected",
+    Connecting = "connecting",
+    Disconnecting = "disconnecting",
+    Connected = "connected"
+}
+
+type TxStatus = 'idle' | 'signing' | 'pending' | 'success' | 'failed';
+
+interface UseApiResult {
+    api?: LegacyClient;
+    isApiReady: boolean;
+    apiError: Error | null;
+}
+declare const useApi: () => UseApiResult;
+
+interface UseAccountResult {
+    account?: Account;
+    address?: string;
+}
+declare const useAccount: () => UseAccountResult;
+
+interface UseAccountsResult {
+    accounts: Account[];
+    selectAccount: (accountOrAddress?: Account | HexString) => void;
+}
+declare const useAccounts: () => UseAccountsResult;
+
+declare const useActiveConnector: () => Connector | undefined;
+
+type SubscriptionFn<TArgs extends any[], TData> = (...params: [...TArgs, Callback<TData>]) => Promise<() => Promise<void>>;
+interface UseSubscriptionOptions<TData, TTransformed = TData> {
+    enabled?: boolean;
+    transform?: (data: TData) => TTransformed;
+    defaultValue?: TTransformed;
+}
+type ApiBoundSubscriptionFactory<TArgs extends any[], TData> = (api: LegacyClient) => SubscriptionFn<TArgs, TData>;
+interface QueryMultiItem {
+    fn: any;
+    args: any[];
+}
+interface UseSubscriptionProps<TArgs extends any[], TData, TTransformed = TData> {
+    queryKey: string | number;
+    factory: ApiBoundSubscriptionFactory<TArgs, TData> | ((api: LegacyClient) => any);
+    params: TArgs | ((api: LegacyClient) => QueryMultiItem[]);
+    options?: UseSubscriptionOptions<TData, TTransformed>;
+}
+interface UseSubscriptionResult<TTransformed> {
+    data?: TTransformed;
+    error?: Error;
+    isLoading: boolean;
+}
+declare const useSubscription: <TArgs extends any[], TData, TTransformed = TData>({ queryKey: userQueryKey, factory, params, options }: UseSubscriptionProps<TArgs, TData, TTransformed>) => UseSubscriptionResult<TTransformed>;
+
+interface ChainProperties {
+    ss58Format?: number;
+    tokenDecimals?: number;
+    tokenSymbol?: string;
+}
+interface UseBalanceProps {
+    address?: string;
+}
+type UseBalanceResult = UseSubscriptionResult<AccountBalance>;
+declare const useBalance: ({ address }: UseBalanceProps) => UseBalanceResult;
+
+type UseBlockNumberResult = UseSubscriptionResult<number>;
+declare const useBlockNumber: () => UseBlockNumberResult;
+
+interface UseChainResult {
+    chain?: Chain;
+    chainId?: string;
+}
+declare const useChain: () => UseChainResult;
+
+declare const useChains: () => Chain[];
+
+declare const useConnectors: () => Connector[];
+
+declare const useConfig: () => Config | undefined;
+
+type LunoMutationOptions<TData = unknown, TError = Error, TVariables = void, TContext = unknown> = Partial<Pick<MutateOptions<TData, TError, TVariables, TContext>, 'onSuccess' | 'onError' | 'onSettled'>>;
+
+interface ConnectVariables {
+    connectorId: string;
+    targetChainId?: string;
+}
+type UseConnectOptions = LunoMutationOptions<void, Error, ConnectVariables, unknown>;
+interface UseConnectResult {
+    connect: (variables: ConnectVariables, options?: UseConnectOptions) => void;
+    connectAsync: (variables: ConnectVariables, options?: UseConnectOptions) => Promise<void>;
+    connectors: Connector[];
+    activeConnector?: Connector;
+    status: ConnectionStatus;
+    data: void | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    reset: () => void;
+    variables: ConnectVariables | undefined;
+}
+declare const useConnect: (hookLevelConfig?: UseConnectOptions) => UseConnectResult;
+
+type UseDisconnectOptions = LunoMutationOptions<void, Error, void, unknown>;
+interface UseDisconnectResult {
+    disconnect: (options?: UseDisconnectOptions) => void;
+    disconnectAsync: (options?: UseDisconnectOptions) => Promise<void>;
+    status: ConnectionStatus;
+    data: void | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    reset: () => void;
+    variables: void | undefined;
+}
+declare const useDisconnect: (hookLevelConfig?: UseDisconnectOptions) => UseDisconnectResult;
+
+interface UseGenesisHashResult {
+    data?: HexString;
+    error: Error | null;
+    isLoading: boolean;
+}
+declare const useGenesisHash: () => UseGenesisHashResult;
+
+type UseRuntimeVersionResult = UseQueryResult<SubstrateRuntimeVersion, Error>;
+declare const useRuntimeVersion: () => UseRuntimeVersionResult;
+
+type DetailedTxStatus = 'idle' | 'broadcasting' | 'inBlock' | 'finalized' | 'invalid' | 'dropped';
+interface TransactionReceipt {
+    transactionHash: HexString;
+    blockHash: HexString;
+    blockNumber?: number;
+    readonly events: IEventRecord[];
+    status: 'failed' | 'success';
+    dispatchError?: DispatchError;
+    errorMessage?: string;
+    dispatchInfo?: DispatchInfo;
+}
+interface SendTransactionVariables {
+    extrinsic: ISubmittableExtrinsic;
+}
+type UseSendTransactionOptions = LunoMutationOptions<TransactionReceipt, Error, SendTransactionVariables, unknown>;
+interface UseSendTransactionResult {
+    sendTransaction: (variables: SendTransactionVariables, options?: UseSendTransactionOptions) => void;
+    sendTransactionAsync: (variables: SendTransactionVariables, options?: UseSendTransactionOptions) => Promise<TransactionReceipt>;
+    data: TransactionReceipt | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    status: 'idle' | 'pending' | 'error' | 'success';
+    reset: () => void;
+    variables: SendTransactionVariables | undefined;
+    txStatus: TxStatus;
+    detailedStatus: DetailedTxStatus;
+}
+declare function useSendTransaction(hookLevelConfig?: UseSendTransactionOptions): UseSendTransactionResult;
+
+interface SendTransactionHashVariables {
+    extrinsic: ISubmittableExtrinsic;
+}
+type UseSendTransactionHashOptions = LunoMutationOptions<HexString, Error, SendTransactionHashVariables, unknown>;
+interface UseSendTransactionHashResult {
+    sendTransaction: (variables: SendTransactionHashVariables, options?: UseSendTransactionHashOptions) => void;
+    sendTransactionAsync: (variables: SendTransactionHashVariables, options?: UseSendTransactionHashOptions) => Promise<HexString>;
+    data: HexString | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    status: 'idle' | 'pending' | 'error' | 'success';
+    reset: () => void;
+    variables: SendTransactionHashVariables | undefined;
+}
+declare function useSendTransactionHash(hookLevelConfig?: UseSendTransactionHashOptions): UseSendTransactionHashResult;
+
+interface SignMessageVariables {
+    message: string;
+}
+interface SignMessageData {
+    signature: string;
+    rawMessage: string;
+    addressUsed: string;
+}
+type UseSignMessageOptions = LunoMutationOptions<SignMessageData, Error, SignMessageVariables, unknown>;
+interface UseSignMessageResult {
+    signMessage: (variables: SignMessageVariables, options?: UseSignMessageOptions) => void;
+    signMessageAsync: (variables: SignMessageVariables, options?: UseSignMessageOptions) => Promise<SignMessageData>;
+    data: SignMessageData | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    status: 'idle' | 'pending' | 'error' | 'success';
+    reset: () => void;
+    variables: SignMessageVariables | undefined;
+}
+declare function useSignMessage(hookLevelConfig?: UseSignMessageOptions): UseSignMessageResult;
+
+interface UseSs58FormatResult {
+    data?: number;
+    isLoading: boolean;
+}
+declare const useSs58Format: () => UseSs58FormatResult;
+
+declare const useStatus: () => ConnectionStatus;
+
+interface SwitchChainVariables {
+    chainId: string;
+}
+type UseSwitchChainOptions = LunoMutationOptions<void, Error, SwitchChainVariables, unknown>;
+interface UseSwitchChainResult {
+    switchChain: (variables: SwitchChainVariables, options?: UseSwitchChainOptions) => void;
+    switchChainAsync: (variables: SwitchChainVariables, options?: UseSwitchChainOptions) => Promise<void>;
+    chains: Chain[];
+    currentChain?: Chain;
+    currentChainId?: string;
+    data: void | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    reset: () => void;
+    variables: SwitchChainVariables | undefined;
+}
+declare const useSwitchChain: (hookLevelConfig?: UseSwitchChainOptions) => UseSwitchChainResult;
+
+interface UseSignerResult {
+    signer?: Signer;
+    isLoading: boolean;
+}
+declare const useSigner: () => UseSignerResult;
+
+export { type ChainProperties, type ConnectVariables, ConnectionStatus, type DetailedTxStatus, LunoProvider, type QueryMultiItem, type SendTransactionHashVariables, type SendTransactionVariables, type SignMessageData, type SignMessageVariables, type SwitchChainVariables, type TransactionReceipt, type UseAccountResult, type UseAccountsResult, type UseApiResult, type UseBalanceProps, type UseBalanceResult, type UseBlockNumberResult, type UseChainResult, type UseConnectOptions, type UseConnectResult, type UseDisconnectOptions, type UseDisconnectResult, type UseGenesisHashResult, type UseRuntimeVersionResult, type UseSendTransactionHashOptions, type UseSendTransactionHashResult, type UseSendTransactionOptions, type UseSendTransactionResult, type UseSignMessageOptions, type UseSignMessageResult, type UseSignerResult, type UseSs58FormatResult, type UseSubscriptionOptions, type UseSubscriptionProps, type UseSubscriptionResult, type UseSwitchChainOptions, type UseSwitchChainResult, useAccount, useAccounts, useActiveConnector, useApi, useBalance, useBlockNumber, useChain, useChains, useConfig, useConnect, useConnectors, useDisconnect, useGenesisHash, useRuntimeVersion, useSendTransaction, useSendTransactionHash, useSignMessage, useSigner, useSs58Format, useStatus, useSubscription, useSwitchChain };