@secondlayer/subgraphs 3.21.0 → 3.22.0

package/dist/src/index.d.ts

@@ -25,15 +25,24 @@ interface SubgraphRelation {
 	/** Target column(s) the fields point at (a uniqueKeys entry on the target). */
 	referencedColumns: string[];
 }
-/** Table definition within a subgraph schema */
+/**
+* Table definition within a subgraph schema.
+*
+* The array fields are `readonly` so a schema literal can be hoisted out of
+* the `defineSubgraph()` call with `as const` (or {@link defineSchema}) and
+* still typecheck — `as const` produces `readonly [readonly ["holder"]]`,
+* which a mutable `string[][]` rejects. Without that, extracting a helper
+* that takes `ctx` meant losing the entire typed surface, which is why the
+* shipped starter reached for `ctx: any`.
+*/
 interface SubgraphTable {
 	columns: Record<string, SubgraphColumn>;
 	/** Composite indexes (each entry is an array of column names) */
-	indexes?: string[][];
+	indexes?: readonly (readonly string[])[];
 	/** Unique key constraints (each entry is an array of column names). Required for upsert. */
-	uniqueKeys?: string[][];
+	uniqueKeys?: readonly (readonly string[])[];
 	/** Foreign-key relations to other tables (for typed ORM joins). */
-	relations?: SubgraphRelation[];
+	relations?: readonly SubgraphRelation[];
 }
 /** Subgraph schema — maps table names to table definitions */
 type SubgraphSchema = Record<string, SubgraphTable>;
