@reown/appkit-utils 1.8.15-viem-upgrade.0 → 1.8.15-wc-linking-reset-headless.0

package/dist/types/exports/bitcoin.d.ts

@@ -0,0 +1,2 @@
+export * from '../src/bitcoin/BitcoinConstantsUtil.js';
+export type * from '../src/bitcoin/BitcoinTypesUtil.js';

package/dist/types/exports/ethers.d.ts

@@ -0,0 +1,6 @@
+export * from '../src/ethers/EthersHelpersUtil.js';
+export * from '../src/ethers/BaseProvider.js';
+export * from '../src/ethers/SafeProvider.js';
+export * from '../src/ethers/InjectedProvider.js';
+export * from '../src/ethers/EthersProvider.js';
+export type * from '../src/ethers/EthersTypesUtil.js';

package/dist/types/exports/index.d.ts

@@ -0,0 +1,35 @@
+import type UniversalProvider from '@walletconnect/universal-provider';
+import type { W3mFrameProvider } from '@reown/appkit-wallet';
+export { ConstantsUtil } from '../src/ConstantsUtil.js';
+export { PresetsUtil } from '../src/PresetsUtil.js';
+export { HelpersUtil } from '../src/HelpersUtil.js';
+export { SemVerUtils } from '../src/SemVerUtils.js';
+export { ErrorUtil } from '../src/ErrorUtil.js';
+export { TokenUtil } from '../src/TokenUtil.js';
+export { LoggerUtil } from '../src/LoggerUtil.js';
+export { CaipNetworksUtil, getBlockchainApiRpcUrl } from '../src/CaipNetworkUtil.js';
+export type { SocialProvider } from '../src/TypeUtil.js';
+export { SocialProviderEnum } from '../src/TypeUtil.js';
+export interface RequestArguments {
+    readonly method: string;
+    readonly params?: readonly unknown[] | object;
+}
+type ProviderEventListener = {
+    connect: (connectParams: {
+        chainId: number;
+    }) => void;
+    disconnect: (error: Error) => void;
+    chainChanged: (chainId: string) => void;
+    accountsChanged: (accounts: string[]) => void;
+    message: (message: {
+        type: string;
+        data: unknown;
+    }) => void;
+};
+export interface Provider {
+    request: <T>(args: RequestArguments) => Promise<T>;
+    on<T extends keyof ProviderEventListener>(event: T, listener: ProviderEventListener[T]): void;
+    removeListener: <T>(event: string, listener: (data: T) => void) => void;
+    emit: (event: string) => void;
+}
+export type UniversalProviderType = UniversalProvider & W3mFrameProvider & Provider;

package/dist/types/exports/solana.d.ts

@@ -0,0 +1,3 @@
+export * from '../src/solana/SolanaConstantsUtil.js';
+export * from '../src/solana/SolanaHelpersUtils.js';
+export type * from '../src/solana/SolanaTypesUtil.js';

package/dist/types/exports/ton.d.ts

@@ -0,0 +1 @@
+export type * from '../src/ton/TonTypesUtil.js';

package/dist/types/exports/wallet-standard.d.ts

@@ -0,0 +1 @@
+export { SolanaWalletConnectStandardWallet } from '../src/wallet-standard/SolanaWalletConnectStandardWallet.js';

package/dist/types/src/CaipNetworkUtil.d.ts

