@bit-buccaneers/wallet-abstraction 0.0.1

package/dist/lib/connectors/binance.d.ts

@@ -0,0 +1,4 @@
+import type { EvmWalletConnector } from '../evm';
+import type { SolanaWalletConnector } from '../solana';
+export declare const createBinanceEvmConnector: () => EvmWalletConnector;
+export declare const createBinanceSolanaConnector: () => SolanaWalletConnector;

package/dist/lib/connectors/exodus.d.ts

@@ -0,0 +1,4 @@
+import type { EvmWalletConnector } from '../evm';
+import type { SolanaWalletConnector } from '../solana';
+export declare const createExodusEvmMobileConnector: () => EvmWalletConnector;
+export declare const createExodusSolanaMobileConnector: () => SolanaWalletConnector;

package/dist/lib/connectors/index.d.ts

@@ -0,0 +1,7 @@
+export { createPhantomEvmConnector, createPhantomSolanaConnector, isPhantomMobilePending, handlePhantomMobileCallback, restorePhantomMobileSession, isPhantomSignPending, handlePhantomSignCallback, } from './phantom';
+export { createMetaMaskEvmConnector, createMetaMaskSolanaConnector } from './metamask';
+export { createSolflareSolanaMobileConnector, isSolflareMobilePending, handleSolflareMobileCallback, restoreSolflareMobileSession, isSolflareSignPending, handleSolflareSignCallback, } from './solflare';
+export { createTrustEvmMobileConnector, createTrustSolanaMobileConnector } from './trust';
+export { createRainbowEvmMobileConnector } from './rainbow';
+export { createExodusEvmMobileConnector, createExodusSolanaMobileConnector } from './exodus';
+export { createBinanceEvmConnector, createBinanceSolanaConnector } from './binance';

package/dist/lib/connectors/metamask.d.ts

@@ -0,0 +1,4 @@
+import type { EvmWalletConnector } from '../evm';
+import type { SolanaWalletConnector } from '../solana';
+export declare const createMetaMaskEvmConnector: () => EvmWalletConnector;
+export declare const createMetaMaskSolanaConnector: () => SolanaWalletConnector;

package/dist/lib/connectors/phantom.d.ts

@@ -0,0 +1,10 @@
+import { type ConnectedResult } from '../core';
+import type { EvmWalletConnector } from '../evm';
+import type { SolanaWalletConnector } from '../solana';
+export declare const createPhantomEvmConnector: () => EvmWalletConnector;
+export declare const createPhantomSolanaConnector: () => SolanaWalletConnector;
+export declare const isPhantomMobilePending: () => boolean;
+export declare const handlePhantomMobileCallback: () => ConnectedResult | null;
+export declare const restorePhantomMobileSession: () => ConnectedResult | null;
+export declare const isPhantomSignPending: () => boolean;
+export declare const handlePhantomSignCallback: () => string | null;

package/dist/lib/connectors/rainbow.d.ts

@@ -0,0 +1,2 @@
+import type { EvmWalletConnector } from '../evm';
+export declare const createRainbowEvmMobileConnector: () => EvmWalletConnector;

package/dist/lib/connectors/shared/constants.d.ts

@@ -0,0 +1,22 @@
+export declare const WC_CHAINS: {
+    readonly EVM_MAINNET: "eip155:1";
+    readonly SOLANA_MAINNET: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+};
+export declare const WC_METHODS: {
+    readonly EVM: readonly ["eth_sendTransaction", "personal_sign", "eth_signTypedData"];
+    readonly SOLANA: readonly ["solana_signTransaction", "solana_signMessage"];
+};
+export declare const WC_EVENTS: {
+    readonly EVM: readonly ["chainChanged", "accountsChanged"];
+    readonly SOLANA: string[];
+};
+export declare const EVM_WC_CONFIG: {
+    readonly chains: readonly ["eip155:1"];
+    readonly methods: readonly ["eth_sendTransaction", "personal_sign", "eth_signTypedData"];
+    readonly events: readonly ["chainChanged", "accountsChanged"];
+};
+export declare const SOLANA_WC_CONFIG: {
+    readonly chains: readonly ["solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"];
+    readonly methods: readonly ["solana_signTransaction", "solana_signMessage"];
+    readonly events: string[];
+};

package/dist/lib/connectors/shared/deeplink.d.ts

