ponder 0.9.3 → 0.9.4-debug.1

package/dist/db-in86nyw7.d.ts

@@ -0,0 +1,625 @@
+import { onchain, OnchainTable, PrimaryKeyBuilder } from './drizzle/onchain.js';
+import { AbiEvent, AbiFunction } from 'abitype';
+import { Hex, Hash, Address, AccessList, TransactionType, Abi, Transport, Chain, LogTopic } from 'viem';
+import { P as Prettify, a as PonderTypeError } from './utils-ceNucOJb.js';
+import { Table, InferSelectModel, InferInsertModel, GetColumnData, Column as Column$1 } from 'drizzle-orm';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { TableConfig, PgTableExtraConfig } from 'drizzle-orm/pg-core';
+import { PgliteDatabase } from 'drizzle-orm/pglite';
+
+/**
+ * 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;
+};
+
+type SqlStatements = {
+    tables: {
+        sql: string[];
+        json: JsonCreateTableStatement[];
+    };
+    enums: {
+        sql: string[];
+        json: JsonCreateEnumStatement[];
+    };
+    indexes: {
+        sql: string[];
+        json: JsonPgCreateIndexStatement[];
+    };
+};
+type Index = any;
+type Column = any;
+interface JsonCreateTableStatement {
+    type: "create_table";
+    tableName: string;
+    schema: string;
+    columns: Column[];
+    compositePKs: string[];
+    compositePkName?: string;
+    uniqueConstraints?: string[];
+    checkConstraints?: string[];
+}
+interface JsonCreateEnumStatement {
+    type: "create_type_enum";
+    name: string;
+    schema: string;
+    values: string[];
+}
+interface JsonPgCreateIndexStatement {
+    type: "create_index_pg";
+    tableName: string;
+    data: Index;
+    schema: string;
+}
+
+/**
+ * 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>;
+    }
+}
+type AbiEventMeta = {
+    safeName: string;
+    signature: string;
+    selector: Hex;
+    item: AbiEvent;
+};
+type AbiFunctionMeta = {
+    safeName: string;
+    signature: string;
+    selector: Hex;
+    item: AbiFunction;
+};
+type AbiEvents = {
+    bySafeName: {
+        [key: string]: AbiEventMeta | undefined;
+    };
+    bySelector: {
+        [key: Hex]: AbiEventMeta | undefined;
+    };
+};
+type AbiFunctions = {
+    bySafeName: {
+        [key: string]: AbiFunctionMeta | undefined;
+    };
+    bySelector: {
+        [key: Hex]: AbiFunctionMeta | undefined;
+    };
+};
+
+/** Indexing functions for event callbacks */
+type IndexingFunctions = {
+    [eventName: string]: (...args: any) => any;
+};
+/** Filter that matches addresses. */
+type Factory = LogFactory;
+type FilterAddress<factory extends Factory | undefined = Factory | undefined> = factory extends Factory ? factory : Address | Address[] | undefined;
+type LogFilter<factory extends Factory | undefined = Factory | undefined> = {
+    type: "log";
+    chainId: number;
+    address: FilterAddress<factory>;
+    topic0: LogTopic;
+    topic1: LogTopic;
+    topic2: LogTopic;
+    topic3: LogTopic;
+    fromBlock: number | undefined;
+    toBlock: number | undefined;
+    include: (`block.${keyof Block}` | `transaction.${keyof Transaction}` | `transactionReceipt.${keyof TransactionReceipt}` | `log.${keyof Log}`)[] | undefined;
+};
+type BlockFilter = {
+    type: "block";
+    chainId: number;
+    interval: number;
+    offset: number;
+    fromBlock: number | undefined;
+    toBlock: number | undefined;
+    include: `block.${keyof Block}`[] | undefined;
+};
+type TransferFilter<fromFactory extends Factory | undefined = Factory | undefined, toFactory extends Factory | undefined = Factory | undefined> = {
+    type: "transfer";
+    chainId: number;
+    fromAddress: FilterAddress<fromFactory>;
+    toAddress: FilterAddress<toFactory>;
+    includeReverted: boolean;
+    fromBlock: number | undefined;
+    toBlock: number | undefined;
+    include: (`block.${keyof Block}` | `transaction.${keyof Transaction}` | `transactionReceipt.${keyof TransactionReceipt}` | `trace.${keyof Trace}`)[] | undefined;
+};
+type TransactionFilter<fromFactory extends Factory | undefined = Factory | undefined, toFactory extends Factory | undefined = Factory | undefined> = {
+    type: "transaction";
+    chainId: number;
+    fromAddress: FilterAddress<fromFactory>;
+    toAddress: FilterAddress<toFactory>;
+    includeReverted: boolean;
+    fromBlock: number | undefined;
+    toBlock: number | undefined;
+    include: (`block.${keyof Block}` | `transaction.${keyof Transaction}` | `transactionReceipt.${keyof TransactionReceipt}`)[] | undefined;
+};
+type TraceFilter<fromFactory extends Factory | undefined = Factory | undefined, toFactory extends Factory | undefined = Factory | undefined> = {
+    type: "trace";
+    chainId: number;
+    fromAddress: FilterAddress<fromFactory>;
+    toAddress: FilterAddress<toFactory>;
+    functionSelector: Hex | Hex[] | undefined;
+    callType: Trace["type"] | undefined;
+    includeReverted: boolean;
+    fromBlock: number | undefined;
+    toBlock: number | undefined;
+    include: (`block.${keyof Block}` | `transaction.${keyof Transaction}` | `transactionReceipt.${keyof TransactionReceipt}` | `trace.${keyof Trace}`)[] | undefined;
+};
+type LogFactory = {
+    type: "log";
+    chainId: number;
+    address: Address | Address[];
+    eventSelector: Hex;
+    childAddressLocation: "topic1" | "topic2" | "topic3" | `offset${number}`;
+};
+type FragmentAddressId = Address | `${Address}_${Factory["eventSelector"]}_${Factory["childAddressLocation"]}` | null;
+type FragmentTopic = Hex | null;
+/** Minimum slice of a {@link Filter} */
+type FragmentId = 
+/** block_{chainId}_{interval}_{offset} */
+`block_${number}_${number}_${number}`
+/** transaction_{chainId}_{fromAddress}_{toAddress} */
+ | `transaction_${number}_${FragmentAddressId}_${FragmentAddressId}`
+/** trace_{chainId}_{fromAddress}_{toAddress}_{functionSelector}_{includeReceipts} */
+ | `trace_${number}_${FragmentAddressId}_${FragmentAddressId}_${Hex | null}_${0 | 1}`
+/** log_{chainId}_{address}_{topic0}_{topic1}_{topic2}_{topic3}_{includeReceipts} */
+ | `log_${number}_${FragmentAddressId}_${FragmentTopic}_${FragmentTopic}_${FragmentTopic}_${FragmentTopic}_${0 | 1}`
+/** transfer_{chainId}_{fromAddress}_{toAddress}_{includeReceipts} */
+ | `transfer_${number}_${FragmentAddressId}_${FragmentAddressId}_${0 | 1}`;
+/** Event source that matches {@link Event}s containing an underlying filter and metadata. */
+type Source = ContractSource | AccountSource | BlockSource;
+type ContractSource<filter extends "log" | "trace" = "log" | "trace", factory extends Factory | undefined = Factory | undefined, fromFactory extends Factory | undefined = Factory | undefined, toFactory extends Factory | undefined = Factory | undefined> = {
+    filter: filter extends "log" ? LogFilter<factory> : TraceFilter<fromFactory, toFactory>;
+} & ContractMetadata;
+type AccountSource<filter extends "transaction" | "transfer" = "transaction" | "transfer", fromFactory extends Factory | undefined = Factory | undefined, toFactory extends Factory | undefined = Factory | undefined> = {
+    filter: filter extends "transaction" ? TransactionFilter<fromFactory, toFactory> : TransferFilter<fromFactory, toFactory>;
+} & AccountMetadata;
+type BlockSource = {
+    filter: BlockFilter;
+} & BlockMetadata;
+type ContractMetadata = {
+    type: "contract";
+    abi: Abi;
+    abiEvents: AbiEvents;
+    abiFunctions: AbiFunctions;
+    name: string;
+    network: Network;
+};
+type AccountMetadata = {
+    type: "account";
+    name: string;
+    network: Network;
+};
+type BlockMetadata = {
+    type: "block";
+    name: string;
+    network: Network;
+};
+type Network = {
+    name: string;
+    chainId: number;
+    transport: ReturnType<Transport>;
+    chain: Chain;
+    pollingInterval: number;
+    maxRequestsPerSecond: number;
+    finalityBlockCount: number;
+    disableCache: boolean;
+};
+/** User-defined tables, enums, and indexes. */
+type Schema = {
+    [name: string]: unknown;
+};
+type SchemaBuild = {
+    schema: Schema;
+    /** SQL statements to create the schema */
+    statements: SqlStatements;
+};
+type IndexingBuild = {
+    /** Ten character hex string identifier. */
+    buildId: string;
+    /** Sources to index. */
+    sources: Source[];
+    /** Networks to index. */
+    networks: Network[];
+    /** Event callbacks for all `sources`.  */
+    indexingFunctions: IndexingFunctions;
+};
+
+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$1> = 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>;
+
+export type { Block as B, Db as D, FragmentId as F, IndexingBuild as I, Log as L, ReadonlyDrizzle as R, Schema as S, TransactionReceipt as T, Transaction as a, Transfer as b, Trace as c, Drizzle as d, SchemaBuild as e };