@raintree-technology/perps 0.1.0

package/dist/adapters/certification.d.ts

@@ -0,0 +1,33 @@
+import { type CapabilityLevel, type PerpDEXAdapter } from "./index.js";
+export declare const ADAPTER_CAPABILITIES_SCHEMA_VERSION = 1;
+type CapabilityCategory = "marketData" | "authenticatedReads" | "orderLifecycle" | "orderCancellation" | "subscriptions" | "advancedTrading";
+interface CapabilityMethodProbe {
+    method: string;
+    implemented: boolean;
+    reason?: string;
+}
+interface CapabilityProbeResult {
+    category: CapabilityCategory;
+    level: CapabilityLevel;
+    implemented: number;
+    total: number;
+    methods: CapabilityMethodProbe[];
+}
+interface ErrorSemanticsResult {
+    ok: boolean;
+    issues: string[];
+}
+export interface AdapterCertificationResult {
+    id: string;
+    name: string;
+    capabilities: Record<CapabilityCategory, CapabilityProbeResult>;
+    errorSemantics: ErrorSemanticsResult;
+}
+export interface AdapterCapabilityReport {
+    schemaVersion: number;
+    generatedAt: number;
+    exchanges: AdapterCertificationResult[];
+}
+export declare function certifyAdapter(adapter: PerpDEXAdapter): AdapterCertificationResult;
+export declare function generateAdapterCapabilityReport(): AdapterCapabilityReport;
+export {};

package/dist/adapters/certification.js

@@ -0,0 +1,99 @@
+import { getAdapter, listAdapters } from "./index.js";
+export const ADAPTER_CAPABILITIES_SCHEMA_VERSION = 1;
+const UNIMPLEMENTED_PATTERN = /(not yet implemented|not implemented|not yet integrated|not integrated|todo:\s*implement)/i;
+const CAPABILITY_CATEGORIES = [
+    "marketData",
+    "authenticatedReads",
+    "orderLifecycle",
+    "orderCancellation",
+    "subscriptions",
+    "advancedTrading",
+];
+const CATEGORY_METHODS = {
+    marketData: ["getMarkets", "getTicker", "getOrderBook", "getFundingRate", "getPublicTrades"],
+    authenticatedReads: ["getPositions", "getOrders", "getBalances", "getTrades", "getOrderHistory", "getFundingHistory"],
+    orderLifecycle: ["placeOrder", "getOrder", "getOrders", "modifyOrder"],
+    orderCancellation: ["cancelOrder", "cancelAllOrders", "cancelAllAfter"],
+    subscriptions: ["subscribe", "subscribeOrderBook", "subscribeTicker"],
+    advancedTrading: ["modifyOrder", "batchPlaceOrders", "batchCancelOrders", "cancelAllAfter", "getOrderHistory", "getFundingHistory", "getPublicTrades", "setMMP", "getMMP", "resetMMP", "placeTWAP", "cancelTWAP", "getTWAPStatus", "updateIsolatedMargin"],
+};
+function methodLooksImplemented(method) {
+    if (typeof method !== "function") {
+        return { method: "unknown", implemented: false, reason: "method missing" };
+    }
+    const source = method.toString();
+    const unimplementedMatch = source.match(UNIMPLEMENTED_PATTERN);
+    if (unimplementedMatch) {
+        return {
+            method: "unknown",
+            implemented: false,
+            reason: `explicit "${unimplementedMatch[0]}" marker`,
+        };
+    }
+    return { method: "unknown", implemented: true };
+}
+function getCapabilityLevel(implemented, total) {
+    if (implemented <= 0)
+        return "none";
+    if (implemented >= total)
+        return "full";
+    return "partial";
+}
+function certifyCategory(adapter, category) {
+    const methods = CATEGORY_METHODS[category].map((methodName) => {
+        const probe = methodLooksImplemented(adapter[methodName]);
+        return {
+            method: methodName,
+            implemented: probe.implemented,
+            reason: probe.reason,
+        };
+    });
+    const implemented = methods.filter((m) => m.implemented).length;
+    const total = methods.length;
+    return {
+        category,
+        level: getCapabilityLevel(implemented, total),
+        implemented,
+        total,
+        methods,
+    };
+}
+function certifyErrorSemantics(capabilities) {
+    const issues = [];
+    for (const category of CAPABILITY_CATEGORIES) {
+        const probes = capabilities[category].methods;
+        for (const probe of probes) {
+            if (!probe.implemented && !probe.reason) {
+                issues.push(`${probe.method}: missing unimplemented reason`);
+            }
+        }
+    }
+    return {
+        ok: issues.length === 0,
+        issues,
+    };
+}
+export function certifyAdapter(adapter) {
+    const capabilities = CAPABILITY_CATEGORIES.reduce((acc, category) => {
+        acc[category] = certifyCategory(adapter, category);
+        return acc;
+    }, {});
+    return {
+        id: adapter.info.id,
+        name: adapter.info.name,
+        capabilities,
+        errorSemantics: certifyErrorSemantics(capabilities),
+    };
+}
+export function generateAdapterCapabilityReport() {
+    const exchanges = listAdapters()
+        .map((exchangeId) => getAdapter(exchangeId))
+        .filter((adapter) => adapter !== null)
+        .map((adapter) => certifyAdapter(adapter))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    return {
+        schemaVersion: ADAPTER_CAPABILITIES_SCHEMA_VERSION,
+        generatedAt: Date.now(),
+        exchanges,
+    };
+}