@@ -0,0 +1,67 @@
+import nacl from 'tweetnacl';
+import type { ConnectedResult } from '../../core';
+export interface DeeplinkConfig {
+    connectUrl: string;
+    storageKeyPrefix: string;
+    encryptionKeyParam: string;
+    callbackParam: string;
+}
+export interface DeeplinkSession {
+    publicKey: string;
+    session: string;
+    sharedSecret: Uint8Array;
+}
+export interface StoredSession {
+    publicKey: string;
+    session: string;
+    sharedSecret: number[];
+}
+/**
+ * Get or create dApp keypair for encryption
+ */
+export declare const getDappKeyPair: (storageKey: string) => nacl.BoxKeyPair;
+/**
+ * Clear dApp keypair from storage
+ */
+export declare const clearDappKeyPair: (storageKey: string) => void;
+/**
+ * Build connect URL with encryption params
+ */
+export declare const buildConnectUrl: (config: DeeplinkConfig, params: {
+    appUrl: string;
+    redirectUrl: string;
+    cluster?: string;
+    chain?: string;
+}) => string;
+/**
+ * Parse encrypted connect response from URL params
+ */
+export declare const parseConnectResponse: (urlParams: URLSearchParams, config: DeeplinkConfig) => DeeplinkSession | null;
+/**
+ * Check if URL params contain a wallet response
+ */
+export declare const isWalletResponse: (urlParams: URLSearchParams, encryptionKeyParam: string) => boolean;
+/**
+ * Handle mobile callback and return connected result
+ */
+export declare const handleMobileCallback: (config: DeeplinkConfig, pendingKey: string, sessionKey: string) => ConnectedResult | null;
+/**
+ * Restore session from storage
+ */
+export declare const restoreMobileSession: (sessionKey: string) => ConnectedResult | null;
+/**
+ * Clear mobile session
+ */
+export declare const clearMobileSession: (pendingKey: string, sessionKey: string) => void;
+/**
+ * Get stored session with sharedSecret
+ */
+export declare const getStoredSession: (sessionKey: string) => StoredSession | null;
+/**
+ * Build signMessage URL with encrypted payload
+ */
+export declare const buildSignMessageUrl: (signUrl: string, config: DeeplinkConfig, sessionKey: string, message: string, redirectUrl: string) => string | null;
+/**
+ * Parse signMessage response from URL params
+ */
+export declare const parseSignMessageResponse: (config: DeeplinkConfig, sessionKey: string) => string | null;

package/dist/lib/connectors/shared/index.d.ts

@@ -0,0 +1,7 @@
+export * from './constants';
+export * from './deeplink';
+export * from './injected';
+export * from './parsers';
+export * from './utils';
+export * from './walletconnect';
+export * from './wc-connector-factory';

package/dist/lib/connectors/shared/injected.d.ts

@@ -0,0 +1,4 @@
+import type { ConnectedResult } from '../../core';
+export declare const connectEvmInjected: () => Promise<ConnectedResult>;
+export declare const connectSolanaInjected: () => Promise<ConnectedResult>;
+export declare const signSolanaInjected: (message: string) => Promise<string>;

package/dist/lib/connectors/shared/parsers.d.ts

@@ -0,0 +1,23 @@
+import type { ConnectedResult } from '../../core';
+/**
+ * Parse EVM account from WalletConnect namespace format
+ * Format: "eip155:chainId:address"
+ */
+export declare const parseEvmAccount: (account: string) => ConnectedResult;
+/**
+ * Parse Solana account from WalletConnect namespace format
+ * Format: "solana:cluster:address"
+ */
+export declare const parseSolanaAccount: (account: string) => Promise<ConnectedResult>;
+/**
+ * Extract EVM account from WalletConnect session namespaces
+ */
+export declare const getEvmAccountFromSession: (namespaces: Record<string, {
+    accounts?: string[];
+}>) => ConnectedResult;
+/**
+ * Extract Solana account from WalletConnect session namespaces
+ */
+export declare const getSolanaAccountFromSession: (namespaces: Record<string, {
+    accounts?: string[];
+}>) => Promise<ConnectedResult>;

