@polygonlabs/staker-pool-allocations-schemas 0.1.0

package/dist/routes-public/addresses.d.ts

@@ -0,0 +1,79 @@
+import type { RouteWithOpId, TypedRegistry } from '@polygonlabs/openapi-registry';
+import { z } from '../zod.ts';
+export declare const addAddressRoutes: <Ops extends Record<string, RouteWithOpId>, Schemes extends Record<string, true>>(r: TypedRegistry<Ops, Schemes>) => TypedRegistry<Ops & {
+    getAddressAllocationHistory: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getAddressAllocationHistory";
+        readonly method: "get";
+        readonly path: "/v1/{network}/addresses/{address}/allocations";
+        readonly summary: "Per-address cross-distribution allocation history with live claim status";
+        readonly description: string;
+        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: "History rows ordered most-recently-completed first.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            items: z.ZodArray<z.ZodObject<{
+                                address: z.ZodString;
+                                distributionId: z.ZodString;
+                                amount: z.ZodString;
+                                leafIndex: z.ZodNullable<z.ZodNumber>;
+                                merkleRoot: z.ZodString;
+                                completedAt: z.ZodISODateTime;
+                                status: z.ZodEnum<{
+                                    claimed: "claimed";
+                                    unclaimed: "unclaimed";
+                                }>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getUnclaimedProofs: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getUnclaimedProofs";
+        readonly method: "get";
+        readonly path: "/v1/{network}/addresses/{address}/unclaimed-proofs";
+        readonly summary: "Per-address unclaimed-proofs array — the primary claim-flow UI endpoint";
+        readonly description: string;
+        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: "Batch of unclaimed-proof entries ordered oldest-distribution first.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            items: z.ZodArray<z.ZodObject<{
+                                distributionId: z.ZodString;
+                                merkleRoot: z.ZodString;
+                                amount: z.ZodString;
+                                leafIndex: z.ZodNumber;
+                                proof: z.ZodArray<z.ZodString>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, Schemes>;
+//# sourceMappingURL=addresses.d.ts.map

package/dist/routes-public/addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../src/routes-public/addresses.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAIlF,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAG9B,eAAO,MAAM,gBAAgB,GAC3B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA2C1B,CAAC"}

package/dist/routes-public/addresses.js

@@ -0,0 +1,45 @@
+import { AddressSchema, NetworkSchema } from "../common.js";
+import { UnclaimedProofsResponseSchema } from "../unclaimed-proofs.js";
+import { z } from "../zod.js";
+import { AllocationHistoryResponseWireSchema } from "./wire.js";
+export const addAddressRoutes = (r) => r
+    .registerPath({
+    operationId: 'getAddressAllocationHistory',
+    method: 'get',
+    path: '/v1/{network}/addresses/{address}/allocations',
+    summary: 'Per-address cross-distribution allocation history with live claim status',
+    description: 'Returns every allocation row for the given address across all completed ' +
+        'distributions on the network, enriched with `status: "claimed" | "unclaimed"` ' +
+        'derived live at request time by querying the pos-staker-pool-claims subgraph ' +
+        '(spec §3.6, D10). Empty array if the address never qualified.',
+    request: {
+        params: z.object({ network: NetworkSchema, address: AddressSchema })
+    },
+    responses: {
+        200: {
+            description: 'History rows ordered most-recently-completed first.',
+            content: { 'application/json': { schema: AllocationHistoryResponseWireSchema } }
+        }
+    }
+})
+    .registerPath({
+    operationId: 'getUnclaimedProofs',
+    method: 'get',
+    path: '/v1/{network}/addresses/{address}/unclaimed-proofs',
+    summary: 'Per-address unclaimed-proofs array — the primary claim-flow UI endpoint',
+    description: "Returns the address's outstanding allocations with merkle proofs ready to " +
+        'submit to the claimer contract in one batched transaction. Proof generation is ' +
+        'on demand from the persisted leaves (spec D9); the in-memory tree cache absorbs ' +
+        'repeat calls for the same distribution. Empty array if every allocation has been ' +
+        'claimed (or the address has none).',
+    request: {
+        params: z.object({ network: NetworkSchema, address: AddressSchema })
+    },
+    responses: {
+        200: {
+            description: 'Batch of unclaimed-proof entries ordered oldest-distribution first.',
+            content: { 'application/json': { schema: UnclaimedProofsResponseSchema } }
+        }
+    }
+});
+//# sourceMappingURL=addresses.js.map

package/dist/routes-public/addresses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.js","sourceRoot":"","sources":["../../src/routes-public/addresses.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAC9B,OAAO,EAAE,mCAAmC,EAAE,MAAM,WAAW,CAAC;AAEhE,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAI9B,CAA8B,EAC9B,EAAE,CACF,CAAC;KACE,YAAY,CAAC;IACZ,WAAW,EAAE,6BAA6B;IAC1C,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,+CAA+C;IACrD,OAAO,EAAE,0EAA0E;IACnF,WAAW,EACT,0EAA0E;QAC1E,gFAAgF;QAChF,+EAA+E;QAC/E,+DAA+D;IACjE,OAAO,EAAE;QACP,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;KACrE;IACD,SAAS,EAAE;QACT,GAAG,EAAE;YACH,WAAW,EAAE,qDAAqD;YAClE,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,mCAAmC,EAAE,EAAE;SACjF;KACF;CACF,CAAC;KACD,YAAY,CAAC;IACZ,WAAW,EAAE,oBAAoB;IACjC,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,oDAAoD;IAC1D,OAAO,EAAE,yEAAyE;IAClF,WAAW,EACT,4EAA4E;QAC5E,iFAAiF;QACjF,kFAAkF;QAClF,mFAAmF;QACnF,oCAAoC;IACtC,OAAO,EAAE;QACP,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;KACrE;IACD,SAAS,EAAE;QACT,GAAG,EAAE;YACH,WAAW,EAAE,qEAAqE;YAClF,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,6BAA6B,EAAE,EAAE;SAC3E;KACF;CACF,CAAC,CAAC"}

package/dist/routes-public/allocations.d.ts

@@ -0,0 +1,155 @@
+import type { RouteWithOpId, TypedRegistry } from '@polygonlabs/openapi-registry';
+import { z } from '../zod.ts';
+export declare const addAllocationRoutes: <Ops extends Record<string, RouteWithOpId>, Schemes extends Record<string, true>>(r: TypedRegistry<Ops, Schemes>) => TypedRegistry<Ops & {
+    listAllocations: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listAllocations";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/allocations";
+        readonly summary: "List allocations for a completed distribution";
+        readonly description: "Paginated by `leafIndex` ascending.";
+        readonly request: {
+            readonly params: z.ZodObject<{
+                network: z.ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: z.ZodString;
+            }, z.core.$strip>;
+            readonly query: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            }, z.core.$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Page of allocation rows.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            items: z.ZodArray<z.ZodObject<{
+                                address: z.ZodString;
+                                amount: z.ZodString;
+                                leafIndex: z.ZodNullable<z.ZodNumber>;
+                            }, z.core.$strip>>;
+                            nextCursor: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+            readonly 400: {
+                readonly description: string;
+                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 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                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>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listExcludedAllocations: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listExcludedAllocations";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/excluded-allocations";
+        readonly summary: "List off-chain (merkle-excluded) allocations for a distribution";
+        readonly description: string;
+        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 off-chain allocation set.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            items: z.ZodArray<z.ZodObject<{
+                                address: z.ZodString;
+                                amount: z.ZodString;
+                            }, z.core.$strip>>;
+                            total: z.ZodNumber;
+                            totalAmount: z.ZodString;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                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>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getAllocation: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getAllocation";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/allocations/{address}";
+        readonly summary: "Get a single address allocation in a distribution";
+        readonly request: {
+            readonly params: z.ZodObject<{
+                network: z.ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: z.ZodString;
+                address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            }, z.core.$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Allocation row.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            address: z.ZodString;
+                            amount: z.ZodString;
+                            leafIndex: z.ZodNullable<z.ZodNumber>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution or allocation not found.";
+                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=allocations.d.ts.map

package/dist/routes-public/allocations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allocations.d.ts","sourceRoot":"","sources":["../../src/routes-public/allocations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAUlF,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAO9B,eAAO,MAAM,mBAAmB,GAC9B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA+E1B,CAAC"}

package/dist/routes-public/allocations.js

@@ -0,0 +1,81 @@
+import { ErrorResponseSchema } from '@polygonlabs/openapi-registry/error-schemas';
+import { AddressSchema, DistributionIdSchema, NetworkSchema, PaginationQuerySchema } from "../common.js";
+import { z } from "../zod.js";
+import { AllocationListResponseWireSchema, AllocationRowWireSchema, ExcludedAllocationsResponseWireSchema } from "./wire.js";
+export const addAllocationRoutes = (r) => r
+    .registerPath({
+    operationId: 'listAllocations',
+    method: 'get',
+    path: '/v1/{network}/distributions/{distributionId}/allocations',
+    summary: 'List allocations for a completed distribution',
+    description: 'Paginated by `leafIndex` ascending.',
+    request: {
+        params: z.object({ network: NetworkSchema, distributionId: DistributionIdSchema }),
+        query: PaginationQuerySchema
+    },
+    responses: {
+        200: {
+            description: 'Page of allocation rows.',
+            content: { 'application/json': { schema: AllocationListResponseWireSchema } }
+        },
+        // Same 400 override rationale as `listDistributions`: the opaque
+        // cursor decodes in the handler and 400s with `info.code:
+        // 'INVALID_CURSOR'`, which the auto-injected ValidationErrorResponse
+        // shape would strip.
+        400: {
+            description: 'Invalid pagination cursor (`info.code: "INVALID_CURSOR"`) or ' +
+                'request failed schema validation.',
+            content: { 'application/json': { schema: ErrorResponseSchema } }
+        },
+        404: {
+            description: 'Distribution not found or not yet completed.',
+            content: { 'application/json': { schema: ErrorResponseSchema } }
+        }
+    }
+})
+    .registerPath({
+    operationId: 'listExcludedAllocations',
+    method: 'get',
+    path: '/v1/{network}/distributions/{distributionId}/excluded-allocations',
+    summary: 'List off-chain (merkle-excluded) allocations for a distribution',
+    description: 'Recipients allocated but excluded from the merkle tree (excluded addresses) — ' +
+        'not claimable on-chain, settled manually. Not paginated (small bounded set). ' +
+        '`totalAmount` equals the distribution `total_allocated - claimable_total`.',
+    request: {
+        params: z.object({ network: NetworkSchema, distributionId: DistributionIdSchema })
+    },
+    responses: {
+        200: {
+            description: 'The off-chain allocation set.',
+            content: { 'application/json': { schema: ExcludedAllocationsResponseWireSchema } }
+        },
+        404: {
+            description: 'Distribution not found or not yet completed.',
+            content: { 'application/json': { schema: ErrorResponseSchema } }
+        }
+    }
+})
+    .registerPath({
+    operationId: 'getAllocation',
+    method: 'get',
+    path: '/v1/{network}/distributions/{distributionId}/allocations/{address}',
+    summary: 'Get a single address allocation in a distribution',
+    request: {
+        params: z.object({
+            network: NetworkSchema,
+            distributionId: DistributionIdSchema,
+            address: AddressSchema
+        })
+    },
+    responses: {
+        200: {
+            description: 'Allocation row.',
+            content: { 'application/json': { schema: AllocationRowWireSchema } }
+        },
+        404: {
+            description: 'Distribution or allocation not found.',
+            content: { 'application/json': { schema: ErrorResponseSchema } }
+        }
+    }
+});
+//# sourceMappingURL=allocations.js.map

package/dist/routes-public/allocations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allocations.js","sourceRoot":"","sources":["../../src/routes-public/allocations.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAElF,OAAO,EACL,aAAa,EACb,oBAAoB,EACpB,aAAa,EACb,qBAAqB,EACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAC9B,OAAO,EACL,gCAAgC,EAChC,uBAAuB,EACvB,qCAAqC,EACtC,MAAM,WAAW,CAAC;AAEnB,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAIjC,CAA8B,EAC9B,EAAE,CACF,CAAC;KACE,YAAY,CAAC;IACZ,WAAW,EAAE,iBAAiB;IAC9B,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,0DAA0D;IAChE,OAAO,EAAE,+CAA+C;IACxD,WAAW,EAAE,qCAAqC;IAClD,OAAO,EAAE;QACP,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,oBAAoB,EAAE,CAAC;QAClF,KAAK,EAAE,qBAAqB;KAC7B;IACD,SAAS,EAAE;QACT,GAAG,EAAE;YACH,WAAW,EAAE,0BAA0B;YACvC,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,gCAAgC,EAAE,EAAE;SAC9E;QACD,iEAAiE;QACjE,0DAA0D;QAC1D,qEAAqE;QACrE,qBAAqB;QACrB,GAAG,EAAE;YACH,WAAW,EACT,+DAA+D;gBAC/D,mCAAmC;YACrC,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,EAAE;SACjE;QACD,GAAG,EAAE;YACH,WAAW,EAAE,8CAA8C;YAC3D,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,EAAE;SACjE;KACF;CACF,CAAC;KACD,YAAY,CAAC;IACZ,WAAW,EAAE,yBAAyB;IACtC,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,mEAAmE;IACzE,OAAO,EAAE,iEAAiE;IAC1E,WAAW,EACT,gFAAgF;QAChF,+EAA+E;QAC/E,4EAA4E;IAC9E,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,+BAA+B;YAC5C,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,qCAAqC,EAAE,EAAE;SACnF;QACD,GAAG,EAAE;YACH,WAAW,EAAE,8CAA8C;YAC3D,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,EAAE;SACjE;KACF;CACF,CAAC;KACD,YAAY,CAAC;IACZ,WAAW,EAAE,eAAe;IAC5B,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,oEAAoE;IAC1E,OAAO,EAAE,mDAAmD;IAC5D,OAAO,EAAE;QACP,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;YACf,OAAO,EAAE,aAAa;YACtB,cAAc,EAAE,oBAAoB;YACpC,OAAO,EAAE,aAAa;SACvB,CAAC;KACH;IACD,SAAS,EAAE;QACT,GAAG,EAAE;YACH,WAAW,EAAE,iBAAiB;YAC9B,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,uBAAuB,EAAE,EAAE;SACrE;QACD,GAAG,EAAE;YACH,WAAW,EAAE,uCAAuC;YACpD,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,EAAE;SACjE;KACF;CACF,CAAC,CAAC"}

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

@@ -0,0 +1,123 @@
+import type { RouteWithOpId, TypedRegistry } from '@polygonlabs/openapi-registry';
+import { z } from '../zod.ts';
+export declare const addDistributionRoutes: <Ops extends Record<string, RouteWithOpId>, Schemes extends Record<string, true>>(r: TypedRegistry<Ops, Schemes>) => TypedRegistry<Ops & {
+    listDistributions: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listDistributions";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions";
+        readonly summary: "List completed distributions";
+        readonly description: string;
+        readonly request: {
+            readonly params: z.ZodObject<{
+                network: z.ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, z.core.$strip>;
+            readonly query: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            }, z.core.$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Page of distribution summaries.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            items: z.ZodArray<z.ZodObject<{
+                                distributionId: z.ZodString;
+                                status: z.ZodEnum<{
+                                    pending: "pending";
+                                    running: "running";
+                                    completed: "completed";
+                                    failed: "failed";
+                                }>;
+                                startPoSBlock: z.ZodString;
+                                endPoSBlock: z.ZodString;
+                                merkleRoot: z.ZodNullable<z.ZodString>;
+                                totalAllocated: z.ZodNullable<z.ZodString>;
+                                completedAt: z.ZodNullable<z.ZodISODateTime>;
+                            }, z.core.$strip>>;
+                            nextCursor: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+            readonly 400: {
+                readonly description: string;
+                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>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getDistribution: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getDistribution";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}";
+        readonly summary: "Get a single completed distribution";
+        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: "Distribution detail.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: z.ZodObject<{
+                            distributionId: z.ZodString;
+                            status: z.ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                completed: "completed";
+                                failed: "failed";
+                            }>;
+                            startPoSBlock: z.ZodString;
+                            endPoSBlock: z.ZodString;
+                            merkleRoot: z.ZodNullable<z.ZodString>;
+                            totalAllocated: z.ZodNullable<z.ZodString>;
+                            completedAt: z.ZodNullable<z.ZodISODateTime>;
+                            checkpointCount: z.ZodNumber;
+                            polUsdPrice: z.ZodNullable<z.ZodString>;
+                            maxClaimableUsdThreshold: z.ZodNullable<z.ZodString>;
+                            inputsHash: z.ZodNullable<z.ZodString>;
+                            posStakingSubgraphBlock: z.ZodNullable<z.ZodString>;
+                            posStakingSubgraphHash: z.ZodNullable<z.ZodString>;
+                            posCheckpointsSubgraphBlock: z.ZodNullable<z.ZodString>;
+                            posCheckpointsSubgraphHash: z.ZodNullable<z.ZodString>;
+                            posPriorityFeesSubgraphBlock: z.ZodNullable<z.ZodString>;
+                            posPriorityFeesSubgraphHash: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                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-public/distributions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributions.d.ts","sourceRoot":"","sources":["../../src/routes-public/distributions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAMlF,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAE9B,eAAO,MAAM,qBAAqB,GAChC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAqD1B,CAAC"}

package/dist/routes-public/distributions.js

@@ -0,0 +1,55 @@
+import { ErrorResponseSchema } from '@polygonlabs/openapi-registry/error-schemas';
+import { DistributionIdSchema, NetworkSchema, PaginationQuerySchema } from "../common.js";
+import { DistributionDetailSchema, DistributionListResponseSchema } from "../distribution.js";
+import { z } from "../zod.js";
+export const addDistributionRoutes = (r) => r
+    .registerPath({
+    operationId: 'listDistributions',
+    method: 'get',
+    path: '/v1/{network}/distributions',
+    summary: 'List completed distributions',
+    description: 'Paginated list of completed distributions, oldest first by id (e.g. `2026-04`). ' +
+        'Non-completed rows are not surfaced on the public API.',
+    request: {
+        params: z.object({ network: NetworkSchema }),
+        query: PaginationQuerySchema
+    },
+    responses: {
+        200: {
+            description: 'Page of distribution summaries.',
+            content: { 'application/json': { schema: DistributionListResponseSchema } }
+        },
+        // Override the auto-injected ValidationErrorResponse 400: this route
+        // also emits a handler-thrown `BadRequest` for an undecodable opaque
+        // cursor, whose `info` is `{ code: 'INVALID_CURSOR' }` rather than
+        // section-keyed validation trees. The generic ErrorResponse shape is
+        // the honest superset of both bodies — encoding the cursor body
+        // against the narrower ValidationErrorResponse would silently strip
+        // `info.code`.
+        400: {
+            description: 'Invalid pagination cursor (`info.code: "INVALID_CURSOR"`) or ' +
+                'request failed schema validation.',
+            content: { 'application/json': { schema: ErrorResponseSchema } }
+        }
+    }
+})
+    .registerPath({
+    operationId: 'getDistribution',
+    method: 'get',
+    path: '/v1/{network}/distributions/{distributionId}',
+    summary: 'Get a single completed distribution',
+    request: {
+        params: z.object({ network: NetworkSchema, distributionId: DistributionIdSchema })
+    },
+    responses: {
+        200: {
+            description: 'Distribution detail.',
+            content: { 'application/json': { schema: DistributionDetailSchema } }
+        },
+        404: {
+            description: 'Distribution not found or not yet completed.',
+            content: { 'application/json': { schema: ErrorResponseSchema } }
+        }
+    }
+});
+//# sourceMappingURL=distributions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"distributions.js","sourceRoot":"","sources":["../../src/routes-public/distributions.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAElF,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1F,OAAO,EAAE,wBAAwB,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAC9F,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAE9B,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAInC,CAA8B,EAC9B,EAAE,CACF,CAAC;KACE,YAAY,CAAC;IACZ,WAAW,EAAE,mBAAmB;IAChC,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,6BAA6B;IACnC,OAAO,EAAE,8BAA8B;IACvC,WAAW,EACT,kFAAkF;QAClF,wDAAwD;IAC1D,OAAO,EAAE;QACP,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;QAC5C,KAAK,EAAE,qBAAqB;KAC7B;IACD,SAAS,EAAE;QACT,GAAG,EAAE;YACH,WAAW,EAAE,iCAAiC;YAC9C,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,8BAA8B,EAAE,EAAE;SAC5E;QACD,qEAAqE;QACrE,qEAAqE;QACrE,mEAAmE;QACnE,qEAAqE;QACrE,gEAAgE;QAChE,oEAAoE;QACpE,eAAe;QACf,GAAG,EAAE;YACH,WAAW,EACT,+DAA+D;gBAC/D,mCAAmC;YACrC,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,EAAE;SACjE;KACF;CACF,CAAC;KACD,YAAY,CAAC;IACZ,WAAW,EAAE,iBAAiB;IAC9B,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,8CAA8C;IACpD,OAAO,EAAE,qCAAqC;IAC9C,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,sBAAsB;YACnC,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,wBAAwB,EAAE,EAAE;SACtE;QACD,GAAG,EAAE;YACH,WAAW,EAAE,8CAA8C;YAC3D,OAAO,EAAE,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,EAAE;SACjE;KACF;CACF,CAAC,CAAC"}

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

@@ -0,0 +1,46 @@
+import type { RouteWithOpId, TypedRegistry } from '@polygonlabs/openapi-registry';
+import { z } from '../zod.ts';
+export declare const OperationalStatusSchema: z.ZodObject<{
+    status: z.ZodLiteral<"ok">;
+}, z.core.$strip>;
+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 check (K8s probe)";
+        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 check";
+        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-public/operational.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operational.d.ts","sourceRoot":"","sources":["../../src/routes-public/operational.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAElF,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAI9B,eAAO,MAAM,uBAAuB;;iBAEL,CAAC;AAIhC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA6B1B,CAAC"}

package/dist/routes-public/operational.js

@@ -0,0 +1,36 @@
+import { z } from "../zod.js";
+// Exported (and aliased to its registered name in the package barrel) so
+// the @polygonlabs/zod-to-openapi-heyapi codegen audit can resolve it.
+export const OperationalStatusSchema = z
+    .object({ status: z.literal('ok') })
+    .openapi('OperationalStatus');
+// Generic over the parent's `Ops` and `Schemes` accumulators so the helper
+// preserves everything registered before `.with(addOperationalRoutes)`.
+export const addOperationalRoutes = (r) => r
+    .registerPath({
+    operationId: 'getHealthCheck',
+    method: 'get',
+    path: '/health-check',
+    summary: 'Liveness check (K8s probe)',
+    responses: {
+        200: {
+            description: 'Service is alive.',
+            content: { 'application/json': { schema: OperationalStatusSchema } }
+        }
+    }
+})
+    .registerPath({
+    operationId: 'getReadiness',
+    method: 'get',
+    path: '/readiness',
+    summary: 'Readiness check',
+    description: 'Distinguishes "fully ready" from "partially degraded but still serving". ' +
+        'Currently a 200 stub — the real DB + subgraph reachability probe is outstanding work.',
+    responses: {
+        200: {
+            description: 'Service is ready.',
+            content: { 'application/json': { schema: OperationalStatusSchema } }
+        }
+    }
+});
+//# sourceMappingURL=operational.js.map