@useelven/core/dist/index.d.mts

Core React hooks for MultiversX DApps

import { WalletProvider } from '@multiversx/sdk-web-wallet-provider';
import { WalletConnectV2Provider } from '@multiversx/sdk-wallet-connect-provider';
import { ExtensionProvider } from '@multiversx/sdk-extension-provider';
import * as _multiversx_sdk_core from '@multiversx/sdk-core';
import { ApiNetworkProvider, ProxyNetworkProvider, Transaction, ITransactionOnNetwork, IGasLimit, ITransactionPayload, ITransactionValue, TypedValue } from '@multiversx/sdk-core';
import { HWProvider } from '@multiversx/sdk-hw-provider';
import { WebviewProvider } from '@multiversx/sdk-webview-provider/out';
import * as _multiversx_sdk_core_out from '@multiversx/sdk-core/out';
import { KeyedMutator } from 'swr';
import { SWRMutationResponse } from 'swr/mutation';

interface BaseNetworkType extends Record<string, string | string[] | undefined> {
    chainType?: string;
    shortId?: string;
    name?: string;
    egldLabel?: string;
    egldDenomination?: string;
    decimals?: string;
    gasPerDataByte?: string;
    walletConnectDeepLink?: string;
    xAliasAddress?: string;
    walletAddress?: string;
    apiAddress?: string;
    explorerAddress?: string;
    IPFSGateway?: string;
    apiTimeout?: string;
    txWatcherTimeout?: string;
    txWatcherPatience?: string;
}
interface NetworkType extends BaseNetworkType {
    walletConnectV2RelayAddresses?: string[];
    walletConnectV2ProjectId?: string;
}
type DappProvider = ExtensionProvider | WalletConnectV2Provider | WalletProvider | HWProvider | WebviewProvider;
type NetworkProvider = ApiNetworkProvider | ProxyNetworkProvider;

declare const useNetworkSync: (config?: NetworkType) => void;

declare enum LoginMethodsEnum {
    ledger = "ledger",
    walletconnect = "walletconnect",
    wallet = "wallet",
    extension = "extension",
    xalias = "xalias",
    hub = "hub",
    none = ""
}
declare enum EnvironmentsEnum {
    testnet = "testnet",
    devnet = "devnet",
    mainnet = "mainnet",
    notDefined = ""
}
declare enum LocalstorageKeys {
    account = "useElven_dapp__account",
    loginInfo = "useElven_dapp__loginInfo"
}
declare enum WebWalletUrlParamsEnum {
    hasWebWalletGuardianSign = "hasWebWalletGuardianSign"
}
declare enum ESDTType {
    FungibleESDT = "FungibleESDT",
    MetaESDT = "MetaESDT",
    NonFungibleESDT = "NonFungibleESDT",
    SemiFungibleESDT = "SemiFungibleESDT"
}

interface LoggingInState extends Record<string, unknown> {
    pending: boolean;
    error: string;
    loggedIn: boolean;
}

interface TransactionCallbackParams {
    transaction?: Transaction | null;
    error?: string;
    pending?: boolean;
    txResult?: ITransactionOnNetwork | null;
}

interface TransactionParams {
    address?: string;
    gasLimit?: IGasLimit;
    data?: ITransactionPayload | Uint8Array;
    value?: ITransactionValue;
    tx?: Transaction;
}
interface TransactionArgs {
    id?: string;
    callbackUrl?: string;
    cb?: (params: TransactionCallbackParams) => void;
}
declare function useTransaction({ id, callbackUrl, cb }?: TransactionArgs): {
    pending: boolean;
    triggerTx: ({ address, data, gasLimit, value, tx, }: TransactionParams) => Promise<void>;
    transaction: Transaction | null;
    txResult: ITransactionOnNetwork | null;
    error: string;
};

interface Logout {
    dappProvider?: DappProvider;
    callbackUrl?: string;
}
declare const useLogout: () => {
    logout: (params?: Logout) => Promise<void>;
    pending: boolean;
    loggedIn: boolean;
    error: string;
};

interface LocalAccountInstance {
    address: string;
    balance: string;
    nonce: number;
}
interface Login {
    callbackUrl?: string;
}

interface PairingTypesStruct {
    topic: string;
    expiry: number;
    relay: {
        protocol: string;
        data?: string;
    };
    active: boolean;
    peerMetadata?: {
        name: string;
        description: string;
        url: string;
        icons: string[];
        verifyUrl?: string;
        redirect?: {
            native?: string;
            universal?: string;
        };
    };
}
declare const useMobileAppLogin: (params?: Login) => {
    login: () => Promise<void>;
    walletConnectUri: string;
    walletConnectPairings: PairingTypesStruct[] | undefined;
    walletConnectPairingLogin: (topic: string) => Promise<void>;
    walletConnectRemovePairing: (topic: string) => Promise<void>;
    loggedIn: boolean;
    pending: boolean;
    error: string;
    logout: (params?: Logout) => Promise<void>;
    setLoggingInState: (key: keyof LoggingInState, value: unknown) => void;
};

