@cantonconnect/core 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,885 @@
+/**
+ * Core types for CantonConnect SDK
+ *
+ * References:
+ * - Wallet Integration Guide: https://docs.digitalasset.com/integrate/devnet/index.html
+ * - Signing transactions from dApps: https://docs.digitalasset.com/integrate/devnet/signing-transactions-from-dapps/index.html
+ * - OpenRPC dApp API spec: https://github.com/hyperledger-labs/splice-wallet-kernel/blob/main/api-specs/openrpc-dapp-api.json
+ */
+/**
+ * Branded string types for type safety
+ */
+type WalletId = string & {
+    readonly __brand: 'WalletId';
+};
+type PartyId = string & {
+    readonly __brand: 'PartyId';
+};
+type SessionId = string & {
+    readonly __brand: 'SessionId';
+};
+type TransactionHash = string & {
+    readonly __brand: 'TransactionHash';
+};
+type Signature = string & {
+    readonly __brand: 'Signature';
+};
+/**
+ * Network identifier
+ * Standard networks: "devnet" | "testnet" | "mainnet"
+ * Custom networks allowed as string
+ */
+type NetworkId = 'devnet' | 'testnet' | 'mainnet' | string;
+/**
+ * Capability keys that wallets can support
+ * Based on OpenRPC dApp API capabilities
+ */
+type CapabilityKey = 'connect' | 'disconnect' | 'restore' | 'signMessage' | 'signTransaction' | 'submitTransaction' | 'events' | 'deeplink' | 'popup' | 'injected' | 'remoteSigner';
+/**
+ * Wallet installation hints for detection
+ */
+interface InstallHints {
+    /** Window property name (e.g., "consoleWallet") */
+    injectedKey?: string;
+    /** Browser extension ID */
+    extensionId?: string;
+    /** Deep link scheme (e.g., "loop://") */
+    deepLinkScheme?: string;
+    /** Script tag identifier */
+    scriptTag?: string;
+}
+/**
+ * Wallet adapter metadata
+ */
+interface AdapterMetadata {
+    /** NPM package name */
+    packageName: string;
+    /** Version range (semver) */
+    versionRange: string;
+}
+/**
+ * Wallet information from registry
+ */
+interface WalletInfo {
+    /** Wallet identifier */
+    walletId: WalletId;
+    /** Display name */
+    name: string;
+    /** Website URL */
+    website: string;
+    /** Icon URLs (different sizes) */
+    icons: {
+        sm?: string;
+        md?: string;
+        lg?: string;
+    };
+    /** Category (e.g., "browser", "mobile", "hardware") */
+    category?: string;
+    /** Supported capabilities */
+    capabilities: CapabilityKey[];
+    /** Installation detection hints */
+    installHints?: InstallHints;
+    /** Adapter package information */
+    adapter: AdapterMetadata;
+    /** Documentation URLs */
+    docs: string[];
+    /** Minimum SDK version required */
+    minSdkVersion?: string;
+    /** Supported networks */
+    networks: NetworkId[];
+    /** Registry channel */
+    channel: 'stable' | 'beta';
+    /** Additional metadata (e.g., originAllowlist) */
+    metadata?: Record<string, string>;
+}
+/**
+ * Session information
+ * Sessions are origin-bound and encrypted in storage
+ */
+interface Session {
+    /** Unique session ID */
+    sessionId: SessionId;
+    /** Wallet identifier */
+    walletId: WalletId;
+    /** Connected party ID */
+    partyId: PartyId;
+    /** Current network */
+    network: NetworkId;
+    /** Session creation timestamp */
+    createdAt: number;
+    /** Session expiration timestamp (if applicable) */
+    expiresAt?: number;
+    /** Origin of the dApp that created the session */
+    origin: string;
+    /** Capabilities available in this session */
+    capabilitiesSnapshot: CapabilityKey[];
+    /** Additional metadata (encrypted in storage) */
+    metadata?: Record<string, string>;
+}
+/**
+ * Persisted session (for restoration)
+ */
+interface PersistedSession extends Session {
+    /** Encrypted session data */
+    encrypted: string;
+}
+/**
+ * Signed message result
+ */
+interface SignedMessage {
+    /** Signature */
+    signature: Signature;
+    /** Party ID that signed */
+    partyId: PartyId;
+    /** Original message */
+    message: string;
+    /** Nonce used (if provided) */
+    nonce?: string;
+    /** Domain used (if provided) */
+    domain?: string;
+}
+/**
+ * Signed transaction result
+ */
+interface SignedTransaction {
+    /** Signed transaction data */
+    signedTx: unknown;
+    /** Transaction hash */
+    transactionHash: TransactionHash;
+    /** Party ID that signed */
+    partyId: PartyId;
+}
+/**
+ * Transaction receipt
+ */
+interface TxReceipt {
+    /** Transaction hash */
+    transactionHash: TransactionHash;
+    /** Submission timestamp */
+    submittedAt: number;
+    /** Command ID (if available) */
+    commandId?: string;
+    /** Update ID (if available) */
+    updateId?: string;
+}
+/**
+ * Transaction status
+ */
+type TransactionStatus = 'pending' | 'submitted' | 'committed' | 'rejected' | 'failed';
+/**
+ * Transaction status update
+ */
+interface TxStatusUpdate {
+    /** Session ID */
+    sessionId: SessionId;
+    /** Transaction ID */
+    txId: TransactionHash;
+    /** Current status */
+    status: TransactionStatus;
+    /** Raw transaction data (if available) */
+    raw?: unknown;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Helper to create branded WalletId
+ */
+declare function toWalletId(id: string): WalletId;
+/**
+ * Helper to create branded PartyId
+ */
+declare function toPartyId(id: string): PartyId;
+/**
+ * Helper to create branded SessionId
+ */
+declare function toSessionId(id: string): SessionId;
+/**
+ * Helper to create branded TransactionHash
+ */
+declare function toTransactionHash(hash: string): TransactionHash;
+/**
+ * Helper to create branded Signature
+ */
+declare function toSignature(sig: string): Signature;
+
+/**
+ * Error taxonomy for CantonConnect SDK
+ *
+ * All errors extend CantonConnectError with stable error codes.
+ * Error codes are string literals for telemetry and UI message mapping.
+ *
+ * References:
+ * - Wallet Integration Guide: https://docs.digitalasset.com/integrate/devnet/index.html
+ */
+/**
+ * Error code union - stable string literals for telemetry and UI
+ */
+type ErrorCode = 'WALLET_NOT_FOUND' | 'WALLET_NOT_INSTALLED' | 'USER_REJECTED' | 'ORIGIN_NOT_ALLOWED' | 'SESSION_EXPIRED' | 'CAPABILITY_NOT_SUPPORTED' | 'TRANSPORT_ERROR' | 'REGISTRY_FETCH_FAILED' | 'REGISTRY_VERIFICATION_FAILED' | 'REGISTRY_SCHEMA_INVALID' | 'INTERNAL_ERROR' | 'TIMEOUT';
+/**
+ * Error mapping context
+ */
+interface ErrorMappingContext {
+    /** Wallet ID (if applicable) */
+    walletId?: string;
+    /** Operation phase */
+    phase: 'connect' | 'restore' | 'signMessage' | 'signTransaction' | 'submitTransaction';
+    /** Transport type */
+    transport?: 'injected' | 'popup' | 'deeplink' | 'remote';
+    /** Timeout in milliseconds (for timeout errors) */
+    timeoutMs?: number;
+    /** Additional context */
+    details?: Record<string, unknown>;
+}
+/**
+ * Base error class for all CantonConnect errors
+ */
+declare class CantonConnectError extends Error {
+    readonly code: ErrorCode;
+    readonly cause?: unknown;
+    readonly details?: Record<string, unknown>;
+    readonly isOperational: boolean;
+    constructor(message: string, code: ErrorCode, options?: {
+        cause?: unknown;
+        details?: Record<string, unknown>;
+        isOperational?: boolean;
+    });
+    /**
+     * Serialize error to JSON for telemetry/logging
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Wallet not found error
+ */
+declare class WalletNotFoundError extends CantonConnectError {
+    constructor(walletId: string);
+}
+/**
+ * Wallet not installed error
+ */
+declare class WalletNotInstalledError extends CantonConnectError {
+    constructor(walletId: string, reason?: string);
+}
+/**
+ * User rejected error
+ */
+declare class UserRejectedError extends CantonConnectError {
+    constructor(operation: string, details?: Record<string, unknown>);
+}
+/**
+ * Origin not allowed error
+ */
+declare class OriginNotAllowedError extends CantonConnectError {
+    constructor(origin: string, allowedOrigins?: string[]);
+}
+/**
+ * Session expired error
+ */
+declare class SessionExpiredError extends CantonConnectError {
+    constructor(sessionId: string);
+}
+/**
+ * Capability not supported error
+ */
+declare class CapabilityNotSupportedError extends CantonConnectError {
+    constructor(walletId: string, capability: string);
+}
+/**
+ * Transport error
+ */
+declare class TransportError extends CantonConnectError {
+    constructor(message: string, cause?: unknown, details?: Record<string, unknown>);
+}
+/**
+ * Registry fetch failed error
+ */
+declare class RegistryFetchFailedError extends CantonConnectError {
+    constructor(url: string, cause?: unknown);
+}
+/**
+ * Registry verification failed error
+ */
+declare class RegistryVerificationFailedError extends CantonConnectError {
+    constructor(reason: string, details?: Record<string, unknown>);
+}
+/**
+ * Registry schema invalid error
+ */
+declare class RegistrySchemaInvalidError extends CantonConnectError {
+    constructor(reason: string, details?: Record<string, unknown>);
+}
+/**
+ * Internal error (non-operational)
+ */
+declare class InternalError extends CantonConnectError {
+    constructor(message: string, cause?: unknown, details?: Record<string, unknown>);
+}
+/**
+ * Timeout error
+ */
+declare class TimeoutError extends CantonConnectError {
+    constructor(operation: string, timeoutMs: number);
+}
+/**
+ * Map unknown errors to CantonConnectError
+ *
+ * This is the single error mapping strategy used by all adapters.
+ * It normalizes errors from various sources (wallet SDKs, network, etc.)
+ * into typed CantonConnectError instances.
+ */
+declare function mapUnknownErrorToCantonConnectError(err: unknown, context: ErrorMappingContext): CantonConnectError;
+
+/**
+ * Wallet adapter interface contract
+ *
+ * All wallet adapters must implement this interface.
+ * Adapters are responsible for:
+ * - Detecting wallet installation
+ * - Establishing connections
+ * - Signing messages/transactions
+ * - Emitting events
+ *
+ * References:
+ * - OpenRPC dApp API spec: https://github.com/hyperledger-labs/splice-wallet-kernel/blob/main/api-specs/openrpc-dapp-api.json
+ * - Wallet Integration Guide: https://docs.digitalasset.com/integrate/devnet/index.html
+ */
+
+/**
+ * Adapter detection result
+ */
+interface AdapterDetectResult {
+    /** Whether wallet is installed */
+    installed: boolean;
+    /** Reason if not installed */
+    reason?: string;
+}
+/**
+ * Adapter connection result
+ */
+interface AdapterConnectResult {
+    /** Connected party ID */
+    partyId: PartyId;
+    /** Partial session data (SDK will complete it) */
+    session: Partial<Session>;
+    /** Capabilities available in this session */
+    capabilities: CapabilityKey[];
+}
+/**
+ * Sign message parameters
+ */
+interface SignMessageParams {
+    /** Message to sign */
+    message: string;
+    /** Optional nonce */
+    nonce?: string;
+    /** Optional domain */
+    domain?: string;
+}
+/**
+ * Sign transaction parameters
+ */
+interface SignTransactionParams {
+    /** Transaction to sign (type kept as unknown for wallet-specific formats) */
+    tx: unknown;
+}
+/**
+ * Submit transaction parameters
+ */
+interface SubmitTransactionParams {
+    /** Signed transaction */
+    signedTx: unknown;
+}
+/**
+ * Logger interface
+ */
+interface LoggerAdapter {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, error?: unknown, ...args: unknown[]): void;
+}
+/**
+ * Telemetry interface
+ */
+interface TelemetryAdapter {
+    track(event: string, properties?: Record<string, unknown>): void;
+    error(error: Error, properties?: Record<string, unknown>): void;
+}
+/**
+ * Crypto interface
+ */
+interface CryptoAdapter {
+    encrypt(data: string, key: string): Promise<string>;
+    decrypt(encrypted: string, key: string): Promise<string>;
+    generateKey(): Promise<string>;
+}
+/**
+ * Storage interface
+ */
+interface StorageAdapter {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+/**
+ * Registry client interface (for adapters to query wallet info)
+ */
+interface RegistryClientAdapter {
+    getWallet(walletId: WalletId): Promise<unknown>;
+}
+/**
+ * Adapter context provided to all adapter methods
+ */
+interface AdapterContext {
+    /** Application name */
+    appName: string;
+    /** Origin (for origin binding) */
+    origin: string;
+    /** Network */
+    network: NetworkId;
+    /** Logger */
+    logger: LoggerAdapter;
+    /** Telemetry (optional) */
+    telemetry?: TelemetryAdapter;
+    /** Registry client */
+    registry: RegistryClientAdapter;
+    /** Crypto adapter */
+    crypto: CryptoAdapter;
+    /** Storage adapter */
+    storage: StorageAdapter;
+    /** Timeout helper */
+    timeout: (ms: number) => Promise<never>;
+    /** Abort signal (for cancellation) */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Adapter event names
+ */
+type AdapterEventName = 'connect' | 'disconnect' | 'sessionExpired' | 'txStatus' | 'error';
+/**
+ * Wallet adapter interface
+ *
+ * All wallet adapters must implement this interface.
+ * Optional methods (marked with ?) should only be implemented
+ * if the wallet supports that capability.
+ */
+interface WalletAdapter {
+    /** Wallet identifier */
+    readonly walletId: WalletId;
+    /** Wallet display name */
+    readonly name: string;
+    /**
+     * Get supported capabilities
+     */
+    getCapabilities(): CapabilityKey[];
+    /**
+     * Detect if wallet is installed
+     */
+    detectInstalled(): Promise<AdapterDetectResult>;
+    /**
+     * Connect to wallet
+     * @param ctx Adapter context
+     * @param opts Connection options (optional)
+     */
+    connect(ctx: AdapterContext, opts?: {
+        timeoutMs?: number;
+        partyId?: PartyId;
+    }): Promise<AdapterConnectResult>;
+    /**
+     * Disconnect from wallet
+     * @param ctx Adapter context
+     * @param session Session to disconnect
+     */
+    disconnect(ctx: AdapterContext, session: Session): Promise<void>;
+    /**
+     * Restore session (optional - only if wallet supports it)
+     * @param ctx Adapter context
+     * @param persisted Persisted session data
+     */
+    restore?(ctx: AdapterContext, persisted: PersistedSession): Promise<Session | null>;
+    /**
+     * Sign message (optional - only if wallet supports it)
+     * @param ctx Adapter context
+     * @param session Active session
+     * @param params Sign message parameters
+     */
+    signMessage?(ctx: AdapterContext, session: Session, params: SignMessageParams): Promise<SignedMessage>;
+    /**
+     * Sign transaction (optional - only if wallet supports it)
+     * @param ctx Adapter context
+     * @param session Active session
+     * @param params Sign transaction parameters
+     */
+    signTransaction?(ctx: AdapterContext, session: Session, params: SignTransactionParams): Promise<SignedTransaction>;
+    /**
+     * Submit transaction (optional - only if wallet supports it)
+     * @param ctx Adapter context
+     * @param session Active session
+     * @param params Submit transaction parameters
+     */
+    submitTransaction?(ctx: AdapterContext, session: Session, params: SubmitTransactionParams): Promise<TxReceipt>;
+    /**
+     * Subscribe to adapter events (optional)
+     * @param event Event name
+     * @param handler Event handler
+     * @returns Unsubscribe function
+     */
+    on?(event: AdapterEventName, handler: (payload: unknown) => void): () => void;
+}
+/**
+ * Check if adapter supports required capabilities
+ * Throws CapabilityNotSupportedError if not supported
+ */
+declare function capabilityGuard(adapter: WalletAdapter, requiredCapabilities: CapabilityKey[]): void;
+/**
+ * Check if wallet is installed
+ * Throws WalletNotInstalledError if not installed
+ */
+declare function installGuard(adapter: WalletAdapter): Promise<void>;
+
+/**
+ * Session management utilities
+ */
+
+/**
+ * Generate a unique session ID
+ */
+declare function generateSessionId(): SessionId;
+/**
+ * Validate session structure
+ */
+declare function validateSession(session: unknown): session is Session;
+/**
+ * Check if session is expired
+ */
+declare function isSessionExpired(session: Session): boolean;
+/**
+ * Create a session with default values
+ */
+declare function createSession(walletId: string, partyId: string, network: string, origin: string, capabilities?: string[], expiresInMs?: number): Session;
+
+/**
+ * Transport layer types for wallet communication
+ *
+ * Supports deep link, popup, and postMessage transports for mobile and web wallets.
+ */
+
+/**
+ * Transport type
+ */
+type TransportType = 'deeplink' | 'popup' | 'postmessage' | 'injected';
+/**
+ * Transport options
+ */
+interface TransportOptions {
+    /** Timeout in milliseconds */
+    timeoutMs?: number;
+    /** Allowed callback origins */
+    allowedOrigins?: string[];
+    /** Current origin for validation */
+    origin: string;
+}
+/**
+ * Connect request payload
+ */
+interface ConnectRequest {
+    appName: string;
+    origin: string;
+    network: string;
+    requestedCapabilities?: string[];
+    state: string;
+    redirectUri?: string;
+}
+/**
+ * Connect response payload
+ */
+interface ConnectResponse {
+    state: string;
+    partyId?: PartyId;
+    sessionToken?: string;
+    expiresAt?: number;
+    capabilities?: string[];
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Sign request payload
+ */
+interface SignRequest {
+    message?: string;
+    transaction?: unknown;
+    state: string;
+    redirectUri?: string;
+}
+/**
+ * Sign response payload
+ */
+interface SignResponse {
+    state: string;
+    signature?: string;
+    transactionHash?: string;
+    jobId?: string;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Job status (for async approval flows)
+ */
+interface JobStatus {
+    jobId: string;
+    status: 'pending' | 'approved' | 'denied' | 'expired';
+    result?: {
+        signature?: string;
+        transactionHash?: string;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Transport interface
+ */
+interface Transport$1 {
+    /**
+     * Open a connection request
+     */
+    openConnectRequest(url: string, request: ConnectRequest, options: TransportOptions): Promise<ConnectResponse>;
+    /**
+     * Open a sign request
+     */
+    openSignRequest(url: string, request: SignRequest, options: TransportOptions): Promise<SignResponse>;
+    /**
+     * Poll job status (if supported)
+     */
+    pollJobStatus?(jobId: string, statusUrl: string, options: TransportOptions): Promise<JobStatus>;
+}
+
+/**
+ * Deep Link Transport
+ *
+ * Opens a deep link URL (mobile) and awaits callback via redirect or postMessage.
+ *
+ * Security:
+ * - State parameter (nonce) for CSRF protection
+ * - Origin validation
+ * - Timeout enforcement
+ * - Callback origin allowlist
+ */
+
+/**
+ * Deep link transport implementation
+ */
+declare class DeepLinkTransport implements Transport$1 {
+    /**
+     * Generate a random state nonce
+     */
+    private generateState;
+    /**
+     * Build deep link URL with query parameters
+     */
+    private buildDeepLinkUrl;
+    /**
+     * Validate callback origin
+     */
+    private validateOrigin;
+    /**
+     * Wait for callback via postMessage or redirect
+     */
+    private waitForCallback;
+    /**
+     * Open a connection request
+     */
+    openConnectRequest(url: string, request: ConnectRequest, options: TransportOptions): Promise<ConnectResponse>;
+    /**
+     * Open a sign request
+     */
+    openSignRequest(url: string, request: SignRequest, options: TransportOptions): Promise<SignResponse>;
+}
+
+/**
+ * Popup Transport
+ *
+ * Opens a centered popup window and establishes a postMessage channel.
+ *
+ * Security:
+ * - Origin validation
+ * - State parameter validation
+ * - Popup window management
+ */
+
+/**
+ * Popup transport implementation
+ */
+declare class PopupTransport implements Transport$1 {
+    /**
+     * Generate a random state nonce
+     */
+    private generateState;
+    /**
+     * Build URL with query parameters
+     */
+    private buildUrl;
+    /**
+     * Validate message origin
+     */
+    private validateOrigin;
+    /**
+     * Open popup window
+     */
+    private openPopup;
+    /**
+     * Wait for postMessage callback
+     */
+    private waitForCallback;
+    /**
+     * Open a connection request
+     */
+    openConnectRequest(url: string, request: ConnectRequest, options: TransportOptions): Promise<ConnectResponse>;
+    /**
+     * Open a sign request
+     */
+    openSignRequest(url: string, request: SignRequest, options: TransportOptions): Promise<SignResponse>;
+}
+
+/**
+ * PostMessage Transport
+ *
+ * Establishes a postMessage channel with an existing window/iframe.
+ *
+ * Security:
+ * - Origin validation
+ * - State parameter validation
+ */
+
+/**
+ * PostMessage transport implementation
+ */
+declare class PostMessageTransport implements Transport$1 {
+    /**
+     * Generate a random state nonce
+     */
+    private generateState;
+    /**
+     * Validate message origin
+     */
+    private validateOrigin;
+    /**
+     * Send message and wait for response
+     */
+    private sendAndWait;
+    /**
+     * Open a connection request
+     */
+    openConnectRequest(url: string, request: ConnectRequest, options: TransportOptions): Promise<ConnectResponse>;
+    /**
+     * Open a sign request
+     */
+    openSignRequest(url: string, request: SignRequest, options: TransportOptions): Promise<SignResponse>;
+}
+
+/**
+ * Mock Transport
+ *
+ * For testing and development. Simulates transport behavior without real network calls.
+ */
+
+/**
+ * Mock transport implementation
+ */
+declare class MockTransport implements Transport$1 {
+    private mockResponses;
+    private mockJobs;
+    /**
+     * Set mock response for a state
+     */
+    setMockResponse(state: string, response: ConnectResponse | SignResponse): void;
+    /**
+     * Set mock job status
+     */
+    setMockJob(jobId: string, status: JobStatus): void;
+    /**
+     * Clear all mocks
+     */
+    clearMocks(): void;
+    /**
+     * Open a connection request (mock)
+     */
+    openConnectRequest(_url: string, request: ConnectRequest, _options: TransportOptions): Promise<ConnectResponse>;
+    /**
+     * Open a sign request (mock)
+     */
+    openSignRequest(_url: string, request: SignRequest, _options: TransportOptions): Promise<SignResponse>;
+    /**
+     * Poll job status (mock)
+     */
+    pollJobStatus(jobId: string, _statusUrl: string, _options: TransportOptions): Promise<JobStatus>;
+}
+
+/**
+ * Transport abstractions for wallet communication
+ */
+/**
+ * Transport message
+ */
+interface TransportMessage<T = unknown> {
+    /** Message ID */
+    id: string;
+    /** Message type */
+    type: string;
+    /** Message payload */
+    payload: T;
+    /** Timestamp */
+    timestamp: number;
+    /** Origin */
+    origin?: string;
+}
+/**
+ * Transport response
+ */
+interface TransportResponse<T = unknown> {
+    /** Response ID (matches request ID) */
+    id: string;
+    /** Success flag */
+    success: boolean;
+    /** Response data (if success) */
+    data?: T;
+    /** Error (if not success) */
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Transport interface for wallet communication
+ * Different wallets may use different transports (postMessage, WebSocket, HTTP, etc.)
+ */
+interface Transport {
+    /**
+     * Send a message and wait for response
+     */
+    send<TRequest = unknown, TResponse = unknown>(message: TransportMessage<TRequest>): Promise<TransportResponse<TResponse>>;
+    /**
+     * Subscribe to incoming messages
+     */
+    onMessage(handler: (message: TransportMessage) => void): () => void;
+    /**
+     * Check if transport is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Connect the transport
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect the transport
+     */
+    disconnect(): Promise<void>;
+}
+
+export { type AdapterConnectResult, type AdapterContext, type AdapterDetectResult, type AdapterEventName, type AdapterMetadata, CantonConnectError, type CapabilityKey, CapabilityNotSupportedError, type ConnectRequest, type ConnectResponse, type CryptoAdapter, DeepLinkTransport, type ErrorCode, type ErrorMappingContext, type InstallHints, InternalError, type JobStatus, type LoggerAdapter, MockTransport, type NetworkId, OriginNotAllowedError, type PartyId, type PersistedSession, PopupTransport, PostMessageTransport, type RegistryClientAdapter, RegistryFetchFailedError, RegistrySchemaInvalidError, RegistryVerificationFailedError, type Session, SessionExpiredError, type SessionId, type SignMessageParams, type SignRequest, type SignResponse, type SignTransactionParams, type Signature, type SignedMessage, type SignedTransaction, type StorageAdapter, type SubmitTransactionParams, type TelemetryAdapter, TimeoutError, type TransactionHash, type TransactionStatus, type Transport, TransportError, type TransportOptions, type TransportType, type TxReceipt, type TxStatusUpdate, UserRejectedError, type WalletAdapter, type WalletId, type WalletInfo, WalletNotFoundError, WalletNotInstalledError, capabilityGuard, createSession, generateSessionId, installGuard, isSessionExpired, mapUnknownErrorToCantonConnectError, toPartyId, toSessionId, toSignature, toTransactionHash, toWalletId, validateSession };