package/dist/lib/connectors/shared/utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Check if current device is mobile
+ */
+export declare const isMobile: () => boolean;
+/**
+ * Check if running inside a wallet's in-app browser
+ */
+export declare const isInWalletBrowser: (key: string) => boolean;
+/**
+ * Get current page URL for redirect callbacks
+ */
+export declare const getCurrentUrl: () => string;
+/**
+ * Open deeplink via anchor click (avoids page unload on mobile)
+ */
+export declare const openDeeplink: (url: string) => void;
+/**
+ * Create in-app browser deeplink URL
+ */
+export declare const createInAppBrowserUrl: (baseUrl: string, targetUrl?: string) => string;
+/**
+ * Wait for a value to become available (polling)
+ */
+export declare const waitForValue: <T>(getValue: () => T | null | undefined) => Promise<T>;

package/dist/lib/connectors/shared/walletconnect.d.ts

@@ -0,0 +1,12 @@
+import type { ConnectedResult, ConnectResult } from '../../core';
+export interface WcConnectConfig {
+    chains: readonly string[];
+    methods: readonly string[];
+    events: readonly string[];
+}
+/**
+ * Connect via WalletConnect with QR code and optional mobile deeplink
+ */
+export declare const connectViaWalletConnect: (wcConfig: WcConnectConfig, parseSession: (namespaces: Record<string, {
+    accounts?: string[];
+}>) => ConnectedResult | Promise<ConnectedResult>, getDeeplink?: (uri: string) => string) => Promise<ConnectResult>;

package/dist/lib/connectors/shared/wc-connector-factory.d.ts

@@ -0,0 +1,10 @@
+import type { EvmWalletConnector } from '../../evm';
+import type { SolanaWalletConnector } from '../../solana';
+import { type WalletId } from '../../wallets';
+export interface WcWalletConfig {
+    walletId: WalletId;
+    wcDeeplink: string;
+    injectedKey: string;
+}
+export declare const createWcEvmConnector: (config: WcWalletConfig) => EvmWalletConnector;
+export declare const createWcSolanaConnector: (config: WcWalletConfig) => SolanaWalletConnector;

package/dist/lib/connectors/solflare.d.ts

@@ -0,0 +1,11 @@
+import { type ConnectedResult } from '../core';
+import type { SolanaWalletConnector } from '../solana';
+import { type StoredSession } from './shared';
+export declare const createSolflareSolanaMobileConnector: () => SolanaWalletConnector;
+export declare const isSolflareMobilePending: () => boolean;
+export declare const handleSolflareMobileCallback: () => ConnectedResult | null;
+export declare const getSolflareMobileSession: () => StoredSession | null;
+export declare const restoreSolflareMobileSession: () => ConnectedResult | null;
+export declare const clearSolflareMobileSession: () => void;
+export declare const isSolflareSignPending: () => boolean;
+export declare const handleSolflareSignCallback: () => string | null;

package/dist/lib/connectors/trust.d.ts

@@ -0,0 +1,4 @@
+import type { EvmWalletConnector } from '../evm';
+import type { SolanaWalletConnector } from '../solana';
+export declare const createTrustEvmMobileConnector: () => EvmWalletConnector;
+export declare const createTrustSolanaMobileConnector: () => SolanaWalletConnector;

package/dist/lib/context/WalletContext.d.ts

@@ -0,0 +1,23 @@
+import { type Accessor, type ParentProps } from 'solid-js';
+import { type ChainType, type ConnectedResult, type ConnectResult, type GroupedWallet } from '../core';
+import { type EvmChains, type EvmWalletConnector } from '../evm';
+import { type SolanaWalletConnector } from '../solana';
+import { type WalletConnectConfig } from '../walletconnect';
+export interface WalletContextValue {
+    evmConnectors: Accessor<EvmWalletConnector[]>;
+    evmConnection: Accessor<ConnectedResult | null>;
+    solanaConnectors: Accessor<SolanaWalletConnector[]>;
+    solanaConnection: Accessor<ConnectedResult | null>;
+    groupedWallets: Accessor<GroupedWallet[]>;
+    connectEvm: (connector: EvmWalletConnector) => Promise<ConnectResult>;
+    disconnectEvm: () => Promise<void>;
+    connectSolana: (connector: SolanaWalletConnector) => Promise<ConnectResult>;
+    disconnectSolana: () => Promise<void>;
+    signMessage: (chainType: ChainType, message: string) => Promise<string>;
+}
+export interface WalletProviderProps {
+    evmChains: EvmChains;
+    walletConnect?: WalletConnectConfig;
+}
+export declare const WalletProvider: (props: ParentProps<WalletProviderProps>) => import("solid-js").JSX.Element;
+export declare function useWallet(): WalletContextValue;