package/dist/adapters/decibel/order-manager.d.ts

@@ -0,0 +1,45 @@
+import type { Hex } from "viem";
+export interface DecibelExecutionMarket {
+    marketName: string;
+    marketAddr: string;
+    pxDecimals: number;
+    szDecimals: number;
+    tickSize: bigint;
+    lotSize: bigint;
+    minSize: bigint;
+}
+export interface PlaceDecibelOrderParams {
+    market: DecibelExecutionMarket;
+    side: "buy" | "sell";
+    price: number;
+    sizeUnits: number;
+    timeInForce?: 0 | 1 | 2;
+    reduceOnly?: boolean;
+    clientOrderId?: string;
+    stopPrice?: number;
+    tpTriggerPrice?: number;
+    tpLimitPrice?: number;
+    slTriggerPrice?: number;
+    slLimitPrice?: number;
+    builderAddr?: string;
+    builderFeeBps?: number;
+}
+export interface DecibelOrderManagerConfig {
+    fullnodeUrl: string;
+    network: "testnet" | "mainnet";
+    packageAddress: string;
+    privateKey: Hex;
+    subaccountAddress: string;
+}
+export declare class DecibelOrderManager {
+    private readonly aptos;
+    private readonly account;
+    private readonly packageAddress;
+    private subaccountAddress;
+    constructor(config: DecibelOrderManagerConfig);
+    setSubaccount(addr: string): void;
+    placeOrder(params: PlaceDecibelOrderParams): Promise<string>;
+    cancelOrder(orderId: string, marketAddr: string): Promise<string>;
+    cancelAllOrders(marketAddr: string): Promise<string>;
+    configureUserSettingsForMarket(marketAddr: string, isCross: boolean, userLeverageBps: number): Promise<string>;
+}

package/dist/adapters/decibel/order-manager.js

