@trustware/sdk-staging 1.1.5-staging.1 → 1.1.6-staging.2

package/dist/manager-CXSw1h5e.d.cts

@@ -0,0 +1,738 @@
+declare enum TrustwareErrorCode {
+    INVALID_CONFIG = "INVALID_CONFIG",
+    INVALID_API_KEY = "INVALID_API_KEY",
+    WALLET_NOT_CONNECTED = "WALLET_NOT_CONNECTED",
+    BRIDGE_FAILED = "BRIDGE_FAILED",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR",
+    INPUT_ERROR = "INPUT_ERROR"
+}
+
+declare class TrustwareError extends Error {
+    code: TrustwareErrorCode;
+    userMessage?: string;
+    cause?: unknown;
+    constructor(params: {
+        code: TrustwareErrorCode;
+        message: string;
+        userMessage?: string;
+        cause?: unknown;
+    });
+    toJSON(): {
+        name: string;
+        code: TrustwareErrorCode;
+        message: string;
+        userMessage: string | undefined;
+    };
+}
+
+type TrustwareWidgetTheme = {
+    primaryColor: string;
+    secondaryColor: string;
+    backgroundColor: string;
+    textColor: string;
+    borderColor: string;
+    radius: number;
+};
+type TrustwareWidgetMessages = {
+    title: string;
+    description: string;
+};
+declare const DEFAULT_THEME: TrustwareWidgetTheme;
+declare const DEFAULT_MESSAGES: TrustwareWidgetMessages;
+
+type WalletId = "metamask" | "coinbase" | "walletconnect" | "rainbow" | "phantom-evm" | "phantom-solana" | "solflare" | "backpack" | "rabby" | "brave" | "okx" | "zerion" | "taho" | "safe" | "imtoken" | "trust" | "bitget" | "kucoin";
+type WalletCategory = "injected" | "walletconnect" | "app";
+type WalletEcosystem = "evm" | "solana" | "multi";
+type WalletMeta = {
+    id: WalletId;
+    name: string;
+    category: WalletCategory;
+    ecosystem: WalletEcosystem;
+    logo: string;
+    emoji?: string;
+    homepage?: string;
+    chromeWebStore?: string;
+    android?: string;
+    ios?: string;
+    deepLink?: (currentUrl: string) => string;
+    detectFlags?: string[];
+};
+type EIP1193 = {
+    request(args: {
+        method: string;
+        params?: unknown[] | object;
+    }): Promise<unknown>;
+};
+type EIP6963ProviderDetail = {
+    info: {
+        uuid: string;
+        name: string;
+        icon: string;
+        rdns?: string;
+        version?: string;
+        wallets?: {
+            name: string;
+            version?: string;
+        }[];
+        features?: string[];
+    };
+    provider: any;
+    methods: string[];
+    events: string[];
+};
+type DetectedWallet = {
+    meta: WalletMeta;
+    via: "eip6963" | "injected-flag" | "walletconnect" | "solana-window";
+    detail?: EIP6963ProviderDetail;
+    provider?: any;
+};
+type SolanaProviderLike = {
+    isPhantom?: boolean;
+    isSolflare?: boolean;
+    isBackpack?: boolean;
+    isConnected?: boolean;
+    publicKey?: {
+        toString(): string;
+    };
+    connect?: (options?: Record<string, unknown>) => Promise<unknown>;
+    disconnect?: () => Promise<void>;
+    signAndSendTransaction?: (transaction: unknown, options?: Record<string, unknown>) => Promise<{
+        signature?: string;
+    } | string>;
+    signTransaction?: (transaction: unknown) => Promise<{
+        serialize: () => Uint8Array;
+    }>;
+    on?: (event: string, listener: (...args: unknown[]) => void) => void;
+    off?: (event: string, listener: (...args: unknown[]) => void) => void;
+    removeListener?: (event: string, listener: (...args: unknown[]) => void) => void;
+};
+type BaseWalletInterface = {
+    ecosystem: "evm" | "solana";
+    getAddress(): Promise<string>;
+    disconnect?(): Promise<void>;
+};
+type EvmWalletInterface = BaseWalletInterface & {
+    ecosystem: "evm";
+    getChainId(): Promise<number>;
+    switchChain(chainId: number): Promise<void>;
+} & ({
+    type: "eip1193";
+    request(args: {
+        method: string;
+        params?: unknown[] | object;
+    }): Promise<unknown>;
+} | {
+    type: "wagmi";
+    sendTransaction(tx: {
+        to: `0x${string}`;
+        data: `0x${string}`;
+        value?: bigint;
+        chainId?: number;
+    }): Promise<{
+        hash: `0x${string}`;
+    }>;
+});
+type SolanaWalletInterface = BaseWalletInterface & {
+    ecosystem: "solana";
+    type: "solana";
+    getChainKey(): Promise<string>;
+    sendSerializedTransaction(serializedTransactionBase64: string, chainId?: string): Promise<string>;
+};
+type WalletInterFaceAPI = EvmWalletInterface | SolanaWalletInterface;
+type SimpleWalletInterface = {
+    getAddress(): Promise<string>;
+    disconnect?(): Promise<void>;
+};
+
+type ChainMeta = {
+    id: string;
+    networkIdentifier: string;
+    nativeCurrency: {
+        symbol: string;
+        decimals: number;
+        name: string;
+    };
+};
+type TokenMeta = {
+    chainId: string;
+    address: `0x${string}`;
+    symbol: string;
+    decimals: number;
+    visible?: boolean;
+    active?: boolean;
+};
+type BalanceRow = {
+    chain_key: string;
+    category: "native" | "erc20" | "spl" | "btc";
+    contract?: string;
+    address?: string;
+    symbol?: string;
+    decimals: number;
+    balance: string;
+    name?: string;
+    logoURI?: string;
+    usdPrice?: number;
+};
+type WalletAddressBalanceWrapper = {
+    chain_id: string;
+    balances: BalanceRow[];
+    count: number;
+    error: string | null;
+    source: string;
+};
+type TokenPageOptions = {
+    cursor?: string;
+    limit?: number;
+    q?: string;
+};
+type TokenPageInfo = {
+    hasNextPage: boolean;
+    nextCursor?: string;
+};
+type TokenPageResult = {
+    data: TokenDef[];
+    pageInfo: TokenPageInfo;
+};
+type BalanceStreamOptions = {
+    stream?: boolean;
+    signal?: AbortSignal;
+    strict?: boolean;
+};
+type ChainType = "evm" | "cosmos" | "solana" | "btc" | string;
+interface NativeCurrency {
+    symbol: string;
+    name?: string;
+    decimals?: number;
+    icon?: string;
+}
+interface ChainDef {
+    /** API commonly sends both. We canonicalize on chainId as string. */
+    chainId: string | number;
+    id?: string | number;
+    /** Keys we use to resolve chains from presets / user input */
+    networkIdentifier?: string;
+    axelarChainName?: string;
+    networkName?: string;
+    /** UI/availability flags */
+    enabled?: boolean;
+    visible?: boolean;
+    isTestnet?: boolean;
+    /** Display */
+    chainIconURI?: string;
+    nativeCurrency?: NativeCurrency;
+    /** Kinds (some payloads use both) */
+    type?: ChainType;
+    chainType?: ChainType;
+    /** Nice-to-have extras we won't rely on but keep for completeness */
+    blockExplorerUrls?: string[];
+    rpc?: string;
+    rpcList?: string[];
+}
+type TokenType = "evm" | "solana" | "btc" | string;
+interface TokenDef {
+    /** Core identity */
+    address: string;
+    chainId: string | number;
+    /** Display */
+    logoURI?: string;
+    name: string;
+    symbol: string;
+    /** Behavior / filtering */
+    decimals: number;
+    active?: boolean;
+    visible?: boolean;
+    type: TokenType;
+    /** Optional metadata */
+    usdPrice?: number;
+    coingeckoId?: string;
+    createdBy?: string;
+    subGraphIds?: string[];
+    subGraphOnly?: boolean;
+}
+type TokenWithBalance = TokenDef & {
+    balance?: bigint;
+};
+
+type WalletAddressSource = "provider" | "manual" | "imported";
+type WalletIdentityAddress = {
+    address: string;
+    chainType: ChainType;
+    chainKey?: string;
+    chainId?: string;
+    providerId?: string;
+    source: WalletAddressSource;
+};
+type WalletIdentity = {
+    addresses: WalletIdentityAddress[];
+};
+type WalletAddressResolution = {
+    status: "resolved";
+    address: string;
+    source: WalletAddressSource;
+    chainType: ChainType;
+    chainKey?: string;
+    chainId?: string;
+} | {
+    status: "missing" | "invalid";
+    reason: string;
+    address?: string;
+    source?: WalletAddressSource;
+    chainType?: ChainType;
+    chainKey?: string;
+    chainId?: string;
+};
+type WalletIdentityChainLike = ChainDef | ChainType | string | null;
+
+type BuildRouteBody = {
+    fromChain: string;
+    toChain: string;
+    fromToken: string;
+    toToken: string;
+    fromAmount: string;
+    fromAddress: string;
+    toAddress: string;
+    fromAmountUsd?: string;
+    fromAmountUSD?: string;
+    refundAddress?: string;
+    direction?: string;
+    slippage?: number;
+    slippageBps?: number;
+    linkId?: string;
+    memo?: string;
+};
+type TxRequest = {
+    to?: string;
+    target?: string;
+    data: string;
+    value?: string;
+    gasLimit?: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+    chainId?: number | string;
+    gasPrice?: string;
+};
+declare function buildRoute(body: BuildRouteBody, signal?: AbortSignal): Promise<{
+    intentId: string;
+    txReq: TxRequest;
+    actions: unknown[];
+    finalExchangeRate: {
+        fromAmountUSD?: string;
+        toAmountMinUSD?: string;
+    };
+    route: RoutePlan | undefined;
+}>;
+declare function buildDepositAddress(body: BuildRouteBody, signal?: AbortSignal): Promise<{
+    intentId: string;
+    depositAddress: string;
+    actions: unknown[];
+    finalExchangeRate: {
+        fromAmountUSD?: string;
+        toAmountMinUSD?: string;
+    };
+    route: RoutePlan | undefined;
+}>;
+declare function submitReceipt(intentId: string, txHash: string): Promise<any>;
+declare function getStatus(intentId: string): Promise<Transaction>;
+declare function pollStatus(intentId: string, { intervalMs, timeoutMs }?: {
+    intervalMs?: number | undefined;
+    timeoutMs?: number | undefined;
+}): Promise<Transaction>;
+
+type RouteParams = {
+    fromChain: string;
+    toChain: string;
+    fromToken: string;
+    toToken: string;
+    fromAmount: string | number;
+    fromAddress: string;
+    toAddress: string;
+    slippage?: number;
+};
+type RouteIntent = {
+    id: string;
+    fromChainId: string | number;
+    toChainId: string | number;
+    fromToken: string;
+    toToken: string;
+    fromAddress: string;
+    toAddress: string;
+    fromAmountWei: string | number;
+    quoteToAmountWei: string | number;
+    minToAmountWei: string | number;
+    requestId?: string;
+    routeRaw?: unknown;
+    status: "created" | "submitted" | "bridging" | "success" | "failed";
+    createdDate: Date | string;
+    updatedDate: Date | string;
+};
+type Transaction = {
+    id: string;
+    intentId: string;
+    fromAddress: string;
+    toAddress: string;
+    fromChainId: string | number;
+    toChainId: string | number;
+    sourceTxHash: string;
+    destTxHash: string;
+    requestId: string;
+    transactionRequest: unknown;
+    status: "submitted" | "bridging" | "success" | "failed";
+    statusRaw?: unknown;
+    routePath?: unknown;
+    routeStatus?: unknown;
+    toAmountWei?: string | number;
+    fromChainBlock: number;
+    toChainBlock: number;
+    fromChainTxUrl?: string;
+    toChainTxUrl?: string;
+    gasStatus?: string;
+    isGMPTransaction?: boolean;
+    axelarTransactionUrl?: string;
+    createdDate: Date | string;
+    updatedDate: Date | string;
+    timeSpentMs?: number;
+};
+type RouteEstimate = {
+    fromAmount?: string;
+    toAmount?: string;
+    toAmountMin?: string;
+    fromAmountUsd?: string;
+    toAmountUsd?: string;
+    totalFeesUsd?: string;
+    toAmountMinUsd?: string;
+    fees?: unknown[];
+};
+type RoutePlan = {
+    estimate?: RouteEstimate;
+    execution?: {
+        transaction?: TxRequest;
+    };
+    steps?: unknown[];
+    provider?: string;
+    requestId?: string;
+    reliabilityScore?: number;
+    diagnostics?: {
+        rawPayload?: unknown;
+    };
+};
+type BuildRouteResult = {
+    intentId: string;
+    txReq: TxRequest;
+    actions: unknown[];
+    finalExchangeRate: {
+        fromAmountUSD?: string;
+        toAmountMinUSD?: string;
+    };
+    route: RoutePlan | undefined;
+};
+
+type TrustwareEvent = {
+    type: "error";
+    error: TrustwareError;
+} | {
+    type: "transaction_started";
+} | {
+    type: "transaction_success";
+    txHash: string;
+    transaction?: Transaction;
+} | {
+    type: "wallet_connected";
+    address: string;
+} | {
+    type: "token_page_loaded";
+    chainRef: string;
+    query?: string;
+    count: number;
+    hasNextPage: boolean;
+    cursor?: string;
+} | {
+    type: "token_page_error";
+    chainRef: string;
+    query?: string;
+    cursor?: string;
+    message: string;
+} | {
+    type: "balance_stream_chunk";
+    address: string;
+    chunkSize: number;
+} | {
+    type: "balance_stream_fallback";
+    address: string;
+    message: string;
+};
+
+/** WalletConnect configuration options (all optional - SDK has built-in defaults) */
+type WalletConnectConfig = {
+    /** Override the built-in WalletConnect project ID (optional - SDK includes one) */
+    projectId?: string;
+    /** Chain IDs to support (defaults to [1] for Ethereum mainnet) */
+    chains?: number[];
+    /** Optional chain IDs (chains that can be switched to) */
+    optionalChains?: number[];
+    /** dApp metadata shown in wallet */
+    metadata?: {
+        name: string;
+        description?: string;
+        url: string;
+        icons?: string[];
+    };
+    /** Custom relay URL (defaults to WalletConnect's relay) */
+    relayUrl?: string;
+    /** Whether to show our custom QR modal (default: true) */
+    showQrModal?: boolean;
+    /** Disable WalletConnect entirely (default: false) */
+    disabled?: boolean;
+};
+/** Resolved WalletConnect config with defaults applied */
+type ResolvedWalletConnectConfig = {
+    projectId: string;
+    chains: number[];
+    optionalChains: number[];
+    metadata: {
+        name: string;
+        description: string;
+        url: string;
+        icons: string[];
+    };
+    relayUrl?: string;
+    showQrModal: boolean;
+};
+type TrustwareConfigOptions = {
+    apiKey: string;
+    routes: {
+        toChain: string;
+        toToken: string;
+        fromToken?: string;
+        fromChain?: string;
+        fromAddress?: string;
+        toAddress?: string;
+        defaultSlippage?: number;
+        routeType?: string;
+        options?: {
+            routeRefreshMs?: number;
+            fixedFromAmount?: string | number;
+            minAmountOut?: string | number;
+            maxAmountOut?: string | number;
+        };
+    };
+    autoDetectProvider?: boolean;
+    theme?: TrustwareWidgetTheme;
+    messages?: Partial<TrustwareWidgetMessages>;
+    retry?: RetryConfig;
+    walletConnect?: WalletConnectConfig;
+    features?: FeatureFlags;
+    onError?: (error: TrustwareError) => void;
+    onSuccess?: (transaction: Transaction) => void;
+    onEvent?: (event: TrustwareEvent) => void;
+};
+type ResolvedTrustwareConfig = {
+    apiKey: string;
+    routes: {
+        toChain: string;
+        toToken: string;
+        fromToken?: string;
+        fromAddress?: string;
+        toAddress?: string;
+        defaultSlippage: number;
+        routeType: string;
+        options: {
+            routeRefreshMs?: number;
+            fixedFromAmount?: string | number;
+            minAmountOut?: string | number;
+            maxAmountOut?: string | number;
+        };
+    };
+    autoDetectProvider: boolean;
+    theme: TrustwareWidgetTheme;
+    messages: TrustwareWidgetMessages;
+    retry: ResolvedRetryConfig;
+    walletConnect?: ResolvedWalletConnectConfig | WalletConnectConfig | undefined;
+    features: ResolvedFeatureFlags;
+    onError?: (error: TrustwareError) => void;
+    onSuccess?: (transaction: Transaction) => void;
+    onEvent?: (event: TrustwareEvent) => void;
+};
+type FeatureFlags = {
+    tokensPagination?: boolean;
+    balanceStreaming?: boolean;
+    shouldAllowGA4?: boolean;
+};
+type ResolvedFeatureFlags = {
+    tokensPagination: boolean;
+    balanceStreaming: boolean;
+    shouldAllowGA4: boolean;
+};
+declare const DEFAULT_SLIPPAGE = 1;
+declare const DEFAULT_AUTO_DETECT_PROVIDER = false;
+type RateLimitInfo = {
+    /** Maximum requests allowed in the current window */
+    limit: number;
+    /** Requests remaining in the current window */
+    remaining: number;
+    /** Unix timestamp when the rate limit window resets */
+    reset: number;
+    /** Seconds until rate limit resets (only present on 429 responses) */
+    retryAfter?: number;
+};
+type RetryConfig = {
+    /** Enable automatic retry on 429 responses (default: true). Note: This does NOT disable backend rate limits, only client-side retry behavior. */
+    autoRetry?: boolean;
+    /** Maximum number of retries on 429 (default: 3) */
+    maxRetries?: number;
+    /** Base delay in ms for exponential backoff (default: 1000) */
+    baseDelayMs?: number;
+    /** Callback when rate limit info is received from server */
+    onRateLimitInfo?: (info: RateLimitInfo) => void;
+    /** Callback when rate limit is hit (429 received) */
+    onRateLimited?: (info: RateLimitInfo, retryCount: number) => void;
+    /** Callback when remaining requests fall below threshold */
+    onRateLimitApproaching?: (info: RateLimitInfo, threshold: number) => void;
+    /** Threshold for onRateLimitApproaching callback (default: 5) */
+    approachingThreshold?: number;
+};
+type ResolvedRetryConfig = {
+    autoRetry: boolean;
+    maxRetries: number;
+    baseDelayMs: number;
+    approachingThreshold: number;
+    onRateLimitInfo?: (info: RateLimitInfo) => void;
+    onRateLimited?: (info: RateLimitInfo, retryCount: number) => void;
+    onRateLimitApproaching?: (info: RateLimitInfo, threshold: number) => void;
+};
+declare const DEFAULT_RETRY_CONFIG: ResolvedRetryConfig;
+declare const DEFAULT_FEATURE_FLAGS: ResolvedFeatureFlags;
+
+type WagmiConnector = {
+    /** Human label like "MetaMask", "WalletConnect" */
+    name: string;
+    /** Free-form type hint: "injected" | "walletConnect" | ... */
+    type?: string;
+};
+type WagmiBridge = {
+    /** Host app believes it’s connected (Wagmi state) */
+    isConnected(): boolean;
+    /** List of available connectors */
+    connectors(): WagmiConnector[];
+    /** Try connecting via a specific connector */
+    connect(connector: WagmiConnector): Promise<void>;
+    /** Disconnect current session */
+    disconnect(): Promise<void>;
+};
+
+declare function createWalletIdentity(addresses?: WalletIdentityAddress[]): WalletIdentity;
+declare function upsertWalletIdentityAddress(identity: WalletIdentity, next: WalletIdentityAddress): WalletIdentity;
+declare function resolveWalletAddressForChain(identity: WalletIdentity, chain?: WalletIdentityChainLike): WalletAddressResolution;
+declare function buildWalletIdentityAddress(params: {
+    address: string;
+    chain: WalletIdentityChainLike;
+    source: WalletAddressSource;
+    providerId?: string;
+}): WalletIdentityAddress | null;
+declare class IdentityStore {
+    private _identity;
+    get snapshot(): WalletIdentity;
+    reset(): void;
+    upsert(next: WalletIdentityAddress): WalletIdentity;
+    resolve(chain?: WalletIdentityChainLike): WalletAddressResolution;
+}
+
+type Status = "idle" | "detecting" | "connecting" | "connected" | "error";
+type ConnectedVia = "extension" | "walletconnect" | "direct" | null;
+type Listener = (s: Status) => void;
+interface WalletSnapshot {
+    status: Status;
+    connectedVia: ConnectedVia;
+    walletType: "walletconnect" | "other";
+    error: string | null;
+    detected: DetectedWallet[];
+    wallet: WalletInterFaceAPI | null;
+    simple: SimpleWalletInterface | null;
+    identity: ReturnType<any>;
+    connectedWalletId: string | null;
+    address: string | null;
+    isConnected: boolean;
+}
+declare class WalletManager {
+    private _status;
+    private _connectedVia;
+    private _wallet;
+    private _detected;
+    private _listeners;
+    private _error;
+    private _identity;
+    private _providerCleanup;
+    private _connectedWalletId;
+    private _address;
+    private _onExternalDisconnectCallback;
+    private _snapshot;
+    get status(): Status;
+    get error(): string | null;
+    get detected(): DetectedWallet[];
+    get wallet(): WalletInterFaceAPI | null;
+    get connectedVia(): ConnectedVia;
+    get connectedWalletId(): string | null;
+    get address(): string | null;
+    get isConnected(): boolean;
+    get walletType(): "walletconnect" | "other";
+    get simple(): SimpleWalletInterface | null;
+    get identity(): WalletIdentity;
+    get snapshot(): WalletSnapshot;
+    private buildSnapshot;
+    onChange(fn: Listener): () => boolean;
+    private emit;
+    onExternalDisconnect(cb: () => void): () => void;
+    private triggerExternalDisconnect;
+    setDetected(list: DetectedWallet[]): void;
+    autoAttach(opts?: {
+        wagmi?: WagmiBridge;
+        pick?: (list: DetectedWallet[]) => DetectedWallet | undefined;
+    }): Promise<void>;
+    connectDetected(target: DetectedWallet, opts?: {
+        wagmi?: WagmiBridge;
+    }): Promise<{
+        error: null;
+        api: WalletInterFaceAPI;
+    } | {
+        error: string;
+        api: WalletInterFaceAPI | null;
+    } | undefined>;
+    connectWalletConnect(walletCfg?: WalletConnectConfig): Promise<{
+        error: null;
+        api: WalletInterFaceAPI;
+    } | {
+        error: string;
+        api: null;
+    }>;
+    disconnect(wagmi?: WagmiBridge): Promise<void>;
+    attachWallet(api: WalletInterFaceAPI): void;
+    setStatus(s: Status): void;
+    addIdentityAddress(address: WalletIdentityAddress): void;
+    resolveAddressForChain(chain: Parameters<IdentityStore["resolve"]>[0]): WalletAddressResolution;
+    private clearProviderCleanup;
+    private clearConnectedState;
+    private fullReset;
+    private bindExtensionProviderEvents;
+    private syncIdentityFromWallet;
+}
+declare const walletManager: WalletManager;
+declare function useWireDetectionIntoManager(): void;
+declare function useWalletConnectConnect(walletCfg?: WalletConnectConfig): () => Promise<{
+    error: null;
+    api: WalletInterFaceAPI;
+} | {
+    error: string;
+    api: null;
+}>;
+declare function useWalletInfo(wagmi?: WagmiBridge): {
+    walletMetaId: string | null;
+    address: string | null;
+    isConnected: boolean;
+    connectedVia: ConnectedVia;
+    walletType: "walletconnect" | "other";
+    status: Status;
+    disconnect: () => Promise<void>;
+};
+declare function useWalletExternalDisconnect(cb: () => void): void;
+
+export { type WalletEcosystem as $, type TokenDef as A, type BalanceRow as B, type ChainDef as C, DEFAULT_AUTO_DETECT_PROVIDER as D, type EIP1193 as E, type FeatureFlags as F, type TokenMeta as G, type TokenPageInfo as H, IdentityStore as I, type TokenPageOptions as J, type TokenPageResult as K, type TokenType as L, type TokenWithBalance as M, type NativeCurrency as N, type TrustwareWidgetMessages as O, type TrustwareWidgetTheme as P, type WagmiBridge as Q, type RateLimitInfo as R, type SimpleWalletInterface as S, type TrustwareConfigOptions as T, type WagmiConnector as U, type WalletAddressBalanceWrapper as V, type WalletInterFaceAPI as W, type WalletAddressResolution as X, type WalletAddressSource as Y, type WalletCategory as Z, type WalletConnectConfig as _, TrustwareError as a, type WalletId as a0, type WalletIdentity as a1, type WalletIdentityAddress as a2, type WalletIdentityChainLike as a3, type WalletMeta as a4, buildWalletIdentityAddress as a5, createWalletIdentity as a6, resolveWalletAddressForChain as a7, upsertWalletIdentityAddress as a8, useWireDetectionIntoManager as a9, type WalletSnapshot as aa, useWalletConnectConnect as ab, useWalletExternalDisconnect as ac, useWalletInfo as ad, walletManager as ae, buildRoute as af, buildDepositAddress as ag, submitReceipt as ah, getStatus as ai, pollStatus as aj, type Transaction as b, type TrustwareEvent as c, type BalanceStreamOptions as d, type BuildRouteResult as e, type ChainMeta as f, type ChainType as g, DEFAULT_FEATURE_FLAGS as h, DEFAULT_MESSAGES as i, DEFAULT_RETRY_CONFIG as j, DEFAULT_SLIPPAGE as k, DEFAULT_THEME as l, type DetectedWallet as m, type EIP6963ProviderDetail as n, type EvmWalletInterface as o, type ResolvedFeatureFlags as p, type ResolvedRetryConfig as q, type ResolvedTrustwareConfig as r, type ResolvedWalletConnectConfig as s, type RetryConfig as t, type RouteEstimate as u, type RouteIntent as v, type RouteParams as w, type RoutePlan as x, type SolanaProviderLike as y, type SolanaWalletInterface as z };