package/dist/lib/context/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useEvmWallet, type UseEvmWalletReturn } from './useEvmWallet';
+export { useSolanaWallet, type UseSolanaWalletReturn } from './useSolanaWallet';
+export { useWalletConnect, type UseWalletConnectOptions, type UseWalletConnectReturn, } from './useWalletConnect';

package/dist/lib/context/hooks/useEvmWallet.d.ts

@@ -0,0 +1,14 @@
+import { type ConnectedResult, type ConnectResult } from '../../core';
+import { type EvmChains, type EvmWalletConnector } from '../../evm';
+export interface UseEvmWalletOptions {
+    chains: EvmChains;
+}
+export interface UseEvmWalletReturn {
+    evmConnectors: () => EvmWalletConnector[];
+    evmConnection: () => ConnectedResult | null;
+    setEvmConnection: (connection: ConnectedResult | null) => void;
+    connectEvm: (connector: EvmWalletConnector) => Promise<ConnectResult>;
+    disconnectEvm: () => Promise<void>;
+    connectedEvmConnector: () => EvmWalletConnector | null;
+}
+export declare const useEvmWallet: (options: UseEvmWalletOptions) => UseEvmWalletReturn;

package/dist/lib/context/hooks/useSolanaWallet.d.ts

@@ -0,0 +1,11 @@
+import { type ConnectedResult, type ConnectResult } from '../../core';
+import { type SolanaWalletConnector } from '../../solana';
+export interface UseSolanaWalletReturn {
+    solanaConnectors: () => SolanaWalletConnector[];
+    solanaConnection: () => ConnectedResult | null;
+    setSolanaConnection: (connection: ConnectedResult | null) => void;
+    connectSolana: (connector: SolanaWalletConnector) => Promise<ConnectResult>;
+    disconnectSolana: () => Promise<void>;
+    connectedSolanaConnector: () => SolanaWalletConnector | null;
+}
+export declare const useSolanaWallet: () => UseSolanaWalletReturn;

package/dist/lib/context/hooks/useWalletConnect.d.ts

@@ -0,0 +1,16 @@
+import type { ConnectedResult } from '../../core';
+import { type WalletConnectConfig } from '../../walletconnect';
+export interface UseWalletConnectOptions {
+    config?: WalletConnectConfig;
+    onEvmConnection?: (connection: ConnectedResult) => void;
+    onSolanaConnection?: (connection: ConnectedResult) => void;
+}
+export interface UseWalletConnectReturn {
+    disconnectWcEvm: () => Promise<void>;
+    disconnectWcSolana: () => Promise<void>;
+    hasWcEvmSession: () => boolean;
+    hasWcSolanaSession: () => boolean;
+    signWcEvmMessage: (message: string) => Promise<string>;
+    signWcSolanaMessage: (message: string) => Promise<string>;
+}
+export declare const useWalletConnect: (options: UseWalletConnectOptions) => UseWalletConnectReturn;

package/dist/lib/context/index.d.ts

@@ -0,0 +1 @@
+export { WalletProvider, useWallet, type WalletContextValue, type WalletProviderProps } from './WalletContext';

package/dist/lib/core/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const STORAGE_KEYS: {
+    readonly SOLANA_WALLET: "wallet-abstraction:solana-wallet";
+};

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

@@ -0,0 +1,7 @@
+import type { ConnectedResult, PendingResult, QRCodeResult } from './types';
+export declare const connectedResult: (address: string, options?: {
+    chainId?: number;
+    publicKey?: Uint8Array;
+}) => ConnectedResult;
+export declare const qrcodeResult: (uri: string, wait: () => Promise<ConnectedResult>) => QRCodeResult;
+export declare const pendingResult: () => PendingResult;

package/dist/lib/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './helpers';
+export * from './storage';
+export * from './types';
+export * from './utils';

package/dist/lib/core/storage.d.ts

@@ -0,0 +1,8 @@
+export declare const storage: {
+    get: <T>(key: string) => T | null;
+    getString: (key: string) => string | null;
+    set: <T>(key: string, value: T) => void;
+    setString: (key: string, value: string) => void;
+    remove: (key: string) => void;
+    has: (key: string) => boolean;
+};

package/dist/lib/core/types.d.ts