@@ -0,0 +1,140 @@
+import { Aptos, AptosConfig, Ed25519Account, Ed25519PrivateKey, Network, } from "@aptos-labs/ts-sdk";
+import { createLogger } from "../../lib/logger.js";
+const log = createLogger("decibel:orders");
+export class DecibelOrderManager {
+    aptos;
+    account;
+    packageAddress;
+    subaccountAddress;
+    constructor(config) {
+        const aptosConfig = new AptosConfig({
+            network: config.network === "mainnet" ? Network.MAINNET : Network.TESTNET,
+            fullnode: config.fullnodeUrl,
+        });
+        this.aptos = new Aptos(aptosConfig);
+        this.account = new Ed25519Account({
+            privateKey: new Ed25519PrivateKey(config.privateKey),
+        });
+        this.packageAddress = config.packageAddress;
+        this.subaccountAddress = config.subaccountAddress;
+    }
+    setSubaccount(addr) {
+        this.subaccountAddress = addr;
+    }
+    async placeOrder(params) {
+        const { market, side, price, sizeUnits, timeInForce = 0, reduceOnly = false, clientOrderId, stopPrice, tpTriggerPrice, tpLimitPrice, slTriggerPrice, slLimitPrice, builderAddr, builderFeeBps, } = params;
+        const chainPrice = formatPrice(price, market);
+        const chainSize = formatSize(sizeUnits, market);
+        const isBuy = side === "buy";
+        const payload = {
+            function: `${this.packageAddress}::dex_accounts::place_order_to_subaccount`,
+            typeArguments: [],
+            functionArguments: [
+                this.subaccountAddress,
+                market.marketAddr,
+                chainPrice.toString(),
+                chainSize.toString(),
+                isBuy,
+                timeInForce,
+                reduceOnly,
+                clientOrderId ?? null,
+                stopPrice != null ? formatPrice(stopPrice, market).toString() : null,
+                tpTriggerPrice != null ? formatPrice(tpTriggerPrice, market).toString() : null,
+                tpLimitPrice != null ? formatPrice(tpLimitPrice, market).toString() : null,
+                slTriggerPrice != null ? formatPrice(slTriggerPrice, market).toString() : null,
+                slLimitPrice != null ? formatPrice(slLimitPrice, market).toString() : null,
+                builderAddr ?? null,
+                builderFeeBps ?? null,
+            ],
+        };
+        const tx = await this.aptos.transaction.build.simple({
+            sender: this.account.accountAddress,
+            data: payload,
+        });
+        const pending = await this.aptos.signAndSubmitTransaction({
+            signer: this.account,
+            transaction: tx,
+        });
+        log.info("Decibel order submitted", {
+            txHash: pending.hash,
+            market: market.marketName,
+            side,
+            price,
+            size: sizeUnits,
+            tif: timeInForce,
+            reduceOnly,
+        });
+        return pending.hash;
+    }
+    async cancelOrder(orderId, marketAddr) {
+        const payload = {
+            function: `${this.packageAddress}::dex_accounts::cancel_order_to_subaccount`,
+            typeArguments: [],
+            functionArguments: [this.subaccountAddress, orderId, marketAddr],
+        };
+        const tx = await this.aptos.transaction.build.simple({
+            sender: this.account.accountAddress,
+            data: payload,
+        });
+        const pending = await this.aptos.signAndSubmitTransaction({
+            signer: this.account,
+            transaction: tx,
+        });
+        log.info("Decibel order cancel submitted", { txHash: pending.hash, orderId });
+        return pending.hash;
+    }
+    async cancelAllOrders(marketAddr) {
+        const payload = {
+            function: `${this.packageAddress}::dex_accounts::cancel_bulk_order_to_subaccount`,
+            typeArguments: [],
+            functionArguments: [this.subaccountAddress, marketAddr],
+        };
+        const tx = await this.aptos.transaction.build.simple({
+            sender: this.account.accountAddress,
+            data: payload,
+        });
+        const pending = await this.aptos.signAndSubmitTransaction({
+            signer: this.account,
+            transaction: tx,
+        });
+        log.info("Decibel cancel-all submitted", { txHash: pending.hash, marketAddr });
+        return pending.hash;
+    }
+    async configureUserSettingsForMarket(marketAddr, isCross, userLeverageBps) {
+        const leverageBps = Math.max(1, Math.round(userLeverageBps));
+        const payload = {
+            function: `${this.packageAddress}::dex_accounts::configure_user_settings_for_market`,
+            typeArguments: [],
+            functionArguments: [this.subaccountAddress, marketAddr, isCross, leverageBps],
+        };
+        const tx = await this.aptos.transaction.build.simple({
+            sender: this.account.accountAddress,
+            data: payload,
+        });
+        const pending = await this.aptos.signAndSubmitTransaction({
+            signer: this.account,
+            transaction: tx,
+        });
+        log.info("Decibel user settings update submitted", {
+            txHash: pending.hash,
+            marketAddr,
+            isCross,
+            userLeverageBps: leverageBps,
+        });
+        return pending.hash;
+    }
+}
+function decimalToChainUnits(amount, decimals) {
+    return BigInt(Math.round(amount * 10 ** decimals));
+}
+function formatPrice(price, market) {
+    const raw = decimalToChainUnits(price, market.pxDecimals);
+    const tick = market.tickSize;
+    return (raw / tick) * tick;
+}
+function formatSize(size, market) {
+    const raw = decimalToChainUnits(size, market.szDecimals);
+    const lot = market.lotSize;
+    const rounded = (raw / lot) * lot;
+    return rounded < market.minSize ? market.minSize : rounded;
+}

