@polygonlabs/staker-pool-allocations-schemas 0.1.0

package/dist/registry-management.d.ts

@@ -0,0 +1,525 @@
+import { TypedRegistry } from '@polygonlabs/openapi-registry';
+export declare const buildManagementRegistry: () => TypedRegistry<{}, {
+    ApiKeyAuth: true;
+}> & TypedRegistry<{
+    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: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/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: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, {
+    ApiKeyAuth: true;
+}> & TypedRegistry<{
+    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: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/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: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    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: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, import("zod/v4/core").$strip>;
+            readonly body: {
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            startPoSBlock: import("zod").ZodString;
+                            endPoSBlock: import("zod").ZodString;
+                            distributionId: import("zod").ZodOptional<import("zod").ZodString>;
+                            force: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            polUsdPrice: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/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: import("zod").ZodObject<{
+                            network: import("zod").ZodEnum<{
+                                mainnet: "mainnet";
+                                amoy: "amoy";
+                            }>;
+                            distributionId: import("zod").ZodString;
+                            status: import("zod").ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                completed: "completed";
+                                failed: "failed";
+                            }>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 409: {
+                readonly description: "`force: true` on a non-terminal distribution.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/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: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "The distribution and its allocations were removed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            network: import("zod").ZodEnum<{
+                                mainnet: "mainnet";
+                                amoy: "amoy";
+                            }>;
+                            distributionId: import("zod").ZodString;
+                            removed: import("zod").ZodBoolean;
+                            priorStatus: import("zod").ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                failed: "failed";
+                            }>;
+                            deletedAllocations: import("zod").ZodNumber;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "No distribution with that (network, id).";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 409: {
+                readonly description: "The distribution is `completed` and cannot be deleted.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, {
+    ApiKeyAuth: true;
+}> & TypedRegistry<{
+    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: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/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: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    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: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, import("zod/v4/core").$strip>;
+            readonly body: {
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            startPoSBlock: import("zod").ZodString;
+                            endPoSBlock: import("zod").ZodString;
+                            distributionId: import("zod").ZodOptional<import("zod").ZodString>;
+                            force: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            polUsdPrice: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/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: import("zod").ZodObject<{
+                            network: import("zod").ZodEnum<{
+                                mainnet: "mainnet";
+                                amoy: "amoy";
+                            }>;
+                            distributionId: import("zod").ZodString;
+                            status: import("zod").ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                completed: "completed";
+                                failed: "failed";
+                            }>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 409: {
+                readonly description: "`force: true` on a non-terminal distribution.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/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: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "The distribution and its allocations were removed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            network: import("zod").ZodEnum<{
+                                mainnet: "mainnet";
+                                amoy: "amoy";
+                            }>;
+                            distributionId: import("zod").ZodString;
+                            removed: import("zod").ZodBoolean;
+                            priorStatus: import("zod").ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                failed: "failed";
+                            }>;
+                            deletedAllocations: import("zod").ZodNumber;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "No distribution with that (network, id).";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 409: {
+                readonly description: "The distribution is `completed` and cannot be deleted.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    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: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "The excluded-address list.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                network: import("zod").ZodEnum<{
+                                    mainnet: "mainnet";
+                                    amoy: "amoy";
+                                }>;
+                                label: import("zod").ZodString;
+                                createdBy: import("zod").ZodString;
+                                createdAt: import("zod").ZodISODateTime;
+                                updatedAt: import("zod").ZodISODateTime;
+                                address: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/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: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, import("zod/v4/core").$strip>;
+            readonly body: {
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            address: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+                            label: import("zod").ZodString;
+                            createdBy: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "The upserted excluded-address row.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            network: import("zod").ZodEnum<{
+                                mainnet: "mainnet";
+                                amoy: "amoy";
+                            }>;
+                            label: import("zod").ZodString;
+                            createdBy: import("zod").ZodString;
+                            createdAt: import("zod").ZodISODateTime;
+                            updatedAt: import("zod").ZodISODateTime;
+                            address: import("zod").ZodString;
+                        }, import("zod/v4/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: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                address: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Removal result.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            network: import("zod").ZodEnum<{
+                                mainnet: "mainnet";
+                                amoy: "amoy";
+                            }>;
+                            removed: import("zod").ZodBoolean;
+                            address: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, {
+    ApiKeyAuth: true;
+}>;
+//# sourceMappingURL=registry-management.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry-management.d.ts","sourceRoot":"","sources":["../src/registry-management.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAmB9D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBD,CAAC"}

package/dist/registry-management.js

@@ -0,0 +1,33 @@
+import { TypedRegistry } from '@polygonlabs/openapi-registry';
+import { addManagementDistributionRoutes } from "./routes-management/distributions.js";
+import { addExcludedAddressRoutes } from "./routes-management/excluded-addresses.js";
+import { addOperationalRoutes } from "./routes-management/operational.js";
+// Registry composition for the WORKER service's management surface (the
+// public read API has its own registry). `TypedRegistry` accumulates the
+// registered operations and security schemes into its *type* via chained
+// method returns — the chain's final value is what `buildManagementRegistry`
+// returns, and the worker derives the registry-driven router, the typed
+// handler binding (`HandlerMapFor<typeof buildManagementRegistry, ...>`),
+// and the served OpenAPI document from that one inferred type.
+//
+// One chained expression on purpose: discarding any link's return drops the
+// type-level narrow even though the runtime registration still happens (see
+// @polygonlabs/openapi-registry's "The one rule"). To add a route, append a
+// `.registerPath({...})` inside the relevant helper under
+// `./routes-management/`, or add a new domain helper and `.with(...)` here.
+export const buildManagementRegistry = () => new TypedRegistry()
+    // Operations opt in via `security: [{ ApiKeyAuth: [] }]`; the
+    // registry-driven router then requires an `ApiKeyAuth` handler at
+    // compile time and runs it before request validation. The operational
+    // probes declare no security and stay unauthenticated.
+    .registerSecurityScheme('ApiKeyAuth', {
+    type: 'apiKey',
+    in: 'header',
+    name: 'x-api-key',
+    description: 'Management API key (`MANAGEMENT_API_KEY`, Secret-Manager-backed). ' +
+        'Required on every management operation.'
+})
+    .with(addOperationalRoutes)
+    .with(addManagementDistributionRoutes)
+    .with(addExcludedAddressRoutes);
+//# sourceMappingURL=registry-management.js.map

package/dist/registry-management.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-management.js","sourceRoot":"","sources":["../src/registry-management.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AACvF,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE1E,wEAAwE;AACxE,yEAAyE;AACzE,yEAAyE;AACzE,6EAA6E;AAC7E,wEAAwE;AACxE,0EAA0E;AAC1E,+DAA+D;AAC/D,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,4EAA4E;AAC5E,0DAA0D;AAC1D,4EAA4E;AAC5E,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,EAAE,CAC1C,IAAI,aAAa,EAAE;IACjB,8DAA8D;IAC9D,kEAAkE;IAClE,sEAAsE;IACtE,uDAAuD;KACtD,sBAAsB,CAAC,YAAY,EAAE;IACpC,IAAI,EAAE,QAAQ;IACd,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,WAAW;IACjB,WAAW,EACT,oEAAoE;QACpE,yCAAyC;CAC5C,CAAC;KACD,IAAI,CAAC,oBAAoB,CAAC;KAC1B,IAAI,CAAC,+BAA+B,CAAC;KACrC,IAAI,CAAC,wBAAwB,CAAC,CAAC"}