ponder 0.9.2 → 0.9.4-debug.1

package/dist/experimental_unsafe_stores.d.ts

@@ -0,0 +1,375 @@
+import { D as Db, S as Schema, F as FragmentId, I as IndexingBuild, d as Drizzle, e as SchemaBuild } from './db-in86nyw7.js';
+import { Hash, Hex, Address } from 'viem';
+import { ColumnType, Kysely } from 'kysely';
+import { PGlite } from '@electric-sql/pglite';
+import { Pool, PoolClient } from 'pg';
+import { P as Prettify } from './utils-ceNucOJb.js';
+import { LevelWithSilent } from 'pino';
+import prometheus from 'prom-client';
+import './drizzle/onchain.js';
+import 'drizzle-orm/pg-core';
+import 'drizzle-orm';
+import 'drizzle-orm/pg-core/columns/all';
+import 'abitype';
+import 'drizzle-orm/node-postgres';
+import 'drizzle-orm/pglite';
+
+type IndexingStore<policy extends "historical" | "realtime"> = policy extends "realtime" ? Db<Schema> : Db<Schema> & {
+    /** Persist the cache to the database. */
+    flush: () => Promise<void>;
+    /** Return `true` if the cache size in bytes is above the limit specified by `option.indexingCacheMaxBytes`. */
+    isCacheFull: () => boolean;
+};
+
+type LogMode = "pretty" | "json";
+type LogLevel = Prettify<LevelWithSilent>;
+type Logger = ReturnType<typeof createLogger>;
+type Log = {
+    level: 60 | 50 | 40 | 30 | 20 | 10;
+    time: number;
+    service: string;
+    msg: string;
+    error?: Error;
+};
+declare function createLogger({ level, mode, }: {
+    level: LogLevel;
+    mode?: LogMode;
+}): {
+    fatal(options: Omit<Log, "level" | "time">): void;
+    error(options: Omit<Log, "level" | "time">): void;
+    warn(options: Omit<Log, "level" | "time">): void;
+    info(options: Omit<Log, "level" | "time">): void;
+    debug(options: Omit<Log, "level" | "time">): void;
+    trace(options: Omit<Log, "level" | "time">): void;
+    flush: () => Promise<unknown>;
+};
+
+declare class MetricsService {
+    registry: prometheus.Registry;
+    start_timestamp: number;
+    rps: {
+        [network: string]: {
+            count: number;
+            timestamp: number;
+        }[];
+    };
+    ponder_historical_total_indexing_seconds: prometheus.Gauge<"network">;
+    ponder_historical_cached_indexing_seconds: prometheus.Gauge<"network">;
+    ponder_historical_completed_indexing_seconds: prometheus.Gauge<"network">;
+    ponder_indexing_timestamp: prometheus.Gauge<"network">;
+    ponder_indexing_has_error: prometheus.Gauge<"network">;
+    ponder_indexing_completed_events: prometheus.Gauge<"event">;
+    ponder_indexing_function_duration: prometheus.Histogram<"event">;
+    ponder_indexing_abi_decoding_duration: prometheus.Histogram;
+    ponder_sync_block: prometheus.Gauge<"network">;
+    ponder_sync_is_realtime: prometheus.Gauge<"network">;
+    ponder_sync_is_complete: prometheus.Gauge<"network">;
+    ponder_historical_duration: prometheus.Histogram<"network">;
+    ponder_historical_total_blocks: prometheus.Gauge<"network">;
+    ponder_historical_cached_blocks: prometheus.Gauge<"network">;
+    ponder_historical_completed_blocks: prometheus.Gauge<"network">;
+    ponder_realtime_reorg_total: prometheus.Counter<"network">;
+    ponder_realtime_latency: prometheus.Histogram<"network">;
+    ponder_database_method_duration: prometheus.Histogram<"service" | "method">;
+    ponder_database_method_error_total: prometheus.Counter<"service" | "method">;
+    ponder_http_server_port: prometheus.Gauge;
+    ponder_http_server_active_requests: prometheus.Gauge<"method" | "path">;
+    ponder_http_server_request_duration_ms: prometheus.Histogram<"method" | "path" | "status">;
+    ponder_http_server_request_size_bytes: prometheus.Histogram<"method" | "path" | "status">;
+    ponder_http_server_response_size_bytes: prometheus.Histogram<"method" | "path" | "status">;
+    ponder_rpc_request_duration: prometheus.Histogram<"network" | "method">;
+    ponder_rpc_request_lag: prometheus.Histogram<"network" | "method">;
+    ponder_postgres_query_total: prometheus.Counter<"pool">;
+    ponder_postgres_query_queue_size: prometheus.Gauge<"pool">;
+    ponder_postgres_pool_connections: prometheus.Gauge<"pool" | "kind">;
+    constructor();
+    /**
+     * Get string representation for all metrics.
+     * @returns Metrics encoded using Prometheus v0.0.4 format.
+     */
+    getMetrics(): Promise<string>;
+    resetIndexingMetrics(): void;
+    resetApiMetrics(): void;
+}
+
+type Options = {
+    command: "dev" | "start" | "serve" | "codegen" | "list";
+    configFile: string;
+    schemaFile: string;
+    apiDir: string;
+    apiFile: string;
+    rootDir: string;
+    indexingDir: string;
+    generatedDir: string;
+    ponderDir: string;
+    logDir: string;
+    port: number;
+    hostname?: string;
+    telemetryUrl: string;
+    telemetryDisabled: boolean;
+    telemetryConfigDir: string | undefined;
+    logLevel: LevelWithSilent;
+    logFormat: "json" | "pretty";
+    databaseHeartbeatInterval: number;
+    databaseHeartbeatTimeout: number;
+    databaseMaxQueryParameters: number;
+    factoryAddressCountThreshold: number;
+    indexingCacheMaxBytes: number;
+    indexingCacheFlushRatio: number;
+    syncEventsQuerySize: number;
+    syncHandoffStaleSeconds: number;
+};
+
+type Shutdown = {
+    add: (callback: () => unknown | Promise<unknown>) => void;
+    kill: () => Promise<void>;
+    isKilled: boolean;
+    abortController: AbortController;
+};
+
+type TelemetryEvent = {
+    name: "lifecycle:session_start";
+    properties: {
+        cli_command: string;
+    };
+} | {
+    name: "lifecycle:session_end";
+    properties: {
+        duration_seconds: number;
+    };
+} | {
+    name: "lifecycle:heartbeat_send";
+    properties: {
+        duration_seconds: number;
+    };
+};
+type Telemetry = ReturnType<typeof createTelemetry>;
+declare function createTelemetry({ options, logger, shutdown, }: {
+    options: Options;
+    logger: Logger;
+    shutdown: Shutdown;
+}): {
+    record: (_event: TelemetryEvent) => void;
+    flush: () => Promise<void>;
+};
+
+type Common = {
+    options: Options;
+    logger: Logger;
+    metrics: MetricsService;
+    telemetry: Telemetry;
+    shutdown: Shutdown;
+};
+
+type BlocksTable = {
+    hash: Hash;
+    chainId: number;
+    checkpoint: string;
+    number: ColumnType<string, string | bigint, string | bigint>;
+    timestamp: ColumnType<string, string | bigint, string | bigint>;
+    baseFeePerGas: ColumnType<string, string | bigint, string | bigint> | null;
+    difficulty: ColumnType<string, string | bigint, string | bigint>;
+    extraData: Hex;
+    gasLimit: ColumnType<string, string | bigint, string | bigint>;
+    gasUsed: ColumnType<string, string | bigint, string | bigint>;
+    logsBloom: Hex;
+    miner: Address;
+    mixHash: Hash | null;
+    nonce: Hex | null;
+    parentHash: Hash;
+    receiptsRoot: Hex;
+    sha3Uncles: Hash | null;
+    size: ColumnType<string, string | bigint, string | bigint>;
+    stateRoot: Hash;
+    totalDifficulty: ColumnType<string, string | bigint, string | bigint> | null;
+    transactionsRoot: Hash;
+};
+type LogsTable = {
+    id: string;
+    chainId: number;
+    checkpoint: string | null;
+    blockHash: Hash;
+    blockNumber: ColumnType<string, string | bigint, string | bigint>;
+    logIndex: number;
+    transactionHash: Hash;
+    transactionIndex: number;
+    address: Address;
+    topic0: Hex | null;
+    topic1: Hex | null;
+    topic2: Hex | null;
+    topic3: Hex | null;
+    data: Hex;
+};
+type TransactionsTable = {
+    hash: Hash;
+    chainId: number;
+    /** `checkpoint` will be null for transactions inserted before 0.8. This is to avoid a very slow migration. */
+    checkpoint: string | null;
+    blockHash: Hash;
+    blockNumber: ColumnType<string, string | bigint, string | bigint>;
+    from: Address;
+    gas: ColumnType<string, string | bigint, string | bigint>;
+    input: Hex;
+    nonce: number;
+    r: Hex | null;
+    s: Hex | null;
+    to: Address | null;
+    transactionIndex: number;
+    v: ColumnType<string, string | bigint, string | bigint> | null;
+    value: ColumnType<string, string | bigint, string | bigint>;
+    type: Hex;
+    gasPrice: ColumnType<string, string | bigint, string | bigint> | null;
+    maxFeePerGas: ColumnType<string, string | bigint, string | bigint> | null;
+    maxPriorityFeePerGas: ColumnType<string, string | bigint, string | bigint> | null;
+    accessList: string | null;
+};
+type TransactionReceiptsTable = {
+    transactionHash: Hash;
+    chainId: number;
+    blockHash: Hash;
+    blockNumber: ColumnType<string, string | bigint, string | bigint>;
+    contractAddress: Address | null;
+    cumulativeGasUsed: ColumnType<string, string | bigint, string | bigint>;
+    effectiveGasPrice: ColumnType<string, string | bigint, string | bigint>;
+    from: Address;
+    gasUsed: ColumnType<string, string | bigint, string | bigint>;
+    logsBloom: Hex;
+    status: Hex;
+    to: Address | null;
+    transactionIndex: number;
+    type: Hex;
+};
+type TracesTable = {
+    id: string;
+    chainId: number;
+    checkpoint: string;
+    type: string;
+    transactionHash: Hex;
+    blockHash: Hex;
+    blockNumber: ColumnType<string, string | bigint, string | bigint>;
+    from: Address;
+    to: Address | null;
+    gas: ColumnType<string, string | bigint, string | bigint>;
+    gasUsed: ColumnType<string, string | bigint, string | bigint>;
+    input: Hex;
+    functionSelector: Hex;
+    output: Hex | null;
+    error: string | null;
+    revertReason: string | null;
+    value: ColumnType<string | null, string | bigint | null, string | bigint | null>;
+    index: number;
+    subcalls: number;
+    isReverted: number;
+};
+type RpcRequestResultsTable = {
+    request: string;
+    request_hash: ColumnType<string, undefined>;
+    chain_id: number;
+    block_number: ColumnType<string | undefined, string | bigint | undefined, string | bigint | undefined>;
+    result: string;
+};
+type IntervalTable = {
+    fragment_id: FragmentId;
+    chain_id: number;
+    blocks: string;
+};
+type PonderSyncSchema = {
+    blocks: BlocksTable;
+    logs: LogsTable;
+    transactions: TransactionsTable;
+    transactionReceipts: TransactionReceiptsTable;
+    traces: TracesTable;
+    rpc_request_results: RpcRequestResultsTable;
+    intervals: IntervalTable;
+};
+
+type Database = {
+    driver: PostgresDriver | PGliteDriver;
+    qb: QueryBuilder;
+    wrap: <T>(options: {
+        method: string;
+        includeTraceLogs?: boolean;
+    }, fn: () => Promise<T>) => Promise<T>;
+    /** Migrate the `ponder_sync` schema. */
+    migrateSync(): Promise<void>;
+    /** Migrate the user schema. */
+    migrate({ buildId }: Pick<IndexingBuild, "buildId">): Promise<void>;
+    /** Determine the app checkpoint, possibly reverting unfinalized rows. */
+    recoverCheckpoint(): Promise<string>;
+    createIndexes(): Promise<void>;
+    createTriggers(): Promise<void>;
+    removeTriggers(): Promise<void>;
+    revert(args: {
+        checkpoint: string;
+    }): Promise<void>;
+    finalize(args: {
+        checkpoint: string;
+    }): Promise<void>;
+    complete(args: {
+        checkpoint: string;
+    }): Promise<void>;
+};
+type PonderApp = {
+    is_locked: 0 | 1;
+    is_dev: 0 | 1;
+    heartbeat_at: number;
+    build_id: string;
+    checkpoint: string;
+    table_names: string[];
+    version: string;
+};
+type PonderInternalSchema = {
+    _ponder_meta: {
+        key: "app";
+        value: PonderApp;
+    };
+    _ponder_status: {
+        network_name: string;
+        block_number: number | null;
+        block_timestamp: number | null;
+        ready: boolean;
+    };
+} & {
+    [_: ReturnType<typeof getTableNames>[number]["sql"]]: unknown;
+} & {
+    [_: ReturnType<typeof getTableNames>[number]["reorg"]]: unknown & {
+        operation_id: number;
+        operation: 0 | 1 | 2;
+        checkpoint: string;
+    };
+};
+type PGliteDriver = {
+    instance: PGlite;
+};
+type PostgresDriver = {
+    internal: Pool;
+    user: Pool;
+    sync: Pool;
+    readonly: Pool;
+    listen: PoolClient | undefined;
+};
+type QueryBuilder = {
+    /** For updating metadata and handling reorgs */
+    internal: Kysely<PonderInternalSchema>;
+    /** For indexing-store methods in user code */
+    user: Kysely<any>;
+    /** Used to interact with the sync-store */
+    sync: Kysely<PonderSyncSchema>;
+    drizzle: Drizzle<Schema>;
+    drizzleReadonly: Drizzle<Schema>;
+};
+
+declare const createHistoricalIndexingStore: ({ common, schemaBuild: { schema }, database, isDatabaseEmpty, }: {
+    common: Common;
+    schemaBuild: Pick<SchemaBuild, "schema">;
+    database: Database;
+    isDatabaseEmpty: boolean;
+}) => IndexingStore<"historical">;
+
+declare const createRealtimeIndexingStore: ({ schemaBuild: { schema }, database, }: {
+    common: Common;
+    schemaBuild: Pick<SchemaBuild, "schema">;
+    database: Database;
+}) => IndexingStore<"realtime">;
+
+export { createHistoricalIndexingStore, createRealtimeIndexingStore };

package/dist/experimental_unsafe_stores.js

@@ -0,0 +1,11 @@
+import {
+  createHistoricalIndexingStore,
+  createRealtimeIndexingStore
+} from "./chunk-6AOFLZJ4.js";
+import "./chunk-MJKRYIBO.js";
+import "./chunk-K2TLRLX3.js";
+export {
+  createHistoricalIndexingStore,
+  createRealtimeIndexingStore
+};
+//# sourceMappingURL=experimental_unsafe_stores.js.map

package/dist/experimental_unsafe_stores.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}