chore(sdl): merge main into aep-86 sdk branch

Resolve the SDL validator conflict by preserving the AEP-86 verification schema and the upstream reclamation duration validation added on main.

Signed-off-by: Joseph Chalabi <chalabi.joseph@gmail.com>

Author: chalabi2

go/sdl/sdl-input.schema.yaml

@@ -565,10 +565,10 @@ properties:
     properties:
       min_window:
         type: string
+        pattern: "^[1-9][0-9]*(s|m|h)$"
         description: >-
-          Minimum reclamation window duration the tenant requires.
-          Go duration format (e.g. "1h", "24h", "720h").
-        minLength: 1
+          Minimum reclamation window the tenant requires, as a whole number
+          followed by a unit (s, m, or h). E.g. "1h", "24h", "720h".
     required:
       - min_window
     type: object

testdata/sdl/input/invalid/v2.1-reclamation-bad-window.yaml

@@ -0,0 +1,36 @@
+# yaml-language-server: $schema=../../../../go/sdl/sdl-input.schema.yaml
+---
+version: "2.1"
+services:
+  web:
+    image: nginx:latest
+    expose:
+      - port: 80
+        as: 80
+        to:
+          - global: true
+profiles:
+  compute:
+    web:
+      resources:
+        cpu:
+          units: 100m
+        memory:
+          size: 512Mi
+        storage:
+          size: 512Mi
+  placement:
+    akash:
+      pricing:
+        web:
+          denom: uakt
+          amount: 1000
+deployment:
+  web:
+    akash:
+      profile: web
+      count: 1
+reclamation:
+  # Structurally valid (non-empty string) but semantically invalid: a window of
+  # zero is rejected by the Go-parity check (min_window must be > 0).
+  min_window: "0s"

testdata/sdl/input/schema-only-invalid/reclamation-compound-window.yaml

@@ -0,0 +1,37 @@
+# yaml-language-server: $schema=../../../../go/sdl/sdl-input.schema.yaml
+---
+version: "2.1"
+services:
+  web:
+    image: nginx:latest
+    expose:
+      - port: 80
+        as: 80
+        to:
+          - global: true
+profiles:
+  compute:
+    web:
+      resources:
+        cpu:
+          units: 100m
+        memory:
+          size: 512Mi
+        storage:
+          size: 512Mi
+  placement:
+    akash:
+      pricing:
+        web:
+          denom: uakt
+          amount: 1000
+deployment:
+  web:
+    akash:
+      profile: web
+      count: 1
+reclamation:
+  # Accepted by Go's time.ParseDuration (compound, 90m > 0) but rejected by the
+  # stricter schema pattern (^[1-9][0-9]*(s|m|h)$). Schema-only-invalid: schema
+  # rejects, Go parser accepts.
+  min_window: "1h30m"

ts/src/sdl/manifest/generateManifest.spec.ts

@@ -806,6 +806,45 @@ describe(generateManifest.name, () => {
     });
   });
 
