@initia/initia.js 1.0.21 → 2.0.0-rc.1

package/dist/entry.events.d.mts

@@ -0,0 +1,338 @@
+import { $t as buildEventQuery, An as WsEvmSyncStatus, Cn as Subscription, Dn as WsBlockHeader, En as WsBlock, Kt as EventFilter, Mn as WsValidatorUpdates, Nn as isCosmosEvent, On as WsEvmBlockHeader, Pn as isEvmEvent, Sn as SessionOptions, Tn as ValidatorUpdatesEventSpec, Xt as TxSearchClient, Zt as WaitForEventOptions, _n as EvmHeadsEventSpec, an as hasWebSocketEndpoint, bn as EvmSyncingEventSpec, cn as BlockHeaderEventSpec, dn as CosmosCustomEventSpec, en as matchesEventFilter, fa as WebSocketNotAvailableError, fn as CosmosEventSpec, gn as EvmEventSpec, hn as EvmCustomEventSpec, in as createSession, jn as WsTxResult, kn as WsEvmLog, ln as ConnectionEvent, mn as EventSpec, on as subscribe, pn as EventDataMap, rn as WebSocketSession, sn as BlockEventSpec, tn as waitForEvent, un as ConnectionEventType, vn as EvmLogsEventSpec, wn as TxEventSpec, xn as InferEventData, yn as EvmPendingTxsEventSpec } from "./types-DGrP9Ro_.mjs";
+
+//#region src/client/events.d.ts
+/**
+ * Cosmos Event Utilities
+ *
+ * Provides helpers for working with Cosmos SDK transaction events.
+ * These utilities work with events from both transaction results and WebSocket subscriptions.
+ */
+/**
+ * Cosmos event attribute.
+ */
+interface EventAttribute {
+  /** Attribute key */
+  key: string;
+  /** Attribute value */
+  value: string;
+}
+/**
+ * Cosmos event from transaction result.
+ */
+interface CosmosEvent {
+  /** Event type (e.g., 'transfer', 'message', 'coin_spent') */
+  type: string;
+  /** Event attributes */
+  attributes: EventAttribute[];
+}
+/**
+ * Parsed Wasm event with structured data.
+ */
+interface ParsedWasmEvent {
+  /** Contract address */
+  contractAddress: string;
+  /** Action name (from _action attribute or first custom attribute) */
+  action?: string;
+  /** All attributes as key-value pairs (excluding underscore-prefixed system attributes) */
+  data: Record<string, string>;
+  /** Original event */
+  raw: CosmosEvent;
+}
+/**
+ * Parsed Move event with structured data.
+ */
+interface ParsedMoveEvent {
+  /** Module address */
+  moduleAddress?: string;
+  /** Module name */
+  moduleName?: string;
+  /** Event type (full type string) */
+  eventType?: string;
+  /** Event data (base64 decoded if possible) */
+  data: Record<string, string>;
+  /** Original event */
+  raw: CosmosEvent;
+}
+/**
+ * Find the first event with the specified type.
+ *
+ * @param events - Array of events to search
+ * @param type - Event type to find
+ * @returns First matching event or undefined
+ *
+ * @example
+ * ```typescript
+ * import { findEvent } from 'initia.js'
+ *
+ * const transferEvent = findEvent(txResult.events, 'transfer')
+ * if (transferEvent) {
+ *   console.log('Transfer found')
+ * }
+ * ```
+ */
+declare function findEvent(events: CosmosEvent[], type: string): CosmosEvent | undefined;
+/**
+ * Find all events with the specified type.
+ *
+ * @param events - Array of events to search
+ * @param type - Event type to find
+ * @returns Array of matching events
+ *
+ * @example
+ * ```typescript
+ * import { findEvents } from 'initia.js'
+ *
+ * const transfers = findEvents(txResult.events, 'transfer')
+ * console.log(`Found ${transfers.length} transfers`)
+ * ```
+ */
+declare function findEvents(events: CosmosEvent[], type: string): CosmosEvent[];
+/**
+ * Get a single attribute value from an event.
+ *
+ * @param event - Event to get attribute from
+ * @param key - Attribute key
+ * @returns Attribute value or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * import { findEvent, getEventAttribute } from 'initia.js'
+ *
+ * const transfer = findEvent(events, 'transfer')
+ * if (transfer) {
+ *   const recipient = getEventAttribute(transfer, 'recipient')
+ *   const amount = getEventAttribute(transfer, 'amount')
+ *   console.log(`Transferred ${amount} to ${recipient}`)
+ * }
+ * ```
+ */
+declare function getEventAttribute(event: CosmosEvent, key: string): string | undefined;
+/**
+ * Get an attribute value from events by event type and attribute key.
+ *
+ * Shorthand for `findEvent` + `getEventAttribute`.
+ *
+ * @param events - Array of events to search
+ * @param type - Event type to find
+ * @param key - Attribute key to extract
+ * @returns Attribute value or undefined if event/attribute not found
+ *
+ * @example
+ * ```typescript
+ * import { getEventValue } from 'initia.js'
+ *
+ * const codeId = getEventValue(result.events, 'store_code', 'code_id')
+ * const contractAddr = getEventValue(result.events, 'instantiate', '_contract_address')
+ * ```
+ */
+declare function getEventValue(events: CosmosEvent[], type: string, key: string): string | undefined;
+/**
+ * Get all attributes from an event as a Record.
+ *
+ * @param event - Event to get attributes from
+ * @returns Record of attribute key-value pairs
+ *
+ * @example
+ * ```typescript
+ * import { findEvent, getEventAttributes } from 'initia.js'
+ *
+ * const transfer = findEvent(events, 'transfer')
+ * if (transfer) {
+ *   const attrs = getEventAttributes(transfer)
+ *   console.log(attrs)  // { sender: "init1...", recipient: "init1...", amount: "1000uinit" }
+ * }
+ * ```
+ */
+declare function getEventAttributes(event: CosmosEvent): Record<string, string>;
+/**
+ * Filter events by type and optionally by attribute values.
+ *
+ * @param events - Array of events to filter
+ * @param type - Event type to match
+ * @param attributes - Optional attribute key-value pairs to match
+ * @returns Array of matching events
+ *
+ * @example
+ * ```typescript
+ * import { filterEvents } from 'initia.js'
+ *
+ * // Find all transfers to a specific recipient
+ * const transfers = filterEvents(events, 'transfer', {
+ *   recipient: 'init1...'
+ * })
+ * ```
+ */
+declare function filterEvents(events: CosmosEvent[], type: string, attributes?: Record<string, string>): CosmosEvent[];
+/**
+ * Check if an event is a Wasm event.
+ *
+ * @param event - Event to check
+ * @returns true if the event is a Wasm event
+ */
+declare function isWasmEvent(event: CosmosEvent): boolean;
+/**
+ * Parse Wasm events from transaction events.
+ *
+ * Wasm events have type 'wasm' and include:
+ * - `_contract_address`: The contract that emitted the event
+ * - Other attributes are custom data from the contract
+ *
+ * @param events - Array of events to parse
+ * @returns Array of parsed Wasm events
+ *
+ * @example
+ * ```typescript
+ * import { parseWasmEvents } from 'initia.js'
+ *
+ * const wasmEvents = parseWasmEvents(txResult.events)
+ * for (const event of wasmEvents) {
+ *   console.log(`Contract: ${event.contractAddress}`)
+ *   console.log(`Action: ${event.action}`)
+ *   console.log(`Data:`, event.data)
+ * }
+ * ```
+ */
+declare function parseWasmEvents(events: CosmosEvent[]): ParsedWasmEvent[];
+/**
+ * Find Wasm events by contract address.
+ *
+ * @param events - Array of events to search
+ * @param contractAddress - Contract address to filter by
+ * @returns Array of parsed Wasm events from the specified contract
+ *
+ * @example
+ * ```typescript
+ * import { findWasmEventsByContract } from 'initia.js'
+ *
+ * const events = findWasmEventsByContract(txResult.events, 'init1...')
+ * ```
+ */
+declare function findWasmEventsByContract(events: CosmosEvent[], contractAddress: string): ParsedWasmEvent[];
+/**
+ * Find Wasm events by action.
+ *
+ * @param events - Array of events to search
+ * @param action - Action name to filter by
+ * @returns Array of parsed Wasm events with the specified action
+ *
+ * @example
+ * ```typescript
+ * import { findWasmEventsByAction } from 'initia.js'
+ *
+ * const transfers = findWasmEventsByAction(txResult.events, 'transfer')
+ * ```
+ */
+declare function findWasmEventsByAction(events: CosmosEvent[], action: string): ParsedWasmEvent[];
+/**
+ * Check if an event is a Move event.
+ *
+ * @param event - Event to check
+ * @returns true if the event is a Move event
+ */
+declare function isMoveEvent(event: CosmosEvent): boolean;
+/**
+ * Parse Move events from transaction events.
+ *
+ * Move events have type 'move' and include:
+ * - `type_tag`: Full type of the event (e.g., "0x1::coin::DepositEvent")
+ * - `data`: Base64 encoded BCS data
+ *
+ * @param events - Array of events to parse
+ * @returns Array of parsed Move events
+ *
+ * @example
+ * ```typescript
+ * import { parseMoveEvents } from 'initia.js'
+ *
+ * const moveEvents = parseMoveEvents(txResult.events)
+ * for (const event of moveEvents) {
+ *   console.log(`Type: ${event.eventType}`)
+ *   console.log(`Module: ${event.moduleAddress}::${event.moduleName}`)
+ *   console.log(`Data:`, event.data)
+ * }
+ * ```
+ */
+declare function parseMoveEvents(events: CosmosEvent[]): ParsedMoveEvent[];
+/**
+ * Find Move events by module.
+ *
+ * @param events - Array of events to search
+ * @param moduleAddress - Module address (e.g., "0x1")
+ * @param moduleName - Optional module name to filter by
+ * @returns Array of parsed Move events from the specified module
+ *
+ * @example
+ * ```typescript
+ * import { findMoveEventsByModule } from 'initia.js'
+ *
+ * // Find all events from 0x1::coin module
+ * const coinEvents = findMoveEventsByModule(txResult.events, '0x1', 'coin')
+ * ```
+ */
+declare function findMoveEventsByModule(events: CosmosEvent[], moduleAddress: string, moduleName?: string): ParsedMoveEvent[];
+/**
+ * Find Move events by event type.
+ *
+ * @param events - Array of events to search
+ * @param eventType - Full event type (e.g., "0x1::coin::DepositEvent")
+ * @returns Array of parsed Move events with the specified type
+ *
+ * @example
+ * ```typescript
+ * import { findMoveEventsByType } from 'initia.js'
+ *
+ * const deposits = findMoveEventsByType(
+ *   txResult.events,
+ *   '0x1::coin::DepositEvent'
+ * )
+ * ```
+ */
+declare function findMoveEventsByType(events: CosmosEvent[], eventType: string): ParsedMoveEvent[];
+/**
+ * Extract typed attributes from events matching a given type.
+ *
+ * Returns an array of objects with the specified keys extracted from each matching event.
+ * Uses `const` generics so callers don't need `as const` on the keys array.
+ *
+ * @param events - Array of events to search
+ * @param type - Event type to match
+ * @param keys - Attribute keys to extract
+ * @returns Array of typed attribute objects
+ *
+ * @example
+ * ```typescript
+ * import { parseEventAttrs } from 'initia.js/events'
+ *
+ * const transfers = parseEventAttrs(result.events, 'transfer', ['recipient', 'sender', 'amount'])
+ * // → Array<{ recipient: string, sender: string, amount: string }>
+ *
+ * transfers[0].recipient // autocomplete works
+ * ```
+ */
+declare function parseEventAttrs<const K extends readonly string[]>(events: CosmosEvent[], type: string, keys: K): Array<{ [P in K[number]]: string }>;
+/**
+ * Parse Move events by type tag, with automatic JSON data parsing.
+ *
+ * Filters Move events by type_tag and parses the `data` attribute from JSON string
+ * into a typed object. Returns parsed data for each matching event.
+ *
+ * @param events - Array of events to search
+ * @param typeTag - Full Move type tag (e.g., "0x1::coin::WithdrawEvent")
+ * @returns Array of parsed data objects
+ *
+ * @example
+ * ```typescript
+ * import { parseMoveEventData } from 'initia.js/events'
+ *
+ * const withdraws = parseMoveEventData(result.events, '0x1::coin::WithdrawEvent')
+ * // → Array<{ store_addr: string, metadata_addr: string, amount: string }>
+ *
+ * for (const w of withdraws) {
+ *   console.log(`Withdrew ${w.amount} from ${w.store_addr}`)
+ * }
+ * ```
+ */
+declare function parseMoveEventData(events: CosmosEvent[], typeTag: string): Array<Record<string, unknown>>;
+//#endregion
+export { type BlockEventSpec, type BlockHeaderEventSpec, type ConnectionEvent, type ConnectionEventType, type CosmosCustomEventSpec, CosmosEvent, type CosmosEventSpec, EventAttribute, type EventDataMap, type EventFilter, type EventSpec, type EvmCustomEventSpec, type EvmEventSpec, type EvmHeadsEventSpec, type EvmLogsEventSpec, type EvmPendingTxsEventSpec, type EvmSyncingEventSpec, type InferEventData, ParsedMoveEvent, ParsedWasmEvent, type SessionOptions, type Subscription, type TxEventSpec, type TxSearchClient, type ValidatorUpdatesEventSpec, type WaitForEventOptions, WebSocketNotAvailableError, WebSocketSession, type WsBlock, type WsBlockHeader, type WsEvmBlockHeader, type WsEvmLog, type WsEvmSyncStatus, type WsTxResult, type WsValidatorUpdates, buildEventQuery, createSession, filterEvents, findEvent, findEvents, findMoveEventsByModule, findMoveEventsByType, findWasmEventsByAction, findWasmEventsByContract, getEventAttribute, getEventAttributes, getEventValue, hasWebSocketEndpoint, isCosmosEvent, isEvmEvent, isMoveEvent, isWasmEvent, matchesEventFilter, parseEventAttrs, parseMoveEventData, parseMoveEvents, parseWasmEvents, subscribe, waitForEvent };
+//# sourceMappingURL=entry.events.d.mts.map