@@ -0,0 +1,59 @@
+import { type HttpTransport, type Transport } from 'viem';
+import { type AppKitNetwork, type CaipNetwork, type CaipNetworkId, type ChainNamespace, type CustomRpcUrl, type CustomRpcUrlMap } from '@reown/appkit-common';
+export declare function getBlockchainApiRpcUrl(caipNetworkId: CaipNetworkId, projectId: string): string;
+type ExtendCaipNetworkParams = {
+    customNetworkImageUrls: Record<number | string, string> | undefined;
+    projectId: string;
+    customRpc?: boolean;
+    customRpcUrls?: CustomRpcUrlMap;
+};
+export declare const CaipNetworksUtil: {
+    /**
+     * Extends the RPC URL with the project ID if the RPC URL is a Reown URL
+     * @param rpcUrl - The RPC URL to extend
+     * @param projectId - The project ID to extend the RPC URL with
+     * @returns The extended RPC URL
+     */
+    extendRpcUrlWithProjectId(rpcUrl: string, projectId: string): string;
+    isCaipNetwork(network: AppKitNetwork): network is CaipNetwork;
+    getChainNamespace(network: AppKitNetwork): ChainNamespace<import("@reown/appkit-common").InternalChainNamespace>;
+    getCaipNetworkId(network: AppKitNetwork): CaipNetworkId;
+    getDefaultRpcUrl(caipNetwork: AppKitNetwork, caipNetworkId: CaipNetworkId, projectId: string): string;
+    /**
+     * Extends the CaipNetwork object with the image ID and image URL if the image ID is not provided
+     * @param params - The parameters object
+     * @param params.caipNetwork - The CaipNetwork object to extend
+     * @param params.networkImageIds - The network image IDs
+     * @param params.customNetworkImageUrls - The custom network image URLs
+     * @param params.projectId - The project ID
+     * @param params.customRpc - Boolean to indicate if the custom RPC URL should be used
+     * @param params.customRpcUrls - The map of chain and custom RPC URLs to be used by the AppKit
+     * @returns The extended array of CaipNetwork objects
+     */
+    extendCaipNetwork(caipNetwork: AppKitNetwork | CaipNetwork, { customNetworkImageUrls, projectId, customRpcUrls }: ExtendCaipNetworkParams): CaipNetwork;
+    /**
+     * Extends the array of CaipNetwork objects with the image ID and image URL if the image ID is not provided
+     * @param caipNetworks - The array of CaipNetwork objects to extend
+     * @param params - The parameters object
+     * @param params.networkImageIds - The network image IDs
+     * @param params.customNetworkImageUrls - The custom network image URLs
+     * @param params.customRpcUrls - The map of chain and custom RPC URLs to be used by the AppKit
+     * @param params.projectId - The project ID
+     * @returns The extended array of CaipNetwork objects
+     */
+    extendCaipNetworks(caipNetworks: AppKitNetwork[], { customNetworkImageUrls, projectId, customRpcUrls }: ExtendCaipNetworkParams): [CaipNetwork, ...CaipNetwork[]];
+    getViemTransport(caipNetwork: CaipNetwork, projectId: string, customRpcUrls?: CustomRpcUrl[]): import("viem").FallbackTransport<HttpTransport[]>;
+    extendWagmiTransports(caipNetwork: CaipNetwork, projectId: string, transport: Transport): Transport | import("viem").FallbackTransport<readonly [Transport, HttpTransport<undefined, false>]>;
+    /**
+     * Generates the unsupported network object with the given CaipNetwork ID
+     * @param caipNetworkId - The CAIP network ID
+     * @returns The unsupported CAIP network object
+     */
+    getUnsupportedNetwork(caipNetworkId: CaipNetworkId): CaipNetwork;
+    /**
+     * Gets the CaipNetwork object from the storage if `@appkit/active_caip_network_id` is being set
+     * @returns CaipNetwork or undefined
+     */
+    getCaipNetworkFromStorage(defaultCaipNetwork?: CaipNetwork): CaipNetwork | undefined;
+};
+export {};

package/dist/types/src/ConstantsUtil.d.ts