package/dist/adapters/decibel/rest-client.d.ts

@@ -0,0 +1,176 @@
+export interface DecibelMarketResponse {
+    market_name: string;
+    market_addr: string;
+    max_leverage: number | string;
+    px_decimals: number | string;
+    sz_decimals: number | string;
+    tick_size: string | number;
+    lot_size: string | number;
+    min_size: string | number;
+    market_mode: "Open" | "ReduceOnly" | "CloseOnly" | string;
+}
+export interface DecibelPriceResponse {
+    market: string;
+    oracle_px: number | string;
+    mark_px: number | string;
+    mid_px: number | string;
+    funding_rate_bps: number | string;
+    open_interest: number | string;
+    transaction_unix_ms?: number | string;
+}
+export interface DecibelDepthLevel {
+    price: number | string;
+    size: number | string;
+}
+export interface DecibelDepthResponse {
+    market: string;
+    bids: DecibelDepthLevel[];
+    asks: DecibelDepthLevel[];
+    unix_ms?: number | string;
+}
+export interface DecibelAccountOverviewResponse {
+    equity?: number | string;
+    perp_equity_balance?: number | string;
+    total_collateral?: number | string;
+    total_margin?: number | string;
+    unrealized_pnl?: number | string;
+    realized_pnl?: number | string;
+    margin_utilization?: number | string;
+    cross_margin_ratio?: number | string;
+}
+export interface DecibelAccountPositionResponse {
+    market_name?: string;
+    market?: string;
+    size: number | string;
+    entry_price: number | string;
+    mark_price?: number | string;
+    oracle_price?: number | string;
+    unrealized_pnl?: number | string;
+    unrealized_funding?: number | string;
+    liquidation_price?: number | string;
+    estimated_liquidation_price?: number | string;
+    leverage?: number | string;
+    user_leverage?: number | string;
+}
+export interface DecibelOrderResponse {
+    order_id?: string;
+    client_order_id?: string;
+    market?: string;
+    market_name?: string;
+    is_buy?: boolean;
+    side?: string;
+    order_type?: string;
+    status?: string;
+    orig_size?: number | string;
+    remaining_size?: number | string;
+    filled_size?: number | string;
+    price?: number | string;
+    trigger_price?: number | string;
+    reduce_only?: boolean;
+    is_reduce_only?: boolean;
+    post_only?: boolean;
+    is_post_only?: boolean;
+    unix_ms?: number | string;
+}
+export interface DecibelTradeResponse {
+    trade_id?: string;
+    fill_id?: string;
+    order_id?: string;
+    market?: string;
+    market_name?: string;
+    is_buy?: boolean;
+    side?: string;
+    price?: number | string;
+    size?: number | string;
+    fee?: number | string;
+    fee_asset?: string;
+    unix_ms?: number | string;
+}
+export interface DecibelAssetContextResponse {
+    market: string;
+    mark_price: number | string;
+    mid_price: number | string;
+    oracle_price: number | string;
+    previous_day_price: number | string;
+    price_change_pct_24h: number | string;
+    volume_24h: number | string;
+    open_interest: number | string;
+}
+export interface DecibelCandlestickResponse {
+    t: number;
+    T: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    v: number;
+    i: string;
+}
+export interface DecibelSubaccountResponse {
+    subaccount_address: string;
+    primary_account_address: string;
+    is_primary: boolean;
+    is_active: boolean;
+    custom_label: string | null;
+}
+export interface DecibelFundingHistoryResponse {
+    market: string;
+    action: string;
+    size: number | string;
+    is_funding_positive: boolean;
+    realized_funding_amount: number | string;
+    is_rebate: boolean;
+    fee_amount: number | string;
+    transaction_unix_ms: number | string;
+}
+export interface DecibelFundHistoryResponse {
+    type: string;
+    amount: number | string;
+    unix_ms: number | string;
+}
+export interface DecibelPublicTradeResponse {
+    account?: string;
+    market: string;
+    action?: string;
+    source?: string;
+    trade_id: string;
+    size: number | string;
+    price: number | string;
+    is_profit?: boolean;
+    realized_pnl_amount?: number | string;
+    is_funding_positive?: boolean;
+    realized_funding_amount?: number | string;
+    is_rebate?: boolean;
+    fee_amount?: number | string;
+    order_id?: string;
+    client_order_id?: string;
+    transaction_unix_ms: number | string;
+    transaction_version?: number | string;
+}
+export interface DecibelOrderLookupResponse {
+    status: string;
+    details?: string;
+    order?: DecibelOrderResponse;
+}
+export declare class DecibelRestClient {
+    private readonly baseUrl;
+    private readonly bearerToken?;
+    constructor(baseUrl: string, bearerToken?: string);
+    getMarkets(): Promise<DecibelMarketResponse[]>;
+    getPrices(marketAddr?: string): Promise<DecibelPriceResponse[]>;
+    getDepth(marketAddr: string, limit?: number): Promise<DecibelDepthResponse>;
+    getAccountOverview(accountAddr: string): Promise<DecibelAccountOverviewResponse>;
+    getAccountPositions(accountAddr: string): Promise<DecibelAccountPositionResponse[]>;
+    getOpenOrders(accountAddr: string): Promise<DecibelOrderResponse[]>;
+    getOrderHistory(accountAddr: string, limit?: number, offset?: number): Promise<DecibelOrderResponse[]>;
+    getTradeHistory(accountAddr: string, marketAddr?: string, limit?: number, offset?: number): Promise<DecibelTradeResponse[]>;
+    getAssetContexts(marketAddr?: string): Promise<DecibelAssetContextResponse[]>;
+    getCandlesticks(marketAddr: string, interval: string, startTime: number, endTime: number): Promise<DecibelCandlestickResponse[]>;
+    getSubaccounts(ownerAddr: string): Promise<DecibelSubaccountResponse[]>;
+    getFundingHistory(accountAddr: string, limit?: number, offset?: number): Promise<DecibelFundingHistoryResponse[]>;
+    getOrderById(accountAddr: string, marketAddr: string, orderId?: string, clientOrderId?: string): Promise<DecibelOrderLookupResponse>;
+    getPublicTrades(marketAddr: string, limit?: number, offset?: number, orderId?: string): Promise<DecibelPublicTradeResponse[]>;
+    getFundHistory(accountAddr: string, limit?: number, offset?: number): Promise<DecibelFundHistoryResponse[]>;
+    private fetchApi;
+    private unwrapRows;
+}