declare const useLogin: (params?: Login) => {
    walletConnectUri: string;
    walletConnectPairingLogin: (topic: string) => Promise<void>;
    walletConnectPairings: PairingTypesStruct[] | undefined;
    walletConnectRemovePairing: (topic: string) => Promise<void>;
    getHWAccounts: (page?: number, pageSize?: number) => Promise<string[]>;
    login: (type: LoginMethodsEnum, ledgerAccountIndex?: number, ledgerPage?: number, ledgerPageSize?: number) => Promise<null>;
    isLoggedIn: boolean;
    isLoggingIn: boolean;
    error: string;
    setLoggingInState: (key: keyof LoggingInState, value: unknown) => void;
};

declare const useLoginInfo: () => {
    loginMethod: LoginMethodsEnum;
    expires: number;
    loginToken: string;
    signature: string;
    accessToken: string;
};

declare const useLoggingIn: () => {
    pending: boolean;
    error: string;
    loggedIn: boolean;
};

declare const useWebWalletLogin: (params: Login | undefined) => {
    login: () => Promise<void>;
    loggedIn: boolean;
    pending: boolean;
    error: string;
    logout: (params?: Logout) => Promise<void>;
    setLoggingInState: (key: keyof LoggingInState, value: unknown) => void;
};

declare const useXaliasLogin: (params: Login | undefined) => {
    login: () => Promise<void>;
    loggedIn: boolean;
    pending: boolean;
    error: string;
    logout: (params?: Logout) => Promise<void>;
    setLoggingInState: (key: keyof LoggingInState, value: unknown) => void;
};

declare const useLedgerLogin: (params?: Login) => {
    login: (addressIndex?: number, page?: number, pageSize?: number) => Promise<void>;
    loggedIn: boolean;
    pending: boolean;
    getHWAccounts: (page?: number, pageSize?: number) => Promise<string[]>;
    error: string;
    logout: (params?: Logout) => Promise<void>;
    setLoggingInState: (key: keyof LoggingInState, value: unknown) => void;
};

declare const useExtensionLogin: (params?: Login) => {
    login: () => Promise<void>;
    loggedIn: boolean;
    pending: boolean;
    error: string;
    logout: (params?: Logout) => Promise<void>;
    setLoggingInState: (key: keyof LoggingInState, value: unknown) => void;
};

declare const useAccount: () => {
    addressIndex: number;
    address: string;
    balance: string;
    nonce: number;
    activeGuardianAddress: string;
};

declare const useConfig: () => {
    chainType: string | undefined;
    shortId: string | undefined;
    name: string | undefined;
    egldLabel: string | undefined;
    egldDenomination: string | undefined;
    decimals: string | undefined;
    gasPerDataByte: string | undefined;
    walletConnectDeepLink: string | undefined;
    xAliasAddress: string | undefined;
    walletAddress: string | undefined;
    apiAddress: string | undefined;
    explorerAddress: string | undefined;
    apiTimeout: string | undefined;
    txWatcherTimeout: string | undefined;
    txWatcherPatience: string | undefined;
    IPFSGateway: string | undefined;
    walletConnectV2RelayAddresses: string[] | readonly string[] | undefined;
    walletConnectV2ProjectId: string | undefined;
};

declare const useNetwork: () => {
    dappProvider: DappProvider | null;
    apiNetworkProvider: _multiversx_sdk_core_out.ApiNetworkProvider | null;
};

interface BaseToken {
    type: ESDTType;
    tokenId: string;
}
interface NonFungibleESDTToken extends BaseToken {
    type: ESDTType.NonFungibleESDT;
    amount?: never;
}
interface OtherToken extends BaseToken {
    type: ESDTType.FungibleESDT | ESDTType.SemiFungibleESDT | ESDTType.MetaESDT;
    amount: string;
}
type MultiTransferToken = NonFungibleESDTToken | OtherToken;
type MultiTokenTransferTxArgs = {
    tokens: MultiTransferToken[];
    receiver: string;
    gasLimit?: never;
    endpointName?: never;
    endpointArgs?: never;
};
type MultiTokenTransferScArgs<T> = {
    tokens: MultiTransferToken[];
    receiver: string;
    gasLimit: number;
    endpointName: string;
    endpointArgs?: T[];
};
type MultiTokenTransferArgs<T> = MultiTokenTransferTxArgs | MultiTokenTransferScArgs<T>;
interface MultiTokenTransferHookProps {
    id?: TransactionArgs['id'];
    callbackUrl?: TransactionArgs['callbackUrl'];
    cb?: TransactionArgs['cb'];
}
declare const useTokenTransfer: ({ id, callbackUrl, cb }?: MultiTokenTransferHookProps) => {
    transfer: <T extends TypedValue>({ tokens, receiver, gasLimit, endpointName, endpointArgs, }: MultiTokenTransferArgs<T>) => Promise<void>;
    pending: boolean;
    transaction: _multiversx_sdk_core.Transaction | null;
    txResult: _multiversx_sdk_core.ITransactionOnNetwork | null;
    error: string;
};