@@ -0,0 +1,28 @@
+export declare const ConstantsUtil: {
+    METMASK_CONNECTOR_NAME: string;
+    TRUST_CONNECTOR_NAME: string;
+    SOLFLARE_CONNECTOR_NAME: string;
+    PHANTOM_CONNECTOR_NAME: string;
+    COIN98_CONNECTOR_NAME: string;
+    MAGIC_EDEN_CONNECTOR_NAME: string;
+    BACKPACK_CONNECTOR_NAME: string;
+    BITGET_CONNECTOR_NAME: string;
+    FRONTIER_CONNECTOR_NAME: string;
+    XVERSE_CONNECTOR_NAME: string;
+    LEATHER_CONNECTOR_NAME: string;
+    OKX_CONNECTOR_NAME: string;
+    BINANCE_CONNECTOR_NAME: string;
+    EIP155: "eip155";
+    ADD_CHAIN_METHOD: string;
+    EIP6963_ANNOUNCE_EVENT: string;
+    EIP6963_REQUEST_EVENT: string;
+    CONNECTOR_RDNS_MAP: Record<string, string>;
+    CONNECTOR_TYPE_EXTERNAL: string;
+    CONNECTOR_TYPE_WALLET_CONNECT: string;
+    CONNECTOR_TYPE_INJECTED: string;
+    CONNECTOR_TYPE_ANNOUNCED: string;
+    CONNECTOR_TYPE_AUTH: string;
+    CONNECTOR_TYPE_MULTI_CHAIN: string;
+    CONNECTOR_TYPE_W3M_AUTH: string;
+    getSDKVersionWarningMessage(currentVersion: string, latestVersion: string): string;
+};

package/dist/types/src/ErrorUtil.d.ts

@@ -0,0 +1,88 @@
+export declare const ErrorUtil: {
+    EmbeddedWalletAbortController: AbortController;
+    /**
+     * Universal Provider errors. Make sure the `message` is matching with the errors thrown by the Universal Provider.
+     * We use the `alertErrorKey` to map the error to the correct AppKit alert error.
+     */
+    UniversalProviderErrors: {
+        UNAUTHORIZED_DOMAIN_NOT_ALLOWED: {
+            message: string;
+            alertErrorKey: string;
+        };
+        JWT_VALIDATION_ERROR: {
+            message: string;
+            alertErrorKey: string;
+        };
+        INVALID_KEY: {
+            message: string;
+            alertErrorKey: string;
+        };
+    };
+    ALERT_ERRORS: {
+        SWITCH_NETWORK_NOT_FOUND: {
+            code: string;
+            displayMessage: string;
+            debugMessage: string;
+        };
+        ORIGIN_NOT_ALLOWED: {
+            code: string;
+            displayMessage: string;
+            debugMessage: () => string;
+        };
+        IFRAME_LOAD_FAILED: {
+            code: string;
+            displayMessage: string;
+            debugMessage: () => string;
+        };
+        IFRAME_REQUEST_TIMEOUT: {
+            code: string;
+            displayMessage: string;
+            debugMessage: () => string;
+        };
+        UNVERIFIED_DOMAIN: {
+            code: string;
+            displayMessage: string;
+            debugMessage: () => string;
+        };
+        JWT_TOKEN_NOT_VALID: {
+            code: string;
+            displayMessage: string;
+            debugMessage: string;
+        };
+        INVALID_PROJECT_ID: {
+            code: string;
+            displayMessage: string;
+            debugMessage: string;
+        };
+        PROJECT_ID_NOT_CONFIGURED: {
+            code: string;
+            displayMessage: string;
+            debugMessage: string;
+        };
+        SERVER_ERROR_APP_CONFIGURATION: {
+            code: string;
+            displayMessage: string;
+            debugMessage: (errorMessage?: string) => string;
+        };
+        RATE_LIMITED_APP_CONFIGURATION: {
+            code: string;
+            displayMessage: string;
+            debugMessage: string;
+        };
+    };
+    ALERT_WARNINGS: {
+        LOCAL_CONFIGURATION_IGNORED: {
+            debugMessage: (warningMessage: string) => string;
+        };
+        INACTIVE_NAMESPACE_NOT_CONNECTED: {
+            code: string;
+            displayMessage: string;
+            debugMessage: (namespace: string, errorMessage?: string) => string;
+        };
+        INVALID_EMAIL: {
+            code: string;
+            displayMessage: string;
+            debugMessage: string;
+        };
+    };
+};

package/dist/types/src/HelpersUtil.d.ts

