@hybrd/xmtp 1.0.10 → 1.1.1

package/dist/index.d.cts

@@ -0,0 +1,860 @@
+import { Client, Conversation, DecodedMessage, Signer } from '@xmtp/node-sdk';
+export { Client, DecodedMessage, Dm, IdentifierKind, LogLevel, Signer, XmtpEnv } from '@xmtp/node-sdk';
+import { privateKeyToAccount } from 'viem/accounts';
+import { GroupUpdated } from '@xmtp/content-type-group-updated';
+export { ContentTypeGroupUpdated, GroupUpdated, GroupUpdatedCodec } from '@xmtp/content-type-group-updated';
+import { Reaction } from '@xmtp/content-type-reaction';
+export { ContentTypeReaction, Reaction } from '@xmtp/content-type-reaction';
+import { Reply } from '@xmtp/content-type-reply';
+export { ContentTypeReply, Reply, ReplyCodec } from '@xmtp/content-type-reply';
+import { TransactionReference } from '@xmtp/content-type-transaction-reference';
+export { ContentTypeTransactionReference, TransactionReference } from '@xmtp/content-type-transaction-reference';
+import { WalletSendCallsParams } from '@xmtp/content-type-wallet-send-calls';
+export { ContentTypeWalletSendCalls, WalletSendCallsParams } from '@xmtp/content-type-wallet-send-calls';
+import { PublicClient, Address } from 'viem';
+import { EventEmitter } from 'node:events';
+export { ContentTypeText, TextParameters } from '@xmtp/content-type-text';
+
+declare const BasenameTextRecordKeys: {
+    readonly Email: "email";
+    readonly Url: "url";
+    readonly Avatar: "avatar";
+    readonly Description: "description";
+    readonly Notice: "notice";
+    readonly Keywords: "keywords";
+    readonly Twitter: "com.twitter";
+    readonly Github: "com.github";
+    readonly Discord: "com.discord";
+    readonly Telegram: "org.telegram";
+    readonly Snapshot: "snapshot";
+    readonly Location: "location";
+};
+type BasenameTextRecordKey = (typeof BasenameTextRecordKeys)[keyof typeof BasenameTextRecordKeys];
+type BaseName = string;
+interface BasenameResolverOptions {
+    /**
+     * Maximum number of basenames to cache
+     * @default 500
+     */
+    maxCacheSize?: number;
+    /**
+     * Cache TTL in milliseconds
+     * @default 3600000 (1 hour)
+     */
+    cacheTtl?: number;
+    /**
+     * Public client
+     * @default null
+     */
+    publicClient: PublicClient;
+}
+/**
+ * Convert an chainId to a coinType hex for reverse chain resolution
+ */
+declare const convertChainIdToCoinType: (chainId: number) => string;
+/**
+ * Helper function to convert an address to its reverse node for ENS lookups
+ */
+declare const convertReverseNodeToBytes: (address: Address, chainId: number) => `0x${string}`;
+declare class BasenameResolver {
+    private cache;
+    private textRecordCache;
+    private readonly maxCacheSize;
+    private readonly cacheTtl;
+    private readonly baseClient;
+    private resolverAddress;
+    private chainId;
+    constructor(options: BasenameResolverOptions);
+    /**
+     * Initialize the resolver address based on the client's chain ID
+     */
+    private initializeResolver;
+    /**
+     * Get the resolver address, initializing if necessary
+     */
+    private getResolverAddress;
+    /**
+     * Resolve a basename from an Ethereum address
+     */
+    getBasename(address: Address): Promise<string | null>;
+    /**
+     * Get the avatar URL for a basename
+     */
+    getBasenameAvatar(basename: BaseName): Promise<string | null>;
+    /**
+     * Get a text record for a basename
+     */
+    getBasenameTextRecord(basename: BaseName, key: BasenameTextRecordKey): Promise<string | null>;
+    /**
+     * Get the Ethereum address that owns a basename
+     */
+    getBasenameAddress(basename: BaseName): Promise<Address | null>;
+    /**
+     * Get all basic metadata for a basename
+     */
+    getBasenameMetadata(basename: BaseName): Promise<{
+        basename: string;
+        avatar: string | null;
+        description: string | null;
+        twitter: string | null;
+        github: string | null;
+        url: string | null;
+    } | null>;
+    /**
+     * Resolve a full basename profile (name + metadata) from an address
+     */
+    resolveBasenameProfile(address: Address): Promise<{
+        basename?: string | undefined;
+        avatar?: string | null | undefined;
+        description?: string | null | undefined;
+        twitter?: string | null | undefined;
+        github?: string | null | undefined;
+        url?: string | null | undefined;
+        address: `0x${string}`;
+    } | null>;
+    /**
+     * Get cached basename if not expired
+     */
+    private getCachedBasename;
+    /**
+     * Cache basename with LRU eviction
+     */
+    private setCachedBasename;
+    /**
+     * Get cached text record if not expired
+     */
+    private getCachedTextRecord;
+    /**
+     * Cache text record
+     */
+    private setCachedTextRecord;
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        basenameCache: {
+            size: number;
+            maxSize: number;
+        };
+        textRecordCache: {
+            size: number;
+        };
+        chainId: number | null;
+        resolverAddress: Address | null;
+    };
+}
+
+interface ResolverOptions {
+    /**
+     * XMTP Client for message and address resolution
+     */
+    xmtpClient: XmtpClient;
+    /**
+     * Mainnet public client for ENS resolution
+     */
+    mainnetClient: PublicClient;
+    /**
+     * Base network public client for basename resolution
+     */
+    baseClient: PublicClient;
+    /**
+     * Maximum cache size for each resolver
+     * @default 1000
+     */
+    maxCacheSize?: number;
+    /**
+     * Cache TTL in milliseconds
+     * @default 3600000 (1 hour)
+     */
+    cacheTtl?: number;
+}
+/**
+ * Master Resolver that wraps all individual resolvers
+ * Provides a unified interface for basename, ENS, address, and XMTP resolution
+ */
+declare class Resolver {
+    private addressResolver;
+    private ensResolver;
+    private basenameResolver;
+    private xmtpResolver;
+    constructor(options: ResolverOptions);
+    /**
+     * Resolve user address from inbox ID with caching
+     * Uses both AddressResolver and XmtpResolver for redundancy
+     */
+    resolveAddress(inboxId: string, conversationId?: string): Promise<`0x${string}` | null>;
+    /**
+     * Resolve an ENS name to an Ethereum address
+     */
+    resolveENSName(ensName: string): Promise<Address | null>;
+    /**
+     * Resolve an address to its primary ENS name (reverse resolution)
+     */
+    resolveAddressToENS(address: Address): Promise<string | null>;
+    /**
+     * Get ENS avatar for a given ENS name
+     */
+    getENSAvatar(ensName: string): Promise<string | null>;
+    /**
+     * Get ENS text record for a given ENS name and key
+     */
+    getENSTextRecord(ensName: string, key: string): Promise<string | null>;
+    /**
+     * Get complete ENS profile for a given ENS name
+     */
+    getENSProfile(ensName: string): Promise<{
+        ensName: string;
+        address: `0x${string}` | null;
+        avatar: string | null;
+        description: string | null;
+        twitter: string | null;
+        github: string | null;
+        url: string | null;
+    } | null>;
+    /**
+     * Get basename from an Ethereum address
+     */
+    getBasename(address: Address): Promise<string | null>;
+    /**
+     * Get basename avatar for a given basename
+     */
+    getBasenameAvatar(basename: BaseName): Promise<string | null>;
+    /**
+     * Get basename text record for a given basename and key
+     */
+    getBasenameTextRecord(basename: BaseName, key: BasenameTextRecordKey): Promise<string | null>;
+    /**
+     * Resolve basename to an Ethereum address
+     */
+    getBasenameAddress(basename: BaseName): Promise<Address | null>;
+    /**
+     * Get basename metadata for a given basename
+     */
+    getBasenameMetadata(basename: BaseName): Promise<{
+        basename: string;
+        avatar: string | null;
+        description: string | null;
+        twitter: string | null;
+        github: string | null;
+        url: string | null;
+    } | null>;
+    /**
+     * Get complete basename profile for a given address
+     */
+    resolveBasenameProfile(address: Address): Promise<{
+        basename?: string | undefined;
+        avatar?: string | null | undefined;
+        description?: string | null | undefined;
+        twitter?: string | null | undefined;
+        github?: string | null | undefined;
+        url?: string | null | undefined;
+        address: `0x${string}`;
+    } | null>;
+    /**
+     * Find any message by ID with caching
+     */
+    findMessage(messageId: string): Promise<XmtpMessage | null>;
+    /**
+     * Find root message by ID (traverses reply chain)
+     */
+    findRootMessage(messageId: string): Promise<XmtpMessage | null>;
+    /**
+     * Universal name resolution - tries to resolve any name (ENS or basename) to an address
+     */
+    resolveName(name: string): Promise<Address | null>;
+    /**
+     * Universal reverse resolution - tries to resolve an address to any name (ENS or basename)
+     */
+    resolveAddressToName(address: Address): Promise<string | null>;
+    /**
+     * Get complete profile for an address (combines ENS and basename data)
+     */
+    getCompleteProfile(address: Address): Promise<{
+        address: `0x${string}`;
+        ensName: string | null;
+        basename: string | null;
+        ensProfile: {
+            ensName: string;
+            address: `0x${string}` | null;
+            avatar: string | null;
+            description: string | null;
+            twitter: string | null;
+            github: string | null;
+            url: string | null;
+        } | null;
+        basenameProfile: {
+            basename?: string | undefined;
+            avatar?: string | null | undefined;
+            description?: string | null | undefined;
+            twitter?: string | null | undefined;
+            github?: string | null | undefined;
+            url?: string | null | undefined;
+            address: `0x${string}`;
+        } | null;
+    }>;
+    /**
+     * Pre-populate all resolver caches
+     */
+    prePopulateAllCaches(): Promise<void>;
+    /**
+     * Create a complete XmtpSender object from an address or inboxId
+     * Uses the resolver to get the best available name and profile information
+     */
+    createXmtpSender(addressOrInboxId: string, conversationId?: string): Promise<XmtpSender>;
+}
+
+/**
+ * @fileoverview XMTP Types
+ *
+ * Type definitions for both the XMTP core client and service client library.
+ */
+
+type HonoVariables = {
+    xmtpClient: XmtpClient;
+    resolver?: Resolver;
+};
+type Codec = GroupUpdated | Reaction | Reply | TransactionReference | WalletSendCallsParams;
+type XmtpClient = Client<string | Codec>;
+type XmtpConversation = Conversation<string | Codec>;
+type XmtpMessage = DecodedMessage<string | Codec>;
+type XmtpSender = {
+    address: string;
+    inboxId: string;
+    name: string;
+    basename?: string;
+};
+type XmtpSubjects = Record<string, `0x${string}`>;
+interface MessageEvent {
+    conversation: XmtpConversation;
+    message: XmtpMessage;
+    rootMessage: XmtpMessage;
+    parentMessage?: XmtpMessage;
+    sender: XmtpSender;
+    subjects: XmtpSubjects;
+}
+interface XmtpServiceClientConfig {
+    serviceUrl: string;
+    serviceToken: string;
+}
+interface TransactionCall {
+    to: string;
+    data: string;
+    gas?: string;
+    value?: string;
+    metadata?: Record<string, unknown>;
+}
+interface TransactionRequest {
+    fromAddress: string;
+    chainId: string;
+    calls: TransactionCall[];
+}
+interface XmtpServiceResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+interface XmtpServiceMessage {
+    id: string;
+    conversationId: string;
+    content: string | Record<string, unknown>;
+    senderInboxId: string;
+    sentAt: string;
+    contentType?: {
+        typeId: string;
+        authorityId?: string;
+        versionMajor?: number;
+        versionMinor?: number;
+    };
+}
+interface XmtpRootMessageResponse {
+    id: string;
+    conversationId: string;
+    content: string | Record<string, unknown>;
+    senderInboxId: string;
+    sentAt: string;
+    contentType?: {
+        typeId: string;
+        authorityId?: string;
+        versionMajor?: number;
+        versionMinor?: number;
+    };
+}
+interface SendMessageParams {
+    content: string;
+}
+interface SendReplyParams {
+    content: string;
+    messageId: string;
+}
+interface SendReactionParams {
+    messageId: string;
+    emoji: string;
+    action: "added" | "removed";
+}
+interface SendTransactionParams extends TransactionRequest {
+}
+interface GetMessageParams {
+    messageId: string;
+}
+interface GetRootMessageParams {
+    messageId: string;
+}
+interface SendMessageResponse {
+    success: boolean;
+    action: "send";
+    conversationId: string;
+}
+interface SendReplyResponse {
+    success: boolean;
+    action: "reply";
+    conversationId: string;
+}
+interface SendReactionResponse {
+    success: boolean;
+    action: "react";
+    conversationId: string;
+}
+interface SendTransactionResponse {
+    success: boolean;
+    action: "transaction";
+    conversationId: string;
+}
+
+interface User {
+    key: `0x${string}`;
+    account: ReturnType<typeof privateKeyToAccount>;
+    wallet: any;
+}
+declare const createUser: (key: string) => User;
+declare const createSigner: (key: string) => Signer;
+declare function createXMTPClient(privateKey: string, opts?: {
+    persist?: boolean;
+    maxRetries?: number;
+    storagePath?: string;
+}): Promise<XmtpClient>;
+/**
+ * Generate a random encryption key
+ * @returns The encryption key as a hex string
+ */
+declare const generateEncryptionKeyHex: () => string;
+/**
+ * Get the encryption key from a hex string
+ * @param hex - The hex string
+ * @returns The encryption key as Uint8Array
+ */
+declare const getEncryptionKeyFromHex: (hex: string) => Uint8Array;
+declare const getDbPath: (description?: string, storagePath?: string) => Promise<string>;
+declare const backupDbToPersistentStorage: (dbPath: string, description: string) => Promise<void>;
+declare const logAgentDetails: (clients: XmtpClient | XmtpClient[]) => Promise<void>;
+declare function validateEnvironment(vars: string[]): Record<string, string>;
+/**
+ * Diagnose XMTP environment and identity issues
+ */
+declare function diagnoseXMTPIdentityIssue(client: XmtpClient, inboxId: string, environment: string): Promise<{
+    canResolve: boolean;
+    suggestions: string[];
+    details: Record<string, any>;
+}>;
+interface XMTPConnectionConfig {
+    maxRetries?: number;
+    retryDelayMs?: number;
+    healthCheckIntervalMs?: number;
+    connectionTimeoutMs?: number;
+    reconnectOnFailure?: boolean;
+}
+interface XMTPConnectionHealth {
+    isConnected: boolean;
+    lastHealthCheck: Date;
+    consecutiveFailures: number;
+    totalReconnects: number;
+    avgResponseTime: number;
+}
+declare class XMTPConnectionManager {
+    private client;
+    private privateKey;
+    private config;
+    private health;
+    private healthCheckTimer;
+    private isReconnecting;
+    constructor(privateKey: string, config?: XMTPConnectionConfig);
+    connect(persist?: boolean): Promise<XmtpClient>;
+    private startHealthMonitoring;
+    private performHealthCheck;
+    private handleConnectionFailure;
+    private sleep;
+    getHealth(): XMTPConnectionHealth;
+    getClient(): XmtpClient | null;
+    disconnect(): Promise<void>;
+}
+declare function createXMTPConnectionManager(privateKey: string, config?: XMTPConnectionConfig): Promise<XMTPConnectionManager>;
+/**
+ * Resolve user address from inbox ID with automatic identity refresh on association errors
+ */
+declare function resolveUserAddress(client: XmtpClient, senderInboxId: string, maxRetries?: number): Promise<string>;
+declare const startPeriodicBackup: (dbPath: string, description: string, intervalMs?: number) => NodeJS.Timeout;
+
+declare const DEFAULT_OPTIONS: string[];
+declare const DEFAULT_AMOUNT = "0.1";
+declare const MAX_USDC_AMOUNT = 10;
+
+interface MessageListenerConfig {
+    publicClient: PublicClient;
+    xmtpClient: XmtpClient;
+    /**
+     * Filter function to determine which messages to process
+     * Return true to process the message, false to skip
+     */
+    filter?: (event: Pick<MessageEvent, "conversation" | "message" | "rootMessage">) => Promise<boolean> | boolean;
+    /**
+     * Heartbeat interval in milliseconds (default: 5 minutes)
+     */
+    heartbeatInterval?: number;
+    /**
+     * Conversation check interval in milliseconds (default: 30 seconds)
+     */
+    conversationCheckInterval?: number;
+    /**
+     * Environment variable key for XMTP environment (default: "XMTP_ENV")
+     */
+    envKey?: string;
+}
+interface MessageListenerEvents {
+    message: [data: MessageEvent];
+    error: [error: Error];
+    started: [];
+    stopped: [];
+    heartbeat: [stats: {
+        messageCount: number;
+        conversationCount: number;
+    }];
+}
+/**
+ * A flexible XMTP message listener that can be configured for different applications
+ */
+declare class MessageListener extends EventEmitter {
+    private xmtpClient;
+    private resolver;
+    private filter?;
+    private heartbeatInterval?;
+    private fallbackCheckInterval?;
+    private messageCount;
+    private conversations;
+    private readonly config;
+    constructor(config: MessageListenerConfig);
+    on<U extends keyof MessageListenerEvents>(event: U, listener: (...args: MessageListenerEvents[U]) => void): this;
+    emit<U extends keyof MessageListenerEvents>(event: U, ...args: MessageListenerEvents[U]): boolean;
+    start(): Promise<void>;
+    private cleanup;
+    stop(): void;
+    /**
+     * Get current statistics
+     */
+    getStats(): {
+        messageCount: number;
+        conversationCount: number;
+        isActive: boolean;
+    };
+}
+/**
+ * Helper function to start a message listener
+ */
+declare function startMessageListener(config: MessageListenerConfig): Promise<MessageListener>;
+/**
+ * Factory function to create a message listener with common filters
+ */
+declare function createMessageListener(config: MessageListenerConfig): MessageListener;
+
+interface ENSResolverOptions {
+    /**
+     * Maximum number of ENS names to cache
+     * @default 500
+     */
+    maxCacheSize?: number;
+    /**
+     * Cache TTL in milliseconds
+     * @default 3600000 (1 hour)
+     */
+    cacheTtl?: number;
+    /**
+     * Mainnet public client for ENS resolution
+     */
+    mainnetClient: PublicClient;
+}
+/**
+ * ENS Resolver for mainnet .eth names
+ * Handles resolution of ENS names to addresses and reverse resolution
+ */
+declare class ENSResolver {
+    private cache;
+    private reverseCache;
+    private readonly maxCacheSize;
+    private readonly cacheTtl;
+    private readonly mainnetClient;
+    constructor(options: ENSResolverOptions);
+    /**
+     * Resolve an ENS name to an Ethereum address
+     */
+    resolveENSName(ensName: string): Promise<Address | null>;
+    /**
+     * Resolve an address to its primary ENS name (reverse resolution)
+     */
+    resolveAddressToENS(address: Address): Promise<string | null>;
+    /**
+     * Get ENS avatar for a name
+     */
+    getENSAvatar(ensName: string): Promise<string | null>;
+    /**
+     * Get ENS text record
+     */
+    getENSTextRecord(ensName: string, key: string): Promise<string | null>;
+    /**
+     * Get comprehensive ENS profile
+     */
+    getENSProfile(ensName: string): Promise<{
+        ensName: string;
+        address: `0x${string}` | null;
+        avatar: string | null;
+        description: string | null;
+        twitter: string | null;
+        github: string | null;
+        url: string | null;
+    } | null>;
+    /**
+     * Check if a name is a valid ENS name (.eth)
+     */
+    isENSName(name: string): boolean;
+    /**
+     * Get cached address if not expired
+     */
+    private getCachedAddress;
+    /**
+     * Cache address with LRU eviction
+     */
+    private setCachedAddress;
+    /**
+     * Get cached ENS name if not expired
+     */
+    private getCachedENSName;
+    /**
+     * Cache ENS name with LRU eviction
+     */
+    private setCachedENSName;
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        addressCache: {
+            size: number;
+            maxSize: number;
+        };
+        reverseCache: {
+            size: number;
+            maxSize: number;
+        };
+    };
+}
+
+/**
+ * Extract basenames/ENS names from message content using @mention pattern
+ * @param content The message content to parse
+ * @returns Array of unique names found in the message
+ */
+declare function extractMentionedNames(content: string): string[];
+/**
+ * Resolve mentioned names to addresses and return as subjects object
+ * @param mentionedNames Array of names to resolve
+ * @param basenameResolver Basename resolver instance
+ * @param ensResolver ENS resolver instance
+ * @returns Promise that resolves to subjects object mapping names to addresses
+ */
+declare function resolveSubjects(mentionedNames: string[], basenameResolver: BasenameResolver, ensResolver: ENSResolver): Promise<Record<string, `0x${string}`>>;
+/**
+ * Extract subjects from message content (combines extraction and resolution)
+ * @param content The message content to parse
+ * @param basenameResolver Basename resolver instance
+ * @param ensResolver ENS resolver instance
+ * @returns Promise that resolves to subjects object mapping names to addresses
+ */
+declare function extractSubjects(content: string, basenameResolver: BasenameResolver, ensResolver: ENSResolver): Promise<Record<string, `0x${string}`>>;
+
+interface XmtpResolverOptions {
+    /**
+     * Maximum number of addresses to cache
+     * @default 1000
+     */
+    maxCacheSize?: number;
+    /**
+     * Cache TTL in milliseconds
+     * @default 86400000 (24 hours)
+     */
+    cacheTtl?: number;
+    /**
+     * Maximum number of messages to cache
+     * @default 1000
+     */
+    maxMessageCacheSize?: number;
+    /**
+     * Message cache TTL in milliseconds
+     * @default 3600000 (1 hour)
+     */
+    messageCacheTtl?: number;
+}
+declare class XmtpResolver {
+    private client;
+    private addressCache;
+    private messageCache;
+    private readonly maxCacheSize;
+    private readonly cacheTtl;
+    private readonly maxMessageCacheSize;
+    private readonly messageCacheTtl;
+    constructor(client: XmtpClient, options?: XmtpResolverOptions);
+    /**
+     * Resolve user address from inbox ID with caching
+     */
+    resolveAddress(inboxId: string, conversationId?: string): Promise<`0x${string}` | null>;
+    /**
+     * Find any message by ID with caching
+     */
+    findMessage(messageId: string): Promise<XmtpMessage | null>;
+    /**
+     * Find root message with caching
+     */
+    findRootMessage(messageId: string): Promise<XmtpMessage | null>;
+    /**
+     * Recursively finds the root message in a reply chain by following reply references
+     */
+    private findRootMessageRecursive;
+    /**
+     * Resolve address from conversation members
+     */
+    private resolveFromConversation;
+    /**
+     * Resolve address from inbox state (network fallback)
+     */
+    private resolveFromInboxState;
+    /**
+     * Get cached address if not expired
+     */
+    private getCachedAddress;
+    /**
+     * Cache address with LRU eviction
+     */
+    private setCachedAddress;
+    /**
+     * Get cached message if not expired
+     */
+    private getCachedMessage;
+    /**
+     * Cache message with LRU eviction
+     */
+    private setCachedMessage;
+    /**
+     * Pre-populate address cache from existing conversations
+     */
+    prePopulateCache(): Promise<void>;
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        address: {
+            size: number;
+            maxSize: number;
+        };
+        message: {
+            size: number;
+            maxSize: number;
+        };
+    };
+}
+
+/**
+ * @fileoverview XMTP Service Client Library
+ *
+ * Clean, reusable client for making HTTP calls to the XMTP listener service.
+ * Handles authentication, request formatting, and error handling.
+ *
+ * This is different from the direct XMTP client - this is for external services
+ * talking to our XMTP listener service.
+ */
+
+declare class XmtpServiceClient {
+    private config;
+    constructor(config: XmtpServiceClientConfig);
+    private request;
+    sendMessage(params: SendMessageParams): Promise<XmtpServiceResponse<SendMessageResponse>>;
+    sendReply(params: SendReplyParams): Promise<XmtpServiceResponse<SendReplyResponse>>;
+    sendReaction(params: SendReactionParams): Promise<XmtpServiceResponse<SendReactionResponse>>;
+    sendTransaction(params: SendTransactionParams): Promise<XmtpServiceResponse<SendTransactionResponse>>;
+    /**
+     * Get a single message by ID
+     */
+    getMessage(params: GetMessageParams): Promise<XmtpServiceResponse<XmtpServiceMessage>>;
+}
+/**
+ * Create an XMTP service client from runtime context
+ * Expects the runtime context to have xmtpServiceUrl and xmtpServiceToken
+ */
+declare function createXmtpServiceClient(serviceUrl: string, serviceToken: string): XmtpServiceClient;
+interface XmtpAuthConfig {
+    serviceUrl: string;
+    serviceToken: string;
+    source: "callback" | "environment";
+}
+/**
+ * Get XMTP authentication configuration from multiple sources
+ * Priority: callback credentials > environment credentials
+ */
+declare function getXmtpAuthConfig(callbackUrl?: string, callbackToken?: string): XmtpAuthConfig | null;
+/**
+ * Create an authenticated XMTP service client
+ * Handles both callback and environment credential sources
+ */
+declare function createAuthenticatedXmtpClient(callbackUrl?: string, callbackToken?: string): XmtpServiceClient;
+/**
+ * Constructs a URL for XMTP tools API endpoints with token authentication
+ *
+ * @param {string} baseUrl - The base URL of the XMTP service (e.g., "https://api.example.com")
+ * @param {string} action - The specific action/endpoint to call (e.g., "send", "receive", "status")
+ * @param {string} token - Authentication token (either JWT or API key)
+ * @returns {string} Complete URL with token as query parameter
+ *
+ * @description
+ * Builds URLs for XMTP tools endpoints using query parameter authentication.
+ * The token is appended as a query parameter for GET request authentication,
+ * following the pattern: `/xmtp-tools/{action}?token={token}`
+ *
+ * @example
+ * ```typescript
+ * const url = getXMTPToolsUrl(
+ *   "https://api.hybrid.dev",
+ *   "send",
+ *   "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+ * );
+ * // Returns: "https://api.hybrid.dev/xmtp-tools/send?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with API key
+ * const url = getXMTPToolsUrl(
+ *   process.env.XMTP_BASE_URL,
+ *   "status",
+ *   process.env.XMTP_API_KEY
+ * );
+ * ```
+ */
+declare function getXMTPToolsUrl(baseUrl: string, action: string, token: string): string;
+
+export { type BaseName, BasenameResolver, type BasenameTextRecordKey, BasenameTextRecordKeys, DEFAULT_AMOUNT, DEFAULT_OPTIONS, ENSResolver, type GetMessageParams, type GetRootMessageParams, type HonoVariables, MAX_USDC_AMOUNT, type MessageEvent, MessageListener, type MessageListenerConfig, type MessageListenerEvents, Resolver, type SendMessageParams, type SendMessageResponse, type SendReactionParams, type SendReactionResponse, type SendReplyParams, type SendReplyResponse, type SendTransactionParams, type SendTransactionResponse, type TransactionCall, type TransactionRequest, type XMTPConnectionConfig, type XMTPConnectionHealth, XMTPConnectionManager, type XmtpAuthConfig, type XmtpClient, type XmtpConversation, type XmtpMessage, XmtpResolver, type XmtpRootMessageResponse, type XmtpSender, XmtpServiceClient, type XmtpServiceClientConfig, type XmtpServiceMessage, type XmtpServiceResponse, type XmtpSubjects, backupDbToPersistentStorage, convertChainIdToCoinType, convertReverseNodeToBytes, createAuthenticatedXmtpClient, createMessageListener, createSigner, createUser, createXMTPClient, createXMTPConnectionManager, createXmtpServiceClient, diagnoseXMTPIdentityIssue, extractMentionedNames, extractSubjects, generateEncryptionKeyHex, getDbPath, getEncryptionKeyFromHex, getXMTPToolsUrl, getXmtpAuthConfig, logAgentDetails, resolveSubjects, resolveUserAddress, startMessageListener, startPeriodicBackup, validateEnvironment };