@polygonlabs/staker-pool-allocations-schemas 0.1.0

package/dist/registry-public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-public.d.ts","sourceRoot":"","sources":["../src/registry-public.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAQ9D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAMP,CAAC"}

package/dist/registry-public.js

@@ -0,0 +1,31 @@
+// Registry composition for the public REST API (`packages/rest-api`).
+//
+// `TypedRegistry` accumulates registered operations into its type via
+// chained method returns — `registerPath` and `with(fn)` each return a
+// `TypedRegistry` narrowed with what was just registered. The chain's
+// final value is what `buildPublicRegistry` returns; the rest-api service
+// derives its typed handler map from it via
+// `HandlerMapFor<typeof buildPublicRegistry>` and the OpenAPI document is
+// generated from the same registry's `definitions`, so the served spec
+// and the mounted routes cannot drift.
+//
+// To add a route: append a `.registerPath({...})` call inside the relevant
+// per-domain helper under `./routes-public/`, or add a new domain helper
+// and `.with(addNewDomainRoutes)` here. Always chain or capture every
+// registration — see `@polygonlabs/openapi-registry`'s "The one rule".
+//
+// The worker's management surface composes its own registry; this one
+// carries only the read-only public endpoints.
+import { TypedRegistry } from '@polygonlabs/openapi-registry';
+import { addAddressRoutes } from "./routes-public/addresses.js";
+import { addAllocationRoutes } from "./routes-public/allocations.js";
+import { addDistributionRoutes } from "./routes-public/distributions.js";
+import { addOperationalRoutes } from "./routes-public/operational.js";
+import { addProofRoutes } from "./routes-public/proofs.js";
+export const buildPublicRegistry = () => new TypedRegistry()
+    .with(addOperationalRoutes)
+    .with(addDistributionRoutes)
+    .with(addAllocationRoutes)
+    .with(addAddressRoutes)
+    .with(addProofRoutes);
+//# sourceMappingURL=registry-public.js.map

package/dist/registry-public.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-public.js","sourceRoot":"","sources":["../src/registry-public.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,EAAE;AACF,sEAAsE;AACtE,uEAAuE;AACvE,sEAAsE;AACtE,0EAA0E;AAC1E,4CAA4C;AAC5C,0EAA0E;AAC1E,uEAAuE;AACvE,uCAAuC;AACvC,EAAE;AACF,2EAA2E;AAC3E,yEAAyE;AACzE,sEAAsE;AACtE,uEAAuE;AACvE,EAAE;AACF,sEAAsE;AACtE,+CAA+C;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,EAAE,CACtC,IAAI,aAAa,EAAE;KAChB,IAAI,CAAC,oBAAoB,CAAC;KAC1B,IAAI,CAAC,qBAAqB,CAAC;KAC3B,IAAI,CAAC,mBAAmB,CAAC;KACzB,IAAI,CAAC,gBAAgB,CAAC;KACtB,IAAI,CAAC,cAAc,CAAC,CAAC"}

package/dist/routes-management/distributions.d.ts