@@ -0,0 +1,46 @@
+import { type ChainNamespace } from '@reown/appkit-common';
+import { type Tokens } from '@reown/appkit-controllers';
+export declare const HelpersUtil: {
+    getCaipTokens(tokens?: Tokens): Tokens | undefined;
+    isLowerCaseMatch(str1?: string, str2?: string): boolean;
+    /**
+     * Iterates the Auth connector supported chains and returns the namespace that is last connected to the active chain.
+     * @returns ChainNamespace | undefined
+     */
+    getActiveNamespaceConnectedToAuth(): ChainNamespace | undefined;
+    /**
+     * Runs a condition function again and again until it returns true or the max number of tries is reached.
+     *
+     * @param conditionFn - A function (can be async) that returns true when the condition is met.
+     * @param intervalMs - Time to wait between tries, in milliseconds.
+     * @param maxRetries - Maximum number of times to try before stopping.
+     * @returns A Promise that resolves to true if the condition becomes true in time, or false if it doesn't.
+     */
+    withRetry({ conditionFn, intervalMs, maxRetries }: {
+        conditionFn: () => boolean | Promise<boolean>;
+        intervalMs: number;
+        maxRetries: number;
+    }): Promise<boolean>;
+    /**
+     * Returns the chain namespace from user's chainId which is returned from Auth provider.
+     * @param chainId - The chainId to parse.
+     * @returns The chain namespace.
+     */
+    userChainIdToChainNamespace(chainId: number | string): ChainNamespace;
+    /**
+     * Get all auth namespaces except the active one
+     * @param activeNamespace - The active namespace
+     * @returns All auth namespaces except the active one
+     */
+    getOtherAuthNamespaces(activeNamespace: ChainNamespace | undefined): ChainNamespace[];
+    /**
+     * Gets the storage info for a connector
+     * @param connectorId - The ID of the connector
+     * @param namespace - The namespace of the connector
+     * @returns
+     */
+    getConnectorStorageInfo(connectorId: string, namespace: ChainNamespace): {
+        hasDisconnected: boolean;
+        hasConnected: boolean;
+    };
+};

package/dist/types/src/LoggerUtil.d.ts

@@ -0,0 +1,3 @@
+export declare const LoggerUtil: {
+    createLogger(onError: (error?: Error, ...args: unknown[]) => void, level?: string): import("@walletconnect/logger").Logger;
+};

package/dist/types/src/PresetsUtil.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectorType } from '@reown/appkit-controllers';
+export declare const PresetsUtil: {
+    ConnectorExplorerIds: Record<string, string>;
+    NetworkImageIds: Record<string, string>;
+    ConnectorImageIds: Record<string, string>;
+    ConnectorNamesMap: Record<string, string>;
+    ConnectorTypesMap: Record<string, ConnectorType>;
+    WalletConnectRpcChainIds: number[];
+};

package/dist/types/src/SemVerUtils.d.ts

@@ -0,0 +1,7 @@
+import { type AppKitSdkVersion } from '@reown/appkit-common';
+export declare const SemVerUtils: {
+    extractVersion(version: string | undefined): string | null;
+    checkSDKVersion(version: AppKitSdkVersion): void;
+    isValidVersion(version: string | undefined): boolean;
+    isOlder(currentVersion: string, latestVersion: string): boolean;
+};

package/dist/types/src/TokenUtil.d.ts

@@ -0,0 +1,9 @@
+export declare const TokenUtil: {
+    TOKEN_ADDRESSES_BY_SYMBOL: {
+        USDC: {
+            8453: string;
+            84532: string;
+        };
+    };
+    getTokenSymbolByAddress(tokenAddress?: string): string | undefined;
+};

package/dist/types/src/TypeUtil.d.ts