type SignMessageArgs = {
    message: string;
    options?: {
        callbackUrl?: string;
    };
};
declare const useSignMessage: () => {
    signMessage: ({ message, options }: SignMessageArgs) => Promise<void>;
    pending: boolean | undefined;
    signature: string | undefined;
    error: string | undefined;
};

interface ScDeployHookProps {
    id?: TransactionArgs['id'];
    callbackUrl?: TransactionArgs['callbackUrl'];
    cb?: TransactionArgs['cb'];
}
interface ScDeployArgs<T> {
    source: Buffer | string;
    gasLimit?: number;
    isUpgradeable?: boolean;
    isReadable?: boolean;
    isPayable?: boolean;
    isPayableBySmartContract?: boolean;
    initArguments?: T[];
}
declare const useScDeploy: ({ id, callbackUrl, cb }?: ScDeployHookProps) => {
    deploy: <T extends TypedValue>({ source, gasLimit, initArguments, isUpgradeable, isReadable, isPayable, isPayableBySmartContract, }: ScDeployArgs<T>) => Promise<void>;
    pending: boolean;
    transaction: _multiversx_sdk_core.Transaction | null;
    txResult: _multiversx_sdk_core.ITransactionOnNetwork | null;
    scAddress: string | undefined;
    error: string;
};

declare enum SCQueryType {
    NUMBER = "number",
    STRING = "string",
    BOOLEAN = "boolean",
    COMPLEX = "complex"
}
interface SCQueryData {
    type: SCQueryType;
    payload?: Record<string, unknown>;
    options?: Record<string, unknown>;
    autoInit?: boolean;
    abiJSON?: {
        name: string;
        endpoints: unknown[];
        types: Record<string, any> | undefined;
    };
}
declare function useScQuery<T extends number | string | boolean | unknown>({ type, payload, options, autoInit, abiJSON, }: SCQueryData): {
    data: T;
    isLoading: boolean;
    isValidating: boolean;
    error: any;
    fetch: KeyedMutator<any> | SWRMutationResponse['trigger'];
};

interface ApiCallData {
    url: string;
    type?: string;
    payload?: Record<string, unknown>;
    options?: Record<string, unknown>;
    autoInit?: boolean;
    baseEndpoint?: string;
}
declare function useApiCall<T>({ url, type, payload, options, autoInit, baseEndpoint, }: ApiCallData): {
    data: T;
    isLoading: boolean;
    isValidating: boolean;
    error: any;
    fetch: KeyedMutator<any> | SWRMutationResponse['trigger'];
};

type AmountArgs = {
    amount: string;
    decimals: number;
    rounding?: number;
};
/**
 * Parses the amount from string
 * @param amount
 * @param decimals
 * @returns bigInt
 */
declare const parseAmount: ({ amount, decimals, }: Omit<AmountArgs, "rounding">) => bigint;
/**
 * Formats the amount from string (bigInt)
 * @param amount
 * @param decimals
 * @param rounding
 * @returns string
 */
declare const formatAmount: ({ amount, decimals, rounding, }: AmountArgs) => string;

export { type BaseNetworkType, type DappProvider, ESDTType, EnvironmentsEnum, type LocalAccountInstance, LocalstorageKeys, type Login, LoginMethodsEnum, type Logout, type MultiTokenTransferArgs, type MultiTokenTransferHookProps, type MultiTransferToken, type NetworkProvider, type NetworkType, type PairingTypesStruct, SCQueryType, type ScDeployArgs, type ScDeployHookProps, type SignMessageArgs, type TransactionArgs, type TransactionCallbackParams, type TransactionParams, WebWalletUrlParamsEnum, formatAmount, parseAmount, useAccount, useApiCall, useConfig, useExtensionLogin, useLedgerLogin, useLoggingIn, useLogin, useLoginInfo, useLogout, useMobileAppLogin, useNetwork, useNetworkSync, useScDeploy, useScQuery, useSignMessage, useTokenTransfer, useTransaction, useWebWalletLogin, useXaliasLogin };