@@ -0,0 +1,137 @@
+import type { RouteWithOpId, TypedRegistry } from '@polygonlabs/openapi-registry';
+import { z } from '../zod.ts';
+export declare const addManagementDistributionRoutes: <Ops extends Record<string, RouteWithOpId>, Schemes extends Record<string, true>>(r: TypedRegistry<Ops, Schemes>) => TypedRegistry<Ops & {
+    triggerDistribution: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "triggerDistribution";
+        readonly method: "post";
+        readonly path: "/v1/{network}/management/distributions";
+        readonly summary: "Trigger a new distribution run";
+        readonly description: string;
+        readonly security: [{
+            readonly ApiKeyAuth: [];
+        }];
+        readonly request: {
+            readonly params: z.ZodObject<{
+                network: z.ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, z.core.$strip>;
+            readonly body: {
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            startPoSBlock: z.ZodString;
+                            endPoSBlock: z.ZodString;
+                            distributionId: z.ZodOptional<z.ZodString>;
+                            force: z.ZodOptional<z.ZodBoolean>;
+                            polUsdPrice: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+        readonly responses: {
+            readonly 202: {
+                readonly description: "Trigger accepted. Status reflects the row at the moment of acceptance.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            network: z.ZodEnum<{
+                                mainnet: "mainnet";
+                                amoy: "amoy";
+                            }>;
+                            distributionId: z.ZodString;
+                            status: z.ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                completed: "completed";
+                                failed: "failed";
+                            }>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+            readonly 409: {
+                readonly description: "`force: true` on a non-terminal distribution.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            error: z.ZodLiteral<true>;
+                            message: z.ZodString;
+                            info: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    deleteDistribution: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "deleteDistribution";
+        readonly method: "delete";
+        readonly path: "/v1/{network}/management/distributions/{distributionId}";
+        readonly summary: "Remove a stale distribution";
+        readonly description: string;
+        readonly security: [{
+            readonly ApiKeyAuth: [];
+        }];
+        readonly request: {
+            readonly params: z.ZodObject<{
+                network: z.ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: z.ZodString;
+            }, z.core.$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "The distribution and its allocations were removed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            network: z.ZodEnum<{
+                                mainnet: "mainnet";
+                                amoy: "amoy";
+                            }>;
+                            distributionId: z.ZodString;
+                            removed: z.ZodBoolean;
+                            priorStatus: z.ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                failed: "failed";
+                            }>;
+                            deletedAllocations: z.ZodNumber;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "No distribution with that (network, id).";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            error: z.ZodLiteral<true>;
+                            message: z.ZodString;
+                            info: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+            readonly 409: {
+                readonly description: "The distribution is `completed` and cannot be deleted.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            error: z.ZodLiteral<true>;
+                            message: z.ZodString;
+                            info: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, Schemes>;
+//# sourceMappingURL=distributions.d.ts.map

package/dist/routes-management/distributions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributions.d.ts","sourceRoot":"","sources":["../../src/routes-management/distributions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAUlF,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAQ9B,eAAO,MAAM,+BAA+B,GAC1C,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EACzC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,EAEpC,GAAG,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgE1B,CAAC"}

package/dist/routes-management/distributions.js

@@ -0,0 +1,72 @@
+import { ErrorResponseSchema } from '@polygonlabs/openapi-registry/error-schemas';
+import { NetworkSchema, DistributionIdSchema } from "../common.js";
+import { DistributionDeleteResponseSchema, DistributionTriggerRequestSchema, DistributionTriggerResponseSchema } from "../management.js";
+import { z } from "../zod.js";
+// Management distribution routes. Both carry `security: [{ ApiKeyAuth: [] }]`
+// — the registry-driven router runs the ApiKeyAuth handler before request
+// validation, so an unauthenticated request 401s without parsing the body.
+// 400 (validation), 401 (auth), and 500 are auto-injected by TypedRegistry
+// from the declared request/security shape; only the handler-emitted codes
+// (404, 409) are declared explicitly here.
+export const addManagementDistributionRoutes = (r) => r
+    .registerPath({
+    operationId: 'triggerDistribution',
+    method: 'post',
+    path: '/v1/{network}/management/distributions',
+    summary: 'Trigger a new distribution run',
+    description: 'Kicks off the in-process worker against the specified PoS block range. ' +
+        "Async — returns 202 with the row's current status and the worker runs " +
+        'out-of-band on the same pod. Operators poll the public distributions ' +
+        'endpoint (or the management :id view, Phase 1 follow-up) for terminal ' +
+        'state.\n\n' +
+        'Requires `x-api-key` header. Idempotent on `distributionId` when supplied. ' +
+        'Set `force: true` to re-run a completed/failed distribution covering the ' +
+        'same range — the prior row + allocations are hard-deleted before the ' +
+        'worker enqueues a new run.',
+    security: [{ ApiKeyAuth: [] }],
+    request: {
+        params: z.object({ network: NetworkSchema }),
+        body: {
+            content: { 'application/json': { schema: DistributionTriggerRequestSchema } }
+        }
+    },
+    responses: {
+        202: {
+            description: 'Trigger accepted. Status reflects the row at the moment of acceptance.',
+            content: { 'application/json': { schema: DistributionTriggerResponseSchema } }
+        },
+        409: {
+            description: '`force: true` on a non-terminal distribution.',
+            content: { 'application/json': { schema: ErrorResponseSchema } }
+        }
+    }
+})
+    .registerPath({
+    operationId: 'deleteDistribution',
+    method: 'delete',
+    path: '/v1/{network}/management/distributions/{distributionId}',
+    summary: 'Remove a stale distribution',
+    description: 'Requires `x-api-key`. Hard-deletes a `pending` / `running` / `failed` distribution ' +
+        'and its allocations — recovery for an orphaned run (e.g. a worker OOM-killed mid-run ' +
+        'leaves the row stuck at `running`). Refuses `completed` distributions (409): those are ' +
+        'published merkle roots claimers depend on — replace one via a force re-run instead.',
+    security: [{ ApiKeyAuth: [] }],
+    request: {
+        params: z.object({ network: NetworkSchema, distributionId: DistributionIdSchema })
+    },
+    responses: {
+        200: {
+            description: 'The distribution and its allocations were removed.',
+            content: { 'application/json': { schema: DistributionDeleteResponseSchema } }
+        },
+        404: {
+            description: 'No distribution with that (network, id).',
+            content: { 'application/json': { schema: ErrorResponseSchema } }
+        },
+        409: {
+            description: 'The distribution is `completed` and cannot be deleted.',
+            content: { 'application/json': { schema: ErrorResponseSchema } }
+        }
+    }
+});
+//# sourceMappingURL=distributions.js.map

package/dist/routes-management/distributions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributions.js","sourceRoot":"","sources":["../../src/routes-management/distributions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAElF,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,EACL,gCAAgC,EAChC,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAE9B,8EAA8E;AAC9E,0EAA0E;AAC1E,2EAA2E;AAC3E,2EAA2E;AAC3E,2EAA2E;AAC3E,2CAA2C;AAC3C,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAI7C,CAA8B,EAC9B,EAAE,CACF,CAAC;KACE,YAAY,CAAC;IACZ,WAAW,EAAE,qBAAqB;IAClC,MAAM,EAAE,MAAM;IACd,IAAI,EAAE,wCAAwC;IAC9C,OAAO,EAAE,gCAAgC;IACzC,WAAW,EACT,yEAAyE;QACzE,wEAAwE;QACxE,uEAAuE;QACvE,wEAAwE;QACxE,YAAY;QACZ,6EAA6E;QAC7E,2EAA2E;QAC3E,uEAAuE;QACvE,4BAA4B;IAC9B,QAAQ,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;IAC9B,OAAO,EAAE;QACP,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;QAC5C,IAAI,EAAE;YACJ,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,gCAAgC,EAAE,EAAE;SAC9E;KACF;IACD,SAAS,EAAE;QACT,GAAG,EAAE;YACH,WAAW,EAAE,wEAAwE;YACrF,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,iCAAiC,EAAE,EAAE;SAC/E;QACD,GAAG,EAAE;YACH,WAAW,EAAE,+CAA+C;YAC5D,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,EAAE;SACjE;KACF;CACF,CAAC;KACD,YAAY,CAAC;IACZ,WAAW,EAAE,oBAAoB;IACjC,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,yDAAyD;IAC/D,OAAO,EAAE,6BAA6B;IACtC,WAAW,EACT,qFAAqF;QACrF,uFAAuF;QACvF,yFAAyF;QACzF,qFAAqF;IACvF,QAAQ,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;IAC9B,OAAO,EAAE;QACP,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,oBAAoB,EAAE,CAAC;KACnF;IACD,SAAS,EAAE;QACT,GAAG,EAAE;YACH,WAAW,EAAE,oDAAoD;YACjE,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,gCAAgC,EAAE,EAAE;SAC9E;QACD,GAAG,EAAE;YACH,WAAW,EAAE,0CAA0C;YACvD,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,EAAE;SACjE;QACD,GAAG,EAAE;YACH,WAAW,EAAE,wDAAwD;YACrE,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,EAAE;SACjE;KACF;CACF,CAAC,CAAC"}

package/dist/routes-management/excluded-addresses.d.ts

@@ -0,0 +1,132 @@
+import type { RouteWithOpId, TypedRegistry } from '@polygonlabs/openapi-registry';
+import { z } from '../zod.ts';
+export declare const addExcludedAddressRoutes: <Ops extends Record<string, RouteWithOpId>, Schemes extends Record<string, true>>(r: TypedRegistry<Ops, Schemes>) => TypedRegistry<Ops & {
+    listExcludedAddresses: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listExcludedAddresses";
+        readonly method: "get";
+        readonly path: "/v1/{network}/management/excluded-addresses";
+        readonly summary: "List addresses excluded from the merkle tree (settled off-chain)";
+        readonly description: "Requires `x-api-key`. Returns the curated excluded-address list for the network.";
+        readonly security: [{
+            readonly ApiKeyAuth: [];
+        }];
+        readonly request: {
+            readonly params: z.ZodObject<{
+                network: z.ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, z.core.$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "The excluded-address list.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            items: z.ZodArray<z.ZodObject<{
+                                network: z.ZodEnum<{
+                                    mainnet: "mainnet";
+                                    amoy: "amoy";
+                                }>;
+                                label: z.ZodString;
+                                createdBy: z.ZodString;
+                                createdAt: z.ZodISODateTime;
+                                updatedAt: z.ZodISODateTime;
+                                address: z.ZodString;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    addExcludedAddress: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "addExcludedAddress";
+        readonly method: "post";
+        readonly path: "/v1/{network}/management/excluded-addresses";
+        readonly summary: "Add (or re-label) an excluded address";
+        readonly description: string;
+        readonly security: [{
+            readonly ApiKeyAuth: [];
+        }];
+        readonly request: {
+            readonly params: z.ZodObject<{
+                network: z.ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, z.core.$strip>;
+            readonly body: {
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                            label: z.ZodString;
+                            createdBy: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "The upserted excluded-address row.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            network: z.ZodEnum<{
+                                mainnet: "mainnet";
+                                amoy: "amoy";
+                            }>;
+                            label: z.ZodString;
+                            createdBy: z.ZodString;
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                            address: z.ZodString;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    removeExcludedAddress: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "removeExcludedAddress";
+        readonly method: "delete";
+        readonly path: "/v1/{network}/management/excluded-addresses/{address}";
+        readonly summary: "Remove an excluded address";
+        readonly description: "Requires `x-api-key`. Idempotent — `removed: false` when the address was not present.";
+        readonly security: [{
+            readonly ApiKeyAuth: [];
+        }];
+        readonly request: {
+            readonly params: z.ZodObject<{
+                network: z.ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            }, z.core.$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Removal result.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            network: z.ZodEnum<{
+                                mainnet: "mainnet";
+                                amoy: "amoy";
+                            }>;
+                            removed: z.ZodBoolean;
+                            address: z.ZodString;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, Schemes>;
+//# sourceMappingURL=excluded-addresses.d.ts.map

package/dist/routes-management/excluded-addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excluded-addresses.d.ts","sourceRoot":"","sources":["../../src/routes-management/excluded-addresses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAQlF,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAoC9B,eAAO,MAAM,wBAAwB,GACnC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EACzC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,EAEpC,GAAG,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAsD1B,CAAC"}

package/dist/routes-management/excluded-addresses.js

@@ -0,0 +1,84 @@
+import { AddressSchema, NetworkSchema } from "../common.js";
+import { AddExcludedAddressRequestSchema, ManagedExcludedAddressSchema, RemoveExcludedAddressResponseSchema } from "../management.js";
+import { z } from "../zod.js";
+// Response-side variants of the excluded-address schemas.
+//
+// The registry-driven router re-encodes every response via `z.encode`
+// against the declared schema, and `z.encode` rejects unidirectional
+// `.transform()`s ("Encountered unidirectional transform during encode").
+// `AddressSchema` lowercases via a one-way transform, so the shared
+// response schemas that embed it can't sit in a response slot. These
+// variants swap the address field for a plain lowercase-only validator —
+// handlers always emit the normalised form, so the constraint tightens
+// nothing on the wire. Same OpenAPI component names as the originals, so
+// the served spec is unchanged. Request-side use of `AddressSchema`
+// (body, path params) is unaffected: request validation decodes forward.
+const AddressOutputSchema = z
+    .string()
+    .regex(/^0x[0-9a-f]{40}$/)
+    .openapi({ example: '0xabc0000000000000000000000000000000000001' });
+const ManagedExcludedAddressOutputSchema = ManagedExcludedAddressSchema.extend({
+    address: AddressOutputSchema
+}).openapi('ManagedExcludedAddress');
+const ExcludedAddressListOutputSchema = z
+    .object({
+    items: z.array(ManagedExcludedAddressOutputSchema)
+})
+    .openapi('ExcludedAddressListResponse');
+const RemoveExcludedAddressOutputSchema = RemoveExcludedAddressResponseSchema.extend({
+    address: AddressOutputSchema
+}).openapi('RemoveExcludedAddressResponse');
+// Excluded-address CRUD. All three carry `security: [{ ApiKeyAuth: [] }]`;
+// 400/401/500 are auto-injected by TypedRegistry from the declared
+// request/security shape.
+export const addExcludedAddressRoutes = (r) => r
+    .registerPath({
+    operationId: 'listExcludedAddresses',
+    method: 'get',
+    path: '/v1/{network}/management/excluded-addresses',
+    summary: 'List addresses excluded from the merkle tree (settled off-chain)',
+    description: 'Requires `x-api-key`. Returns the curated excluded-address list for the network.',
+    security: [{ ApiKeyAuth: [] }],
+    request: { params: z.object({ network: NetworkSchema }) },
+    responses: {
+        200: {
+            description: 'The excluded-address list.',
+            content: { 'application/json': { schema: ExcludedAddressListOutputSchema } }
+        }
+    }
+})
+    .registerPath({
+    operationId: 'addExcludedAddress',
+    method: 'post',
+    path: '/v1/{network}/management/excluded-addresses',
+    summary: 'Add (or re-label) an excluded address',
+    description: 'Requires `x-api-key`. Upserts on (network, address) — re-POSTing an existing ' +
+        'address updates its label. Takes effect on the next distribution run.',
+    security: [{ ApiKeyAuth: [] }],
+    request: {
+        params: z.object({ network: NetworkSchema }),
+        body: { content: { 'application/json': { schema: AddExcludedAddressRequestSchema } } }
+    },
+    responses: {
+        200: {
+            description: 'The upserted excluded-address row.',
+            content: { 'application/json': { schema: ManagedExcludedAddressOutputSchema } }
+        }
+    }
+})
+    .registerPath({
+    operationId: 'removeExcludedAddress',
+    method: 'delete',
+    path: '/v1/{network}/management/excluded-addresses/{address}',
+    summary: 'Remove an excluded address',
+    description: 'Requires `x-api-key`. Idempotent — `removed: false` when the address was not present.',
+    security: [{ ApiKeyAuth: [] }],
+    request: { params: z.object({ network: NetworkSchema, address: AddressSchema }) },
+    responses: {
+        200: {
+            description: 'Removal result.',
+            content: { 'application/json': { schema: RemoveExcludedAddressOutputSchema } }
+        }
+    }
+});
+//# sourceMappingURL=excluded-addresses.js.map

package/dist/routes-management/excluded-addresses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"excluded-addresses.js","sourceRoot":"","sources":["../../src/routes-management/excluded-addresses.ts"],"names":[],"mappings":"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"}

package/dist/routes-management/operational.d.ts

@@ -0,0 +1,48 @@
+import type { RouteWithOpId, TypedRegistry } from '@polygonlabs/openapi-registry';
+import { z } from '../zod.ts';
+export declare const OperationalStatusResponseSchema: z.ZodObject<{
+    status: z.ZodLiteral<"ok">;
+}, z.core.$strip>;
+export type OperationalStatusResponse = z.infer<typeof OperationalStatusResponseSchema>;
+export declare const addOperationalRoutes: <Ops extends Record<string, RouteWithOpId>, Schemes extends Record<string, true>>(r: TypedRegistry<Ops, Schemes>) => TypedRegistry<Ops & {
+    getHealthCheck: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getHealthCheck";
+        readonly method: "get";
+        readonly path: "/health-check";
+        readonly summary: "Liveness probe";
+        readonly description: string;
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is alive.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            status: z.ZodLiteral<"ok">;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getReadiness: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getReadiness";
+        readonly method: "get";
+        readonly path: "/readiness";
+        readonly summary: "Readiness probe";
+        readonly description: string;
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is ready.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            status: z.ZodLiteral<"ok">;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, Schemes>;
+//# sourceMappingURL=operational.d.ts.map

package/dist/routes-management/operational.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operational.d.ts","sourceRoot":"","sources":["../../src/routes-management/operational.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAElF,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAW9B,eAAO,MAAM,+BAA+B;;iBAEL,CAAC;AAExC,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAKxF,eAAO,MAAM,oBAAoB,GAC/B,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EACzC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,EAEpC,GAAG,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiC1B,CAAC"}

package/dist/routes-management/operational.js

@@ -0,0 +1,47 @@
+import { z } from "../zod.js";
+// /health-check is the K8s liveness probe — answers as long as the process
+// can serve HTTP at all. Registered at root (no /v1 prefix) because dry-dock
+// pod specs declare the probe path as `/health-check`, not `/v1/...`.
+//
+// /readiness is the degraded-mode signal — distinguishes "fully ready" from
+// "partially degraded but still serving" once dependencies are wired (DB +
+// subgraphs). Still a 200 stub; path matches the lst-api precedent.
+//
+// Neither carries `security` — pod probes are unauthenticated by design.
+export const OperationalStatusResponseSchema = z
+    .object({ status: z.literal('ok') })
+    .openapi('OperationalStatusResponse');
+// Generic over the parent's `Ops` and `Schemes` so the helper preserves
+// everything the caller had already registered; the chained `registerPath`
+// returns carry the cumulative narrow back through `.with(...)`.
+export const addOperationalRoutes = (r) => r
+    .registerPath({
+    operationId: 'getHealthCheck',
+    method: 'get',
+    path: '/health-check',
+    summary: 'Liveness probe',
+    description: 'K8s liveness probe — answers as long as the process can serve HTTP. ' +
+        'Unauthenticated; dry-dock pod specs hit this exact root path.',
+    responses: {
+        200: {
+            description: 'Service is alive.',
+            content: { 'application/json': { schema: OperationalStatusResponseSchema } }
+        }
+    }
+})
+    .registerPath({
+    operationId: 'getReadiness',
+    method: 'get',
+    path: '/readiness',
+    summary: 'Readiness probe',
+    description: 'Degraded-mode signal — distinguishes "fully ready" from "partially ' +
+        'degraded but still serving". Currently a 200 stub; the real DB + ' +
+        'subgraph reachability probe is outstanding work. Unauthenticated.',
+    responses: {
+        200: {
+            description: 'Service is ready.',
+            content: { 'application/json': { schema: OperationalStatusResponseSchema } }
+        }
+    }
+});
+//# sourceMappingURL=operational.js.map

package/dist/routes-management/operational.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operational.js","sourceRoot":"","sources":["../../src/routes-management/operational.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAE9B,2EAA2E;AAC3E,6EAA6E;AAC7E,sEAAsE;AACtE,EAAE;AACF,4EAA4E;AAC5E,2EAA2E;AAC3E,oEAAoE;AACpE,EAAE;AACF,yEAAyE;AACzE,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC;KAC7C,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;KACnC,OAAO,CAAC,2BAA2B,CAAC,CAAC;AAIxC,wEAAwE;AACxE,2EAA2E;AAC3E,iEAAiE;AACjE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAIlC,CAA8B,EAC9B,EAAE,CACF,CAAC;KACE,YAAY,CAAC;IACZ,WAAW,EAAE,gBAAgB;IAC7B,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,eAAe;IACrB,OAAO,EAAE,gBAAgB;IACzB,WAAW,EACT,sEAAsE;QACtE,+DAA+D;IACjE,SAAS,EAAE;QACT,GAAG,EAAE;YACH,WAAW,EAAE,mBAAmB;YAChC,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,+BAA+B,EAAE,EAAE;SAC7E;KACF;CACF,CAAC;KACD,YAAY,CAAC;IACZ,WAAW,EAAE,cAAc;IAC3B,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,YAAY;IAClB,OAAO,EAAE,iBAAiB;IAC1B,WAAW,EACT,qEAAqE;QACrE,mEAAmE;QACnE,mEAAmE;IACrE,SAAS,EAAE;QACT,GAAG,EAAE;YACH,WAAW,EAAE,mBAAmB;YAChC,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,+BAA+B,EAAE,EAAE;SAC7E;KACF;CACF,CAAC,CAAC"}