@@ -0,0 +1,25 @@
+export type SocialProvider = 'google' | 'github' | 'apple' | 'facebook' | 'x' | 'discord' | 'farcaster';
+export declare enum SocialProviderEnum {
+    Google = "google",
+    Github = "github",
+    Apple = "apple",
+    Facebook = "facebook",
+    X = "x",
+    Discord = "discord",
+    Farcaster = "farcaster"
+}
+type AnyFn = (...args: unknown[]) => unknown;
+export type AsStruct<T> = {
+    [P in keyof T as T[P] extends AnyFn ? never : P]: T[P];
+};
+export type WithoutId<T extends {
+    id: unknown;
+}> = Omit<T, 'id'>;
+export type WithoutIdDistributive<T extends {
+    id: unknown;
+}> = DistributiveOmit<T, 'id'>;
+export type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export declare function hasProperty<T extends string>(value: unknown, propertyKey: T): value is Record<T, unknown>;
+export declare function hasProperties<T extends string>(value: unknown, propertyKeys: T[]): value is Record<T, unknown>;
+export {};

package/dist/types/src/WCNamespaceUtil.d.ts

@@ -0,0 +1,11 @@
+import type { Namespace, NamespaceConfig } from '@walletconnect/universal-provider';
+import type { CaipNetwork } from '@reown/appkit-common';
+export declare const DEFAULT_METHODS: {
+    ton: string[];
+    solana: string[];
+    eip155: string[];
+    bip122: string[];
+};
+export declare function getMethodsByChainNamespace(chainNamespace: string): string[];
+export declare function createDefaultNamespace(chainNamespace: string): Namespace;
+export declare function createNamespaces(caipNetworks: CaipNetwork[]): NamespaceConfig;

package/dist/types/src/bitcoin/BitcoinConstantsUtil.d.ts

@@ -0,0 +1,6 @@
+export declare const BitcoinConstantsUtil: {
+    ACCOUNT_INDEXES: {
+        PAYMENT: number;
+        ORDINAL: number;
+    };
+};

package/dist/types/src/bitcoin/BitcoinTypesUtil.d.ts

@@ -0,0 +1,121 @@
+import type { CaipNetwork } from '@reown/appkit-common';
+import type { Connector, Provider } from '@reown/appkit-controllers';
+interface ChainAdapterConnector extends Connector {
+    chains: CaipNetwork[];
+}
+/**
+ * This is the interface for a Bitcoin connector.
+ */
+export interface BitcoinConnector extends ChainAdapterConnector, Provider {
+    getAccountAddresses(): Promise<BitcoinConnector.AccountAddress[]>;
+    signMessage(params: BitcoinConnector.SignMessageParams): Promise<string>;
+    sendTransfer(params: BitcoinConnector.SendTransferParams): Promise<string>;
+    signPSBT(params: BitcoinConnector.SignPSBTParams): Promise<BitcoinConnector.SignPSBTResponse>;
+    switchNetwork(caipNetworkId: string): Promise<void>;
+}
+export declare enum AddressPurpose {
+    Ordinal = "ordinal",
+    Payment = "payment",
+    Stacks = "stx"
+}
+export declare namespace BitcoinConnector {
+    type AccountAddress = {
+        /**
+         * Public address belonging to the account.
+         */
+        address: string;
+        /**
+         * Public key for the derivation path in hex, without 0x prefix
+         */
+        publicKey?: string;
+        /**
+         * The derivation path of the address e.g. "m/84'/0'/0'/0/0"
+         */
+        path?: string;
+        /**
+         * The purpose of the address
+         */
+        purpose: AddressPurpose;
+    };
+    type SignMessageParams = {
+        /**
+         * The message to be signed
+         */
+        message: string;
+        /**
+         * The address to sign the message with
+         */
+        address: string;
+        /**
+         * The type of signature to use
+         */
+        protocol?: 'ecdsa' | 'bip322';
+    };
+    type SendTransferParams = {
+        /**
+         * The amount to be sent in satoshis
+         */
+        amount: string;
+        /**
+         * The address to send the transfer to
+         */
+        recipient: string;
+    };
+    /**
+     * Parameters for signing a PSBT. The names or types of these parameters may vary across different providers. Refer to the links below for more information:
+     * @link https://docs.unisat.io/dev/open-api-documentation/unisat-wallet#signpsbt
+     * @link https://web3.okx.com/build/dev-docs/sdks/chains/bitcoin/provider#signpsbt
+     * @link https://developer.onekey.so/connect-to-software/webapp-connect-onekey/btc/api-reference/signpsbt
+     * @link https://leather.gitbook.io/developers/bitcoin-methods/signpsbt
+     */
+    type SignPSBTParams = {
+        /**
+         * The PSBT to be signed, string base64 encoded
+         */
+        psbt: string;
+        signInputs: {
+            /**
+             * The address whose private key to use for signing.
+             */
+            address: string;
+            /**
+             * Specifies which input to sign
+             */
+            index: number;
+            /**
+             * Specifies which part(s) of the transaction the signature commits to
+             */
+            sighashTypes: number[];
+            /**
+             * (Optional) The public key corresponding to the private key to use for signing.
+             * At least specify either an address or a public key.
+             */
+            publicKey?: string;
+            /**
+             * (Optional) When signing and unlocking Taproot addresses, the tweakSigner is used by default for signature generation.
+             * Enabling this allows for signing with the original private key.
+             */
+            disableTweakSigner?: boolean;
+            /**
+             * (Optional) By setting useTweakedSigner, you can forcibly decide whether or not to use tweakedSigner.
+             * It has a higher priority than disableTweakSigner.
+             */
+            useTweakedSigner?: boolean;
+        }[];
+        /**
+         * If `true`, the PSBT will be broadcasted after signing. Default is `false`.
+         */
+        broadcast?: boolean;
+    };
+    type SignPSBTResponse = {
+        /**
+         * The signed PSBT, string base64 encoded
+         */
+        psbt: string;
+        /**
+         * The `string` transaction id of the broadcasted transaction or `undefined` if not broadcasted
+         */
+        txid?: string;
+    };
+}
+export {};

