@mikeatlast/ponder 0.16.1-fork.1

package/src/types/eth.ts

@@ -0,0 +1,216 @@
+import type { AccessList, Address, Hash, Hex, TransactionType } from "viem";
+import type { Prettify } from "./utils.js";
+
+/**
+ * A confirmed Ethereum block.
+ *
+ * @link https://docs.soliditylang.org/en/v0.8.20/introduction-to-smart-contracts.html#blocks
+ */
+export 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
+ */
+export 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
+ */
+export type Log = {
+  /** 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;
+  /**
+   * Indicates if this log was removed in a chain reorganization.
+   *
+   * Ponder automatically handles reorgs, so this will always be `false`.
+   */
+  removed: boolean;
+  /** List of order-dependent topics */
+  topics: [Hex, ...Hex[]] | [];
+};
+
+/** A confirmed Ethereum transaction receipt. */
+export 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;
+};
+
+export type Trace = {
+  /** 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. */
+export 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;
+};

package/src/types/utils.ts

@@ -0,0 +1,47 @@
+/**
+ * @description Combines members of an intersection into a readable type.
+ *
+ * @link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+ * @example
+ * Prettify<{ a: string } | { b: string } | { c: number, d: bigint }>
+ * => { a: string, b: string, c: number, d: bigint }
+ */
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+/**
+ * @description Creates a type with all keys K from T as non-null.
+ */
+export type NonNull<T> = {
+  [P in keyof T]-?: NonNullable<T[P]>;
+};
+
+export type PonderTypeError<error extends string> = error;
+
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends (infer U)[]
+    ? DeepPartial<U>[]
+    : T[P] extends object
+      ? DeepPartial<T[P]>
+      : T[P];
+};
+
+/**
+ * @description Creates a partial type with the selected keys required.
+ *
+ * @example
+ * type t = PartialExcept<{ a: string, b: boolean }, "a">
+ * //   ^? t: { a: string, b?: boolean }
+ */
+export type PartialExcept<T, K extends keyof T> = {
+  [P in K]: T[P];
+} & {
+  [P in keyof Omit<T, K>]?: T[P];
+};
+
+/**
+ * @description Marks a property of an object as optional.
+ */
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> &
+  Partial<Pick<T, K>>;

package/src/types/virtual.ts

@@ -0,0 +1,244 @@
+import type { Config } from "@/config/index.js";
+import type {
+  FormatEventArgs,
+  FormatFunctionArgs,
+  FormatFunctionResult,
+  SafeEventNames,
+  SafeFunctionNames,
+} from "@/config/utilityTypes.js";
+import type { ReadonlyClient } from "@/indexing/client.js";
+import type { Schema } from "@/internal/types.js";
+import type {
+  Block,
+  Log,
+  Trace,
+  Transaction,
+  TransactionReceipt,
+  Transfer,
+} from "@/types/eth.js";
+import type { Db } from "./db.js";
+import type { Prettify } from "./utils.js";
+
+export 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`
+    ? // 1. block event
+      {
+        id: string;
+        block: Prettify<Block>;
+      }
+    : name extends `${string}:transaction:${"from" | "to"}`
+      ? // 2. transaction event
+        {
+          id: string;
+          block: Prettify<Block>;
+          transaction: Prettify<Transaction>;
+          transactionReceipt: Prettify<TransactionReceipt>;
+        }
+      : name extends `${string}:transfer:${"from" | "to"}`
+        ? // 3. transfer event
+          {
+            id: string;
+            transfer: Prettify<Transfer>;
+            block: Prettify<Block>;
+            transaction: Prettify<Transaction>;
+            trace: Prettify<Trace>;
+          } & FormatTransactionReceipts<config["accounts"][sourceName]>
+        : name extends `${string}.${string}`
+          ? // 4. call trace event
+            Prettify<
+              {
+                id: string;
+                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
+            ? // 5. setup event
+              never
+            : // 6. log event
+              Prettify<
+                {
+                  id: string;
+                  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" | "chain" | "filter" | "factory"
+  >;
+
+  type ExtractOverridenProperty<
+    contract extends Config["contracts" | "accounts"][string],
+    property extends ContextContractProperty,
+    ///
+    base = Extract<contract, { [p in property]: unknown }>[property],
+    override = Extract<
+      contract["chain"][keyof contract["chain"]],
+      { [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>,
+    sourceChain = sourceName extends sourceName
+      ?
+          | (unknown extends config["contracts"][sourceName]["chain"]
+              ? never
+              : config["contracts"][sourceName]["chain"])
+          | (unknown extends config["blocks"][sourceName]["chain"]
+              ? never
+              : config["blocks"][sourceName]["chain"])
+      : 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"
+        >;
+      };
+    };
+    chain: sourceChain extends string
+      ? // 1. No chain overriding
+        {
+          name: sourceChain;
+          id: config["chains"][sourceChain]["id"];
+        }
+      : // 2. Chain overrides
+        {
+          [key in keyof sourceChain]: {
+            name: key;
+            id: config["chains"][key & keyof config["chains"]]["id"];
+          };
+        }[keyof sourceChain];
+    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;
+  };
+}

package/src/types.d.ts

@@ -0,0 +1,38 @@
+declare module "ponder:registry" {
+  import type { Virtual } from "ponder";
+  type config = typeof import("ponder:internal").config;
+  type schema = typeof import("ponder:internal").schema;
+
+  export const ponder: Virtual.Registry<config["default"], schema>;
+
+  export type EventNames = Virtual.EventNames<config["default"]>;
+  export type Event<name extends EventNames = EventNames> = Virtual.Event<
+    config["default"],
+    name
+  >;
+  export type Context<name extends EventNames = EventNames> = Virtual.Context<
+    config["default"],
+    schema,
+    name
+  >;
+  export type IndexingFunctionArgs<name extends EventNames = EventNames> =
+    Virtual.IndexingFunctionArgs<config["default"], schema, name>;
+}
+
+declare module "ponder:schema" {
+  const schema: typeof import("ponder:internal").schema;
+  export { schema as default };
+}
+
+declare module "ponder:api" {
+  import type { ReadonlyDrizzle } from "ponder";
+  import type { PublicClient } from "viem";
+
+  type schema = typeof import("ponder:internal").schema;
+  type config = typeof import("ponder:internal").config;
+
+  export const db: ReadonlyDrizzle<schema>;
+  export const publicClients: {
+    [chainName in keyof config["default"]["chains"]]: PublicClient;
+  };
+}