@@ -0,0 +1,37 @@
+import { EvmWalletConnector } from '../evm';
+import { SolanaWalletConnector } from '../solana';
+export type ChainType = 'evm' | 'solana';
+export interface ConnectedResult {
+    status: 'connected';
+    address: string;
+    chainId?: number;
+    publicKey?: Uint8Array;
+}
+export interface QRCodeResult {
+    status: 'qrcode';
+    uri: string;
+    wait: () => Promise<ConnectedResult>;
+}
+export interface PendingResult {
+    status: 'pending';
+}
+export type ConnectResult = ConnectedResult | QRCodeResult | PendingResult;
+export interface Wallet {
+    connect: () => Promise<ConnectResult>;
+    disconnect: () => Promise<void>;
+    signMessage: (message: string) => Promise<string>;
+}
+export interface WalletConnector {
+    id: string;
+    name: string;
+    icon?: string;
+    type: ChainType;
+    installed?: boolean;
+    wallet: Wallet;
+}
+export interface GroupedWallet {
+    id: string;
+    name: string;
+    evm?: EvmWalletConnector;
+    solana?: SolanaWalletConnector;
+}

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

@@ -0,0 +1,8 @@
+interface Connector {
+    id: string;
+}
+export declare const addFallbackConnectors: <T extends Connector>(connectors: T[], fallbacks: Array<{
+    id: string;
+    create: () => T;
+}>) => void;
+export {};

package/dist/lib/evm/config.d.ts

@@ -0,0 +1,6 @@
+import { type Config } from '@wagmi/core';
+import { type Chain } from 'viem';
+export type EvmChains = readonly [Chain, ...Chain[]];
+export declare const createEvmConfig: (chains?: EvmChains) => Config;
+export declare const getEvmConfig: () => Config;
+export type { Config };

package/dist/lib/evm/connection.d.ts

@@ -0,0 +1,2 @@
+import { type GetConnectionsReturnType } from '@wagmi/core';
+export declare const watchEvmConnections: (onChange: (connections: GetConnectionsReturnType) => void) => (() => void);

package/dist/lib/evm/connectors.d.ts

@@ -0,0 +1,2 @@
+import type { EvmWalletConnector } from './types';
+export declare const getEvmConnectors: () => EvmWalletConnector[];

package/dist/lib/evm/index.d.ts

@@ -0,0 +1,4 @@
+export { createEvmConfig, getEvmConfig, type Config, type EvmChains } from './config';
+export { getEvmConnectors } from './connectors';
+export { watchEvmConnections } from './connection';
+export type { EvmWallet, EvmWalletConnector } from './types';

package/dist/lib/evm/types.d.ts