package/dist/types/src/ethers/BaseProvider.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderInterface } from '@base-org/account';
+import { EthersProvider } from './EthersProvider.js';
+export declare class BaseProvider extends EthersProvider<ProviderInterface> {
+    initialize(): Promise<void>;
+    getProvider(): Promise<ProviderInterface | undefined>;
+}

package/dist/types/src/ethers/EthersHelpersUtil.d.ts

@@ -0,0 +1,14 @@
+import type { CaipNetwork } from '@reown/appkit-common';
+import type { Provider } from './EthersTypesUtil.js';
+export declare const EthersHelpersUtil: {
+    hexStringToNumber(value: string): number;
+    numberToHexString(value: number | string): string;
+    getUserInfo(provider: Provider): Promise<{
+        chainId: number;
+        addresses: string[];
+    }>;
+    getChainId(provider: Provider): Promise<number>;
+    getAddress(provider: Provider): Promise<string | undefined>;
+    getAddresses(provider: Provider): Promise<string[]>;
+    addEthereumChain(provider: Provider, caipNetwork: CaipNetwork): Promise<void>;
+};

package/dist/types/src/ethers/EthersProvider.d.ts

@@ -0,0 +1,12 @@
+import type { Provider } from '@reown/appkit-controllers';
+export declare abstract class EthersProvider<T> {
+    protected provider?: T;
+    initialized: boolean;
+    abstract initialize(): Promise<void>;
+    getProvider(): Promise<T | undefined>;
+}
+declare global {
+    interface Window {
+        ethereum: Provider;
+    }
+}

package/dist/types/src/ethers/EthersStoreUtil.d.ts

