@ab-org/sdk-core 0.0.1 → 0.1.1

package/dist/index.d.ts

@@ -1,16 +1,536 @@
-export * from "./core/types.js";
-export * from "./core/chains.js";
-export * from "./core/capabilities.js";
-export * from "./core/errors.js";
-export * from "./core/sessionStore.js";
-export * from "./core/walletConnector.js";
-export * from "./core/walletExecution.js";
-export * from "./hooks/useWalletConnect.js";
-export * from "./hooks/useAccount.js";
-export * from "./providers/base.js";
-export * from "./providers/plugin/injectedEvmProvider.js";
-export * from "./providers/plugin/injectedWalletRegistry.js";
-export * from "./providers/plugin/metamaskProvider.js";
-export * from "./providers/social/baseSocialProvider.js";
-export * from "./providers/social/cubeSignerAuth.js";
-export * from "./providers/social/cubistProvider.js";
+import EventEmitter from 'eventemitter3';
+import { Environment, EnvInterface, CubeSignerClient, SessionData } from '@cubist-labs/cubesigner-sdk';
+
+type WalletCapability = "eth_accounts" | "eth_requestAccounts" | "eth_chainId" | "eth_signTransaction" | "eth_sendTransaction" | "personal_sign" | "eth_signTypedData_v4" | "wallet_disconnect" | "wallet_rehydrate" | string;
+interface SessionCapabilityPolicy {
+    id: string;
+    appId?: string;
+    origin?: string;
+    expiresAt?: number;
+    methods?: WalletCapability[];
+    chains?: SupportedChain[];
+    tokens?: SupportedToken[];
+    maxAmount?: string;
+    revocable?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface SessionCapabilityCheck {
+    capability: WalletCapability;
+    chain?: SupportedChain;
+    token?: SupportedToken;
+    amount?: string | number | bigint;
+    appId?: string;
+    origin?: string;
+    now?: number;
+}
+declare class SessionCapabilityError extends Error {
+    constructor(message: string);
+}
+declare const createSessionCapabilityPolicy: (input?: Partial<SessionCapabilityPolicy>) => SessionCapabilityPolicy;
+declare const isSessionExpired: (session: Pick<WalletSession, "expiresAt"> | null | undefined, now?: number) => boolean;
+declare const isCapabilityPolicyExpired: (policy: SessionCapabilityPolicy | null | undefined, now?: number) => boolean;
+declare const sessionSupportsCapability: (session: Pick<WalletSession, "capabilities"> | null | undefined, capability: WalletCapability) => boolean;
+declare const describeSessionCapabilityPolicy: (policy: SessionCapabilityPolicy | null | undefined) => string[];
+declare const assertSessionCapability: (session: WalletSession, check: SessionCapabilityCheck) => void;
+
+type ChainNamespace = "evm" | "solana" | "ab-core";
+type ChainRpcFamily = "evm" | "solana" | "custom";
+interface ChainDescriptor {
+    chain: SupportedChain;
+    namespace: ChainNamespace;
+    reference: string;
+    label: string;
+    rpcFamily: ChainRpcFamily;
+    evmChainId?: number;
+    supportsSmartSessions: boolean;
+    supportsAccountAbstraction: boolean;
+}
+interface ChainContext {
+    walletChain: SupportedChain;
+    walletChainDescriptor: ChainDescriptor;
+    settlementChain: SupportedChain;
+    settlementChainDescriptor: ChainDescriptor;
+}
+declare const getChainDescriptor: (chain: SupportedChain) => ChainDescriptor;
+declare const getAllChainDescriptors: () => ChainDescriptor[];
+declare const getSupportedChainFromEvmChainId: (value: string | number | bigint) => SupportedChain;
+declare const createChainContext: (walletChain: SupportedChain, settlementChain?: SupportedChain) => ChainContext;
+
+type SupportedChain = "AB_CORE" | "ETH" | "BSC" | "SOL" | "ETH_TENDERLY" | "BSC_TENDERLY";
+type SupportedToken = "USD1" | "USDC" | "USDT" | "ETH" | "AB";
+type ProviderCategory = "plugin" | "social";
+type WalletType = "injected" | "social" | "smart";
+type WalletAuthSource = "google" | "twitter" | "wallet" | "session";
+type EvmQuantity = string | number | bigint;
+interface EvmAccessListItem {
+    address: string;
+    storageKeys?: string[];
+}
+interface EvmTransactionRequest {
+    from?: string;
+    to?: string;
+    data?: string;
+    gas?: EvmQuantity;
+    gasPrice?: EvmQuantity;
+    maxFeePerGas?: EvmQuantity;
+    maxPriorityFeePerGas?: EvmQuantity;
+    nonce?: EvmQuantity;
+    value?: EvmQuantity;
+    type?: EvmQuantity;
+    chainId?: EvmQuantity;
+    accessList?: EvmAccessListItem[];
+}
+interface WalletProviderRequest {
+    method: string;
+    params?: unknown[];
+}
+interface WalletProvider {
+    request<T = unknown>(payload: WalletProviderRequest): Promise<T>;
+    disconnect(): Promise<void>;
+}
+interface WalletConnectArgs {
+    options?: unknown;
+    payload?: unknown;
+}
+interface WalletAdapter {
+    id: string;
+    title: string;
+    icon?: string;
+    category?: ProviderCategory;
+    connect(args?: WalletConnectArgs): Promise<WalletSession>;
+    disconnect(): Promise<void>;
+    getProvider(): WalletProvider | null;
+    /**
+     * Silently restore a wallet session from persisted data without user interaction.
+     * Returns a fresh session if the wallet can be reconnected, or null otherwise.
+     */
+    reconnect?(persistedSession: WalletSession): Promise<WalletSession | null>;
+}
+interface WalletSession {
+    address: string;
+    chain: SupportedChain;
+    provider: WalletProvider;
+    walletType?: WalletType;
+    authSource?: WalletAuthSource;
+    sessionId?: string;
+    expiresAt?: number;
+    capabilities?: WalletCapability[];
+    sessionData?: unknown;
+    chainContext?: ChainContext;
+    capabilityPolicy?: SessionCapabilityPolicy;
+}
+interface BalanceInfo {
+    formatted: string;
+    symbol: SupportedToken;
+    wei: bigint;
+}
+interface WalletState {
+    session: WalletSession | null;
+    balance: BalanceInfo | null;
+    isConnecting: boolean;
+}
+
+declare const EVM_TRANSACTION_SIGNING_UNSUPPORTED = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
+declare class EvmTransactionSigningUnsupportedError extends Error {
+    readonly providerName: string;
+    readonly cause?: unknown | undefined;
+    readonly code = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
+    constructor(providerName: string, cause?: unknown | undefined);
+}
+declare const isUnsupportedEvmTransactionSigningError: (error: unknown) => boolean;
+declare const normalizeEvmTransactionSigningError: (providerName: string, error: unknown) => Error;
+
+type WalletEvents = {
+    "session:changed": [WalletSession | null];
+    "session:rehydrated": [WalletSession];
+    "session:expired": [WalletSession];
+    "session:revoked": [WalletSession];
+    "balance:changed": [BalanceInfo | null];
+    "connecting:changed": [boolean];
+};
+declare class SessionStore {
+    private state;
+    private emitter;
+    constructor();
+    getState(): WalletState;
+    setConnecting(flag: boolean): void;
+    setSession(session: WalletSession | null): void;
+    rehydrateSession(session: WalletSession): void;
+    clearSession(): void;
+    expireSession(): void;
+    revokeSession(): void;
+    setBalance(balance: BalanceInfo | null): void;
+    on<T extends keyof WalletEvents>(event: T, listener: (...args: WalletEvents[T]) => void): () => EventEmitter<WalletEvents, any>;
+    private tryRehydrate;
+}
+declare const sessionStore: SessionStore;
+
+declare class WalletConnector {
+    private adapters;
+    private currentAdapterId;
+    constructor(adapters: WalletAdapter[]);
+    private getAdapterById;
+    private getCurrentAdapter;
+    private clearActiveSession;
+    private requireActiveSession;
+    connect(adapterId: string, args?: WalletConnectArgs): Promise<WalletSession>;
+    disconnect(): Promise<void>;
+    rehydrateSession(adapterId: string, session: WalletSession): WalletSession;
+    /**
+     * Attempt to silently reconnect a wallet whose session was rehydrated
+     * from localStorage. Uses the adapter's `reconnect()` if available,
+     * falling back to `connect()` for backward compatibility.
+     *
+     * Returns the restored session on success, or `null` if reconnection
+     * is not possible (e.g. wallet extension removed, social session expired).
+     */
+    tryAutoReconnect(): Promise<WalletSession | null>;
+    supportsCapability(capability: WalletCapability): boolean;
+    requestCurrentProvider<T = unknown>(payload: WalletProviderRequest): Promise<T>;
+    sendEvmTransaction(transaction: EvmTransactionRequest): Promise<string>;
+    signEvmTransaction(transaction: EvmTransactionRequest): Promise<string>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(typedData: Record<string, unknown>): Promise<string>;
+}
+
+interface WalletExecutionClient {
+    readonly session: WalletSession;
+    readonly capabilities: WalletCapability[];
+    supports(capability: WalletCapability): boolean;
+    sendTransaction(transaction: EvmTransactionRequest, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
+    signTransaction(transaction: EvmTransactionRequest, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
+    signMessage(message: string, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
+    signTypedData(typedData: Record<string, unknown>, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
+}
+declare const getWalletExecutionCapabilities: (session?: WalletSession | null) => WalletCapability[];
+declare const createWalletExecutionClient: (session?: WalletSession | null) => WalletExecutionClient;
+declare const createWalletExecutionController: () => {
+    readonly session: WalletSession | null;
+    readonly capabilities: string[];
+    supports(capability: WalletCapability): boolean;
+    sendTransaction(transaction: EvmTransactionRequest, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
+    signTransaction(transaction: EvmTransactionRequest, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
+    signMessage(message: string, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
+    signTypedData(typedData: Record<string, unknown>, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
+};
+
+interface WalletConnectControllerOptions {
+    connector: WalletConnector;
+    defaultAdapterId?: string;
+}
+declare const createWalletConnectController: ({ connector, defaultAdapterId, }: WalletConnectControllerOptions) => {
+    readonly openModal: (adapterId?: string | undefined, args?: WalletConnectArgs) => Promise<void>;
+    readonly disconnect: () => Promise<void>;
+    readonly rehydrate: (adapterId: string, session: WalletSession) => WalletSession;
+    readonly tryAutoReconnect: () => Promise<WalletSession | null>;
+    readonly supports: (capability: WalletCapability) => boolean;
+    readonly isConnected: boolean;
+    readonly isConnecting: boolean;
+};
+
+declare const createAccountController: () => {
+    readonly session: WalletSession | null;
+    readonly address: string | null;
+    readonly chain: SupportedChain | null;
+    readonly balance: BalanceInfo | null;
+    readonly isConnected: boolean;
+    readonly currentProvider: WalletProvider | null;
+    readonly chainContext: ChainContext | null;
+    readonly capabilities: string[];
+    readonly capabilityPolicy: SessionCapabilityPolicy | null;
+};
+
+declare abstract class AbstractProvider implements WalletAdapter {
+    abstract readonly id: string;
+    abstract readonly title: string;
+    abstract readonly category: ProviderCategory;
+    protected currentSession: WalletSession | null;
+    abstract connect(args?: WalletConnectArgs): Promise<WalletSession>;
+    disconnect(): Promise<void>;
+    protected setSession(session: WalletSession): WalletSession;
+    protected clearSession(): void;
+    protected get session(): WalletSession | null;
+    protected requireSession(message?: string): WalletSession;
+    getProvider(): WalletProvider | null;
+    reconnect(_persistedSession: WalletSession): Promise<WalletSession | null>;
+}
+
+interface InjectedEthereumProvider extends WalletProvider {
+    request<T = unknown>(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<T>;
+    providers?: InjectedEthereumProvider[];
+    isMetaMask?: boolean;
+    isCoinbaseWallet?: boolean;
+    isTrust?: boolean;
+    isTrustWallet?: boolean;
+    isPhantom?: boolean;
+    isRabby?: boolean;
+    isOkxWallet?: boolean;
+    isBitKeep?: boolean;
+    isRainbow?: boolean;
+    isZerion?: boolean;
+    isBraveWallet?: boolean;
+    isBitget?: boolean;
+}
+interface EIP6963ProviderInfo {
+    uuid: string;
+    name: string;
+    icon: string;
+    rdns: string;
+}
+interface EIP6963ProviderDetail {
+    info: EIP6963ProviderInfo;
+    provider: InjectedEthereumProvider;
+}
+declare global {
+    interface Window {
+        ethereum?: InjectedEthereumProvider;
+        okxwallet?: InjectedEthereumProvider | {
+            ethereum?: InjectedEthereumProvider;
+        };
+        coinbaseWalletExtension?: InjectedEthereumProvider;
+        trustwallet?: InjectedEthereumProvider | {
+            ethereum?: InjectedEthereumProvider;
+        };
+        phantom?: {
+            ethereum?: InjectedEthereumProvider;
+        };
+        rabby?: InjectedEthereumProvider;
+        bitkeep?: InjectedEthereumProvider | {
+            ethereum?: InjectedEthereumProvider;
+        };
+        rainbow?: {
+            ethereum?: InjectedEthereumProvider;
+        };
+        zerionWallet?: InjectedEthereumProvider;
+        bitget?: InjectedEthereumProvider | {
+            ethereum?: InjectedEthereumProvider;
+        };
+    }
+}
+declare function discoverEIP6963Providers(): EIP6963ProviderDetail[];
+declare function findInjectedProvider(predicate: (provider: InjectedEthereumProvider) => boolean): InjectedEthereumProvider | undefined;
+declare function findEIP6963Provider(predicate: (detail: EIP6963ProviderDetail) => boolean): InjectedEthereumProvider | undefined;
+interface InjectedWalletConfig {
+    id: string;
+    title: string;
+    resolveProvider: () => InjectedEthereumProvider | undefined;
+}
+/**
+ * Force wallet to the default funding chain (e.g. 3131). If the chain is missing (4902), add it then switch.
+ * Call after external wallet connect so subsequent business runs on the configured funding network.
+ */
+declare function switchToFallbackFundingChain(provider: InjectedEthereumProvider): Promise<void>;
+declare class InjectedEvmProvider extends AbstractProvider {
+    private config;
+    private injected?;
+    readonly id: string;
+    readonly title: string;
+    readonly category: "plugin";
+    constructor(config: InjectedWalletConfig, injected?: InjectedEthereumProvider | undefined);
+    isAvailable(): boolean;
+    protected get client(): InjectedEthereumProvider;
+    connect(_args?: WalletConnectArgs): Promise<WalletSession>;
+    reconnect(_persistedSession: WalletSession): Promise<WalletSession | null>;
+}
+declare class MetaMaskProvider extends InjectedEvmProvider {
+    constructor(injected?: InjectedEthereumProvider);
+}
+declare class OKXProvider extends InjectedEvmProvider {
+    constructor(injected?: InjectedEthereumProvider);
+}
+declare class CoinbaseWalletProvider extends InjectedEvmProvider {
+    constructor(injected?: InjectedEthereumProvider);
+}
+declare class TrustWalletProvider extends InjectedEvmProvider {
+    constructor(injected?: InjectedEthereumProvider);
+}
+declare class PhantomProvider extends InjectedEvmProvider {
+    constructor(injected?: InjectedEthereumProvider);
+}
+declare class RabbyProvider extends InjectedEvmProvider {
+    constructor(injected?: InjectedEthereumProvider);
+}
+declare class RainbowProvider extends InjectedEvmProvider {
+    constructor(injected?: InjectedEthereumProvider);
+}
+declare class ZerionProvider extends InjectedEvmProvider {
+    constructor(injected?: InjectedEthereumProvider);
+}
+declare class BraveWalletProvider extends InjectedEvmProvider {
+    constructor(injected?: InjectedEthereumProvider);
+}
+declare class BitgetProvider extends InjectedEvmProvider {
+    constructor(injected?: InjectedEthereumProvider);
+}
+
+interface InjectedWalletRegistryItem {
+    id: string;
+    title: string;
+    installUrl?: string;
+    provider: InjectedEvmProvider;
+    installed: boolean;
+}
+declare function createDefaultInjectedWalletRegistry(): InjectedWalletRegistryItem[];
+
+interface SocialLoginOptions {
+    hint?: string;
+    redirectUri?: string;
+}
+interface SocialConnectArgs extends WalletConnectArgs {
+    options?: SocialLoginOptions;
+}
+declare abstract class AbstractSocialProvider extends AbstractProvider {
+    readonly category: "social";
+    /**
+     * Authenticate and cache a social-wallet session.
+     *
+     * Some providers only need `options`, while others may require an
+     * additional credential payload (for example an OIDC token or OAuth result).
+     */
+    abstract signIn(options?: SocialLoginOptions, payload?: unknown): Promise<void>;
+    abstract signOut(): Promise<void>;
+    connect(args?: WalletConnectArgs): Promise<WalletSession>;
+}
+
+/**
+ * Hook for OIDC login when user does not yet exist in CubeSigner.
+ * Before creating a session, we call CubeSigner SDK's proof (proveOidcIdentity) to check
+ * if the user exists. If proof fails (e.g. user not registered), this is invoked so the
+ * caller can register the user on their backend; then login proceeds.
+ */
+interface OidcLoginHooks {
+    /**
+     * Register the user on your backend when CubeSigner proof indicates the user does not exist.
+     * Called with the same OIDC token; after this resolves, OIDC session creation continues.
+     */
+    registerUser(oidcToken: string): Promise<void>;
+}
+interface CubeSignerConfig {
+    /** CubeSigner environment name or custom env object. */
+    env: Environment | EnvInterface;
+    /** Organization ID. */
+    orgId: string;
+    /** Session scopes (default: `["sign:*", "manage:*"]`). */
+    scopes?: string[];
+    /** Optional capability policy applied to smart-wallet sessions created from this auth flow. */
+    defaultSessionPolicy?: Partial<SessionCapabilityPolicy>;
+    /**
+     * Optional OIDC login hook. When provided, OIDC login will call CubeSigner SDK's
+     * proveOidcIdentity first; if the user does not exist (proof fails), registerUser is
+     * called, then login proceeds. If omitted, login uses the OIDC token directly.
+     */
+    oidcLoginHooks?: OidcLoginHooks;
+}
+interface CubeSignerSession {
+    /** Authenticated CubeSigner client — use it for signing, key management, etc. */
+    client: CubeSignerClient;
+    /** Raw session data (can be persisted / refreshed). */
+    sessionData: SessionData;
+}
+interface TwitterCodeExchangeParams {
+    /** Authorization code from Twitter OAuth 2.0 PKCE flow. */
+    code: string;
+    /** PKCE code_verifier that was generated for the auth request. */
+    codeVerifier: string;
+    /** redirect_uri that was used in the authorization request. */
+    redirectUri: string;
+}
+declare class CubeSignerAuth {
+    private readonly env;
+    private readonly orgId;
+    private readonly scopes;
+    readonly defaultSessionPolicy?: Partial<SessionCapabilityPolicy>;
+    private readonly oidcLoginHooks?;
+    private _client;
+    private _sessionData;
+    constructor(config: CubeSignerConfig);
+    /** Currently authenticated client (null if not logged in). */
+    get client(): CubeSignerClient | null;
+    get currentSession(): CubeSignerSession | null;
+    /**
+     * Login with a Google ID token (JWT).
+     * The token is used directly as the OIDC credential.
+     */
+    loginWithGoogle(idToken: string): Promise<CubeSignerSession>;
+    /**
+     * Login with a Twitter OAuth 2.0 authorization code.
+     *
+     * 1. Exchange the code for an OIDC `id_token` via CubeSigner's
+     *    `/v0/org/{org_id}/oauth2/twitter` endpoint.
+     * 2. Create a CubeSigner session with that token.
+     */
+    loginWithTwitter(params: TwitterCodeExchangeParams): Promise<CubeSignerSession>;
+    signOut(): Promise<void>;
+    /**
+     * Restore a CubeSigner session from previously persisted SessionData.
+     * Useful for reconnecting after page reload without re-authentication.
+     */
+    restoreSession(sessionData: SessionData): Promise<CubeSignerSession>;
+    private authenticateWithOidcToken;
+    /**
+     * Exchange a Twitter authorization code for an OIDC id_token
+     * via CubeSigner's dedicated endpoint.
+     *
+     * `POST {SignerApiRoot}/v0/org/{org_id}/oauth2/twitter`
+     */
+    private exchangeTwitterCode;
+    /**
+     * Create a CubeSigner OIDC session from a generic OIDC id_token.
+     */
+    private createOidcSession;
+}
+
+type CubistLoginMethod = {
+    type: "google";
+    idToken: string;
+} | {
+    type: "twitter";
+    params: TwitterCodeExchangeParams;
+};
+interface CubistSessionAdapter {
+    /**
+     * Convert a raw CubeSigner session into a WalletSession
+     * (resolve the first key's address, chain, build a provider, etc.).
+     */
+    resolve(session: CubeSignerSession): Promise<WalletSession>;
+}
+declare class CubistSocialProvider extends AbstractSocialProvider {
+    readonly id = "cubist";
+    readonly title = "Cubist Social Wallet";
+    private auth;
+    private adapter;
+    private lastCubeSignerSession;
+    /** Stash the login method so `connect()` can auto-retry. */
+    private lastLogin;
+    constructor(config: CubeSignerConfig, adapter?: CubistSessionAdapter);
+    private createWalletSession;
+    private authenticate;
+    private getResolvedLoginMethod;
+    /**
+     * Preferred explicit sign-in entrypoint.
+     */
+    signInWith(method: CubistLoginMethod, _options?: SocialLoginOptions): Promise<void>;
+    /**
+     * Backward-compatible abstract implementation.
+     *
+     * - If `payload` is provided, it is treated as the login method.
+     * - Otherwise reuses the previously cached login method if available.
+     */
+    signIn(_options?: SocialLoginOptions, payload?: unknown): Promise<void>;
+    /**
+     * Explicit connect flow that both authenticates and returns the wallet session.
+     */
+    connectWith(method: CubistLoginMethod, options?: SocialLoginOptions): Promise<WalletSession>;
+    connect(args?: WalletConnectArgs): Promise<WalletSession>;
+    reconnect(persistedSession: WalletSession): Promise<WalletSession | null>;
+    signOut(): Promise<void>;
+    disconnect(): Promise<void>;
+    /** Direct access to the underlying CubeSignerAuth for advanced use-cases. */
+    get cubeSignerAuth(): CubeSignerAuth;
+    get cubeSignerSession(): CubeSignerSession | null;
+}
+
+export { AbstractProvider, AbstractSocialProvider, type BalanceInfo, BitgetProvider, BraveWalletProvider, type ChainContext, type ChainDescriptor, type ChainNamespace, type ChainRpcFamily, CoinbaseWalletProvider, CubeSignerAuth, type CubeSignerConfig, type CubeSignerSession, type CubistLoginMethod, type CubistSessionAdapter, CubistSocialProvider, type EIP6963ProviderDetail, type EIP6963ProviderInfo, EVM_TRANSACTION_SIGNING_UNSUPPORTED, type EvmAccessListItem, type EvmQuantity, type EvmTransactionRequest, EvmTransactionSigningUnsupportedError, type InjectedEthereumProvider, InjectedEvmProvider, type InjectedWalletConfig, type InjectedWalletRegistryItem, MetaMaskProvider, OKXProvider, type OidcLoginHooks, PhantomProvider, type ProviderCategory, RabbyProvider, RainbowProvider, type SessionCapabilityCheck, SessionCapabilityError, type SessionCapabilityPolicy, SessionStore, type SocialConnectArgs, type SocialLoginOptions, type SupportedChain, type SupportedToken, TrustWalletProvider, type TwitterCodeExchangeParams, type WalletAdapter, type WalletAuthSource, type WalletCapability, type WalletConnectArgs, type WalletConnectControllerOptions, WalletConnector, type WalletEvents, type WalletExecutionClient, type WalletProvider, type WalletProviderRequest, type WalletSession, type WalletState, type WalletType, ZerionProvider, assertSessionCapability, createAccountController, createChainContext, createDefaultInjectedWalletRegistry, createSessionCapabilityPolicy, createWalletConnectController, createWalletExecutionClient, createWalletExecutionController, describeSessionCapabilityPolicy, discoverEIP6963Providers, findEIP6963Provider, findInjectedProvider, getAllChainDescriptors, getChainDescriptor, getSupportedChainFromEvmChainId, getWalletExecutionCapabilities, isCapabilityPolicyExpired, isSessionExpired, isUnsupportedEvmTransactionSigningError, normalizeEvmTransactionSigningError, sessionStore, sessionSupportsCapability, switchToFallbackFundingChain };