@@ -68,6 +77,45 @@ interface StxLockFilter {
 type TraitScope = {
 	trait?: string
 };
+/**
+* Scope a source to a DYNAMIC address set discovered from another source's
+* events, instead of a fixed contract list.
+*
+* The standard shape it unlocks: a router plus pools created after you
+* deploy. `contractId` arrays cover a set you know at authoring time; a
+* factory covers the set that grows. It is deliberately NOT tied to contract
+* deployment — the address can come from any field of any event, so it also
+* covers launchpad-minted tokens, DAO extension allowlists, and registry
+* entries.
+*
+* ```ts
+* sources: {
+*   registry: { type: "print_event", contractId: REGISTRY, topic: "pool-created" },
+*   swaps: {
+*     type: "print_event",
+*     topic: "swap",
+*     // every pool the registry has ever announced, including new ones
+*     factory: { from: "registry", field: "data.pool" },
+*   },
+* }
+* ```
+*
+* Two guarantees the runtime provides:
+* - **Same-block ordering** — a contract discovered in block N receives its
+*   own block-N events. Discovery runs before matching, within the block.
+* - **Reorg-scoped** — the discovered set is stamped with the block that
+*   revealed it and rolled back with everything else on a fork, so an address
+*   announced on an orphaned chain does not linger forever.
+*/
+interface FactoryScope {
+	factory?: {
+		/** Source name whose events reveal the addresses. */
+		from: string
+		/** Dotted path to the address on that source's payload
+		*  (e.g. `"data.pool"`, `"contractId"`, `"data.token.id"`). */
+		field: string
+	};
+}
 /** FT event filters */
 interface FtTransferFilter extends TraitScope {
 	type: "ft_transfer";
@@ -147,9 +195,19 @@ interface ContractCallEvent {
 	};
 }
 /** Contract event filters */
-interface ContractCallFilter extends TraitScope {
+interface ContractCallFilter extends TraitScope, FactoryScope {
 	type: "contract_call";
-	contractId?: string;
+	/**
+	* One contract id, or a SET of them (max 20) — the standard DeFi shape is
+	* a router plus N pools, which used to cost N near-identical sources and
+	* handlers, or the `"*"` catch-all that erases per-source typing. Payload
+	* types are identical per `type`, so one handler serves the set and
+	* `event.contractId` disambiguates.
+	*
+	* Supports `*` wildcards (e.g. `"SP1ABC….pool-*"`). Mutually exclusive
+	* with `trait`, which resolves its own set per block.
+	*/
+	contractId?: string | readonly string[];
 	functionName?: string;
 	caller?: string;
 	/**
@@ -187,9 +245,11 @@ type PrintField = ColumnType | {
 } | {
 	list: PrintField
 };
-interface PrintEventFilter extends TraitScope {
+interface PrintEventFilter extends TraitScope, FactoryScope {
 	type: "print_event";
-	contractId?: string;
+	/** One contract id, or a set of them (max 20). Supports `*` wildcards.
+	*  Mutually exclusive with `trait`. */
+	contractId?: string | readonly string[];
 	topic?: string;
 	/**
 	* Per-topic field schema. When declared, the handler's `event` is a
@@ -285,6 +345,16 @@ interface SubgraphDefinition {
 * Validates a subgraph definition, returning the parsed result or throwing on failure.
 */
 declare function validateSubgraphDefinition(def: unknown): SubgraphDefinition;
+/**
+* Per-source-type field vocabulary, DERIVED from
+* {@link SubgraphFilterSchema}. Agent-facing surfaces (the MCP filters
+* reference) used to hand-maintain a parallel copy of this list; deriving it
+* means adding a field to a filter can never leave the documentation behind.
+*/
+declare function filterFieldsByType(): Array<{
+	type: string
+	fields: string[]
+}>;
 interface ReindexOptions {
 	fromBlock?: number;
 	toBlock?: number;
@@ -737,6 +807,48 @@ declare function defineSubgraph<
 	const Sources extends Record<string, SubgraphFilter>,
 	const S extends SubgraphSchema
 >(def: TypedSubgraphDefinition<Sources, S>): TypedSubgraphDefinition<Sources, S>;
+/**
+* Identity helper that preserves a schema literal's exact types so it can be
+* HOISTED out of the `defineSubgraph()` call and reused:
+*
+* ```ts
+* const schema = defineSchema({
+*   balances: {
+*     columns: { holder: { type: "principal" }, amount: { type: "uint" } },
+*     uniqueKeys: [["holder"]],
+*   },
+* });
+*
+* // An extracted helper keeps the full typed surface — table names and row
+* // columns are still checked:
+* function credit(ctx: TypedSubgraphContext<typeof schema>, holder: string) {
+*   ctx.increment("balances", { holder }, { amount: 1n });
+* }
+*
+* defineSubgraph({ name: "balances", schema, sources, handlers });
+* ```
+*
+* `as const` alone does not work here (it produces `readonly` arrays that a
+* mutable `uniqueKeys` rejected) and a bare literal widens `type` to `string`.
+* That gap is why the shipped starter typed its helper `ctx: any` — and in
+* doing so modelled a non-commutative read-modify-write the docs warn against.
+*/
+declare function defineSchema<const S extends SubgraphSchema>(schema: S): S;
+/**
+* The typed handler context for a subgraph definition — for annotating
+* helpers extracted out of a handler:
+*
+* ```ts
+* const def = defineSubgraph({ … });
+* function credit(ctx: InferContext<typeof def>) { … }
+* ```
+*
+* Prefer `TypedSubgraphContext<typeof schema>` when the schema is hoisted;
+* this is the form for when only the definition is in scope.
+*/
+type InferContext<D> = D extends {
+	schema: infer S extends SubgraphSchema
+} ? TypedSubgraphContext<S> : never;
 type PrintValidationResult = {
 	ok: true
 } | {
@@ -988,4 +1100,4 @@ type SparseProbeTarget = {
 declare function canSparseScan(subgraph: SubgraphDefinition): boolean;
 /** Probe targets for a subgraph's filters: decoded type + contract scope when\\n*  the filter pins one (assetIdentifier "SP….contract::asset" or contractId). */
 declare function sparseProbeTargets(subgraph: SubgraphDefinition): SparseProbeTarget[];
-export { validateSubgraphDefinition, validatePrintPayload, sparseProbeTargets, resumeReindex, renderDeployPlan, reindexSubgraph, pgSchemaName, inferPrintTopics, hasBreakingChanges, generateSubgraphSQL, generatePrismaSchema, generateKyselySchema, generateIndexSchema, generateDrizzleSchema, diffSchema, deploySchema, defineSubgraph, canSparseScan, camelizeDataKey, backfillSubgraph, WriteRow, WhereInput, TypedSubgraphDefinition, TypedSubgraphContext, TypedHandlers, TxMeta, TableDiff, SystemRow, SubscribeOptions, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferPayload, StxTransferFilter, StxMintPayload, StxMintFilter, StxLockPayload, StxLockFilter, StxBurnPayload, StxBurnFilter, SparseProbeTarget, RowValue, ReindexOptions, PrismaGenOptions, PrintValidationResult, PrintSample, PrintFieldToTS, PrintField, PrintEventPayload, PrintEventFor, PrintEventFilter, PrintDataOf, NftTransferPayload, NftTransferFilter, NftMintPayload, NftMintFilter, NftBurnPayload, NftBurnFilter, KyselyGenOptions, InferredTopicSchema, InferredPrintField, InferTableRow, InferSubgraphClient, InferColumnType, IndexCodegenTarget, IndexCodegenOptions, INDEX_CODEGEN_TABLES, GeneratedSQL, FtTransferPayload, FtTransferFilter, FtMintPayload, FtMintFilter, FtBurnPayload, FtBurnFilter, FindManyOptions, EventForFilter, DrizzleGenOptions, DeployPlan, DeployDiff, ContractDeployPayload, ContractDeployFilter, ContractCallPayload, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff, ByoMigrationPlan, ByoBreakingChangeError, AnyEvent, AggregateSpec, AggregateResult };
+export { validateSubgraphDefinition, validatePrintPayload, sparseProbeTargets, resumeReindex, renderDeployPlan, reindexSubgraph, pgSchemaName, inferPrintTopics, hasBreakingChanges, generateSubgraphSQL, generatePrismaSchema, generateKyselySchema, generateIndexSchema, generateDrizzleSchema, filterFieldsByType, diffSchema, deploySchema, defineSubgraph, defineSchema, canSparseScan, camelizeDataKey, backfillSubgraph, WriteRow, WhereInput, TypedSubgraphDefinition, TypedSubgraphContext, TypedHandlers, TxMeta, TableDiff, SystemRow, SubscribeOptions, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferPayload, StxTransferFilter, StxMintPayload, StxMintFilter, StxLockPayload, StxLockFilter, StxBurnPayload, StxBurnFilter, SparseProbeTarget, RowValue, ReindexOptions, PrismaGenOptions, PrintValidationResult, PrintSample, PrintFieldToTS, PrintField, PrintEventPayload, PrintEventFor, PrintEventFilter, PrintDataOf, NftTransferPayload, NftTransferFilter, NftMintPayload, NftMintFilter, NftBurnPayload, NftBurnFilter, KyselyGenOptions, InferredTopicSchema, InferredPrintField, InferTableRow, InferSubgraphClient, InferContext, InferColumnType, IndexCodegenTarget, IndexCodegenOptions, INDEX_CODEGEN_TABLES, GeneratedSQL, FtTransferPayload, FtTransferFilter, FtMintPayload, FtMintFilter, FtBurnPayload, FtBurnFilter, FindManyOptions, FactoryScope, EventForFilter, DrizzleGenOptions, DeployPlan, DeployDiff, ContractDeployPayload, ContractDeployFilter, ContractCallPayload, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff, ByoMigrationPlan, ByoBreakingChangeError, AnyEvent, AggregateSpec, AggregateResult };

package/dist/src/index.js

@@ -86,24 +86,105 @@ var VALID_FILTER_TYPES = [
   "contract_deploy",
   "print_event"
 ];
-var SubgraphFilterSchema = z.object({
-  type: z.enum(VALID_FILTER_TYPES),
-  sender: z.string().optional(),
-  recipient: z.string().optional(),
+var contractIdField = z.union([
+  z.string(),
+  z.array(z.string()).min(1).max(20)
+]);
+var traitScope = { trait: z.string().optional() };
+var factoryScope = {
+  factory: z.object({ from: z.string().min(1), field: z.string().min(1) }).strict().optional()
+};
+var amountRange = {
   minAmount: z.bigint().optional(),
-  maxAmount: z.bigint().optional(),
-  assetIdentifier: z.string().optional(),
-  contractId: z.string().optional(),
-  functionName: z.string().optional(),
-  caller: z.string().optional(),
-  deployer: z.string().optional(),
-  contractName: z.string().optional(),
-  topic: z.string().optional(),
-  lockedAddress: z.string().optional(),
-  abi: AbiContractSchema.optional(),
-  trait: z.string().optional(),
-  prints: z.record(z.string(), z.record(z.string(), PrintFieldSchema)).optional()
-}).strict();
+  maxAmount: z.bigint().optional()
+};
+var SubgraphFilterUnion = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("stx_transfer"),
+    sender: z.string().optional(),
+    recipient: z.string().optional(),
+    ...amountRange
+  }).strict(),
+  z.object({
+    type: z.literal("stx_mint"),
+    recipient: z.string().optional(),
+    minAmount: z.bigint().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("stx_burn"),
+    sender: z.string().optional(),
+    minAmount: z.bigint().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("stx_lock"),
+    lockedAddress: z.string().optional(),
+    minAmount: z.bigint().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("ft_transfer"),
+    assetIdentifier: z.string().optional(),
+    sender: z.string().optional(),
+    recipient: z.string().optional(),
+    minAmount: z.bigint().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("ft_mint"),
+    assetIdentifier: z.string().optional(),
+    recipient: z.string().optional(),
+    minAmount: z.bigint().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("ft_burn"),
+    assetIdentifier: z.string().optional(),
+    sender: z.string().optional(),
+    minAmount: z.bigint().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("nft_transfer"),
+    assetIdentifier: z.string().optional(),
+    sender: z.string().optional(),
+    recipient: z.string().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("nft_mint"),
+    assetIdentifier: z.string().optional(),
+    recipient: z.string().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("nft_burn"),
+    assetIdentifier: z.string().optional(),
+    sender: z.string().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("contract_call"),
+    contractId: contractIdField.optional(),
+    functionName: z.string().optional(),
+    caller: z.string().optional(),
+    abi: AbiContractSchema.optional(),
+    ...traitScope,
+    ...factoryScope
+  }).strict(),
+  z.object({
+    type: z.literal("contract_deploy"),
+    deployer: z.string().optional(),
+    contractName: z.string().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("print_event"),
+    contractId: contractIdField.optional(),
+    topic: z.string().optional(),
+    prints: z.record(z.string(), z.record(z.string(), PrintFieldSchema)).optional(),
+    ...traitScope,
+    ...factoryScope
+  }).strict()
+]);
+var SubgraphFilterSchema = SubgraphFilterUnion;
 var SubgraphDefinitionSchema = z.object({
   name: SubgraphNameSchema,
   version: z.string().optional(),
@@ -117,6 +198,23 @@ var SubgraphDefinitionSchema = z.object({
 function validateSubgraphDefinition(def) {
   return SubgraphDefinitionSchema.parse(def);
 }
+function filterFieldsByType() {
+  const options = SubgraphFilterUnion?._def?.options ?? [];
+  const out = [];
+  for (const option of options) {
+    const shape = option?.shape ?? option?._def?.shape;
+    if (!shape)
+      continue;
+    const literal = shape.type?._def?.values?.[0] ?? shape.type?._def?.value ?? undefined;
+    if (typeof literal !== "string")
+      continue;
+    out.push({
+      type: literal,
+      fields: Object.keys(shape).filter((k) => k !== "type")
+    });
+  }
+  return out;
+}
 
 // src/runtime/context.ts
 import { logger } from "@secondlayer/shared/logger";
@@ -217,6 +315,18 @@ function emitJournalDDL(schemaName) {
     `CREATE INDEX IF NOT EXISTS idx_${schemaName}_journal_height ON ${schemaName}._journal (block_height)`
   ];
 }
+function emitFactoryDDL(schemaName) {
+  return [
+    `CREATE TABLE IF NOT EXISTS ${schemaName}._factory_addresses (
+  source_name TEXT NOT NULL,
+  address TEXT NOT NULL,
+  block_height BIGINT NOT NULL,
+  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  PRIMARY KEY (source_name, address)
+)`,
+    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_factory_height ON ${schemaName}._factory_addresses (block_height)`
+  ];
+}
 function emitForeignKeyDDL(schemaName, tableName, tableDef) {
   return (tableDef.relations ?? []).map((rel) => {
     const constraintName = `fk_${schemaName}_${tableName}_${rel.name}`;
@@ -235,6 +345,9 @@ function generateSubgraphSQL(def, schemaNameOverride) {
     statements.push(...emitTableDDL(schemaName, tableName, tableDef));
   }
   statements.push(...emitJournalDDL(schemaName));
+  if (Object.values(def.sources ?? {}).some((src) => src.factory !== undefined)) {
+    statements.push(...emitFactoryDDL(schemaName));
+  }
   for (const [tableName, tableDef] of Object.entries(def.schema)) {
     statements.push(...emitForeignKeyDDL(schemaName, tableName, tableDef));
   }
@@ -379,23 +492,21 @@ class SubgraphContext {
   formatUnits(value, decimals) {
     return formatUnits(value, decimals);
   }
-  async findOne(table, where) {
-    this.validateTable(table);
+  async readRows(table, where, limit) {
     const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
     const { clause } = buildWhereClause(where);
-    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause} LIMIT 1`;
+    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause}${limit !== undefined ? ` LIMIT ${limit}` : ""}`;
     const { rows } = await sql.raw(query).execute(this.db);
-    const row = rows[0] ?? null;
-    return this.overlayOne(table, where, row ? this.coerceRow(table, row) : null);
+    return rows.map((r) => this.coerceRow(table, r));
+  }
+  async findOne(table, where) {
+    this.validateTable(table);
+    const row = (await this.readRows(table, where, 1))[0] ?? null;
+    return this.overlayOne(table, where, row);
   }
   async findMany(table, where) {
     this.validateTable(table);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const { clause } = buildWhereClause(where);
-    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause}`;
-    const { rows } = await sql.raw(query).execute(this.db);
-    const dbRows = rows.map((r) => this.coerceRow(table, r));
-    return this.overlayMany(table, where, dbRows);
+    return this.overlayMany(table, where, await this.readRows(table, where));
   }
   overlayOne(table, where, dbRow) {
     if (this.ops.length === 0)
@@ -1315,6 +1426,9 @@ async function runHandlers(subgraph, matched, ctx, opts) {
 
 // src/runtime/source-matcher.ts
 var patternCache = new Map;
+function matchAny(value, pattern) {
+  return Array.isArray(pattern) ? pattern.some((p) => matchPattern(value, p)) : matchPattern(value, pattern);
+}
 function matchPattern(value, pattern) {
   if (!pattern.includes("*"))
     return value === pattern;
@@ -1327,6 +1441,22 @@ function matchPattern(value, pattern) {
   return re.test(value);
 }
 var EMPTY_SET = new Set;
+function factoryAllows(filter, contractId, factoryContracts) {
+  if (!filter.factory)
+    return true;
+  if (!contractId)
+    return false;
+  return (factoryContracts.get(filter.factory.from) ?? EMPTY_SET).has(contractId);
+}
+function readPath(payload, path) {
+  let cur = payload;
+  for (const key of path.split(".")) {
+    if (cur === null || typeof cur !== "object")
+      return;
+    cur = cur[key];
+  }
+  return cur;
+}
 function traitAllows(filter, contractId, traitContracts) {
   const trait = filter.trait;
   if (!trait)
@@ -1338,7 +1468,7 @@ function traitAllows(filter, contractId, traitContracts) {
 function assetContract(assetId) {
   return assetId?.split("::")[0];
 }
-function matchFilter(filter, transactions, eventsByTx, traitContracts) {
+function matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts = new Map) {
   const results = [];
   switch (filter.type) {
     case "stx_transfer":
@@ -1465,9 +1595,11 @@ function matchFilter(filter, transactions, eventsByTx, traitContracts) {
         if (tx.type !== "contract_call")
           continue;
         if (filter.contractId) {
-          if (!tx.contract_id || !matchPattern(tx.contract_id, filter.contractId))
+          if (!tx.contract_id || !matchAny(tx.contract_id, filter.contractId))
             continue;
         }
+        if (!factoryAllows(filter, tx.contract_id, factoryContracts))
+          continue;
         if (filter.functionName) {
           if (!tx.function_name || !matchPattern(tx.function_name, filter.functionName))
             continue;
@@ -1514,11 +1646,13 @@ function matchFilter(filter, transactions, eventsByTx, traitContracts) {
             return false;
           const printContractId = data.contract_identifier ?? data.contract_id;
           if (filter.contractId) {
-            if (!printContractId || !matchPattern(printContractId, filter.contractId))
+            if (!printContractId || !matchAny(printContractId, filter.contractId))
               return false;
           }
           if (!traitAllows(filter, printContractId, traitContracts))
             return false;
+          if (!factoryAllows(filter, printContractId, factoryContracts))
+            return false;
           return true;
         });
         if (matched.length > 0) {
@@ -1530,7 +1664,7 @@ function matchFilter(filter, transactions, eventsByTx, traitContracts) {
   }
   return results;
 }
-function matchSources(sources, transactions, events, traitContracts = new Map) {
+function matchSources(sources, transactions, events, traitContracts = new Map, factoryContracts = new Map) {
   const eventsByTx = new Map;
   for (const event of events) {
     const list = eventsByTx.get(event.tx_id) ?? [];
@@ -1540,7 +1674,7 @@ function matchSources(sources, transactions, events, traitContracts = new Map) {
   const seen = new Set;
   const results = [];
   for (const [sourceName, filter] of Object.entries(sources)) {
-    const matches = matchFilter(filter, transactions, eventsByTx, traitContracts);
+    const matches = matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts);
     for (const match of matches) {
       const dedupeKey = `${match.tx.tx_id}:${sourceName}`;
       if (!seen.has(dedupeKey)) {
@@ -2195,6 +2329,57 @@ async function resolveRoute(subgraphName, targetDb) {
 function invalidateSubgraphRoute(subgraphName) {
   routeCache.delete(subgraphName);
 }
+async function resolveFactoryContracts(subgraph, blockHeight, schemaName, db, txs, evts) {
+  const factories = new Map;
+  for (const source of Object.values(subgraph.sources)) {
+    const factory = source.factory;
+    if (factory)
+      factories.set(factory.from, factory);
+  }
+  const resolved = new Map;
+  const discovered = [];
+  if (factories.size === 0)
+    return { resolved, discovered };
+  for (const [discoveringSource, factory] of factories) {
+    const known = new Set;
+    try {
+      const rows = await sql3`
+				SELECT address FROM ${sql3.raw(`"${schemaName}"."_factory_addresses"`)}
+				WHERE source_name = ${discoveringSource} AND block_height <= ${blockHeight}
+			`.execute(db);
+      for (const row of rows.rows)
+        known.add(row.address);
+    } catch {}
+    const discovering = subgraph.sources[factory.from];
+    if (discovering) {
+      const matches = matchSources({ [factory.from]: discovering }, txs, evts, new Map, new Map);
+      for (const match of matches) {
+        for (const event of match.events ?? []) {
+          const payload = buildEventPayload(discovering, match.tx, event);
+          const value = readPath(payload, factory.field);
+          if (typeof value === "string" && value.length > 0 && !known.has(value)) {
+            known.add(value);
+            discovered.push({ sourceName: discoveringSource, address: value });
+          }
+        }
+      }
+    }
+    resolved.set(discoveringSource, known);
+  }
+  return { resolved, discovered };
+}
+async function persistFactoryDiscoveries(schemaName, db, blockHeight, discovered) {
+  if (discovered.length === 0)
+    return;
+  for (const { sourceName, address } of discovered) {
+    await sql3`
+			INSERT INTO ${sql3.raw(`"${schemaName}"."_factory_addresses"`)}
+				(source_name, address, block_height)
+			VALUES (${sourceName}, ${address}, ${blockHeight})
+			ON CONFLICT (source_name, address) DO NOTHING
+		`.execute(db);
+  }
+}
 async function resolveTraitContracts(subgraph, blockHeight, db) {
   const traits = new Set;
   for (const source of Object.values(subgraph.sources)) {
@@ -2281,8 +2466,11 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     txs = data.txs;
     evts = data.events;
   }
+  const route = await resolveRoute(subgraphName, targetDb);
+  const schemaName = route.schemaName;
   const traitContracts = await resolveTraitContracts(subgraph, blockHeight, targetDb);
-  const matched = matchSources(subgraph.sources, txs, evts, traitContracts);
+  const { resolved: factoryContracts, discovered } = await resolveFactoryContracts(subgraph, blockHeight, schemaName, targetDb, txs, evts);
+  const matched = matchSources(subgraph.sources, txs, evts, traitContracts, factoryContracts);
   result.matched = matched.length;
   if (matched.length === 0) {
     if (!opts?.skipProgressUpdate) {
@@ -2290,8 +2478,6 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     }
     return result;
   }
-  const route = await resolveRoute(subgraphName, targetDb);
-  const schemaName = route.schemaName;
   const blockMeta = {
     height: block.height,
     hash: block.hash,
@@ -2349,6 +2535,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     });
     result.processed = runResult.processed;
     result.errors = runResult.errors;
+    await persistFactoryDiscoveries(schemaName, route.dataDb, blockHeight, discovered);
     await targetDb.transaction().execute(async (tx) => {
       if (manifest && manifest.count > 0) {
         await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
@@ -3068,6 +3255,9 @@ async function backfillSubgraph(def, opts) {
 function defineSubgraph(def) {
   return def;
 }
+function defineSchema(schema) {
+  return schema;
+}
 // src/print-schema.ts
 import {
   deserializeCV as deserializeCV3
@@ -3987,8 +4177,8 @@ function diffKeyLists(existing, incoming) {
   const existingSet = new Set((existing ?? []).map(key2));
   const incomingSet = new Set((incoming ?? []).map(key2));
   return {
-    added: (incoming ?? []).filter((cols) => !existingSet.has(key2(cols))),
-    removed: (existing ?? []).filter((cols) => !incomingSet.has(key2(cols)))
+    added: (incoming ?? []).filter((cols) => !existingSet.has(key2(cols))).map((cols) => [...cols]),
+    removed: (existing ?? []).filter((cols) => !incomingSet.has(key2(cols))).map((cols) => [...cols])
   };
 }
 function diffSchema(existing, incoming) {
@@ -4345,9 +4535,11 @@ export {
   generateKyselySchema,
   generateIndexSchema,
   generateDrizzleSchema,
+  filterFieldsByType,
   diffSchema,
   deploySchema,
   defineSubgraph,
+  defineSchema,
   canSparseScan,
   camelizeDataKey,
   backfillSubgraph,
@@ -4355,5 +4547,5 @@ export {
   ByoBreakingChangeError
 };
 
-//# debugId=1014943AF0D5A26B64756E2164756E21
+//# debugId=8BECEC189376FB2B64756E2164756E21
 //# sourceMappingURL=index.js.map