@@ -0,0 +1,29 @@
+import type { W3mFrameTypes } from '@reown/appkit-wallet';
+import type { Address, CombinedProvider, Provider } from './EthersTypesUtil.js';
+export type Status = 'reconnecting' | 'connected' | 'disconnected';
+export interface EthersStoreUtilState {
+    provider?: Provider | CombinedProvider;
+    providerType?: 'walletConnect' | 'injected' | 'coinbaseWallet' | 'eip6963' | 'AUTH' | 'coinbaseWalletSDK';
+    address?: Address;
+    chainId?: number;
+    error?: unknown;
+    preferredAccountType?: W3mFrameTypes.AccountType;
+    status: Status;
+    isConnected: boolean;
+}
+type StateKey = keyof EthersStoreUtilState;
+export declare const EthersStoreUtil: {
+    state: EthersStoreUtilState;
+    subscribeKey<K extends StateKey>(key: K, callback: (value: EthersStoreUtilState[K]) => void): () => void;
+    subscribe(callback: (newState: EthersStoreUtilState) => void): () => void;
+    setProvider(provider: EthersStoreUtilState["provider"]): void;
+    setProviderType(providerType: EthersStoreUtilState["providerType"]): void;
+    setAddress(address: EthersStoreUtilState["address"]): void;
+    setPreferredAccountType(preferredAccountType: EthersStoreUtilState["preferredAccountType"]): void;
+    setChainId(chainId: EthersStoreUtilState["chainId"]): void;
+    setStatus(status: EthersStoreUtilState["status"]): void;
+    setIsConnected(isConnected: EthersStoreUtilState["isConnected"]): void;
+    setError(error: EthersStoreUtilState["error"]): void;
+    reset(): void;
+};
+export {};

package/dist/types/src/ethers/EthersTypesUtil.d.ts

@@ -0,0 +1,54 @@
+import type UniversalProvider from '@walletconnect/universal-provider';
+import type { W3mFrameProvider } from '@reown/appkit-wallet';
+import type { BaseProvider } from './BaseProvider.js';
+import type { InjectedProvider } from './InjectedProvider.js';
+import type { SafeProvider } from './SafeProvider.js';
+export type Address = `0x${string}`;
+export type ProviderType = {
+    injected?: InjectedProvider;
+    baseAccount?: BaseProvider;
+    safe?: SafeProvider;
+    EIP6963?: boolean;
+    metadata: Metadata;
+};
+export interface RequestArguments {
+    readonly method: string;
+    readonly params?: readonly unknown[] | object;
+}
+type ProviderEventListener = {
+    connect: (connectParams: {
+        chainId: number;
+    }) => void;
+    disconnect: (error: Error) => void;
+    chainChanged: (chainId: string) => void;
+    accountsChanged: (accounts: string[]) => void;
+    message: (message: {
+        type: string;
+        data: unknown;
+    }) => void;
+};
+export interface Provider {
+    request: <T>(args: RequestArguments) => Promise<T>;
+    on<T extends keyof ProviderEventListener>(event: T, listener: ProviderEventListener[T]): void;
+    removeListener: <T>(event: string, listener: (data: T) => void) => void;
+    emit: (event: string) => void;
+}
+export type Metadata = {
+    name: string;
+    description: string;
+    url: string;
+    icons: string[];
+};
+export type CombinedProvider = W3mFrameProvider & Provider;
+export type UniversalProviderType = UniversalProvider & W3mFrameProvider & Provider;
+export type Chain = {
+    id: string | number;
+    chainId: string | number;
+    name: string;
+    currency: string;
+    explorerUrl: string;
+    rpcUrl: string;
+    chain: string;
+    imageId: string | undefined;
+};
+export {};

package/dist/types/src/ethers/InjectedProvider.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from '@reown/appkit-controllers';
+import { EthersProvider } from './EthersProvider.js';
+export declare class InjectedProvider extends EthersProvider<Provider> {
+    initialize(): Promise<void>;
+}

package/dist/types/src/ethers/SafeProvider.d.ts

@@ -0,0 +1,13 @@
+import { SafeAppProvider } from '@safe-global/safe-apps-provider';
+import { EthersProvider } from './EthersProvider.js';
+declare class _SafeProvider extends SafeAppProvider {
+    request(request: {
+        method: string;
+        params?: any[];
+    }): Promise<any>;
+}
+export declare class SafeProvider extends EthersProvider<_SafeProvider> {
+    initialize(): Promise<void>;
+    getProvider(): Promise<_SafeProvider | undefined>;
+}
+export {};