@@ -0,0 +1,12 @@
+import type { Connector as WagmiConnector } from '@wagmi/core';
+import type { ConnectResult, WalletConnector } from '../core';
+export interface EvmWallet {
+    connect: () => Promise<ConnectResult>;
+    disconnect: () => Promise<void>;
+    signMessage: (message: string) => Promise<string>;
+    _connector: WagmiConnector;
+}
+export interface EvmWalletConnector extends Omit<WalletConnector, 'wallet'> {
+    type: 'evm';
+    wallet: EvmWallet;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { type ChainType, type ConnectResult, type GroupedWallet, type Wallet, type WalletConnector, } from './core';
+export { createEvmConfig, getEvmConfig, getEvmConnectors, watchEvmConnections, type Config, type EvmChains, type EvmWallet, type EvmWalletConnector, } from './evm';
+export { getSolanaWallets, onSolanaWalletsChange, reconnectSolana, watchSolanaConnection, checkPhantomSignCallback, checkSolflareSignCallback, type SolanaConnection, type SolanaWallet, type SolanaWalletConnector, } from './solana';
+export { useWallet, WalletProvider, type WalletContextValue } from './context';
+export { WALLETS, type WalletConfig } from './wallets';
+export { initWalletConnect, type WalletConnectConfig } from './walletconnect';

package/dist/lib/solana/connection.d.ts

@@ -0,0 +1,5 @@
+import type { ConnectedResult } from '../core';
+import type { SolanaConnection, SolanaWalletConnector } from './types';
+export declare const setConnection: (connection: ConnectedResult | null, connector: SolanaWalletConnector | null) => void;
+export declare const getConnection: () => SolanaConnection;
+export declare const watchSolanaConnection: (onChange: (state: SolanaConnection) => void) => (() => void);

package/dist/lib/solana/connectors.d.ts

@@ -0,0 +1,4 @@
+import type { SolanaWalletConnector } from './types';
+export declare const createSolanaMobileConnector: (connector: SolanaWalletConnector) => SolanaWalletConnector;
+export declare const getSolanaWallets: () => SolanaWalletConnector[];
+export declare const onSolanaWalletsChange: (callback: (wallets: SolanaWalletConnector[]) => void) => (() => void);

package/dist/lib/solana/index.d.ts

@@ -0,0 +1,4 @@
+export { setConnection, getConnection, watchSolanaConnection } from './connection';
+export { getSolanaWallets, onSolanaWalletsChange, createSolanaMobileConnector } from './connectors';
+export { reconnectSolana, checkPhantomSignCallback, checkSolflareSignCallback } from './reconnect';
+export type { SolanaWallet, SolanaWalletConnector, SolanaConnection } from './types';

package/dist/lib/solana/reconnect.d.ts

@@ -0,0 +1,3 @@
+export declare const reconnectSolana: () => void;
+export declare const checkPhantomSignCallback: () => string | null;
+export declare const checkSolflareSignCallback: () => string | null;

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

@@ -0,0 +1,16 @@
+import type { WalletAdapterCompatibleStandardWallet } from '@solana/wallet-adapter-base';
+import type { ConnectedResult, ConnectResult, WalletConnector } from '../core';
+export interface SolanaWallet {
+    connect: () => Promise<ConnectResult>;
+    disconnect: () => Promise<void>;
+    signMessage: (message: string) => Promise<string>;
+    _provider: WalletAdapterCompatibleStandardWallet;
+}
+export interface SolanaWalletConnector extends Omit<WalletConnector, 'wallet'> {
+    type: 'solana';
+    wallet: SolanaWallet;
+}
+export interface SolanaConnection {
+    connection: ConnectedResult | null;
+    connector: SolanaWalletConnector | null;
+}

package/dist/lib/walletconnect/client.d.ts

@@ -0,0 +1,31 @@
+import { SignClient } from '@walletconnect/sign-client';
+import type { SessionTypes } from '@walletconnect/types';
+export interface WalletConnectConfig {
+    projectId: string;
+    metadata: {
+        name: string;
+        description: string;
+        url: string;
+        icons: string[];
+    };
+}
+export interface WalletConnectSession {
+    topic: string;
+    namespaces: SessionTypes.Namespaces;
+}
+type SessionChangeCallback = (session: WalletConnectSession | null) => void;
+export declare const onWalletConnectSessionChange: (callback: SessionChangeCallback) => (() => void);
+export declare const initWalletConnect: (config: WalletConnectConfig) => Promise<void>;
+export declare const getSignClient: () => InstanceType<typeof SignClient> | null;
+export declare const getCurrentSession: () => WalletConnectSession | null;
+export declare const setCurrentSession: (session: WalletConnectSession | null) => void;
+export interface ConnectOptions {
+    chains: string[];
+    methods: string[];
+    events: string[];
+    onQRCode?: (uri: string) => void;
+}
+export declare const connectWalletConnect: (options: ConnectOptions) => Promise<WalletConnectSession>;
+export declare const disconnectWalletConnect: () => Promise<void>;
+export declare const requestWalletConnect: <T>(method: string, params: unknown, chainId: string) => Promise<T>;
+export {};

package/dist/lib/walletconnect/index.d.ts

@@ -0,0 +1 @@
+export { connectWalletConnect, type ConnectOptions, disconnectWalletConnect, getCurrentSession, getSignClient, initWalletConnect, onWalletConnectSessionChange, requestWalletConnect, setCurrentSession, type WalletConnectConfig, type WalletConnectSession, } from './client';

package/dist/lib/wallets/config.d.ts

@@ -0,0 +1,7 @@
+export declare const WALLET_IDS: readonly ["metamask", "phantom", "okx", "coinbase", "binance", "bitget", "solflare", "trust", "rabby", "rainbow", "exodus"];
+export type WalletId = (typeof WALLET_IDS)[number];
+export interface WalletConfig {
+    id: WalletId;
+    name: string;
+}
+export declare const WALLETS: WalletConfig[];

package/dist/lib/wallets/index.d.ts

@@ -0,0 +1,2 @@
+export { WALLETS, WALLET_IDS, type WalletConfig, type WalletId } from './config';
+export { normalizeEvmWalletId, normalizeSolanaWalletId } from './mappers';

package/dist/lib/wallets/mappers.d.ts

@@ -0,0 +1,2 @@
+export declare const normalizeEvmWalletId: (id: string) => string;
+export declare const normalizeSolanaWalletId: (id: string) => string;