@secondlayer/shared 11.21.0 → 11.23.0

package/dist/src/archive/range-digest.d.ts

@@ -19,6 +19,27 @@ type FailureClass = (typeof FAILURE_CLASSES)[number];
 declare const RETRY_STATES: readonly ["open", "retrying", "halted", "resolved"];
 type RetryState = (typeof RETRY_STATES)[number];
 type BootstrapSource = "archive" | "genesis" | "import";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 interface BlocksTable {
 	height: number;
 	hash: string;
@@ -179,6 +200,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }

package/dist/src/archive/semantic-digest-builder.d.ts

@@ -19,6 +19,27 @@ type FailureClass = (typeof FAILURE_CLASSES)[number];
 declare const RETRY_STATES: readonly ["open", "retrying", "halted", "resolved"];
 type RetryState = (typeof RETRY_STATES)[number];
 type BootstrapSource = "archive" | "genesis" | "import";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 interface BlocksTable {
 	height: number;
 	hash: string;
@@ -179,6 +200,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }

package/dist/src/coverage/index.d.ts

@@ -336,6 +336,27 @@ declare function cursorIsBeforeBlock(cursor: StreamsCursor, height: number): boo
 declare function planDecoderReceipts(input: DecoderClockInput): DecoderClockResult;
 import { Kysely } from "kysely";
 import { ColumnType, Generated } from "kysely";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 interface BlocksTable {
 	height: number;
 	hash: string;
@@ -496,6 +517,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }

package/dist/src/db/index.d.ts

@@ -20,6 +20,27 @@ type FailureClass = (typeof FAILURE_CLASSES)[number];
 declare const RETRY_STATES: readonly ["open", "retrying", "halted", "resolved"];
 type RetryState = (typeof RETRY_STATES)[number];
 type BootstrapSource = "archive" | "genesis" | "import";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 interface BlocksTable {
 	height: number;
 	hash: string;
@@ -180,6 +201,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }

package/dist/src/db/queries/chain-reorgs.d.ts

@@ -19,6 +19,27 @@ type FailureClass = (typeof FAILURE_CLASSES)[number];
 declare const RETRY_STATES: readonly ["open", "retrying", "halted", "resolved"];
 type RetryState = (typeof RETRY_STATES)[number];
 type BootstrapSource = "archive" | "genesis" | "import";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 interface BlocksTable {
 	height: number;
 	hash: string;
@@ -179,6 +200,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }

package/dist/src/db/queries/contracts.d.ts

@@ -19,6 +19,27 @@ type FailureClass = (typeof FAILURE_CLASSES)[number];
 declare const RETRY_STATES: readonly ["open", "retrying", "halted", "resolved"];
 type RetryState = (typeof RETRY_STATES)[number];
 type BootstrapSource = "archive" | "genesis" | "import";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 interface BlocksTable {
 	height: number;
 	hash: string;
@@ -179,6 +200,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }

package/dist/src/db/queries/instance.d.ts

@@ -19,6 +19,27 @@ type FailureClass = (typeof FAILURE_CLASSES)[number];
 declare const RETRY_STATES: readonly ["open", "retrying", "halted", "resolved"];
 type RetryState = (typeof RETRY_STATES)[number];
 type BootstrapSource = "archive" | "genesis" | "import";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 interface BlocksTable {
 	height: number;
 	hash: string;
@@ -179,6 +200,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }

package/dist/src/db/queries/integrity.d.ts

@@ -19,6 +19,27 @@ type FailureClass = (typeof FAILURE_CLASSES)[number];
 declare const RETRY_STATES: readonly ["open", "retrying", "halted", "resolved"];
 type RetryState = (typeof RETRY_STATES)[number];
 type BootstrapSource = "archive" | "genesis" | "import";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 interface BlocksTable {
 	height: number;
 	hash: string;
@@ -179,6 +200,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }

package/dist/src/db/queries/subgraph-gaps.d.ts

@@ -19,6 +19,27 @@ type FailureClass = (typeof FAILURE_CLASSES)[number];
 declare const RETRY_STATES: readonly ["open", "retrying", "halted", "resolved"];
 type RetryState = (typeof RETRY_STATES)[number];
 type BootstrapSource = "archive" | "genesis" | "import";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 interface BlocksTable {
 	height: number;
 	hash: string;
@@ -179,6 +200,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }

