@chaindex/priorityfee 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,505 @@
+interface HttpTransportOptions {
+    baseUrl: string;
+    apiKey?: string;
+    token?: string;
+    fetch?: typeof globalThis.fetch;
+}
+declare class HttpTransport {
+    private readonly baseUrl;
+    private apiKey?;
+    private token?;
+    private readonly fetch;
+    constructor(options: HttpTransportOptions);
+    setToken(token: string): void;
+    clearToken(): void;
+    get<T>(path: string, params?: Record<string, string | undefined>): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+    private buildUrl;
+    private request;
+}
+
+type Duration = '1s' | '10s' | '30s' | '1min' | '3min' | '5min' | '10min' | '15min' | '30min' | '1hr' | '2hr' | '4hr' | '24hr';
+type DetailLevel = 'minimal' | 'standard' | 'full';
+type Percentile = 'mean' | 'median' | 'min' | 'max' | 'p5' | 'p10' | 'p15' | 'p20' | 'p25' | 'p30' | 'p35' | 'p40' | 'p45' | 'p50' | 'p55' | 'p60' | 'p65' | 'p70' | 'p75' | 'p80' | 'p85' | 'p90' | 'p95' | 'p96' | 'p97' | 'p98' | 'p99' | 'p99.9' | 'p99.99' | 'p99.999';
+type Metric = 'fee' | 'price' | 'limit';
+type TimeResolution = 'minute' | 'hour' | 'day' | 'week' | 'month';
+
+interface Percentiles {
+    mean?: string;
+    median?: string;
+    min?: string;
+    max?: string;
+    p5?: string;
+    p10?: string;
+    p15?: string;
+    p20?: string;
+    p25?: string;
+    p30?: string;
+    p35?: string;
+    p40?: string;
+    p45?: string;
+    p50?: string;
+    p55?: string;
+    p60?: string;
+    p65?: string;
+    p70?: string;
+    p75?: string;
+    p80?: string;
+    p85?: string;
+    p90?: string;
+    p95?: string;
+    p96?: string;
+    p97?: string;
+    p98?: string;
+    p99?: string;
+    p99_9?: string;
+    p99_99?: string;
+    p99_999?: string;
+}
+
+interface BlockModel {
+    slot: string;
+    timestamp: string;
+    number_of_transactions: string;
+    total_priority_fees: string;
+    total_compute_units: string;
+    price?: Percentiles;
+    fee?: Percentiles;
+    limit?: Percentiles;
+}
+interface BlockListResponse {
+    network: string;
+    limit: number;
+    data: BlockModel[];
+}
+interface BlockQueryParams {
+    limit?: number;
+    detail?: DetailLevel;
+    percentiles?: Percentile[];
+}
+
+declare class BlockResource {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    get(params?: BlockQueryParams): Promise<BlockListResponse>;
+    getFee(params?: BlockQueryParams): Promise<BlockListResponse>;
+    getPrice(params?: BlockQueryParams): Promise<BlockListResponse>;
+    getLimit(params?: BlockQueryParams): Promise<BlockListResponse>;
+}
+
+interface RollingModel {
+    timestamp: string;
+    total_priority_fees: string;
+    number_of_transactions: string;
+    number_of_blocks: string;
+    price?: Percentiles;
+    fee?: Percentiles;
+    limit?: Percentiles;
+}
+interface RollingResponse {
+    network: string;
+    duration: Duration;
+    data: RollingModel;
+}
+interface RollingQueryParams {
+    duration?: Duration;
+    detail?: DetailLevel;
+    percentiles?: Percentile[];
+}
+
+declare class RollingResource {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    get(params?: RollingQueryParams): Promise<RollingResponse>;
+    getFee(params?: RollingQueryParams): Promise<RollingResponse>;
+    getPrice(params?: RollingQueryParams): Promise<RollingResponse>;
+    getLimit(params?: RollingQueryParams): Promise<RollingResponse>;
+}
+
+interface TumblingModel {
+    timestamp: string;
+    total_priority_fees: string;
+    number_of_transactions: string;
+    number_of_blocks: string;
+    price?: Percentiles;
+    fee?: Percentiles;
+    limit?: Percentiles;
+}
+interface TumblingResponse {
+    duration: Duration;
+    limit: number;
+    data: TumblingModel[];
+}
+interface TumblingQueryParams {
+    duration?: Duration;
+    limit?: number;
+    detail?: DetailLevel;
+    percentiles?: Percentile[];
+}
+
+declare class TumblingResource {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    get(params?: TumblingQueryParams): Promise<TumblingResponse>;
+    getFee(params?: TumblingQueryParams): Promise<TumblingResponse>;
+    getPrice(params?: TumblingQueryParams): Promise<TumblingResponse>;
+    getLimit(params?: TumblingQueryParams): Promise<TumblingResponse>;
+}
+
+interface DemoModel {
+    timestamp: number;
+    window_seconds: number;
+    window_start: number;
+    window_end: number;
+    tx_count: number;
+    data_points: number;
+    is_valid: boolean;
+    total_fees: number;
+    avg_fee_per_tx: number;
+    fee_per_cu: number;
+    fee_p50: number;
+    fee_p50_count: number;
+    fee_p75: number;
+    fee_p75_count: number;
+    fee_p90: number;
+    fee_p90_count: number;
+    fee_p99: number;
+    fee_p99_count: number;
+    fee_min: number;
+    fee_max: number;
+    price_p50: number;
+    price_p50_count: number;
+    price_p75: number;
+    price_p75_count: number;
+    price_p90: number;
+    price_p90_count: number;
+    price_p99: number;
+    price_p99_count: number;
+    price_min: number;
+    price_max: number;
+    limit_p50: number;
+    limit_p50_count: number;
+    limit_p75: number;
+    limit_p75_count: number;
+    limit_p90: number;
+    limit_p90_count: number;
+    limit_p99: number;
+    limit_p99_count: number;
+    limit_min: number;
+    limit_max: number;
+    total_cu_consumed: number;
+    total_cu_budgeted: number;
+    avg_utilization_pct: number;
+    wasted_cu: number;
+    wasted_cu_pct: number;
+    avg_cu_per_tx: number;
+    fee_efficiency_score: number;
+}
+interface DemoResponse {
+    network: string;
+    data: DemoModel;
+}
+
+declare class DemoResource {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    get(): Promise<DemoResponse>;
+}
+
+interface SiwsVerifyRequest {
+    input: {
+        domain?: string;
+        statement?: string;
+        chainId?: string;
+        issuedAt?: string;
+    };
+    output: {
+        account: {
+            address: string;
+            publicKey: number[];
+        };
+        signature: number[];
+        signedMessage: number[];
+    };
+}
+interface VerifyResponse {
+    token: string;
+    expires_at: number;
+    wallet_address: string;
+}
+interface MeResponse {
+    wallet_address: string;
+    created_at: number;
+    last_login_at: number | null;
+}
+
+declare class AuthResource {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    verify(request: SiwsVerifyRequest): Promise<VerifyResponse>;
+    me(): Promise<MeResponse>;
+}
+
+interface ApiKey {
+    id: string;
+    name: string;
+    key_prefix: string;
+    created_at: number;
+    last_used_at: number | null;
+    request_count: number;
+    disabled_at: number | null;
+}
+interface ApiKeyWithSecret extends Omit<ApiKey, 'last_used_at' | 'request_count' | 'disabled_at'> {
+    key: string;
+}
+interface ListKeysResponse {
+    data: ApiKey[];
+}
+
+declare class KeysResource {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    create(name: string): Promise<ApiKeyWithSecret>;
+    list(): Promise<ListKeysResponse>;
+    delete(id: string): Promise<{
+        disabled: boolean;
+    }>;
+}
+
+interface Endpoint {
+    id: number;
+    path: string;
+    name: string;
+    category: string;
+}
+interface UsageEntry {
+    month: string;
+    endpoint: Endpoint;
+    request_count: number;
+}
+interface UsageResponse {
+    data: UsageEntry[];
+}
+interface DetailedUsageEntry {
+    api_key_id: string;
+    api_key_name: string;
+    time_bucket: number;
+    endpoint: Endpoint;
+    request_count: number;
+}
+interface DetailedUsageResponse {
+    data: DetailedUsageEntry[];
+    resolution: TimeResolution;
+    start: number;
+    end: number;
+}
+interface DetailedUsageParams {
+    resolution: TimeResolution;
+    start?: number;
+    end?: number;
+    api_key_id?: string;
+}
+
+declare class UsageResource {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    get(): Promise<UsageResponse>;
+    getDetailed(params: DetailedUsageParams): Promise<DetailedUsageResponse>;
+}
+
+interface HealthResponse {
+    status: string;
+    service: string;
+    version: string;
+}
+
+declare class HealthResource {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    check(): Promise<HealthResponse>;
+}
+
+interface HttpClientOptions {
+    baseUrl: string;
+    apiKey?: string;
+    token?: string;
+    fetch?: typeof globalThis.fetch;
+}
+declare class HttpClient {
+    readonly block: BlockResource;
+    readonly rolling: RollingResource;
+    readonly tumbling: TumblingResource;
+    readonly demo: DemoResource;
+    readonly auth: AuthResource;
+    readonly keys: KeysResource;
+    readonly usage: UsageResource;
+    readonly health: HealthResource;
+    private readonly transport;
+    constructor(options: HttpClientOptions);
+    setToken(token: string): void;
+    clearToken(): void;
+}
+
+type WsChannel = 'block' | 'rolling' | 'demo';
+interface BlockSubscribeParams {
+    metric?: Metric;
+    detail?: DetailLevel;
+    percentiles?: Percentile[];
+    limit?: number;
+}
+interface RollingSubscribeParams {
+    duration?: Duration;
+    metric?: Metric;
+    detail?: DetailLevel;
+    percentiles?: Percentile[];
+}
+interface DemoSubscribeParams {
+}
+type BlockSubscribeChannel = {
+    type: 'block';
+} & BlockSubscribeParams;
+type RollingSubscribeChannel = {
+    type: 'rolling';
+} & RollingSubscribeParams;
+type DemoSubscribeChannel = {
+    type: 'demo';
+} & DemoSubscribeParams;
+type SubscribeChannel = BlockSubscribeChannel | RollingSubscribeChannel | DemoSubscribeChannel;
+type SubscribeParams = {
+    channel: SubscribeChannel;
+};
+type ClientMessage = {
+    type: 'subscribe';
+    channel: SubscribeChannel;
+} | {
+    type: 'unsubscribe';
+    id: string;
+} | {
+    type: 'ping';
+};
+interface SubscribedMessage {
+    type: 'subscribed';
+    id: string;
+    channel: WsChannel;
+}
+interface DataMessage {
+    type: 'data';
+    id: string;
+    channel: WsChannel;
+    payload: unknown;
+}
+interface UnsubscribedMessage {
+    type: 'unsubscribed';
+    id: string;
+}
+interface WsErrorMessage {
+    type: 'error';
+    id: string | null;
+    code: string;
+    message: string;
+}
+interface PongMessage {
+    type: 'pong';
+}
+type ServerMessage = SubscribedMessage | DataMessage | UnsubscribedMessage | WsErrorMessage | PongMessage;
+interface Subscription {
+    readonly id: string;
+    readonly channel: WsChannel;
+    unsubscribe(): void;
+}
+interface ChannelPayloadMap {
+    block: BlockListResponse;
+    rolling: RollingResponse;
+    demo: DemoResponse;
+}
+interface SubscriptionHandlers<C extends WsChannel> {
+    onData: (data: ChannelPayloadMap[C]) => void;
+    onError?: (error: WsErrorMessage) => void;
+}
+interface WsClientOptions {
+    baseUrl: string;
+    apiKey: string;
+    autoConnect?: boolean;
+    reconnect?: boolean;
+    maxReconnectAttempts?: number;
+    reconnectDelay?: number;
+    pingInterval?: number;
+    WebSocket?: unknown;
+}
+type WsTransportState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting';
+interface WsTransportEvents {
+    open: () => void;
+    close: (code: number, reason: string) => void;
+    error: (error: Event) => void;
+    message: (msg: ServerMessage) => void;
+    stateChange: (state: WsTransportState) => void;
+}
+
+type ClientEventName = 'open' | 'close' | 'error' | 'stateChange';
+type ClientListener<E extends ClientEventName> = WsTransportEvents[E];
+declare class WsClient {
+    private readonly transport;
+    private readonly active;
+    private readonly pending;
+    constructor(options: WsClientOptions);
+    get state(): WsTransportState;
+    connect(): void;
+    disconnect(): void;
+    on<E extends ClientEventName>(event: E, fn: ClientListener<E>): void;
+    off<E extends ClientEventName>(event: E, fn: ClientListener<E>): void;
+    subscribeBlock(params: BlockSubscribeParams, handlers: SubscriptionHandlers<'block'>): Promise<Subscription>;
+    subscribeRolling(params: RollingSubscribeParams, handlers: SubscriptionHandlers<'rolling'>): Promise<Subscription>;
+    subscribeDemo(handlers: SubscriptionHandlers<'demo'>): Promise<Subscription>;
+    private subscribe;
+    private handleMessage;
+    private handleSubscribed;
+    private handleData;
+    private handleError;
+    private handleReconnect;
+}
+
+type EventName = keyof WsTransportEvents;
+type Listener<E extends EventName> = WsTransportEvents[E];
+declare class WsTransport {
+    private ws;
+    private _state;
+    private disposed;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private pingTimer;
+    private pongTimer;
+    private listeners;
+    private readonly url;
+    private readonly reconnect;
+    private readonly maxReconnectAttempts;
+    private readonly reconnectDelay;
+    private readonly pingInterval;
+    private readonly WsCtor;
+    constructor(options: WsClientOptions);
+    get state(): WsTransportState;
+    connect(): void;
+    disconnect(): void;
+    send(msg: ClientMessage): void;
+    on<E extends EventName>(event: E, fn: Listener<E>): void;
+    off<E extends EventName>(event: E, fn: Listener<E>): void;
+    private emit;
+    private setState;
+    private handleMessage;
+    private startPing;
+    private stopPing;
+    private clearPongTimer;
+    private scheduleReconnect;
+    private clearReconnectTimer;
+}
+
+declare class SdkError extends Error {
+    constructor(message: string);
+}
+declare class ApiError extends SdkError {
+    readonly status: number;
+    readonly body?: unknown;
+    constructor(status: number, message: string, body?: unknown);
+}
+
+export { ApiError, type ApiKey, type ApiKeyWithSecret, type BlockListResponse, type BlockModel, type BlockQueryParams, type BlockSubscribeParams, type ChannelPayloadMap, type DemoModel, type DemoResponse, type DemoSubscribeParams, type DetailLevel, type DetailedUsageEntry, type DetailedUsageParams, type DetailedUsageResponse, type Duration, type Endpoint, type HealthResponse, HttpClient, type HttpClientOptions, HttpTransport, type HttpTransportOptions, type ListKeysResponse, type MeResponse, type Metric, type Percentile, type Percentiles, type RollingModel, type RollingQueryParams, type RollingResponse, type RollingSubscribeParams, SdkError, type SiwsVerifyRequest, type SubscribeParams, type Subscription, type SubscriptionHandlers, type TimeResolution, type TumblingModel, type TumblingQueryParams, type TumblingResponse, type UsageEntry, type UsageResponse, type VerifyResponse, type WsChannel, WsClient, type WsClientOptions, type WsErrorMessage, WsTransport, type WsTransportEvents, type WsTransportState };