+  describe("reclamation", () => {
+    it.each([
+      ["24h", "86400"],
+      ["30m", "1800"],
+      ["720h", "2592000"],
+      ["8760h", "31536000"],
+    ])("surfaces min_window %j as a proto Duration (%s seconds)", (minWindow, seconds) => {
+      const { result } = setup({ sdl: createBasicSdl({ reclamation: { min_window: minWindow } }) });
+      expect(result.reclamation?.minWindow?.seconds.toString()).toBe(seconds);
+      expect(result.reclamation?.minWindow?.nanos).toBe(0);
+    });
+
+    it("leaves reclamation undefined when no block is present", () => {
+      const { result } = setup();
+      expect(result.reclamation).toBeUndefined();
+    });
+
+    // Compound ("1h30m"), fractional ("1.5h") and sub-second ("500ms") forms are
+    // accepted by Go's `time.ParseDuration` but rejected by the stricter SDL
+    // schema pattern (`^[1-9][0-9]*(s|m|h)$`).
+    it.each(["abc", "0s", "-1h", "100", "1h30m", "1.5h", "500ms"])("rejects an invalid min_window %j", (minWindow) => {
+      const result = generateManifest(createBasicSdl({ reclamation: { min_window: minWindow } }));
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.value).toContainEqual(expect.objectContaining({
+          instancePath: "/reclamation/min_window",
+        }));
+      }
+    });
+
+    it("exposes reclamation as a lazy, memoized getter", () => {
+      const { result } = setup({ sdl: createBasicSdl({ reclamation: { min_window: "24h" } }) });
+      // It's a getter (computed on access, not eagerly)...
+      expect(Object.getOwnPropertyDescriptor(result, "reclamation")?.get).toBeTypeOf("function");
+      // ...and memoized: repeated reads return the same instance.
+      expect(result.reclamation).toBe(result.reclamation);
+    });
+  });
+
   function setup(input?: {
     sdl: SDLInput;
   }) {
@@ -837,6 +876,7 @@ describe(generateManifest.name, () => {
     credentials?: SDLInput["services"][string]["credentials"];
     expose?: SDLInput["services"][string]["expose"];
     endpoints?: SDLInput["endpoints"];
+    reclamation?: SDLInput["reclamation"];
   } = {}): SDLInput {
     const {
       port = 80,
@@ -880,6 +920,7 @@ describe(generateManifest.name, () => {
             profile: web
             count: 1
       endpoints: ${input.endpoints}
+      reclamation: ${input.reclamation}
     `;
   }
 

ts/src/sdl/manifest/generateManifest.ts

@@ -4,6 +4,7 @@ import { GPU } from "../../generated/protos/akash/base/resources/v1beta4/gpu.ts"
 import { Memory } from "../../generated/protos/akash/base/resources/v1beta4/memory.ts";
 import { Resources } from "../../generated/protos/akash/base/resources/v1beta4/resources.ts";
 import { Storage } from "../../generated/protos/akash/base/resources/v1beta4/storage.ts";
+import { DeploymentReclamation } from "../../generated/protos/akash/deployment/v1/deployment.ts";
 import { GroupSpec } from "../../generated/protos/akash/deployment/v1beta4/groupspec.ts";
 import { ResourceUnit } from "../../generated/protos/akash/deployment/v1beta4/resourceunit.ts";
 import { Group } from "../../generated/protos/akash/manifest/v2beta3/group.ts";
@@ -29,10 +30,12 @@ import {
   type SDLService,
   transformGpuAttributes,
 } from "./manifestUtils.ts";
+import { minWindowToDuration } from "./reclamationDuration.ts";
 
 export interface GenerateManifestOkResult {
   groups: Group[];
   groupSpecs: GroupSpec[];
+  reclamation?: DeploymentReclamation;
 }
 
 export type Manifest = GenerateManifestOkResult["groups"];
@@ -143,8 +146,21 @@ export function generateManifest(sdl: SDLInput): GenerateManifestResult {
   const sortedGroupNames = [...groupsMap.keys()].sort();
   let groups: Group[] | undefined;
   let groupSpecs: GroupSpec[] | undefined;
+  let reclamation: DeploymentReclamation | undefined;
 
   const manifest = {
+    // reclamation is a `MsgCreateDeployment` field, not a manifest group, and is
+    // not needed in every call — so it's lazy like `groups`/`groupSpecs`.
+    // `validateSDL` (run above) already guaranteed `min_window` is valid, so
+    // `minWindowToDuration` never throws here.
+    get reclamation() {
+      if (sdl.reclamation && !reclamation) {
+        reclamation = DeploymentReclamation.fromPartial({
+          minWindow: minWindowToDuration(sdl.reclamation.min_window),
+        });
+      }
+      return reclamation;
+    },
     get groups() {
       groups ??= sortedGroupNames.map((placementName) => {
         const deployments = deploymentsByPlacement.get(placementName)!;

ts/src/sdl/manifest/reclamationDuration.spec.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+
+import { minWindowToDuration } from "./reclamationDuration.ts";
+
+describe("minWindowToDuration", () => {
+  it.each([
+    ["1s", "1"],
+    ["30m", "1800"],
+    ["1h", "3600"],
+    ["24h", "86400"],
+    ["720h", "2592000"],
+    ["8760h", "31536000"], // year-scale window: exact seconds, no precision loss
+  ])("converts %j to %s seconds with zero nanos", (input, seconds) => {
+    const duration = minWindowToDuration(input);
+    expect(duration.seconds.toString()).toBe(seconds);
+    expect(duration.nanos).toBe(0);
+  });
+
+  // Defensive: the SDL schema pattern guarantees a valid format upstream, but a
+  // direct call with a value the schema would have rejected throws clearly.
+  it.each(["1h30m", "1.5h", "500ms", "0s", "-1h", "100", "abc", ""])("throws on the schema-rejected value %j", (input) => {
+    expect(() => minWindowToDuration(input)).toThrow(/invalid reclamation min_window/);
+  });
+});

ts/src/sdl/manifest/reclamationDuration.ts

@@ -0,0 +1,21 @@
+import { Duration } from "../../generated/protos/google/protobuf/duration.ts";
+
+const UNIT_SECONDS: Record<string, bigint> = { s: 1n, m: 60n, h: 3600n };
+
+/**
+ * Converts a reclamation `min_window` into a proto `Duration`. The SDL schema
+ * pattern (`^[1-9][0-9]*(s|m|h)$`) has already guaranteed the format (and `> 0`)
+ * before this runs, so on the request hot path we split off the trailing unit
+ * and parse the amount directly instead of re-running a regex. The cheap
+ * unit/integer/positivity guards stay only to reject obviously-invalid direct
+ * calls. Whole-unit windows are an exact second count, so `nanos` is always 0
+ * and the BigInt product never loses precision.
+ */
+export function minWindowToDuration(value: string): Duration {
+  const unitSeconds = UNIT_SECONDS[value.at(-1) ?? ""];
+  const amount = Number(value.slice(0, -1));
+  if (unitSeconds === undefined || !Number.isInteger(amount) || amount <= 0) {
+    throw new Error(`invalid reclamation min_window "${value}"`);
+  }
+  return Duration.fromPartial({ seconds: (BigInt(amount) * unitSeconds).toString(), nanos: 0 });
+}

ts/src/sdl/validateSDL/validateSDL.spec.ts

@@ -2190,6 +2190,42 @@ describe(validateSDL.name, () => {
     });
   });
 
+  describe("reclamation validation", () => {
+    it.each(["24h", "720h", "8760h", "30m", "1s"])("accepts a valid min_window %j", (minWindow) => {
+      const { validate } = setup({ reclamation: { min_window: minWindow } });
+      expect(validate()).toBeUndefined();
+    });
+
+    it("accepts reclamation on a v2.0 SDL (version-agnostic)", () => {
+      const { validate } = setup({ version: "2.0", reclamation: { min_window: "720h" } });
+      expect(validate()).toBeUndefined();
+    });
+
+    it("accepts reclamation on a v2.1 SDL", () => {
+      const { validate } = setup({ version: "2.1", reclamation: { min_window: "30m" } });
+      expect(validate()).toBeUndefined();
+    });
+
+    it("returns no reclamation error when the block is absent", () => {
+      const { validate } = setup();
+      expect(validate()).toBeUndefined();
+    });
+
+    // The schema pattern is intentionally stricter than Go's `time.ParseDuration`:
+    // it rejects compound ("1h30m"), fractional ("1.5h"), sub-second units
+    // ("500ms"), signs, zero, and unitless values, leaving only whole s/m/h
+    // windows. Go stays the lenient layer (see go/sdl/reclamation.go).
+    it.each(["abc", "0s", "-1h", "100", "1h30m", "1.5h", "500ms"])("rejects an invalid min_window %j", (minWindow) => {
+      const { validate } = setup({ reclamation: { min_window: minWindow } });
+      expect(validate()).toContainEqual(expect.objectContaining({
+        instancePath: "/reclamation/min_window",
+        schemaPath: "#/properties/reclamation/properties/min_window/pattern",
+        keyword: "pattern",
+        message: expect.stringContaining("whole number followed by s, m, or h"),
+      }));
+    });
+  });
+
   function setup(overrides: DeepPartial<SDLInput> = {}, networkId: NetworkId = "sandbox") {
     const defaultSDL: SDLInput = {
       version: "2.0",

ts/src/sdl/validateSDL/validateSDL.ts

@@ -13,6 +13,12 @@ const ERROR_MESSAGES: ErrorMessages = {
   "#/definitions/exposeToWithIpEnforcesGlobal"() {
     return `If an IP is declared, the directive must be declared as global.`;
   },
+  // Mirrors the shared schema's `min_window` pattern (`^[1-9][0-9]*(s|m|h)$`).
+  // Go stays the lenient layer (`go/sdl/reclamation.go` accepts any `> 0`
+  // `time.ParseDuration`), so this is a sanctioned schema-only-stricter rule.
+  "#/properties/reclamation/properties/min_window/pattern"() {
+    return `Reclamation min_window must be a whole number followed by s, m, or h (e.g. "24h", "30m").`;
+  },
 };
 
 export function validateSDL(sdl: SDLInput): undefined | ValidationError[] {