package/dist/adapters/decibel/rest-client.js

@@ -0,0 +1,155 @@
+import { createLogger } from "../../lib/logger.js";
+import { fetchWithTimeout } from "../../lib/fetch.js";
+import { isRecord } from "../utils.js";
+const log = createLogger("decibel:rest");
+export class DecibelRestClient {
+    baseUrl;
+    bearerToken;
+    constructor(baseUrl, bearerToken) {
+        this.baseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+        this.bearerToken = bearerToken;
+    }
+    async getMarkets() {
+        return this.fetchApi("api/v1/markets");
+    }
+    async getPrices(marketAddr) {
+        const params = {};
+        if (marketAddr)
+            params.market = marketAddr;
+        return this.fetchApi("api/v1/prices", params);
+    }
+    async getDepth(marketAddr, limit) {
+        const params = { market: marketAddr };
+        if (limit != null)
+            params.limit = limit;
+        return this.fetchApi("api/v1/depth", params);
+    }
+    async getAccountOverview(accountAddr) {
+        return this.fetchApi("api/v1/account_overviews", { account: accountAddr }, true);
+    }
+    async getAccountPositions(accountAddr) {
+        const payload = await this.fetchApi("api/v1/account_positions", { account: accountAddr }, true);
+        return this.unwrapRows(payload);
+    }
+    async getOpenOrders(accountAddr) {
+        const payload = await this.fetchApi("api/v1/open_orders", { user: accountAddr }, true);
+        return this.unwrapRows(payload);
+    }
+    async getOrderHistory(accountAddr, limit = 200, offset = 0) {
+        const payload = await this.fetchApi("api/v1/order_history", { user: accountAddr, limit, offset }, true);
+        return this.unwrapRows(payload);
+    }
+    async getTradeHistory(accountAddr, marketAddr, limit = 200, offset = 0) {
+        const params = {
+            user: accountAddr,
+            limit,
+            offset,
+        };
+        if (marketAddr) {
+            params.market = marketAddr;
+        }
+        const payload = await this.fetchApi("api/v1/trade_history", params, true);
+        return this.unwrapRows(payload);
+    }
+    async getAssetContexts(marketAddr) {
+        const params = {};
+        if (marketAddr)
+            params.market = marketAddr;
+        return this.fetchApi("api/v1/asset_contexts", params);
+    }
+    async getCandlesticks(marketAddr, interval, startTime, endTime) {
+        return this.fetchApi("api/v1/candlesticks", {
+            market: marketAddr,
+            interval,
+            startTime,
+            endTime,
+        });
+    }
+    async getSubaccounts(ownerAddr) {
+        return this.fetchApi("api/v1/subaccounts", {
+            owner: ownerAddr,
+        });
+    }
+    async getFundingHistory(accountAddr, limit = 200, offset = 0) {
+        const payload = await this.fetchApi("api/v1/funding_rate_history", { account: accountAddr, limit, offset }, true);
+        return this.unwrapRows(payload);
+    }
+    async getOrderById(accountAddr, marketAddr, orderId, clientOrderId) {
+        const params = {
+            account: accountAddr,
+            market: marketAddr,
+        };
+        if (orderId)
+            params.order_id = orderId;
+        if (clientOrderId)
+            params.client_order_id = clientOrderId;
+        return this.fetchApi("api/v1/orders", params, true);
+    }
+    async getPublicTrades(marketAddr, limit = 200, offset = 0, orderId) {
+        const params = {
+            market: marketAddr,
+            limit,
+            offset,
+        };
+        if (orderId)
+            params.order_id = orderId;
+        const payload = await this.fetchApi("api/v1/trades", params);
+        return this.unwrapRows(payload);
+    }
+    async getFundHistory(accountAddr, limit = 200, offset = 0) {
+        const payload = await this.fetchApi("api/v1/fund_history", { account: accountAddr, limit, offset }, true);
+        return this.unwrapRows(payload);
+    }
+    async fetchApi(path, params, requiresAuth = false) {
+        const url = new URL(path, this.baseUrl);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        const headers = {
+            Origin: "https://app.decibel.trade",
+        };
+        if (requiresAuth) {
+            if (!this.bearerToken) {
+                throw new Error(`Decibel endpoint '${path}' requires DECIBEL_API_BEARER_TOKEN`);
+            }
+            headers.Authorization = `Bearer ${this.bearerToken}`;
+        }
+        else if (this.bearerToken) {
+            headers.Authorization = `Bearer ${this.bearerToken}`;
+        }
+        log.debug(`GET ${url.pathname}${url.search}`);
+        const json = await fetchWithTimeout(url.toString(), {
+            headers,
+        });
+        if (json && typeof json === "object" && "status" in json) {
+            const status = json.status;
+            if (status === "failed" || status === "timeout" || status === "notFound") {
+                const message = json.message ?? "unknown error";
+                throw new Error(`Decibel API ${path} ${status}: ${message}`);
+            }
+        }
+        return json;
+    }
+    unwrapRows(payload) {
+        if (Array.isArray(payload)) {
+            return payload;
+        }
+        if (isRecord(payload)) {
+            const candidates = [
+                payload.results,
+                payload.data,
+                isRecord(payload.data) ? payload.data.rows : undefined,
+                isRecord(payload.data) ? payload.data.orders : undefined,
+                isRecord(payload.data) ? payload.data.trades : undefined,
+            ];
+            for (const candidate of candidates) {
+                if (Array.isArray(candidate)) {
+                    return candidate;
+                }
+            }
+        }
+        return [];
+    }
+}

package/dist/adapters/decibel/ws-feed.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter } from "node:events";
+export interface DecibelWsFeedOptions {
+    reconnectDelayMs?: number;
+    pingIntervalMs?: number;
+}
+export declare class DecibelWsFeed extends EventEmitter {
+    private ws;
+    private readonly wsUrl;
+    private readonly bearerToken?;
+    private readonly subscriptions;
+    private readonly reconnectDelay;
+    private readonly pingInterval;
+    private pingTimer;
+    private reconnectTimer;
+    private shouldReconnect;
+    constructor(wsUrl: string, bearerToken?: string, opts?: DecibelWsFeedOptions);
+    connect(): void;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    close(): void;
+    isConnected(): boolean;
+    private doConnect;
+    private sendSubscribe;
+    private startPing;
+    private stopPing;
+    private clearReconnectTimer;
+    private handleMessage;
+}