@aboutcircles/sdk-rpc 0.1.0

package/README.md

@@ -0,0 +1,169 @@
+# @aboutcircles/sdk-rpc
+
+TypeScript wrapper for Circles RPC methods.
+
+## Installation
+
+```bash
+bun install
+```
+
+## Usage
+
+```typescript
+import { CirclesRpc } from '@aboutcircles/sdk-rpc';
+
+// Create RPC instance with default endpoint (https://rpc.circlesubi.network/)
+const rpc = new CirclesRpc();
+
+// Or use custom RPC endpoint
+const rpc = new CirclesRpc('https://rpc.aboutcircles.com/');
+
+// Note: All addresses are automatically normalized to lowercase
+// since the Circles indexer stores addresses in lowercase
+
+// Note: All numeric values (balances, amounts, timestamps) are returned as bigint
+const balance = await rpc.circlesV2.getTotalBalance('0xcadd4ea3bcc361fc4af2387937d7417be8d7dfc2');
+console.log(balance); // 1000000000000000000n
+
+// Find a path between two addresses
+const path = await rpc.circlesV2.findPath({
+  from: '0x749c930256b47049cb65adcd7c25e72d5de44b3b',
+  to: '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+  targetFlow: 99999999999999999999999999999999999n
+});
+
+// Query trust relations
+const trustRelations = await rpc.query.query({
+  Namespace: 'V_CrcV2',
+  Table: 'TrustRelations',
+  Columns: [],
+  Filter: [{
+    Type: 'Conjunction',
+    ConjunctionType: 'Or',
+    Predicates: [
+      {
+        Type: 'FilterPredicate',
+        FilterType: 'Equals',
+        Column: 'truster',
+        Value: '0xae3a29a9ff24d0e936a5579bae5c4179c4dff565'
+      },
+      {
+        Type: 'FilterPredicate',
+        FilterType: 'Equals',
+        Column: 'trustee',
+        Value: '0xae3a29a9ff24d0e936a5579bae5c4179c4dff565'
+      }
+    ]
+  }],
+  Order: []
+});
+
+// Get common trust
+const commonTrust = await rpc.trust.getCommonTrust(
+  '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+  '0xe8fc7a2d0573e5164597b05f14fa9a7fca7b215c'
+);
+
+// Get token balances
+const balances = await rpc.balance.getTokenBalances('0x7cadf434b692ca029d950607a4b3f139c30d4e98');
+// Each balance includes:
+// - attoCircles, staticAttoCircles, attoCrc (as bigint)
+// - circles, staticCircles, crc (as number)
+// - token type flags (isErc20, isErc1155, isWrapped, etc.)
+
+// Get avatar info
+const avatarInfo = await rpc.avatar.getAvatarInfo('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+
+// Get network snapshot
+const snapshot = await rpc.avatar.getNetworkSnapshot();
+
+// Get profile by address
+const profile = await rpc.profile.getProfileByAddress('0xc3a1428c04c426cdf513c6fc8e09f55ddaf50cd7');
+
+// Get profiles by address batch
+const profiles = await rpc.profile.getProfileByAddressBatch([
+  '0xc3a1428c04c426cdf513c6fc8e09f55ddaf50cd7',
+  '0xf712d3b31de494b5c0ea51a6a407460ca66b12e8'
+]);
+
+// Search profiles
+const results = await rpc.profile.searchProfiles('alice', 10, 0);
+
+// Get available tables
+const tables = await rpc.query.tables();
+
+// Query events
+const events = await rpc.query.events(
+  38000000,
+  null,
+  ['CrcV1_Trust'],
+  null,
+  false
+);
+```
+
+## API
+
+**Note:** All balance and amount values are returned as `bigint` for safe handling of large numbers.
+
+### CirclesV2 Methods
+
+- `getTotalBalanceV1(address, asTimeCircles?): Promise<bigint>` - Get total v1 Circles balance
+- `getTotalBalance(address, asTimeCircles?): Promise<bigint>` - Get total v2 Circles balance
+- `findPath(params): Promise<PathResponse>` - Calculate transfer path between addresses
+  - **params**: `{ from, to, targetFlow, useWrappedBalances?, fromTokens?, toTokens?, excludeFromTokens?, excludeToTokens?, simulatedBalances? }`
+  - All amounts are `bigint`, addresses normalized to lowercase
+  - Returns path with `flow` and `transfers` (all amounts as `bigint`)
+
+### Query Methods
+
+- `query(params)` - Query tables with filters
+- `tables()` - Get available namespaces and tables
+- `events(fromBlock, toBlock, eventTypes, address, includeTransactionData)` - Query events
+
+### Trust Methods
+
+- `getCommonTrust(address1, address2)` - Get common trust relations
+
+### Balance Methods
+
+- `getTokenBalances(address): Promise<TokenBalance[]>` - Get token balance breakdown
+  - Returns balances with raw amounts as `bigint` (attoCircles, staticAttoCircles, attoCrc)
+  - And converted amounts as `number` (circles, staticCircles, crc)
+  - Includes token type flags (isErc20, isErc1155, isWrapped, isInflationary, isGroup)
+
+### Avatar Methods
+
+- `getAvatarInfo(address): Promise<AvatarInfo | undefined>` - Get avatar information
+- `getAvatarInfoBatch(addresses[]): Promise<AvatarInfo[]>` - Get multiple avatar infos in batch
+- `getNetworkSnapshot(): Promise<NetworkSnapshot>` - Get full network snapshot
+
+### Profile Methods
+
+- `getProfileByCid(cid): Promise<Profile | null>` - Get profile by CID
+- `getProfileByCidBatch(cids[]): Promise<(Profile | null)[]>` - Get multiple profiles by CID
+- `getProfileByAddress(address): Promise<Profile | null>` - Get profile by address
+- `getProfileByAddressBatch(addresses[]): Promise<(Profile | null)[]>` - Get multiple profiles by address
+- `searchProfiles(query, limit?, offset?): Promise<Profile[]>` - Search profiles
+
+### Token Methods
+
+- `getTokenInfo(address): Promise<TokenInfo | undefined>` - Get token information
+- `getTokenInfoBatch(addresses[]): Promise<TokenInfo[]>` - Get multiple token infos in batch
+
+### Invitation Methods
+
+- `getInvitedBy(address): Promise<Address | undefined>` - Get the avatar that invited a specific address
+
+## Build
+
+```bash
+bun run build
+```
+
+## Development
+
+```bash
+bun run dev
+```