package/dist/src/db/queries/subgraph-operations.d.ts

@@ -19,6 +19,27 @@ type FailureClass = (typeof FAILURE_CLASSES)[number];
 declare const RETRY_STATES: readonly ["open", "retrying", "halted", "resolved"];
 type RetryState = (typeof RETRY_STATES)[number];
 type BootstrapSource = "archive" | "genesis" | "import";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 interface BlocksTable {
 	height: number;
 	hash: string;
@@ -179,6 +200,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }

package/dist/src/db/queries/subgraphs.d.ts

@@ -1,4 +1,25 @@
 import { Kysely } from "kysely";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
 import { ColumnType, Generated, Selectable } from "kysely";
 /**
 * Coverage-kernel constraints. SQL CHECKs in migration 0116 must stay
@@ -179,6 +200,14 @@ interface SubgraphsTable {
 	expires_at: Date | null;
 	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
 	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
 	created_at: Generated<Date>;
 	updated_at: Generated<Date>;
 }
@@ -1110,6 +1139,9 @@ declare function registerSubgraph(db: Kysely<Database>, data: {
 	startBlock?: number
 	handlerCode?: string
 	sourceCode?: string
+	pin?: string | null
+	pinPreimage?: string | null
+	verification?: SubgraphVerification | null
 }): Promise<Subgraph>;
 declare function getSubgraph(db: Kysely<Database>, name: string, accountId?: string): Promise<Subgraph | null>;
 declare function listSubgraphs(db: Kysely<Database>, accountId?: string): Promise<Subgraph[]>;
@@ -1140,6 +1172,9 @@ declare function clearSubgraphBillingPaused(db: Kysely<Database>, name: string):
 declare function updateSubgraphHandlerPath(db: Kysely<Database>, name: string, handlerPath: string, opts?: {
 	handlerCode?: string
 	sourceCode?: string
+	pin?: string | null
+	pinPreimage?: string | null
+	verification?: SubgraphVerification | null
 }): Promise<void>;
 declare function deleteSubgraph(db: Kysely<Database>, name: string, accountId?: string): Promise<Subgraph | null>;
 /** Set or clear a paid subgraph's expiry (NULL = no expiry, e.g. on claim). */

package/dist/src/db/queries/subgraphs.js

@@ -92,7 +92,10 @@ async function registerSubgraph(db, data) {
     handler_code: data.handlerCode ?? null,
     source_code: data.sourceCode ?? null,
     schema_name: data.schemaName ?? null,
-    start_block: data.startBlock ?? 0
+    start_block: data.startBlock ?? 0,
+    pin: data.pin ?? null,
+    pin_preimage: data.pinPreimage ?? null,
+    verification: data.verification ? jsonb(data.verification) : null
   };
   const updateSet = {
     version: data.version,
@@ -103,6 +106,9 @@ async function registerSubgraph(db, data) {
     source_code: data.sourceCode ?? null,
     schema_name: data.schemaName ?? null,
     start_block: data.startBlock ?? 0,
+    pin: values.pin,
+    pin_preimage: values.pin_preimage,
+    verification: values.verification,
     updated_at: new Date
   };
   if (!isPlatformMode()) {
@@ -166,6 +172,11 @@ async function updateSubgraphHandlerPath(db, name, handlerPath, opts) {
     handler_path: handlerPath,
     ...opts?.handlerCode != null ? { handler_code: opts.handlerCode } : {},
     ...opts?.sourceCode != null ? { source_code: opts.sourceCode } : {},
+    ...opts?.pin !== undefined ? { pin: opts.pin } : {},
+    ...opts?.pinPreimage !== undefined ? { pin_preimage: opts.pinPreimage } : {},
+    ...opts?.verification !== undefined ? {
+      verification: opts.verification ? jsonb(opts.verification) : null
+    } : {},
     updated_at: new Date
   }).where("name", "=", name).execute();
 }
@@ -220,5 +231,5 @@ export {
   updateSubgraphStatus
 };
 
-//# debugId=23059D593B71468164756E2164756E21
+//# debugId=3407FD67D654BD8464756E2164756E21
 //# sourceMappingURL=subgraphs.js.map