@towns-labs/app-framework 4.0.0

package/dist/app.d.ts

@@ -0,0 +1,680 @@
+import { type SendTipMemberParams } from '@towns-labs/web3';
+import type { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
+import { type ClientV2, type ParsedEvent, type CreateTownsClientParams } from '@towns-labs/sdk';
+import { Hono } from 'hono';
+import { ChannelMessage, Tags, InteractionRequestPayload, InteractionResponsePayload, StreamEvent } from '@towns-labs/proto';
+import type { ChannelMessage_Post_Mention, PlainMessage, SlashCommand, BlockchainTransaction, AppMetadata, ConversationSeed, Proposal, PositionsResponse } from '@towns-labs/proto';
+import { type EventDedupConfig } from './modules/eventDedup';
+import { type UserInfo } from './modules/user';
+export type { UserInfo } from './modules/user';
+import { type FlattenedInteractionRequest } from './modules/interaction-api';
+import type { FacilitatorConfig, RouteConfig } from 'x402/types';
+import { type Chain, type Transport, type Address, type Account, type WalletClient, type TransactionReceipt } from 'viem';
+import type { AgentIdentityConfig, AgentIdentityMetadata } from './identity-types';
+type AgentActions = ReturnType<typeof buildAgentActions>;
+export type AgentCommand = PlainMessage<SlashCommand> & {
+    paid?: RouteConfig;
+};
+export type AgentCapability = {
+    name: string;
+    description: string;
+    input: StandardJSONSchemaV1;
+    examples?: Array<{
+        userQuery: string;
+        parameters: string;
+    }>;
+};
+export type ProposalResult = {
+    title: string;
+    explanation: string;
+    confidence: number;
+    parameters?: string;
+    expiresAt?: Date;
+    warnings?: string[];
+    expectedOutcome?: string;
+};
+type InferCapabilityParameters<Caps extends AgentCapability[], Name extends string> = Extract<Caps[number], {
+    name: Name;
+}> extends {
+    input: infer S extends StandardJSONSchemaV1;
+} ? NonNullable<S['~standard']['types']>['output'] : unknown;
+export type AgentHandler = ReturnType<typeof buildAgentActions>;
+export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+export type AgentPayload<T extends keyof AgentEvents<Commands>, Commands extends AgentCommand[] = []> = Parameters<AgentEvents<Commands>[T]>[1];
+type ImageAttachment = {
+    type: 'image';
+    alt?: string;
+    url: string;
+};
+type ChunkedMediaAttachment = {
+    type: 'chunked';
+    data: Blob;
+    width?: number;
+    height?: number;
+    filename: string;
+} | {
+    type: 'chunked';
+    data: Uint8Array;
+    width?: number;
+    height?: number;
+    filename: string;
+    mimetype: string;
+};
+type LinkAttachment = {
+    type: 'link';
+    url: string;
+    title?: string;
+    description?: string;
+    image?: {
+        width: number;
+        height: number;
+        url: string;
+    };
+};
+type MiniAppAttachment = {
+    type: 'miniapp';
+    url: string;
+};
+type TickerAttachment = {
+    type: 'ticker';
+    address: string;
+    chainId: string;
+};
+type InfoCardAttachment = {
+    type: 'infoCard';
+    title: {
+        icon?: 'check' | 'x' | 'warning' | 'info';
+        text: string;
+        badge?: {
+            text: string;
+            variant?: 'positive' | 'negative';
+        };
+    };
+    fields: Array<{
+        label?: string;
+        value: {
+            type: 'text';
+            icon?: 'check' | 'x' | 'warning' | 'info';
+            text: string;
+            badge?: {
+                text: string;
+                variant?: 'positive' | 'negative';
+            };
+        } | {
+            type: 'user';
+            userId: Uint8Array;
+        } | {
+            type: 'token';
+            chainId: string;
+            address: string;
+            amount: string;
+        } | {
+            type: 'contract';
+            chainId: string;
+            address: string;
+        } | {
+            type: 'marketItem';
+            name: string;
+            price: string;
+            iconUrl?: string;
+            subtitle?: string;
+            change?: string;
+            changePct?: string;
+            direction?: 'positive' | 'negative';
+            outcomes?: Array<{
+                label: string;
+                value: string;
+                variant?: 'positive' | 'negative';
+            }>;
+        };
+    }>;
+};
+export type MessageOpts = {
+    threadId?: string;
+    replyId?: string;
+    ephemeral?: boolean;
+};
+export type PostMessageOpts = MessageOpts & {
+    mentions?: Array<{
+        userId: string;
+        displayName: string;
+    } | {
+        roleId: number;
+    } | {
+        atChannel: true;
+    }>;
+    attachments?: Array<ImageAttachment | ChunkedMediaAttachment | LinkAttachment | TickerAttachment | MiniAppAttachment | InfoCardAttachment>;
+};
+export type DecryptedInteractionResponse = {
+    recipient: Uint8Array;
+    payload: PlainMessage<InteractionResponsePayload>;
+};
+export type MentionPayload = Pick<ChannelMessage_Post_Mention, 'userId' | 'displayName'>;
+export type MessagePayload = BasePayload & {
+    /** The decrypted message content */
+    message: string;
+    /** In case of a reply, that's  the eventId of the message that got replied */
+    replyId: string | undefined;
+    /** In case of a thread, that's the thread id where the message belongs to */
+    threadId: string | undefined;
+    /** Users mentioned in the message */
+    mentions: MentionPayload[];
+    /** Convenience flag to check if the agent was mentioned */
+    isMentioned: boolean;
+};
+export type RedactionPayload = BasePayload & {
+    /** The event ID that got redacted */
+    refEventId: string;
+};
+export type MessageEditPayload = BasePayload & {
+    /** The event ID of the message that got edited */
+    refEventId: string;
+    /** New message */
+    message: string;
+    /** In case of a reply, that's  the eventId of the message that got replied */
+    replyId: string | undefined;
+    /** In case of a thread, that's the thread id where the message belongs to */
+    threadId: string | undefined;
+    /** Users mentioned in the message */
+    mentions: MentionPayload[];
+    /** Convenience flag to check if the agent was mentioned */
+    isMentioned: boolean;
+};
+export type ReactionPayload = BasePayload & {
+    /** The reaction that was added */
+    reaction: string;
+    /** The event ID of the message that got reacted to */
+    messageId: string;
+    /** The user ID of the user that added the reaction */
+    userId: string;
+};
+export type EventRevokePayload = BasePayload & {
+    /** The event ID of the message that got revoked */
+    refEventId: string;
+};
+export type TipPayload = BasePayload & {
+    /** The message ID of the parent of the tip */
+    messageId: string;
+    /** The address that sent the tip */
+    senderAddress: Address;
+    /** The address that received the tip */
+    receiverAddress: Address;
+    /** The user ID that received the tip */
+    receiverUserId: string;
+    /** The amount of the tip */
+    amount: bigint;
+    /** The currency of the tip */
+    currency: Address;
+};
+export type StreamEventPayload = BasePayload & {
+    parsed: ParsedEvent;
+};
+export type SlashCommandPayload<Commands extends AgentCommand[] = []> = BasePayload & {
+    /** The slash command that was invoked (without the /) */
+    command: Commands[number]['name'];
+    /** Arguments passed after the command
+     * @example
+     * ```
+     * /help
+     * args: []
+     * ```
+     * ```
+     * /sum 1 2
+     * args: ['1', '2']
+     * ```
+     */
+    args: string[];
+    /** Users mentioned in the command */
+    mentions: MentionPayload[];
+    /** The eventId of the message that got replied */
+    replyId: string | undefined;
+    /** The thread id where the message belongs to */
+    threadId: string | undefined;
+};
+export type RawGmMessagePayload = BasePayload & {
+    typeUrl: string;
+    message: Uint8Array;
+};
+export type GmPayload<Schema extends StandardSchemaV1> = BasePayload & {
+    typeUrl: string;
+    schema: Schema;
+    data: InferOutput<Schema>;
+};
+export type InteractionResponseEventPayload = BasePayload & {
+    /** The interaction response that was received */
+    response: DecryptedInteractionResponse;
+    threadId: string | undefined;
+};
+export type ConversationSeedResponsePayload = BasePayload & {
+    seedId: string;
+    seed: ConversationSeed | undefined;
+    response: {
+        case: 'selectedProposal';
+        value: Proposal;
+    } | {
+        case: 'userMessage';
+        value: string;
+    };
+    replyId: string | undefined;
+    threadId: string | undefined;
+};
+export type SelectedProposalPayload = BasePayload & {
+    seedId: string;
+    seed: ConversationSeed | undefined;
+    proposal: Proposal;
+    replyId: string | undefined;
+    threadId: string | undefined;
+};
+export type AgentEvents<Commands extends AgentCommand[] = []> = {
+    message: (handler: AgentActions, event: MessagePayload) => void | Promise<void>;
+    redaction: (handler: AgentActions, event: RedactionPayload) => void | Promise<void>;
+    messageEdit: (handler: AgentActions, event: MessageEditPayload) => void | Promise<void>;
+    reaction: (handler: AgentActions, event: ReactionPayload) => Promise<void> | void;
+    eventRevoke: (handler: AgentActions, event: EventRevokePayload) => Promise<void> | void;
+    tip: (handler: AgentActions, event: TipPayload) => Promise<void> | void;
+    channelJoin: (handler: AgentActions, event: BasePayload) => Promise<void> | void;
+    channelLeave: (handler: AgentActions, event: BasePayload) => Promise<void> | void;
+    streamEvent: (handler: AgentActions, event: StreamEventPayload) => Promise<void> | void;
+    slashCommand: (handler: AgentActions, event: SlashCommandPayload<Commands>) => Promise<void> | void;
+    rawGmMessage: (handler: AgentActions, event: RawGmMessagePayload) => void | Promise<void>;
+    gm: <Schema extends StandardSchemaV1>(handler: AgentActions, event: GmPayload<Schema>) => void | Promise<void>;
+    interactionResponse: (handler: AgentActions, event: InteractionResponseEventPayload) => void | Promise<void>;
+    conversationSeedResponse: (handler: AgentActions, event: ConversationSeedResponsePayload) => void | Promise<void>;
+    selectedProposal: (handler: AgentActions, event: SelectedProposalPayload) => void | Promise<void>;
+};
+export type BasePayload = {
+    /** The user ID of the user that triggered the event */
+    userId: Address;
+    /** channelId that the event was triggered in */
+    channelId: string;
+    /** The ID of the event that triggered */
+    eventId: string;
+    /** The creation time of the event */
+    createdAt: Date;
+    /** The raw event payload */
+    event: StreamEvent;
+    /** Convenience flag to check if the event triggered on a DM channel */
+    isDm: boolean;
+    /** Convenience flag to check if the event triggered on a GDM channel */
+    isGdm: boolean;
+    /** Resolved user info from the app registry (display name, username) */
+    user: UserInfo;
+};
+export declare class App<Commands extends AgentCommand[] = [], Capabilities extends AgentCapability[] = []> {
+    readonly client: ClientV2<AgentActions>;
+    readonly appAddress: Address;
+    agentUserId: string;
+    viem: WalletClient<Transport, Chain, Account>;
+    private readonly jwtSecret;
+    private currentMessageTags;
+    private readonly emitter;
+    private readonly slashCommandHandlers;
+    private readonly gmTypedHandlers;
+    private readonly commands;
+    private readonly capabilities;
+    private readonly capabilityHandlers;
+    private conciergeRequestHandler?;
+    private positionsHandler?;
+    metadata: PlainMessage<AppMetadata>;
+    private readonly identityConfig?;
+    private readonly eventDedup;
+    private readonly paymentConfig?;
+    private readonly pendingPayments;
+    private readonly paymentCommands;
+    private readonly userInfoCache;
+    constructor(clientV2: ClientV2<AgentActions>, viem: WalletClient<Transport, Chain, Account>, jwtSecretBase64: string, appAddress: Address, commands?: Commands, capabilities?: Capabilities, identityConfig?: AgentIdentityConfig, dedupConfig?: EventDedupConfig, paymentConfig?: FacilitatorConfig, metadata?: PlainMessage<AppMetadata>);
+    getUser(userId: Address): Promise<UserInfo | undefined>;
+    getUser(userIds: Address[]): Promise<Map<Address, UserInfo | undefined>>;
+    start(): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+    private jwtMiddleware;
+    private webhookHandler;
+    private processProposals;
+    private handleEvent;
+    private isGroupEncryptionSession;
+    private handleKeySolicitation;
+    private handleChannelMessage;
+    private handlePaymentResponse;
+    /**
+     * get the public device key of the agent
+     * @returns the public device key of the agent
+     */
+    getUserDevice(): import("@towns-labs/encryption").UserDevice;
+    /**
+     * Send a message to a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param message - The cleartext of the message
+     * @param opts - The options for the message
+     */
+    sendMessage(streamId: string, message: string, opts?: PostMessageOpts): Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    /**
+     * Send a reaction to a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param refEventId - The eventId of the event to react to
+     * @param reaction - The reaction to send
+     */
+    sendReaction(streamId: string, refEventId: string, reaction: string): Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    /**
+     * Remove an specific event from a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param refEventId - The eventId of the event to remove
+     */
+    removeEvent(streamId: string, refEventId: string): Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    /**
+     * Add a user (or app) to a stream via user membership action.
+     * Requires the agent to already be a member of the stream.
+     * @param streamId - Id of the stream to join (channel, space, gdm)
+     * @param userId - User ID to add
+     */
+    joinUser(streamId: string, userId: string): Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    /**
+     * Edit an specific message from a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param messageId - The eventId of the message to edit
+     * @param message - The new message text
+     */
+    editMessage(streamId: string, messageId: string, message: string, opts?: PostMessageOpts): Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    /**
+     * Send a GM (generic message) to a stream with schema validation
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param typeUrl - The type URL identifying the message format
+     * @param schema - StandardSchema for validation
+     * @param data - Data to validate and send
+     */
+    sendGM<Schema extends StandardSchemaV1>(streamId: string, typeUrl: string, schema: Schema, data: InferInput<Schema>, opts?: MessageOpts): Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    /**
+     * Send a raw GM (generic message) to a stream without schema validation
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param typeUrl - The type URL identifying the message format
+     * @param message - Optional raw message data as bytes
+     * @param opts - The options for the message
+     */
+    sendRawGM(streamId: string, typeUrl: string, message: Uint8Array, opts?: MessageOpts): Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    /**
+     * Send a conversation seed to a stream
+     * @param streamId - Id of the stream. Usually channelId
+     * @param seed - The conversation seed payload
+     * @param opts - The options for the message
+     */
+    sendConversationSeed(streamId: string, seed: PlainMessage<ConversationSeed>, opts?: MessageOpts): Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    /**
+     * Send an interaction request to a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param contentOrPayload - The interaction request content (old format) or flattened payload (new format)
+     * @param recipientOrOpts - Recipient bytes (old format) or message options (new format)
+     * @param opts - The options for the interaction request (old format only)
+     * @returns The eventId of the interaction request
+     */
+    sendInteractionRequest(streamId: string, content: PlainMessage<InteractionRequestPayload['content']>, recipient?: Uint8Array, opts?: MessageOpts): Promise<{
+        eventId: string;
+        requestId: string;
+    }>;
+    sendInteractionRequest(streamId: string, payload: FlattenedInteractionRequest, opts?: MessageOpts): Promise<{
+        eventId: string;
+        requestId: string;
+    }>;
+    /**
+     * Send an AddMember interaction request to add a user to a GDM
+     * @param streamId - Id of the GDM stream
+     * @param userId - The user ID to add to the GDM
+     * @param opts - Optional message and other options
+     * @returns The eventId and requestId of the interaction request
+     */
+    sendAddMemberRequest(streamId: string, userId: Address, opts?: {
+        message?: string;
+    } & MessageOpts): Promise<{
+        eventId: string;
+        requestId: string;
+    }>;
+    pinMessage(streamId: string, eventId: string, streamEvent: StreamEvent): Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    unpinMessage(streamId: string, eventId: string): Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    /** Sends a tip to a user by looking up their smart account.
+     *  Tip will always get funds from the app account balance.
+     * @param params - Tip parameters including userId, amount, messageId, channelId, currency.
+     * @returns The transaction hash and event ID
+     */
+    sendTip(params: Omit<SendTipMemberParams, 'spaceId' | 'tokenId' | 'currency' | 'receiver'> & {
+        currency?: Address;
+        userId: Address;
+    }): Promise<{
+        txHash: string;
+        eventId: string;
+    }>;
+    /**
+     * Triggered when someone sends a message.
+     * This is triggered for all messages, including direct messages and group messages.
+     */
+    onMessage(fn: AgentEvents['message']): import("nanoevents").Unsubscribe;
+    onRedaction(fn: AgentEvents['redaction']): import("nanoevents").Unsubscribe;
+    /**
+     * Triggered when a message gets edited
+     */
+    onMessageEdit(fn: AgentEvents['messageEdit']): import("nanoevents").Unsubscribe;
+    /**
+     * Triggered when someone reacts to a message
+     */
+    onReaction(fn: AgentEvents['reaction']): import("nanoevents").Unsubscribe;
+    /**
+     * Triggered when a message is revoked by a moderator
+     */
+    onEventRevoke(fn: AgentEvents['eventRevoke']): import("nanoevents").Unsubscribe;
+    /**
+     * Triggered when someone tips the agent
+     */
+    onTip(fn: AgentEvents['tip']): import("nanoevents").Unsubscribe;
+    /**
+     * Triggered when someone joins a channel
+     */
+    onChannelJoin(fn: AgentEvents['channelJoin']): import("nanoevents").Unsubscribe;
+    /**
+     * Triggered when someone leaves a channel
+     */
+    onChannelLeave(fn: AgentEvents['channelLeave']): import("nanoevents").Unsubscribe;
+    onStreamEvent(fn: AgentEvents['streamEvent']): import("nanoevents").Unsubscribe;
+    onSlashCommand(command: Commands[number]['name'], fn: AgentEvents<Commands>['slashCommand']): () => void;
+    onCapability<Name extends Capabilities[number]['name'] | (string & {})>(name: Name, fn: (handler: AgentActions, event: {
+        capabilityName: Name;
+        parameters: InferCapabilityParameters<Capabilities, Name>;
+        userQuery: string;
+        context: string | undefined;
+        timeoutMs: number | undefined;
+    }) => ProposalResult[] | Promise<ProposalResult[]>): () => void;
+    onPositions(handler: (handler: AgentActions, event: {
+        userId: string;
+    }) => Promise<PlainMessage<PositionsResponse>> | PlainMessage<PositionsResponse>): () => void;
+    onConciergeRequest(fn: (handler: AgentActions, event: {
+        conversationSeedId: string;
+        userQuery: string;
+        context?: string;
+        externalRef?: string;
+        proposalTimeoutMs?: bigint;
+        conciergeTimeoutMs?: bigint;
+    }) => Promise<Partial<PlainMessage<ConversationSeed>> | void>): () => void;
+    /**
+     * Triggered when someone sends a GM (generic message) with type validation using StandardSchema
+     * @param typeUrl - The type URL to listen for
+     * @param schema - The StandardSchema to validate the message data
+     * @param handler - The handler function to call when a message is received
+     */
+    onGmMessage<Schema extends StandardSchemaV1>(typeUrl: string, schema: Schema, handler: (handler: AgentActions, event: BasePayload & {
+        typeUrl: string;
+        data: InferOutput<Schema>;
+    }) => void | Promise<void>): () => void;
+    onRawGmMessage(handler: AgentEvents['rawGmMessage']): import("nanoevents").Unsubscribe;
+    /**
+     * Triggered when someone sends an interaction response
+     * @param fn - The handler function to call when an interaction response is received
+     */
+    onInteractionResponse(fn: AgentEvents['interactionResponse']): import("nanoevents").Unsubscribe;
+    /**
+     * Triggered when someone sends a conversation seed response
+     */
+    onConversationSeedResponse(fn: AgentEvents['conversationSeedResponse']): import("nanoevents").Unsubscribe;
+    /**
+     * Triggered when a user selects a proposal that targets this bot.
+     * Only fires for selectedProposal responses where targetAgentId matches this bot's appAddress.
+     */
+    onSelectedProposal(fn: AgentEvents['selectedProposal']): import("nanoevents").Unsubscribe;
+    /**
+     * Get the stream view for a stream
+     * Stream views contain contextual information about the stream (space, channel, etc)
+     * Stream views contain member data for all streams - you can iterate over all members in a channel via: `streamView.getMembers().joined.keys()`
+     * note: potentially expensive operation because streams can be large, fine to use in small streams
+     * @param streamId - The stream ID to get the view for
+     * @returns The stream view
+     */
+    getStreamView(streamId: string): Promise<import("@towns-labs/sdk").StreamStateView>;
+    /**
+     * Get the ERC-8004 compliant metadata JSON
+     * This should be hosted at /.well-known/agent-metadata.json
+     * Merges cached app metadata with local identity config
+     * @returns The ERC-8004 compliant metadata object or null
+     */
+    getIdentityMetadata(): Promise<AgentIdentityMetadata | null>;
+    /**
+     * Get the tokenURI that would be used for ERC-8004 registration
+     * Returns null if no domain is configured
+     * @returns The .well-known URL or null
+     */
+    getTokenURI(): string | null;
+}
+export declare const makeTownsApp: <Commands extends AgentCommand[] = [], Capabilities extends AgentCapability[] = []>(appPrivateData: string, opts?: {
+    /** In case you need to override the embedded JWT token from app private data */
+    jwtSecret?: string;
+    baseRpcUrl?: string;
+    commands?: Commands;
+    capabilities?: Capabilities;
+    identity?: AgentIdentityConfig;
+    dedup?: EventDedupConfig;
+    paymentConfig?: FacilitatorConfig;
+} & Partial<Omit<CreateTownsClientParams, "env" | "encryptionDevice">>) => Promise<App<Commands, Capabilities>>;
+declare const buildAgentActions: (client: ClientV2, viem: WalletClient<Transport, Chain, Account>, appAddress: Address) => {
+    sendMessage: (streamId: string, message: string, opts?: PostMessageOpts, tags?: PlainMessage<Tags>) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    editMessage: (streamId: string, messageId: string, message: string, opts?: PostMessageOpts, tags?: PlainMessage<Tags>) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    sendReaction: (streamId: string, messageId: string, reaction: string, tags?: PlainMessage<Tags>) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    sendInteractionRequest: {
+        (streamId: string, content: PlainMessage<InteractionRequestPayload["content"]>, recipient?: Uint8Array, opts?: MessageOpts, tags?: PlainMessage<Tags>): Promise<{
+            eventId: string;
+            requestId: string;
+        }>;
+        (streamId: string, payload: FlattenedInteractionRequest, opts?: MessageOpts, tags?: PlainMessage<Tags>): Promise<{
+            eventId: string;
+            requestId: string;
+        }>;
+    };
+    sendGM: <Schema extends StandardSchemaV1>(streamId: string, typeUrl: string, schema: Schema, data: InferInput<Schema>, opts?: MessageOpts, tags?: PlainMessage<Tags>) => ReturnType<({ streamId, payload, tags, ephemeral, }: {
+        streamId: string;
+        payload: ChannelMessage;
+        tags?: PlainMessage<Tags>;
+        ephemeral?: boolean;
+    }) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>>;
+    sendRawGM: (streamId: string, typeUrl: string, message: Uint8Array, opts?: MessageOpts, tags?: PlainMessage<Tags>) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    sendConversationSeed: (streamId: string, seed: PlainMessage<ConversationSeed>, opts?: MessageOpts, tags?: PlainMessage<Tags>) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    removeEvent: (streamId: string, messageId: string, tags?: PlainMessage<Tags>) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    sendKeySolicitation: (streamId: string, sessionIds: string[]) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    uploadDeviceKeys: () => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    pinMessage: (streamId: string, eventId: string, streamEvent: StreamEvent) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    unpinMessage: (streamId: string, eventId: string) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+    getChannelSettings: (_channelId: string) => Promise<never>;
+    sendBlockchainTransaction: (chainId: number, receipt: TransactionReceipt, content?: PlainMessage<BlockchainTransaction>["content"], tags?: PlainMessage<Tags>) => Promise<{
+        txHash: string;
+        eventId: string;
+    }>;
+    sendTip: (params: Omit<SendTipMemberParams, "spaceId" | "tokenId" | "currency" | "receiver"> & {
+        currency?: Address;
+        userId: Address;
+    }, tags?: PlainMessage<Tags>) => Promise<{
+        txHash: string;
+        eventId: string;
+    }>;
+    joinUser: (streamId: string, userId: string) => Promise<{
+        eventId: string;
+        prevMiniblockHash: Uint8Array;
+        envelope: import("@towns-labs/proto").Envelope;
+    }>;
+};
+//# sourceMappingURL=app.d.ts.map