@vultisig/rujira 1.0.0

package/dist/discovery/discovery.js

@@ -0,0 +1,250 @@
+import { MAINNET_CONFIG } from '../config.js';
+import { DEFAULT_MAKER_FEE, DEFAULT_TAKER_FEE } from '../config/constants.js';
+import { thornodeRateLimiter } from '../utils/rate-limiter.js';
+import { GraphQLClient } from './graphql-client.js';
+export class RujiraDiscovery {
+    constructor(options = {}) {
+        this.cache = null;
+        this.pendingDiscovery = null;
+        const networkConfig = MAINNET_CONFIG;
+        this.rpcEndpoint = options.rpcEndpoint || networkConfig.rpcEndpoint;
+        this.cacheTtl = options.cacheTtl ?? 5 * 60 * 1000;
+        this.debug = options.debug || false;
+        this.finCodeId = networkConfig.contracts.finCodeId;
+        // Mainnet-only GraphQL endpoints
+        this.graphql = new GraphQLClient({
+            httpEndpoint: 'https://api.rujira.network/api/graphql',
+            wsEndpoint: 'wss://api.rujira.network/socket',
+            ...options.graphql,
+        });
+    }
+    async discoverContracts(forceRefresh = false) {
+        if (!forceRefresh && this.cache && this.isCacheValid()) {
+            this.log('Using cached contracts');
+            return this.cache;
+        }
+        if (this.pendingDiscovery) {
+            this.log('Discovery already in progress, waiting for existing request...');
+            return this.pendingDiscovery;
+        }
+        this.log('Discovering contracts...');
+        this.pendingDiscovery = this.performDiscovery();
+        try {
+            return await this.pendingDiscovery;
+        }
+        finally {
+            this.pendingDiscovery = null;
+        }
+    }
+    async performDiscovery() {
+        try {
+            const contracts = await this.discoverViaGraphQL();
+            this.cache = contracts;
+            return contracts;
+        }
+        catch (error) {
+            this.log('GraphQL discovery failed, analyzing error...', error);
+            if (!this.shouldFallbackToChain(error)) {
+                this.log('Error is not recoverable, failing without fallback');
+                throw error;
+            }
+            this.log('Error is recoverable, trying chain query fallback...');
+            try {
+                const contracts = await this.discoverViaChain();
+                this.cache = contracts;
+                return contracts;
+            }
+            catch (chainError) {
+                this.log('Chain discovery also failed', chainError);
+                if (error instanceof GraphQLClient.GraphQLError && error.type === 'auth') {
+                    throw error;
+                }
+                return {
+                    fin: {},
+                    discoveredAt: Date.now(),
+                    source: 'fallback-failed',
+                    lastError: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }
+    }
+    shouldFallbackToChain(error) {
+        if (error instanceof GraphQLClient.GraphQLError) {
+            switch (error.type) {
+                case 'auth':
+                    return false;
+                default:
+                    return true;
+            }
+        }
+        return true;
+    }
+    async findMarket(baseAsset, quoteAsset) {
+        try {
+            const market = await this.graphql.getMarket(baseAsset, quoteAsset);
+            if (market) {
+                return this.transformMarket(market);
+            }
+            const reverseMarket = await this.graphql.getMarket(quoteAsset, baseAsset);
+            if (reverseMarket) {
+                return this.transformMarket(reverseMarket);
+            }
+            return null;
+        }
+        catch (error) {
+            this.log('findMarket failed', error);
+            const contracts = await this.discoverContracts();
+            const pairKey = `${baseAsset}/${quoteAsset}`;
+            const reversePairKey = `${quoteAsset}/${baseAsset}`;
+            const address = contracts.fin[pairKey] || contracts.fin[reversePairKey];
+            if (address) {
+                return {
+                    address,
+                    baseAsset,
+                    quoteAsset,
+                    baseDenom: '',
+                    quoteDenom: '',
+                    tick: '0',
+                    takerFee: DEFAULT_TAKER_FEE,
+                    makerFee: DEFAULT_MAKER_FEE,
+                    active: true,
+                };
+            }
+            return null;
+        }
+    }
+    async getContractAddress(baseAsset, quoteAsset) {
+        const market = await this.findMarket(baseAsset, quoteAsset);
+        return market?.address || null;
+    }
+    async listMarkets() {
+        try {
+            const response = await this.graphql.getMarkets();
+            return response.markets.map(m => this.transformMarket(m));
+        }
+        catch (error) {
+            this.log('listMarkets failed', error);
+            return [];
+        }
+    }
+    clearCache() {
+        this.cache = null;
+    }
+    getCacheTtl() {
+        return this.cacheTtl;
+    }
+    getCacheStatus() {
+        const ttl = this.cacheTtl;
+        if (!this.cache) {
+            return { cached: false, valid: false, ttl };
+        }
+        const age = Date.now() - this.cache.discoveredAt;
+        const valid = this.isCacheValid();
+        return { cached: true, age, valid, ttl };
+    }
+    async discoverViaGraphQL() {
+        const response = await this.graphql.getMarkets();
+        const fin = {};
+        for (const market of response.markets) {
+            const pairKey = `${market.denoms.base}/${market.denoms.quote}`;
+            fin[pairKey] = market.address;
+        }
+        return {
+            fin,
+            discoveredAt: Date.now(),
+            source: 'graphql',
+        };
+    }
+    async discoverViaChain() {
+        const fin = {};
+        const baseUrl = this.rpcEndpoint.replace(':26657', '').replace('rpc', 'thornode');
+        const restUrl = baseUrl.includes('thornode') ? baseUrl : 'https://thornode.ninerealms.com';
+        try {
+            // Paginate through all contracts for this code ID
+            const PAGE_SIZE = 50;
+            const allContracts = [];
+            let nextKey = null;
+            do {
+                let url = `${restUrl}/cosmwasm/wasm/v1/code/${this.finCodeId}/contracts?pagination.limit=${PAGE_SIZE}`;
+                if (nextKey) {
+                    url += `&pagination.key=${encodeURIComponent(nextKey)}`;
+                }
+                const contractsResponse = await thornodeRateLimiter.fetch(url);
+                if (!contractsResponse.ok) {
+                    throw new Error(`Failed to fetch contracts: ${contractsResponse.status}`);
+                }
+                const page = (await contractsResponse.json());
+                allContracts.push(...page.contracts);
+                nextKey = page.pagination?.next_key || null;
+                this.log(`Fetched ${page.contracts.length} contracts (total: ${allContracts.length})`);
+            } while (nextKey);
+            const addresses = allContracts;
+            this.log(`Found ${addresses.length} FIN contracts total`);
+            // Query contract configs in parallel with concurrency cap
+            const CONCURRENCY = 5;
+            for (let i = 0; i < addresses.length; i += CONCURRENCY) {
+                const batch = addresses.slice(i, i + CONCURRENCY);
+                const results = await Promise.allSettled(batch.map(async (address) => {
+                    const configResponse = await thornodeRateLimiter.fetch(`${restUrl}/cosmwasm/wasm/v1/contract/${address}/smart/eyJjb25maWciOnt9fQ==`);
+                    if (!configResponse.ok)
+                        return null;
+                    const configData = (await configResponse.json());
+                    if (configData.data?.denoms?.length === 2) {
+                        const base = this.normalizeDenom(configData.data.denoms[0]);
+                        const quote = this.normalizeDenom(configData.data.denoms[1]);
+                        return { pairKey: `${base}/${quote}`, address };
+                    }
+                    return null;
+                }));
+                for (const result of results) {
+                    if (result.status === 'fulfilled' && result.value) {
+                        fin[result.value.pairKey] = result.value.address;
+                        this.log(`Discovered: ${result.value.pairKey} -> ${result.value.address.slice(0, 20)}...`);
+                    }
+                    else if (result.status === 'rejected') {
+                        this.log('Failed to query contract config:', result.reason);
+                    }
+                }
+            }
+            this.log(`Chain discovery complete: ${Object.keys(fin).length} markets`);
+        }
+        catch (error) {
+            this.log('Chain discovery failed:', error);
+        }
+        return {
+            fin,
+            discoveredAt: Date.now(),
+            source: 'chain',
+        };
+    }
+    normalizeDenom(denom) {
+        return denom.toLowerCase();
+    }
+    transformMarket(market) {
+        const baseDenom = market.denoms.base.toLowerCase();
+        const quoteDenom = market.denoms.quote.toLowerCase();
+        return {
+            address: market.address,
+            baseAsset: baseDenom,
+            quoteAsset: quoteDenom,
+            baseDenom,
+            quoteDenom,
+            tick: market.config?.tick || '0',
+            takerFee: market.config?.fee_taker || DEFAULT_TAKER_FEE,
+            makerFee: market.config?.fee_maker || DEFAULT_MAKER_FEE,
+            active: true,
+        };
+    }
+    isCacheValid() {
+        if (!this.cache)
+            return false;
+        if (this.cacheTtl === 0)
+            return false;
+        return Date.now() - this.cache.discoveredAt < this.cacheTtl;
+    }
+    log(...args) {
+        if (this.debug) {
+            console.log('[RujiraDiscovery]', ...args);
+        }
+    }
+}

package/dist/discovery/graphql-client.d.ts

@@ -0,0 +1,46 @@
+import type { GraphQLMarketsResponse } from './types.js';
+export type GraphQLClientOptions = {
+    wsEndpoint?: string;
+    httpEndpoint?: string;
+    apiKey?: string;
+    timeout?: number;
+    /** Max retries on transient (5xx/network) errors. Default: 3 */
+    maxRetries?: number;
+};
+export declare class GraphQLClient {
+    private httpEndpoint;
+    private wsEndpoint;
+    private apiKey?;
+    private timeout;
+    private maxRetries;
+    /** Backoff schedule in ms for each retry attempt */
+    private static readonly RETRY_BACKOFF_MS;
+    constructor(options?: GraphQLClientOptions);
+    static GraphQLError: {
+        new (message: string, type: "network" | "server" | "graphql" | "timeout" | "auth" | "unknown", status?: number | undefined, graphqlErrors?: Array<{
+            message: string;
+            extensions?: Record<string, unknown>;
+        }> | undefined): {
+            readonly type: "network" | "server" | "graphql" | "timeout" | "auth" | "unknown";
+            readonly status?: number | undefined;
+            readonly graphqlErrors?: Array<{
+                message: string;
+                extensions?: Record<string, unknown>;
+            }> | undefined;
+            name: string;
+            message: string;
+            stack?: string;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    /** Returns true if the error type is eligible for retry (transient failures only). */
+    private static isRetryable;
+    query<T = unknown>(query: string, variables?: Record<string, unknown>): Promise<T>;
+    private executeQuery;
+    getMarkets(): Promise<GraphQLMarketsResponse>;
+    getMarket(baseAsset: string, quoteAsset: string): Promise<GraphQLMarketsResponse['markets'][0] | null>;
+    getWsEndpoint(): string;
+}
+//# sourceMappingURL=graphql-client.d.ts.map

package/dist/discovery/graphql-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-client.d.ts","sourceRoot":"","sources":["../../src/discovery/graphql-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAExD,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,MAAM,CAAC,CAAQ;IACvB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,UAAU,CAAQ;IAE1B,oDAAoD;IACpD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAoB;gBAEhD,OAAO,GAAE,oBAAyB;IAQ9C,MAAM,CAAC,YAAY;sBAEN,MAAM,QACO,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,WAC9D,MAAM,8BACC,KAAK,CAAC;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;SAAE,CAAC;2BAF1E,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS;8BAC9D,MAAM;qCACC,KAAK,CAAC;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;aAAE,CAAC;;;;;;;;MAKnG;IAED,sFAAsF;IACtF,OAAO,CAAC,MAAM,CAAC,WAAW;IAIpB,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;YA0B1E,YAAY;IA2FpB,UAAU,IAAI,OAAO,CAAC,sBAAsB,CAAC;IA6C7C,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAY5G,aAAa,IAAI,MAAM;CAGxB"}

package/dist/discovery/graphql-client.js

@@ -0,0 +1,137 @@
+export class GraphQLClient {
+    constructor(options = {}) {
+        this.httpEndpoint = options.httpEndpoint || 'https://api.rujira.network/api/graphql';
+        this.wsEndpoint = options.wsEndpoint || 'wss://api.rujira.network/socket';
+        this.apiKey = options.apiKey;
+        this.timeout = options.timeout || 30000;
+        this.maxRetries = options.maxRetries ?? 3;
+    }
+    /** Returns true if the error type is eligible for retry (transient failures only). */
+    static isRetryable(error) {
+        return error.type === 'server' || (error.type === 'network' && error.status !== 429);
+    }
+    async query(query, variables) {
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            if (attempt > 0 && lastError) {
+                const backoff = GraphQLClient.RETRY_BACKOFF_MS[attempt - 1] ?? 2000;
+                await new Promise(resolve => setTimeout(resolve, backoff));
+            }
+            try {
+                return await this.executeQuery(query, variables);
+            }
+            catch (error) {
+                if (!(error instanceof GraphQLClient.GraphQLError))
+                    throw error;
+                lastError = error;
+                // Only retry on transient (5xx / network) failures
+                if (!GraphQLClient.isRetryable(error) || attempt === this.maxRetries) {
+                    throw error;
+                }
+            }
+        }
+        // Unreachable, but satisfies TypeScript
+        throw lastError;
+    }
+    async executeQuery(query, variables) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (this.apiKey) {
+                headers['Authorization'] = `Bearer ${this.apiKey}`;
+            }
+            const response = await fetch(this.httpEndpoint, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ query, variables }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                if (response.status === 401 || response.status === 403) {
+                    throw new GraphQLClient.GraphQLError(`Authentication failed: ${response.status} ${response.statusText}`, 'auth', response.status);
+                }
+                if (response.status === 429) {
+                    throw new GraphQLClient.GraphQLError(`Rate limited by Rujira API: ${response.status} ${response.statusText}. ` +
+                        'Provide an API token (RujiraClientOptions.apiKey / GraphQLClientOptions.apiKey) to increase limits.', 'network', response.status);
+                }
+                if (response.status >= 500) {
+                    throw new GraphQLClient.GraphQLError(`Server error: ${response.status} ${response.statusText}`, 'server', response.status);
+                }
+                throw new GraphQLClient.GraphQLError(`GraphQL request failed: ${response.status} ${response.statusText}`, 'network', response.status);
+            }
+            const result = (await response.json());
+            if (result.errors && result.errors.length > 0) {
+                throw new GraphQLClient.GraphQLError(`GraphQL errors: ${result.errors.map(e => e.message).join(', ')}`, 'graphql', undefined, result.errors);
+            }
+            return result.data;
+        }
+        catch (error) {
+            if (error instanceof GraphQLClient.GraphQLError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new GraphQLClient.GraphQLError(`GraphQL request timed out after ${this.timeout}ms`, 'timeout');
+            }
+            throw new GraphQLClient.GraphQLError(`GraphQL request failed: ${error instanceof Error ? error.message : String(error)}`, 'unknown');
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async getMarkets() {
+        const query = `
+      query FinMarkets {
+        fin {
+          address
+          assetBase {
+            asset
+          }
+          assetQuote {
+            asset
+          }
+          tick
+          feeTaker
+          feeMaker
+        }
+      }
+    `;
+        const result = await this.query(query);
+        return {
+            markets: result.fin.map(m => ({
+                address: m.address,
+                denoms: {
+                    base: m.assetBase.asset.toLowerCase(),
+                    quote: m.assetQuote.asset.toLowerCase(),
+                },
+                config: {
+                    tick: m.tick,
+                    fee_taker: m.feeTaker,
+                    fee_maker: m.feeMaker,
+                },
+            })),
+        };
+    }
+    async getMarket(baseAsset, quoteAsset) {
+        const allMarkets = await this.getMarkets();
+        const market = allMarkets.markets.find(m => (m.denoms.base === baseAsset && m.denoms.quote === quoteAsset) ||
+            (m.denoms.base === quoteAsset && m.denoms.quote === baseAsset));
+        return market || null;
+    }
+    getWsEndpoint() {
+        return this.wsEndpoint;
+    }
+}
+/** Backoff schedule in ms for each retry attempt */
+GraphQLClient.RETRY_BACKOFF_MS = [500, 1000, 2000];
+GraphQLClient.GraphQLError = class extends Error {
+    constructor(message, type, status, graphqlErrors) {
+        super(message);
+        this.type = type;
+        this.status = status;
+        this.graphqlErrors = graphqlErrors;
+        this.name = 'GraphQLError';
+    }
+};

package/dist/discovery/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Contract discovery module for Rujira SDK
+ * Discovers FIN contract addresses via Rujira GraphQL API
+ * @module discovery
+ */
+export { type DiscoveryOptions, RujiraDiscovery } from './discovery.js';
+export { GraphQLClient, type GraphQLClientOptions } from './graphql-client.js';
+export type { DiscoveredContracts, Market } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/discovery/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAC9E,YAAY,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA"}

package/dist/discovery/index.js

@@ -0,0 +1,7 @@
+/**
+ * Contract discovery module for Rujira SDK
+ * Discovers FIN contract addresses via Rujira GraphQL API
+ * @module discovery
+ */
+export { RujiraDiscovery } from './discovery.js';
+export { GraphQLClient } from './graphql-client.js';

package/dist/discovery/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Discovery types
+ * @module discovery/types
+ */
+/**
+ * Market/trading pair from Rujira API
+ */
+export type Market = {
+    /** FIN contract address */
+    address: string;
+    /** Base asset (e.g., "BTC.BTC") */
+    baseAsset: string;
+    /** Quote asset (e.g., "THOR.RUNE") */
+    quoteAsset: string;
+    /** Base asset denom */
+    baseDenom: string;
+    /** Quote asset denom */
+    quoteDenom: string;
+    /** Tick size */
+    tick: string;
+    /** Taker fee */
+    takerFee: string;
+    /** Maker fee */
+    makerFee: string;
+    /** Whether market is active */
+    active: boolean;
+};
+/**
+ * Discovered contracts result
+ */
+export type DiscoveredContracts = {
+    /** FIN contracts by pair key (e.g., "BTC.BTC/THOR.RUNE") */
+    fin: Record<string, string>;
+    /** BOW (AMM) contracts if discovered */
+    bow?: Record<string, string>;
+    /** Other contracts */
+    other?: Record<string, string>;
+    /** Discovery timestamp */
+    discoveredAt: number;
+    /** Source of discovery */
+    source: 'graphql' | 'chain' | 'cache' | 'fallback-failed';
+    /** Last error message if discovery failed */
+    lastError?: string;
+};
+/**
+ * GraphQL market response
+ */
+export type GraphQLMarketsResponse = {
+    markets: Array<{
+        address: string;
+        denoms: {
+            base: string;
+            quote: string;
+        };
+        config?: {
+            tick?: string;
+            fee_taker?: string;
+            fee_maker?: string;
+        };
+    }>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/discovery/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/discovery/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,uBAAuB;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,wBAAwB;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,+BAA+B;IAC/B,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,4DAA4D;IAC5D,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3B,wCAAwC;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,sBAAsB;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,0BAA0B;IAC1B,YAAY,EAAE,MAAM,CAAA;IACpB,0BAA0B;IAC1B,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,iBAAiB,CAAA;IACzD,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,KAAK,CAAC;QACb,OAAO,EAAE,MAAM,CAAA;QACf,MAAM,EAAE;YACN,IAAI,EAAE,MAAM,CAAA;YACZ,KAAK,EAAE,MAAM,CAAA;SACd,CAAA;QACD,MAAM,CAAC,EAAE;YACP,IAAI,CAAC,EAAE,MAAM,CAAA;YACb,SAAS,CAAC,EAAE,MAAM,CAAA;YAClB,SAAS,CAAC,EAAE,MAAM,CAAA;SACnB,CAAA;KACF,CAAC,CAAA;CACH,CAAA"}

package/dist/discovery/types.js

@@ -0,0 +1,5 @@
+/**
+ * Discovery types
+ * @module discovery/types
+ */
+export {};