package/dist/client.d.ts

@@ -0,0 +1,58 @@
+import type { Address } from '@aboutcircles/sdk-types';
+import { Observable } from './events';
+import type { CirclesEvent } from './events';
+/**
+ * Base RPC client for making JSON-RPC calls to Circles RPC endpoints
+ * Supports both HTTP requests and WebSocket subscriptions
+ */
+export declare class RpcClient {
+    private rpcUrl;
+    private requestId;
+    private websocket;
+    private websocketConnected;
+    private pendingResponses;
+    private subscriptionListeners;
+    private reconnectAttempt;
+    private readonly initialBackoff;
+    private readonly maxBackoff;
+    constructor(rpcUrl: string);
+    /**
+     * Make a JSON-RPC call
+     */
+    call<TParams = unknown[], TResult = unknown>(method: string, params: TParams): Promise<TResult>;
+    /**
+     * Update the RPC URL
+     */
+    setRpcUrl(rpcUrl: string): void;
+    /**
+     * Get the current RPC URL
+     */
+    getRpcUrl(): string;
+    /**
+     * Initiates a WebSocket connection
+     * @private
+     */
+    private connect;
+    /**
+     * Schedules a reconnect using exponential backoff with random jitter
+     * @private
+     */
+    private scheduleReconnect;
+    /**
+     * Attempts to reconnect the WebSocket
+     * @private
+     */
+    private reconnect;
+    /**
+     * Sends a message over WebSocket
+     * @private
+     */
+    private sendMessage;
+    /**
+     * Subscribe to Circles events via WebSocket
+     * @param address Optional address to filter events for a specific avatar
+     * @returns Observable that emits CirclesEvent objects
+     */
+    subscribe(address?: Address): Promise<Observable<CirclesEvent>>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmC,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACxF,OAAO,EAAE,UAAU,EAA+B,MAAM,UAAU,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG7C;;;GAGG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAa;IAG9B,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,gBAAgB,CAA2B;IACnD,OAAO,CAAC,qBAAqB,CAEtB;IAGP,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;gBAEzB,MAAM,EAAE,MAAM;IAI1B;;OAEG;IACG,IAAI,CAAC,OAAO,GAAG,OAAO,EAAE,EAAE,OAAO,GAAG,OAAO,EAC/C,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,OAAO,CAAC;IA6CnB;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;;OAGG;IACH,OAAO,CAAC,OAAO;IAiDf;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAqBzB;;;OAGG;YACW,SAAS;IAWvB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAmBnB;;;;OAIG;IACG,SAAS,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;CAsBtE"}

package/dist/client.js

@@ -0,0 +1,194 @@
+import { Observable, parseRpcSubscriptionMessage } from './events';
+import { RpcError } from './errors';
+/**
+ * Base RPC client for making JSON-RPC calls to Circles RPC endpoints
+ * Supports both HTTP requests and WebSocket subscriptions
+ */
+export class RpcClient {
+    rpcUrl;
+    requestId = 0;
+    // WebSocket fields
+    websocket = null;
+    websocketConnected = false;
+    pendingResponses = {};
+    subscriptionListeners = {};
+    // Backoff-related fields for reconnection
+    reconnectAttempt = 0;
+    initialBackoff = 2000; // 2 seconds
+    maxBackoff = 120000; // 2 minutes
+    constructor(rpcUrl) {
+        this.rpcUrl = rpcUrl;
+    }
+    /**
+     * Make a JSON-RPC call
+     */
+    async call(method, params) {
+        this.requestId++;
+        const request = {
+            jsonrpc: '2.0',
+            id: this.requestId,
+            method,
+            params,
+        };
+        try {
+            const response = await fetch(this.rpcUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(request),
+            });
+            if (!response.ok) {
+                throw RpcError.connectionFailed(this.rpcUrl, new Error(`HTTP ${response.status}: ${response.statusText}`));
+            }
+            const jsonResponse = await response.json();
+            if (jsonResponse.error) {
+                throw RpcError.fromJsonRpcError(jsonResponse.error);
+            }
+            if (jsonResponse.result === undefined) {
+                throw RpcError.invalidResponse(method, jsonResponse);
+            }
+            return jsonResponse.result;
+        }
+        catch (error) {
+            if (error instanceof RpcError) {
+                throw error;
+            }
+            throw RpcError.connectionFailed(this.rpcUrl, error);
+        }
+    }
+    /**
+     * Update the RPC URL
+     */
+    setRpcUrl(rpcUrl) {
+        this.rpcUrl = rpcUrl;
+    }
+    /**
+     * Get the current RPC URL
+     */
+    getRpcUrl() {
+        return this.rpcUrl;
+    }
+    /**
+     * Initiates a WebSocket connection
+     * @private
+     */
+    connect() {
+        return new Promise((resolve) => {
+            let wsUrl = this.rpcUrl.replace('http', 'ws');
+            if (wsUrl.endsWith('/')) {
+                wsUrl += 'ws';
+            }
+            else {
+                wsUrl += '/ws';
+            }
+            this.websocket = new WebSocket(wsUrl);
+            this.websocket.onopen = () => {
+                console.log('WebSocket connected');
+                this.websocketConnected = true;
+                // Reset the reconnect backoff attempts
+                this.reconnectAttempt = 0;
+                resolve();
+            };
+            this.websocket.onmessage = (event) => {
+                const message = JSON.parse(event.data);
+                const { id, method, params } = message;
+                if (id !== undefined && this.pendingResponses[id]) {
+                    this.pendingResponses[id].resolve(message);
+                    delete this.pendingResponses[id];
+                }
+                if (method === 'eth_subscription' && params) {
+                    const { subscription, result } = params;
+                    if (this.subscriptionListeners[subscription]) {
+                        this.subscriptionListeners[subscription].forEach(listener => listener(result));
+                    }
+                }
+            };
+            this.websocket.onclose = () => {
+                console.warn('WebSocket closed');
+                this.websocketConnected = false;
+            };
+            this.websocket.onerror = (error) => {
+                console.error('WebSocket error:', error);
+                this.websocketConnected = false;
+                // Schedule a reconnect
+                this.scheduleReconnect();
+            };
+        });
+    }
+    /**
+     * Schedules a reconnect using exponential backoff with random jitter
+     * @private
+     */
+    scheduleReconnect() {
+        // Exponential backoff: 2^attempt * initialBackoff
+        const delay = Math.min(this.initialBackoff * Math.pow(2, this.reconnectAttempt), this.maxBackoff);
+        // Add proportional jitter (between 0% and 50% of the delay)
+        const jitter = delay * (Math.random() * 0.5);
+        const timeout = delay + jitter;
+        console.log(`Reconnecting in ${Math.round(timeout)}ms (attempt #${this.reconnectAttempt + 1})`);
+        this.reconnectAttempt++;
+        setTimeout(() => {
+            this.reconnect();
+        }, timeout);
+    }
+    /**
+     * Attempts to reconnect the WebSocket
+     * @private
+     */
+    async reconnect() {
+        if (this.websocketConnected)
+            return;
+        try {
+            await this.connect();
+            console.log('Reconnection successful');
+        }
+        catch (err) {
+            console.error('Reconnection attempt failed:', err);
+            this.scheduleReconnect();
+        }
+    }
+    /**
+     * Sends a message over WebSocket
+     * @private
+     */
+    sendMessage(method, params, timeout = 5000) {
+        if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN) {
+            return Promise.reject(RpcError.connectionFailed(this.rpcUrl));
+        }
+        const id = this.requestId++;
+        const message = { jsonrpc: '2.0', method, params, id };
+        return new Promise((resolve, reject) => {
+            this.pendingResponses[id] = { resolve, reject };
+            this.websocket.send(JSON.stringify(message));
+            setTimeout(() => {
+                if (this.pendingResponses[id]) {
+                    this.pendingResponses[id].reject(RpcError.timeout(method, timeout));
+                    delete this.pendingResponses[id];
+                }
+            }, timeout);
+        });
+    }
+    /**
+     * Subscribe to Circles events via WebSocket
+     * @param address Optional address to filter events for a specific avatar
+     * @returns Observable that emits CirclesEvent objects
+     */
+    async subscribe(address) {
+        const normalizedAddress = address?.toLowerCase();
+        if (!this.websocketConnected) {
+            await this.connect();
+        }
+        const observable = Observable.create();
+        const subscriptionArgs = JSON.stringify(normalizedAddress ? { address: normalizedAddress } : {});
+        const response = await this.sendMessage('eth_subscribe', ['circles', subscriptionArgs]);
+        const subscriptionId = response.result;
+        if (!this.subscriptionListeners[subscriptionId]) {
+            this.subscriptionListeners[subscriptionId] = [];
+        }
+        this.subscriptionListeners[subscriptionId].push((events) => {
+            parseRpcSubscriptionMessage(events).forEach(event => observable.emit(event));
+        });
+        return observable.property;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,44 @@
+/**
+ * RPC Package Error Types
+ */
+import { CirclesError } from '@aboutcircles/sdk-utils';
+/**
+ * RPC-specific error sources
+ */
+export type RpcErrorSource = 'RPC_CONNECTION' | 'RPC_REQUEST' | 'RPC_RESPONSE' | 'RPC_TIMEOUT' | 'RPC_WEBSOCKET';
+/**
+ * RPC-related errors
+ */
+export declare class RpcError extends CirclesError<RpcErrorSource> {
+    constructor(message: string, options?: {
+        code?: string | number;
+        source?: RpcErrorSource;
+        cause?: unknown;
+        context?: Record<string, any>;
+    });
+    /**
+     * Create error for connection failures
+     */
+    static connectionFailed(url: string, cause?: unknown): RpcError;
+    /**
+     * Create error for timeout
+     */
+    static timeout(method: string, timeout: number): RpcError;
+    /**
+     * Create error for invalid response
+     */
+    static invalidResponse(method: string, response: any): RpcError;
+    /**
+     * Create error from JSON-RPC error response
+     */
+    static fromJsonRpcError(error: {
+        code: number;
+        message: string;
+        data?: any;
+    }): RpcError;
+    /**
+     * Create error for WebSocket failures
+     */
+    static websocketError(message: string, cause?: unknown): RpcError;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,gBAAgB,GAChB,aAAa,GACb,cAAc,GACd,aAAa,GACb,eAAe,CAAC;AAEpB;;GAEG;AACH,qBAAa,QAAS,SAAQ,YAAY,CAAC,cAAc,CAAC;gBAEtD,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QACvB,MAAM,CAAC,EAAE,cAAc,CAAC;QACxB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAC/B;IAKH;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ;IAS/D;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ;IAQzD;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,GAAG,QAAQ;IAQ/D;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,GAAG,CAAA;KAAE,GAAG,QAAQ;IAQvF;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ;CAOlE"}

package/dist/errors.js

@@ -0,0 +1,63 @@
+/**
+ * RPC Package Error Types
+ */
+import { CirclesError } from '@aboutcircles/sdk-utils';
+/**
+ * RPC-related errors
+ */
+export class RpcError extends CirclesError {
+    constructor(message, options) {
+        super('RpcError', message, { ...options, source: options?.source ?? 'RPC_REQUEST' });
+    }
+    /**
+     * Create error for connection failures
+     */
+    static connectionFailed(url, cause) {
+        return new RpcError('Failed to connect to RPC endpoint', {
+            code: 'RPC_CONNECTION_FAILED',
+            source: 'RPC_CONNECTION',
+            cause,
+            context: { url },
+        });
+    }
+    /**
+     * Create error for timeout
+     */
+    static timeout(method, timeout) {
+        return new RpcError('RPC request timed out', {
+            code: 'RPC_TIMEOUT',
+            source: 'RPC_TIMEOUT',
+            context: { method, timeout },
+        });
+    }
+    /**
+     * Create error for invalid response
+     */
+    static invalidResponse(method, response) {
+        return new RpcError('Invalid RPC response', {
+            code: 'RPC_INVALID_RESPONSE',
+            source: 'RPC_RESPONSE',
+            context: { method, response },
+        });
+    }
+    /**
+     * Create error from JSON-RPC error response
+     */
+    static fromJsonRpcError(error) {
+        return new RpcError(error.message, {
+            code: error.code,
+            source: 'RPC_RESPONSE',
+            context: { data: error.data },
+        });
+    }
+    /**
+     * Create error for WebSocket failures
+     */
+    static websocketError(message, cause) {
+        return new RpcError(message, {
+            code: 'RPC_WEBSOCKET_ERROR',
+            source: 'RPC_WEBSOCKET',
+            cause,
+        });
+    }
+}

package/dist/events/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Event observation and subscription system
+ */
+export type { CirclesEvent, CirclesEventType, CirclesBaseEvent, CirclesEventOfType, RpcSubscriptionEvent, } from './types';
+export { isCirclesEvent } from './types';
+export { parseRpcEvent, parseRpcSubscriptionMessage } from './parser';
+export { Observable } from './observable';
+//# sourceMappingURL=index.d.ts.map

package/dist/events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/events/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAGzC,OAAO,EAAE,aAAa,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAC;AAGtE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/dist/events/index.js

@@ -0,0 +1,8 @@
+/**
+ * Event observation and subscription system
+ */
+export { isCirclesEvent } from './types';
+// Parser
+export { parseRpcEvent, parseRpcSubscriptionMessage } from './parser';
+// Observable
+export { Observable } from './observable';

package/dist/events/observable.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Observable class for event streaming
+ * Provides a simple publish-subscribe pattern for Circles events
+ */
+export declare class Observable<TEvent> {
+    private readonly _subscribers;
+    /**
+     * Subscribe to events
+     * @param subscriber Callback function to be called for each event
+     * @returns Unsubscribe function to stop receiving events
+     */
+    subscribe(subscriber: (value: TEvent) => void): () => void;
+    protected constructor();
+    protected emit(value: TEvent): void;
+    /**
+     * Create a new Observable with an emitter
+     */
+    static create<T>(): {
+        property: Observable<T>;
+        emit: (e: T) => void;
+    };
+}
+//# sourceMappingURL=observable.d.ts.map

package/dist/events/observable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../../src/events/observable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,UAAU,CAAC,MAAM;IAC5B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAEhE;;;;OAIG;IACH,SAAS,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI;IAU1D,SAAS;IAIT,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM;IAI5B;;OAEG;WACW,MAAM,CAAC,CAAC,KAAK;QAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;QAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAA;KAAE;CAO7E"}

package/dist/events/observable.js

@@ -0,0 +1,37 @@
+/**
+ * Observable class for event streaming
+ * Provides a simple publish-subscribe pattern for Circles events
+ */
+export class Observable {
+    _subscribers = [];
+    /**
+     * Subscribe to events
+     * @param subscriber Callback function to be called for each event
+     * @returns Unsubscribe function to stop receiving events
+     */
+    subscribe(subscriber) {
+        this._subscribers.push(subscriber);
+        return () => {
+            const index = this._subscribers.indexOf(subscriber);
+            if (index > -1) {
+                this._subscribers.splice(index, 1);
+            }
+        };
+    }
+    constructor() {
+        this._subscribers = [];
+    }
+    emit(value) {
+        this._subscribers.forEach(sub => sub(value));
+    }
+    /**
+     * Create a new Observable with an emitter
+     */
+    static create() {
+        const observable = new Observable();
+        return {
+            property: observable,
+            emit: (e) => observable.emit(e)
+        };
+    }
+}

package/dist/events/parser.d.ts

@@ -0,0 +1,10 @@
+import type { CirclesEvent, RpcSubscriptionEvent } from './types';
+/**
+ * Parse a single RPC subscription event into a CirclesEvent
+ */
+export declare function parseRpcEvent(rpcEvent: RpcSubscriptionEvent): CirclesEvent;
+/**
+ * Parse an array of RPC subscription events
+ */
+export declare function parseRpcSubscriptionMessage(message: RpcSubscriptionEvent[]): CirclesEvent[];
+//# sourceMappingURL=parser.d.ts.map

package/dist/events/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/events/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAgFlE;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,oBAAoB,GAAG,YAAY,CAwB1E;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,YAAY,EAAE,CAE3F"}