ponder 0.9.5-debug.1 → 0.9.5

package/dist/index.d.ts

@@ -0,0 +1,819 @@
+import { P as Prettify, a as PonderTypeError } from './utils-ceNucOJb.js';
+import { Abi, AbiEvent as AbiEvent$1, AbiFunction, AbiParametersToPrimitiveTypes, FormatAbiItem } from 'abitype';
+import { AbiEvent, GetEventArgs, ParseAbiItem, Abi as Abi$1, Narrow, Transport, Hex, Hash, Address, AccessList, TransactionType, Chain, Client, PublicRpcSchema, publicActions, MulticallParameters, MulticallReturnType, ContractFunctionName, ContractFunctionArgs, ReadContractParameters, ReadContractReturnType, SimulateContractParameters, SimulateContractReturnType, GetBlockReturnType, GetTransactionCountReturnType, GetBlockTransactionCountReturnType, PublicActions } from 'viem';
+import { onchain, OnchainTable, PrimaryKeyBuilder } from './drizzle/onchain.js';
+export { bigint, hex, onchainEnum, onchainTable, primaryKey } from './drizzle/onchain.js';
+import { Table, InferSelectModel, InferInsertModel, GetColumnData, Column } from 'drizzle-orm';
+export { and, asc, avg, avgDistinct, between, count, countDistinct, desc, eq, exists, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, max, min, ne, not, notBetween, notExists, notIlike, notInArray, notLike, or, relations, sql, sum, sumDistinct } from 'drizzle-orm';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { TableConfig, PgTableExtraConfig } from 'drizzle-orm/pg-core';
+export { alias, boolean, char, cidr, date, doublePrecision, except, exceptAll, foreignKey, index, inet, bigint as int8, integer, intersect, intersectAll, interval, json, jsonb, line, macaddr, macaddr8, numeric, point, real, smallint, text, time, timestamp, union, unionAll, uniqueIndex, uuid, varchar } from 'drizzle-orm/pg-core';
+import { PgliteDatabase } from 'drizzle-orm/pglite';
+export { MergeAbis, ReplaceBigInts, loadBalance, mergeAbis, rateLimit, replaceBigInts } from '@ponder/utils';
+import * as hono from 'hono';
+import 'drizzle-orm/pg-core/columns/all';
+
+type Factory<event extends AbiEvent = AbiEvent> = {
+    /** Address of the factory contract that creates this contract. */
+    address: `0x${string}` | readonly `0x${string}`[];
+    /** ABI event that announces the creation of a new instance of this contract. */
+    event: event;
+    /** Name of the factory event parameter that contains the new child contract address. */
+    parameter: Exclude<event["inputs"][number]["name"], undefined>;
+};
+declare const factory: <event extends AbiEvent>(factory: Factory<event>) => Factory<event>;
+type AddressConfig = {
+    address?: `0x${string}` | readonly `0x${string}`[] | Factory;
+};
+
+type ExtractAbiEvents<abi extends Abi, events = Extract<abi[number], {
+    type: "event";
+}>> = [events] extends [never] ? AbiEvent$1 : events;
+type ExtractAbiFunctions<abi extends Abi, functions = Extract<abi[number], {
+    type: "function";
+}>> = [functions] extends [never] ? AbiFunction : functions;
+/** Return the abi event given the abi and compact signature. */
+type ParseAbiEvent<abi extends Abi, signature extends string, abiEvents extends AbiEvent$1 = ExtractAbiEvents<abi>, noOverloadEvent = Extract<abiEvents, {
+    name: signature;
+}>, overloadEvent = Extract<abiEvents, ParseAbiItem<`event ${signature}`>>> = [noOverloadEvent] extends [never] ? [overloadEvent] extends [never] ? AbiEvent$1 : overloadEvent : noOverloadEvent;
+/** Return the abi function given the abi and compact signature. */
+type ParseAbiFunction<abi extends Abi, signature extends string, abiFunctions extends AbiFunction = ExtractAbiFunctions<abi>, noOverloadFunction = Extract<abiFunctions, {
+    name: signature extends `${infer _signature}()` ? _signature : never;
+}>, overloadFunction = Extract<abiFunctions, ParseAbiItem<`function ${signature}`>>> = [overloadFunction] extends [never] ? [noOverloadFunction] extends [never] ? AbiFunction : noOverloadFunction : overloadFunction;
+/** Return the compact signature given the abi and abi event. */
+type FormatAbiEvent<abi extends Abi, event extends AbiEvent$1, abiEvents extends AbiEvent$1 = ExtractAbiEvents<abi>, matchingNameEvents extends AbiEvent$1 = Extract<abiEvents, {
+    name: event["name"];
+}>> = [matchingNameEvents] extends [never] ? Abi extends abi ? event["name"] : never : [Exclude<matchingNameEvents, event>] extends [never] ? event["name"] : FormatAbiItem<event> extends `event ${infer signature}` ? signature : never;
+/** Return the compact signature given the abi and abi function. */
+type FormatAbiFunction<abi extends Abi, _function extends AbiFunction, abiFunctions extends AbiFunction = ExtractAbiFunctions<abi>, matchingNameFunctions extends AbiFunction = Extract<abiFunctions, {
+    name: _function["name"];
+}>> = [matchingNameFunctions] extends [never] ? Abi extends abi ? `${_function["name"]}()` : never : [Exclude<matchingNameFunctions, _function>] extends [never] ? `${_function["name"]}()` : FormatAbiItem<_function> extends `function ${infer signature}` ? signature : never;
+/**
+ * Return an union of safe event names that handle event overridding.
+ */
+type SafeEventNames<abi extends Abi, abiEvents extends AbiEvent$1 = ExtractAbiEvents<abi>> = abiEvents extends abiEvents ? FormatAbiEvent<abi, abiEvents> : never;
+/**
+ * Return an union of safe function names that handle function overridding.
+ */
+type SafeFunctionNames<abi extends Abi, abiFunctions extends AbiFunction = ExtractAbiFunctions<abi>> = abiFunctions extends abiFunctions ? FormatAbiFunction<abi, abiFunctions> : never;
+type FormatEventArgs<abi extends Abi, signature extends string> = GetEventArgs<Abi, string, {
+    EnableUnion: false;
+    IndexedOnly: false;
+    Required: true;
+}, ParseAbiEvent<abi, signature>>;
+type FormatFunctionArgs<abi extends Abi, signature extends string, args = AbiParametersToPrimitiveTypes<ParseAbiFunction<abi, signature>["inputs"]>> = readonly [] extends args ? never : args;
+type FormatFunctionResult<abi extends Abi, signature extends string, result = AbiParametersToPrimitiveTypes<ParseAbiFunction<abi, signature>["outputs"]>> = readonly [] extends result ? never : result extends readonly [unknown] ? result[0] : result;
+
+type FilterArgs<abi extends Abi$1, event extends string> = GetEventArgs<abi, string, {
+    EnableUnion: true;
+    IndexedOnly: true;
+    Required: false;
+}, ParseAbiEvent<abi, event>>;
+type GetEventFilter<abi extends Abi$1, safeEventNames extends string = SafeEventNames<abi>> = {
+    filter?: (safeEventNames extends safeEventNames ? {
+        event: safeEventNames;
+        args: FilterArgs<abi, safeEventNames>;
+    } : never) | (safeEventNames extends safeEventNames ? {
+        event: safeEventNames;
+        args: FilterArgs<abi, safeEventNames>;
+    } : never)[];
+};
+
+type Config = {
+    database?: DatabaseConfig$1;
+    ordering?: "omnichain" | "multichain";
+    networks: {
+        [networkName: string]: NetworkConfig$1<unknown>;
+    };
+    contracts: {
+        [contractName: string]: GetContract;
+    };
+    accounts: {
+        [accountName: string]: AccountConfig<unknown>;
+    };
+    blocks: {
+        [sourceName: string]: GetBlockFilter<unknown>;
+    };
+};
+type CreateConfigReturnType<networks, contracts, accounts, blocks> = {
+    database?: DatabaseConfig$1;
+    ordering?: "omnichain" | "multichain";
+    networks: networks;
+    contracts: contracts;
+    accounts: accounts;
+    blocks: blocks;
+};
+declare const createConfig: <const networks, const contracts = {}, const accounts = {}, const blocks = {}>(config: {
+    database?: DatabaseConfig$1 | undefined;
+    ordering?: "omnichain" | "multichain" | undefined;
+    networks: NetworksConfig<Narrow<networks>>;
+    contracts?: ContractsConfig<networks, Narrow<contracts>> | undefined;
+    accounts?: AccountsConfig<networks, Narrow<accounts>> | undefined;
+    blocks?: BlockFiltersConfig<networks, blocks> | undefined;
+}) => CreateConfigReturnType<networks, contracts, accounts, blocks>;
+type DatabaseConfig$1 = {
+    kind: "pglite";
+    /** Directory path to use for PGlite database files. Default: `".ponder/pglite"`. */
+    directory?: string;
+} | {
+    kind: "postgres";
+    /** Postgres database connection string. Default: `DATABASE_PRIVATE_URL` > `DATABASE_URL` environment variable. */
+    connectionString?: string;
+    /** Postgres pool configuration passed to `node-postgres`. */
+    poolConfig?: {
+        /** Maximum number of clients in the pool. Default: `30`. */
+        max?: number;
+    };
+};
+type BlockConfig$1 = {
+    /** Block number at which to start indexing events (inclusive). If `undefined`, events will be processed from block 0. Default: `undefined`. */
+    startBlock?: number | "latest";
+    /** Block number at which to stop indexing events (inclusive). If `undefined`, events will be processed in real-time. Default: `undefined`. */
+    endBlock?: number | "latest";
+};
+type TransactionReceiptConfig = {
+    includeTransactionReceipts?: boolean;
+};
+type FunctionCallConfig = {
+    includeCallTraces?: boolean;
+};
+type NetworkConfig$1<network> = {
+    /** Chain ID of the network. */
+    chainId: network extends {
+        chainId: infer chainId extends number;
+    } ? chainId | number : number;
+    /** A viem `http`, `webSocket`, or `fallback` [Transport](https://viem.sh/docs/clients/transports/http.html).
+     *
+     * __To avoid rate limiting, include a custom RPC URL.__ Usage:
+     *
+     * ```ts
+     * import { http } from "viem";
+     *
+     * const network = {
+     *    name: "mainnet",
+     *    chainId: 1,
+     *    transport: http("https://eth-mainnet.g.alchemy.com/v2/..."),
+     * }
+     * ```
+     */
+    transport: Transport;
+    /** Polling interval (in ms). Default: `1_000`. */
+    pollingInterval?: number;
+    /** Maximum number of RPC requests per second. Default: `50`. */
+    maxRequestsPerSecond?: number;
+    /** Disable RPC request caching. Default: `false`. */
+    disableCache?: boolean;
+};
+type NetworksConfig<networks> = {} extends networks ? {} : {
+    [networkName in keyof networks]: NetworkConfig$1<networks[networkName]>;
+};
+type AbiConfig<abi extends Abi | readonly unknown[]> = {
+    /** Contract application byte interface. */
+    abi: abi;
+};
+type GetContractNetwork<networks, abi extends Abi, allNetworkNames extends string = [keyof networks] extends [never] ? string : keyof networks & string> = {
+    /**
+     * Network that this contract is deployed to. Must match a network name in `networks`.
+     * Any filter information overrides the values in the higher level "contracts" property.
+     */
+    network: allNetworkNames | {
+        [name in allNetworkNames]?: Prettify<AddressConfig & GetEventFilter<abi> & TransactionReceiptConfig & FunctionCallConfig & BlockConfig$1>;
+    };
+};
+type ContractConfig$1<networks, abi extends Abi> = Prettify<AbiConfig<abi> & GetContractNetwork<networks, abi> & AddressConfig & GetEventFilter<abi> & TransactionReceiptConfig & FunctionCallConfig & BlockConfig$1>;
+type GetContract<networks = unknown, contract = unknown> = contract extends {
+    abi: infer abi extends Abi;
+} ? ContractConfig$1<networks, abi> : ContractConfig$1<networks, Abi>;
+type ContractsConfig<networks, contracts> = {} extends contracts ? {} : {
+    [name in keyof contracts]: GetContract<networks, contracts[name]>;
+};
+type GetAccountNetwork<networks, allNetworkNames extends string = [keyof networks] extends [never] ? string : keyof networks & string> = {
+    /**
+     * Network that this account is deployed to. Must match a network name in `networks`.
+     * Any filter information overrides the values in the higher level "accounts" property.
+     */
+    network: allNetworkNames | {
+        [name in allNetworkNames]?: Prettify<AddressConfig & TransactionReceiptConfig & BlockConfig$1>;
+    };
+};
+type AccountConfig<networks> = Prettify<GetAccountNetwork<networks> & Required<AddressConfig> & TransactionReceiptConfig & BlockConfig$1>;
+type AccountsConfig<networks, accounts> = {} extends accounts ? {} : {
+    [name in keyof accounts]: AccountConfig<networks>;
+};
+type BlockFilterConfig = {
+    /** Block number at which to start indexing events (inclusive). If `undefined`, events will be processed from block 0. Default: `undefined`. */
+    startBlock?: number | "latest";
+    /** Block number at which to stop indexing events (inclusive). If `undefined`, events will be processed in real-time. Default: `undefined`. */
+    endBlock?: number | "latest";
+    interval?: number;
+};
+type GetBlockFilter<networks, allNetworkNames extends string = [keyof networks] extends [never] ? string : keyof networks & string> = BlockFilterConfig & {
+    network: allNetworkNames | {
+        [name in allNetworkNames]?: BlockFilterConfig;
+    };
+};
+type BlockFiltersConfig<networks = unknown, blocks = unknown> = {} extends blocks ? {} : {
+    [name in keyof blocks]: GetBlockFilter<networks>;
+};
+
+/**
+ * A confirmed Ethereum block.
+ *
+ * @link https://docs.soliditylang.org/en/v0.8.20/introduction-to-smart-contracts.html#blocks
+ */
+type Block = {
+    /** Base fee per gas */
+    baseFeePerGas: bigint | null;
+    /** Difficulty for this block */
+    difficulty: bigint;
+    /** "Extra data" field of this block */
+    extraData: Hex;
+    /** Maximum gas allowed in this block */
+    gasLimit: bigint;
+    /** Total used gas by all transactions in this block */
+    gasUsed: bigint;
+    /** Block hash */
+    hash: Hash;
+    /** Logs bloom filter */
+    logsBloom: Hex;
+    /** Address that received this block’s mining rewards */
+    miner: Address;
+    /** Unique identifier for the block. */
+    mixHash: Hash | null;
+    /** Proof-of-work hash */
+    nonce: Hex | null;
+    /** Block number */
+    number: bigint;
+    /** Parent block hash */
+    parentHash: Hash;
+    /** Root of the this block’s receipts trie */
+    receiptsRoot: Hex;
+    /** SHA3 of the uncles data in this block */
+    sha3Uncles: Hash | null;
+    /** Size of this block in bytes */
+    size: bigint;
+    /** Root of this block’s final state trie */
+    stateRoot: Hash;
+    /** Unix timestamp of when this block was collated */
+    timestamp: bigint;
+    /** Total difficulty of the chain until this block */
+    totalDifficulty: bigint | null;
+    /** Root of this block’s transaction trie */
+    transactionsRoot: Hash;
+};
+/**
+ * A confirmed Ethereum transaction. Contains `legacy`, `EIP-1559`, or `EIP-2930` fee values depending on the transaction `type`.
+ *
+ * @link https://docs.soliditylang.org/en/v0.8.20/introduction-to-smart-contracts.html#transactions
+ */
+type Transaction = Prettify<{
+    /** Transaction sender */
+    from: Address;
+    /** Gas provided for transaction execution */
+    gas: bigint;
+    /** Hash of this transaction */
+    hash: Hash;
+    /** Contract code or a hashed method call */
+    input: Hex;
+    /** Unique number identifying this transaction */
+    nonce: number;
+    /** ECDSA signature r */
+    r: Hex | null;
+    /** ECDSA signature s */
+    s: Hex | null;
+    /** Transaction recipient or `null` if deploying a contract */
+    to: Address | null;
+    /** Index of this transaction in the block */
+    transactionIndex: number;
+    /** ECDSA recovery ID */
+    v: bigint | null;
+    /** Value in wei sent with this transaction */
+    value: bigint;
+} & ({
+    /** Transaction type. */
+    type: "legacy";
+    accessList?: never;
+    /** Base fee per gas. Only present in legacy and EIP-2930 transactions. */
+    gasPrice: bigint;
+    maxFeePerGas?: never;
+    maxPriorityFeePerGas?: never;
+} | {
+    /** Transaction type. */
+    type: "eip2930";
+    /** List of addresses and storage keys the transaction will access. */
+    accessList: AccessList;
+    /** Base fee per gas. Only present in legacy and EIP-2930 transactions. */
+    gasPrice: bigint;
+    maxFeePerGas?: never;
+    maxPriorityFeePerGas?: never;
+} | {
+    /** Transaction type. */
+    type: "eip1559";
+    accessList?: never;
+    gasPrice?: never;
+    /** Total fee per gas in wei (gasPrice/baseFeePerGas + maxPriorityFeePerGas). Only present in EIP-1559 transactions. */
+    maxFeePerGas: bigint;
+    /** Max priority fee per gas (in wei). Only present in EIP-1559 transactions. */
+    maxPriorityFeePerGas: bigint;
+} | {
+    /** Transaction type. */
+    type: "deposit";
+    accessList?: never;
+    gasPrice?: never;
+    /** Total fee per gas in wei (gasPrice/baseFeePerGas + maxPriorityFeePerGas). Only present in EIP-1559 transactions. */
+    maxFeePerGas?: bigint;
+    /** Max priority fee per gas (in wei). Only present in EIP-1559 transactions. */
+    maxPriorityFeePerGas?: bigint;
+} | {
+    /** Transaction type. */
+    type: Hex;
+    gasPrice?: never;
+    accessList?: never;
+    maxFeePerGas?: never;
+    maxPriorityFeePerGas?: never;
+})>;
+/**
+ * A confirmed Ethereum log.
+ *
+ * @link https://docs.soliditylang.org/en/v0.8.20/abi-spec.html#events
+ */
+type Log = {
+    /** Globally unique identifier for this log (`${blockHash}-${logIndex}`) */
+    id: string;
+    /** The address from which this log originated */
+    address: Address;
+    /** Contains the non-indexed arguments of the log */
+    data: Hex;
+    /** Index of this log within its block */
+    logIndex: number;
+    /** `true` if this log has been removed in a chain reorganization */
+    removed: boolean;
+    /** List of order-dependent topics */
+    topics: [Hex, ...Hex[]] | [];
+};
+/** A confirmed Ethereum transaction receipt. */
+type TransactionReceipt = {
+    /** Address of new contract or `null` if no contract was created */
+    contractAddress: Address | null;
+    /** Gas used by this and all preceding transactions in this block */
+    cumulativeGasUsed: bigint;
+    /** Pre-London, it is equal to the transaction's gasPrice. Post-London, it is equal to the actual gas price paid for inclusion. */
+    effectiveGasPrice: bigint;
+    /** Transaction sender */
+    from: Address;
+    /** Gas used by this transaction */
+    gasUsed: bigint;
+    /** Logs bloom filter */
+    logsBloom: Hex;
+    /** `success` if this transaction was successful or `reverted` if it failed */
+    status: "success" | "reverted";
+    /** Transaction recipient or `null` if deploying a contract */
+    to: Address | null;
+    /** Transaction type */
+    type: TransactionType;
+};
+type Trace = {
+    /** Globally unique identifier for this trace (`${transactionHash}-${tracePosition}`) */
+    id: string;
+    /** The type of the call. */
+    type: "CALL" | "CALLCODE" | "DELEGATECALL" | "STATICCALL" | "CREATE" | "CREATE2" | "SELFDESTRUCT";
+    /** The address of that initiated the call. */
+    from: Address;
+    /** The address of the contract that was called. */
+    to: Address | null;
+    /** How much gas was left before the call. */
+    gas: bigint;
+    /** How much gas was used by the call. */
+    gasUsed: bigint;
+    /** Calldata input. */
+    input: Hex;
+    /** Output of the call, if any. */
+    output?: Hex;
+    /** Error message, if any. */
+    error?: string;
+    /** Why this call reverted, if it reverted. */
+    revertReason?: string;
+    /** Value transferred. */
+    value: bigint | null;
+    /** Index of this trace in the transaction. */
+    traceIndex: number;
+    /** Number of subcalls. */
+    subcalls: number;
+};
+/** A native token transfer. */
+type Transfer = {
+    /** The address that sent the transfer */
+    from: Address;
+    /** The address that received the transfer */
+    to: Address;
+    /** The amount of tokens transferred */
+    value: bigint;
+};
+
+/**
+ * Fix issue with Array.isArray not checking readonly arrays
+ * {@link https://github.com/microsoft/TypeScript/issues/17002}
+ */
+declare global {
+    interface ArrayConstructor {
+        isArray(arg: ReadonlyArray<any> | any): arg is ReadonlyArray<any>;
+    }
+}
+
+/** User-defined tables, enums, and indexes. */
+type Schema = {
+    [name: string]: unknown;
+};
+
+type Drizzle<TSchema extends Schema = {
+    [name: string]: never;
+}> = NodePgDatabase<TSchema> | PgliteDatabase<TSchema>;
+type ReadonlyDrizzle<TSchema extends Schema = {
+    [name: string]: never;
+}> = Omit<Drizzle<TSchema>, "insert" | "update" | "delete" | "transaction" | "refreshMaterializedView" | "_">;
+type Db<schema extends Schema> = {
+    /**
+     * Find a row
+     *
+     * - Docs: https://ponder.sh/docs/indexing/write-to-the-database#find
+     *
+     * @example
+     * ```ts twoslash
+     * const result = await db.find(table, { id: 10 });
+     * ```
+     *
+     * @param table - The table to select from.
+     * @param key - The primary key.
+     * @returns The row if it exists or undefined if it doesn't.
+     */
+    find: Find;
+    /**
+     * Create new rows
+     *
+     * - Docs: https://ponder.sh/docs/indexing/write-to-the-database#insert
+     *
+     * @example
+     * ```ts twoslash
+     * await db.insert(table).values({ id: 10, name: "joe" });
+     * ```
+     *
+     * @example
+     * ```ts twoslash
+     * await db.insert(table).values([
+     *   { id: 10, name: "joe" },
+     *   { id: 3, name: "rob" }
+     * ]);
+     * ```
+     *
+     * @example
+     * ```ts twoslash
+     * await db.insert(table).values({ id: 10, name: "joe" }).onConflictDoNothing();
+     * ```
+     *
+     * @example
+     * ```ts twoslash
+     * await db
+     *   .insert(table)
+     *   .values({ id: 10, name: "joe" })
+     *   .onConflictDoUpdate((row) => ({ age: row.age + 3 }));
+     * ```
+     *
+     * @param table - The table to insert into.
+     */
+    insert: Insert;
+    /**
+     * Update a row
+     *
+     * - Docs: https://ponder.sh/docs/indexing/write-to-the-database#update
+     *
+     * @example
+     * ```ts twoslash
+     * await db
+     *   .update(table, { id: 10 })
+     *   .set({ age: 19 });
+     * ```
+     *
+     * @example
+     * ```ts twoslash
+     * await db
+     *   .update(table, { id: 10 })
+     *   .set((row) => ({ age: row.age + 3 }));
+     * ```
+     *
+     * @param table - The table to select from.
+     * @param key - The primary key.
+     */
+    update: Update;
+    /**
+     * Delete a row
+     *
+     * - Docs: https://ponder.sh/docs/indexing/write-to-the-database#delete
+     *
+     * @example
+     * ```ts twoslash
+     * const deleted = await db.delete(table, { id: 10 });
+     * ```
+     *
+     * @param table - The table to select from.
+     * @param key - The primary key.
+     * @returns `true` if the row existed.
+     */
+    delete: Delete;
+    /**
+     * Access the raw drizzle object
+     *
+     * - Docs: https://ponder.sh/docs/indexing/write-to-the-database#raw-sql
+     */
+    sql: Prettify<Omit<Drizzle<schema>, "refreshMaterializedView" | "_">>;
+};
+type InferPrimaryKey<table extends Table, columns extends Record<string, Column> = table["_"]["columns"], columnNames extends keyof columns & string = keyof columns & string> = columnNames extends columnNames ? columns[columnNames]["_"]["isPrimaryKey"] extends true ? columnNames : never : never;
+type Key<table extends Table, compositePrimaryKey extends keyof table["_"]["columns"] = InferCompositePrimaryKey<table>, primaryKey extends keyof table["_"]["columns"] = [
+    compositePrimaryKey
+] extends [never] ? InferPrimaryKey<table> : compositePrimaryKey> = {
+    [columnName in primaryKey]: GetColumnData<table["_"]["columns"][columnName]>;
+};
+type InferCompositePrimaryKey<table extends OnchainTable<TableConfig & {
+    extra: PgTableExtraConfig | undefined;
+}>, extra extends PgTableExtraConfig | undefined = table["_"]["config"]["extra"], builders = extra[keyof extra]> = builders extends builders ? builders extends PrimaryKeyBuilder ? builders["columnNames"] : never : never;
+type Find = <table extends Table>(table: table extends {
+    [onchain]: true;
+} ? table : PonderTypeError<`db.find() can only be used with onchain tables, and '${table["_"]["name"]}' is an offchain table.`>, key: Key<table>) => Promise<InferSelectModel<table> | null>;
+type Insert = <table extends Table, insertModel = InferInsertModel<table>, selectModel = InferSelectModel<table>, updateModel = Prettify<Omit<insertModel, keyof Key<table>>>, updateFn = (row: selectModel) => Partial<updateModel>>(table: table extends {
+    [onchain]: true;
+} ? table : PonderTypeError<`Indexing functions can only write to onchain tables, and '${table["_"]["name"]}' is an offchain table.`>) => {
+    /**
+     * Create new rows
+     *
+     * - Docs: https://ponder.sh/docs/indexing/write-to-the-database#insert
+     *
+     * @example
+     * ```ts twoslash
+     * await db.insert(table).values({ id: 10, name: "joe" });
+     * ```
+     *
+     * @example
+     * ```ts twoslash
+     * await db.insert(table).values([
+     *   { id: 10, name: "joe" },
+     *   { id: 3, name: "rob" }
+     * ]);
+     * ```
+     * @param table - The table to insert into.
+     */
+    values: <values extends insertModel | insertModel[]>(values: values) => Promise<values extends unknown[] ? selectModel[] : selectModel> & {
+        /**
+         * Create new rows, cancelling the insert if there is a conflict
+         *
+         * - Docs: https://ponder.sh/docs/indexing/write-to-the-database#upsert--conflict-resolution
+         * @example
+         * ```ts twoslash
+         * await db.insert(table).values({ id: 10, name: "joe" }).onConflictDoNothing();
+         * ```
+         * @param table - The table to insert into.
+         */
+        onConflictDoNothing: () => Promise<values extends unknown[] ? (selectModel | null)[] : selectModel | null>;
+        /**
+         * Create new rows, updating the row if there is a conflict
+         *
+         * - Docs: https://ponder.sh/docs/indexing/write-to-the-database#upsert--conflict-resolution
+         *
+         * @example
+         * ```ts twoslash
+         * await db
+         *   .insert(table)
+         *   .values({ id: 10, name: "joe" })
+         *   .onConflictDoUpdate({ age: 24 });
+         * ```
+         *
+         * @example
+         * ```ts twoslash
+         * await db
+         *   .insert(table)
+         *   .values({ id: 10, name: "joe" })
+         *   .onConflictDoUpdate((row) => ({ age: row.age + 3 }));
+         * ```
+         *
+         * @param table - The table to insert into.
+         */
+        onConflictDoUpdate: (values: Partial<updateModel> | updateFn) => Promise<values extends unknown[] ? selectModel[] : selectModel>;
+    };
+};
+type Update = <table extends Table, insertModel = InferInsertModel<table>, selectModel = InferSelectModel<table>, insertValues = Prettify<Omit<insertModel, keyof Key<table>>>, updateFn = (row: selectModel) => Partial<insertModel>>(table: table extends {
+    [onchain]: true;
+} ? table : PonderTypeError<`Indexing functions can only write to onchain tables, and '${table["_"]["name"]}' is an offchain table.`>, key: Key<table>) => {
+    /**
+     * Update a row
+     *
+     * - Docs: https://ponder.sh/docs/indexing/write-to-the-database#update
+     *
+     * @example
+     * ```ts twoslash
+     * await db
+     *   .update(table, { id: 10 })
+     *   .set({ age: 19 });
+     * ```
+     *
+     * @example
+     * ```ts twoslash
+     * await db
+     *   .update(table, { id: 10 })
+     *   .set((row) => ({ age: row.age + 3 }));
+     * ```
+     *
+     * @param table - The table to select from.
+     * @param key - The primary key.
+     */
+    set: (values: Partial<insertValues> | updateFn) => Promise<selectModel>;
+};
+type Delete = <table extends Table>(table: table extends {
+    [onchain]: true;
+} ? table : PonderTypeError<`Indexing functions can only write to onchain tables, and '${table["_"]["name"]}' is an offchain table.`>, key: Key<table>) => Promise<boolean>;
+
+/** Viem actions where the `block` property is optional and implicit. */
+declare const blockDependentActions: readonly ["getBalance", "call", "estimateGas", "getFeeHistory", "getProof", "getCode", "getStorageAt", "getEnsAddress", "getEnsAvatar", "getEnsName", "getEnsResolver", "getEnsText"];
+/** Viem actions where the `block` property is non-existent. */
+declare const nonBlockDependentActions: readonly ["getTransaction", "getTransactionReceipt", "getTransactionConfirmations"];
+type BlockOptions = {
+    cache?: undefined;
+    blockNumber?: undefined;
+} | {
+    cache: "immutable";
+    blockNumber?: undefined;
+} | {
+    cache?: undefined;
+    blockNumber: bigint;
+};
+type RequiredBlockOptions = {
+    /** Hash of the block. */
+    blockHash: Hash;
+    blockNumber?: undefined;
+} | {
+    blockHash?: undefined;
+    /** The block number. */
+    blockNumber: bigint;
+};
+type BlockDependentAction<fn extends (client: any, args: any) => unknown, params = Parameters<fn>[0], returnType = ReturnType<fn>> = (args: Omit<params, "blockTag" | "blockNumber"> & BlockOptions) => returnType;
+type PonderActions = {
+    [action in (typeof blockDependentActions)[number]]: BlockDependentAction<ReturnType<typeof publicActions>[action]>;
+} & {
+    multicall: <const contracts extends readonly unknown[], allowFailure extends boolean = true>(args: Omit<MulticallParameters<contracts, allowFailure>, "blockTag" | "blockNumber"> & BlockOptions) => Promise<MulticallReturnType<contracts, allowFailure>>;
+    readContract: <const abi extends Abi$1 | readonly unknown[], functionName extends ContractFunctionName<abi, "pure" | "view">, const args extends ContractFunctionArgs<abi, "pure" | "view", functionName>>(args: Omit<ReadContractParameters<abi, functionName, args>, "blockTag" | "blockNumber"> & BlockOptions) => Promise<ReadContractReturnType<abi, functionName, args>>;
+    simulateContract: <const abi extends Abi$1 | readonly unknown[], functionName extends ContractFunctionName<abi, "nonpayable" | "payable">, const args extends ContractFunctionArgs<abi, "nonpayable" | "payable", functionName>>(args: Omit<SimulateContractParameters<abi, functionName, args>, "blockTag" | "blockNumber"> & BlockOptions) => Promise<SimulateContractReturnType<abi, functionName, args>>;
+    getBlock: <includeTransactions extends boolean = false>(args: {
+        /** Whether or not to include transaction data in the response. */
+        includeTransactions?: includeTransactions | undefined;
+    } & RequiredBlockOptions) => Promise<GetBlockReturnType<Chain | undefined, includeTransactions>>;
+    getTransactionCount: (args: {
+        /** The account address. */
+        address: Address;
+    } & RequiredBlockOptions) => Promise<GetTransactionCountReturnType>;
+    getBlockTransactionCount: (args: RequiredBlockOptions) => Promise<GetBlockTransactionCountReturnType>;
+} & Pick<PublicActions, (typeof nonBlockDependentActions)[number]>;
+type ReadOnlyClient<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined> = Prettify<Omit<Client<transport, chain, undefined, PublicRpcSchema, PonderActions>, "extend" | "key" | "batch" | "cacheTime" | "account" | "type" | "uid" | "chain" | "name" | "pollingInterval" | "transport" | "ccipRead">>;
+
+declare namespace Virtual {
+    type Setup = "setup";
+    type _FormatEventNames<contract extends Config["contracts"][string], safeEventNames = SafeEventNames<contract["abi"]>> = string extends safeEventNames ? never : safeEventNames;
+    type _FormatFunctionNames<contract extends Config["contracts"][string], safeFunctionNames = SafeFunctionNames<contract["abi"]>> = string extends safeFunctionNames ? never : safeFunctionNames;
+    /** "{ContractName}:{EventName}" | "{ContractName}.{FunctionName}()" | "{SourceName}:block" | "{SourceName}:transaction:from" . */
+    export type FormatEventNames<contracts extends Config["contracts"], accounts extends Config["accounts"], blocks extends Config["blocks"]> = {
+        [name in keyof contracts]: `${name & string}:${_FormatEventNames<contracts[name]> | Setup}`;
+    }[keyof contracts] | {
+        [name in keyof accounts]: `${name & string}:${"transaction" | "transfer"}:${"from" | "to"}`;
+    }[keyof accounts] | {
+        [name in keyof blocks]: `${name & string}:block`;
+    }[keyof blocks] | {
+        [name in keyof contracts]: true extends ExtractOverridenProperty<contracts[name], "includeCallTraces"> ? `${name & string}.${_FormatFunctionNames<contracts[name]>}` : never;
+    }[keyof contracts];
+    type FormatTransactionReceipts<source extends Config["contracts" | "accounts"][string], includeTxr = ExtractOverridenProperty<source, "includeTransactionReceipts">> = includeTxr extends includeTxr ? includeTxr extends true ? {
+        transactionReceipt: Prettify<TransactionReceipt>;
+    } : {
+        transactionReceipt?: never;
+    } : never;
+    export type ExtractEventName<name extends string> = name extends `${string}:${infer EventName extends string}` ? EventName : name extends `${string}.${infer EventName extends string}` ? EventName : never;
+    export type ExtractSourceName<name extends string> = name extends `${infer SourceName extends string}:${string}` ? SourceName : name extends `${infer SourceName extends string}.${string}` ? SourceName : never;
+    export type EventNames<config extends Config> = FormatEventNames<config["contracts"], config["accounts"], config["blocks"]>;
+    export type Event<config extends Config, name extends EventNames<config>, sourceName extends ExtractSourceName<name> = ExtractSourceName<name>, eventName extends ExtractEventName<name> = ExtractEventName<name>> = name extends `${string}:block` ? {
+        block: Prettify<Block>;
+    } : name extends `${string}:transaction:${"from" | "to"}` ? {
+        block: Prettify<Block>;
+        transaction: Prettify<Transaction>;
+        transactionReceipt: Prettify<TransactionReceipt>;
+    } : name extends `${string}:transfer:${"from" | "to"}` ? // 3. transfer event
+    {
+        transfer: Prettify<Transfer>;
+        block: Prettify<Block>;
+        transaction: Prettify<Transaction>;
+        trace: Prettify<Trace>;
+    } & FormatTransactionReceipts<config["accounts"][sourceName]> : name extends `${string}.${string}` ? Prettify<{
+        args: FormatFunctionArgs<config["contracts"][sourceName]["abi"], eventName>;
+        result: FormatFunctionResult<config["contracts"][sourceName]["abi"], eventName>;
+        trace: Prettify<Trace>;
+        block: Prettify<Block>;
+        transaction: Prettify<Transaction>;
+    } & FormatTransactionReceipts<config["contracts"][sourceName]>> : eventName extends Setup ? never : Prettify<{
+        name: eventName;
+        args: FormatEventArgs<config["contracts"][sourceName]["abi"], eventName>;
+        log: Prettify<Log>;
+        block: Prettify<Block>;
+        transaction: Prettify<Transaction>;
+    } & FormatTransactionReceipts<config["contracts"][sourceName]>>;
+    type ContextContractProperty = Exclude<keyof Config["contracts"][string], "abi" | "network" | "filter" | "factory">;
+    type ExtractOverridenProperty<contract extends Config["contracts" | "accounts"][string], property extends ContextContractProperty, base = Extract<contract, {
+        [p in property]: unknown;
+    }>[property], override = Extract<contract["network"][keyof contract["network"]], {
+        [p in property]: unknown;
+    }>[property]> = ([base] extends [never] ? undefined : base) | override;
+    export type Context<config extends Config, schema extends Schema, name extends EventNames<config>, sourceName extends ExtractSourceName<name> = ExtractSourceName<name>, sourceNetwork = sourceName extends sourceName ? (unknown extends config["contracts"][sourceName]["network"] ? never : config["contracts"][sourceName]["network"]) | (unknown extends config["blocks"][sourceName]["network"] ? never : config["blocks"][sourceName]["network"]) : never> = {
+        contracts: {
+            [_contractName in keyof config["contracts"]]: {
+                abi: config["contracts"][_contractName]["abi"];
+                address: ExtractOverridenProperty<config["contracts"][_contractName], "address">;
+                startBlock: ExtractOverridenProperty<config["contracts"][_contractName], "startBlock">;
+                endBlock: ExtractOverridenProperty<config["contracts"][_contractName], "endBlock">;
+            };
+        };
+        network: sourceNetwork extends string ? {
+            name: sourceNetwork;
+            chainId: config["networks"][sourceNetwork]["chainId"];
+        } : {
+            [key in keyof sourceNetwork]: {
+                name: key;
+                chainId: config["networks"][key & keyof config["networks"]]["chainId"];
+            };
+        }[keyof sourceNetwork];
+        client: Prettify<ReadOnlyClient>;
+        db: Db<schema>;
+    };
+    export type IndexingFunctionArgs<config extends Config, schema extends Schema, name extends EventNames<config>> = {
+        event: Event<config, name>;
+        context: Context<config, schema, name>;
+    };
+    export type Registry<config extends Config, schema extends Schema> = {
+        on: <name extends EventNames<config>>(_name: name, indexingFunction: (args: {
+            event: Event<config, name>;
+        } & {
+            context: Prettify<Context<config, schema, name>>;
+        }) => Promise<void> | void) => void;
+    };
+    export {  };
+}
+
+/**
+ * Middleware for `@ponder/client`.
+ *
+ * @param db - Drizzle database instance
+ * @param schema - Ponder schema
+ *
+ * @example
+ * ```ts
+ * import { db } from "ponder:api";
+ * import schema from "ponder:schema";
+ * import { Hono } from "hono";
+ * import { client } from "ponder";
+ *
+ * const app = new Hono();
+ *
+ * app.use("/sql/*", client({ db, schema }));
+ *
+ * export default app;
+ * ```
+ */
+declare const client: ({ db, }: {
+    db: ReadonlyDrizzle<Schema>;
+    schema: Schema;
+}) => hono.MiddlewareHandler<any, string, {}>;
+
+/**
+ * Middleware for GraphQL with an interactive web view.
+ *
+ * - Docs: https://ponder.sh/docs/query/api-functions#register-graphql-middleware
+ *
+ * @example
+ * import { db } from "ponder:api";
+ * import schema from "ponder:schema";
+ * import { graphql } from "@/index.js";
+ * import { Hono } from "hono";
+ *
+ * const app = new Hono();
+ *
+ * app.use("/graphql", graphql({ db, schema }));
+ *
+ * export default app;
+ *
+ */
+declare const graphql: ({ db, schema }: {
+    db: ReadonlyDrizzle<Schema>;
+    schema: Schema;
+}, { maxOperationTokens, maxOperationDepth, maxOperationAliases, }?: {
+    maxOperationTokens?: number | undefined;
+    maxOperationDepth?: number | undefined;
+    maxOperationAliases?: number | undefined;
+}) => hono.MiddlewareHandler<any, string, {}>;
+
+type ContractConfig = Prettify<Config["contracts"][string]>;
+type NetworkConfig = Prettify<Config["networks"][string]>;
+type BlockConfig = Prettify<Config["blocks"][string]>;
+type DatabaseConfig = Prettify<Config["database"]>;
+
+export { type Block, type BlockConfig, type ContractConfig, type DatabaseConfig, type Log, type NetworkConfig, type ReadonlyDrizzle, type Transaction, type TransactionReceipt, Virtual, client, createConfig, factory, graphql };