@glowlabs-org/utils 0.2.47 → 0.2.48

package/dist/esm/utils/stake-control.d.ts

@@ -0,0 +1,156 @@
+import z from "zod";
+export declare const stakeControlEIP712Domain: {
+    readonly name: "ControlManager";
+    readonly version: "1";
+    readonly chainId: number;
+    readonly verifyingContract: "0x0000000000000000000000000000000000000000";
+};
+export declare const stakeEIP712Types: {
+    readonly Stake: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "toZoneId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
+export declare const unstakeUnlockEIP712Types: {
+    readonly Unstake: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "fromZoneId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
+export declare const unstakeMoveEIP712Types: {
+    readonly UnstakeMove: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "fromZoneId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "toZoneId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
+export declare const restakeEIP712Types: {
+    readonly Restake: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "fromZoneId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "toZoneId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
+export declare const stakeSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    amount: z.ZodString;
+    toZoneId: z.ZodString;
+    deadline: z.ZodString;
+}, z.core.$strip>;
+export declare const unstakeUnlockSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    amount: z.ZodString;
+    fromZoneId: z.ZodString;
+    deadline: z.ZodString;
+}, z.core.$strip>;
+export declare const unstakeMoveSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    amount: z.ZodString;
+    fromZoneId: z.ZodString;
+    toZoneId: z.ZodString;
+    deadline: z.ZodString;
+}, z.core.$strip>;
+export declare const restakeSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    amount: z.ZodString;
+    fromZoneId: z.ZodString;
+    toZoneId: z.ZodString;
+    deadline: z.ZodString;
+}, z.core.$strip>;
+export type StakeSignatureRequest = z.infer<typeof stakeSignatureRequestSchema>;
+export type UnstakeUnlockSignatureRequest = z.infer<typeof unstakeUnlockSignatureRequestSchema>;
+export type UnstakeMoveSignatureRequest = z.infer<typeof unstakeMoveSignatureRequestSchema>;
+export type RestakeSignatureRequest = z.infer<typeof restakeSignatureRequestSchema>;
+export type StakeMessage = {
+    nonce: bigint;
+    amount: bigint;
+    toZoneId: bigint;
+    deadline: bigint;
+};
+export type UnstakeUnlockMessage = {
+    nonce: bigint;
+    amount: bigint;
+    fromZoneId: bigint;
+    deadline: bigint;
+};
+export type UnstakeMoveMessage = {
+    nonce: bigint;
+    amount: bigint;
+    fromZoneId: bigint;
+    toZoneId: bigint;
+    deadline: bigint;
+};
+export type RestakeMessage = {
+    nonce: bigint;
+    amount: bigint;
+    fromZoneId: bigint;
+    toZoneId: bigint;
+    deadline: bigint;
+};
+export type SignatureValidationReason = "deadline_expired" | "signature_failed" | "signer_mismatch" | null;
+export type SignatureValidationResult = {
+    valid: boolean;
+    recovered: string | null;
+    reason: SignatureValidationReason;
+};
+type StakeMessageInput = Pick<StakeSignatureRequest, "nonce" | "amount" | "toZoneId" | "deadline">;
+type UnstakeUnlockMessageInput = Pick<UnstakeUnlockSignatureRequest, "nonce" | "amount" | "fromZoneId" | "deadline">;
+type UnstakeMoveMessageInput = Pick<UnstakeMoveSignatureRequest, "nonce" | "amount" | "fromZoneId" | "toZoneId" | "deadline">;
+type RestakeMessageInput = Pick<RestakeSignatureRequest, "nonce" | "amount" | "fromZoneId" | "toZoneId" | "deadline">;
+export declare function buildStakeMessage(req: StakeMessageInput): StakeMessage;
+export declare function buildUnstakeUnlockMessage(req: UnstakeUnlockMessageInput): UnstakeUnlockMessage;
+export declare function buildUnstakeMoveMessage(req: UnstakeMoveMessageInput): UnstakeMoveMessage;
+export declare function buildRestakeMessage(req: RestakeMessageInput): RestakeMessage;
+export declare function validateStakeSignature(input: StakeSignatureRequest, domain?: typeof stakeControlEIP712Domain): Promise<SignatureValidationResult>;
+export declare function validateUnstakeUnlockSignature(input: UnstakeUnlockSignatureRequest, domain?: typeof stakeControlEIP712Domain): Promise<SignatureValidationResult>;
+export declare function validateUnstakeMoveSignature(input: UnstakeMoveSignatureRequest, domain?: typeof stakeControlEIP712Domain): Promise<SignatureValidationResult>;
+export declare function validateRestakeSignature(input: RestakeSignatureRequest, domain?: typeof stakeControlEIP712Domain): Promise<SignatureValidationResult>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glowlabs-org/utils",
-  "version": "0.2.47",
+  "version": "0.2.48",
   "description": "A library containing all typechain types and addresses relating to the glow guarded launch",
   "keywords": [],
   "author": "",
@@ -41,10 +41,10 @@
     "node": ">=16"
   },
   "peerDependencies": {
+    "decimal.js": "^10.4.3",
     "ethers": "6.x.x",
     "merkletreejs": "^0.3.11",
-    "viem": "^2.19.7",
-    "decimal.js": "^10.4.3"
+    "viem": "^2.19.7"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^26.0.1",
@@ -61,6 +61,9 @@
     "typescript": "^5.5.4",
     "viem": "^2.7.16"
   },
+  "dependencies": {
+    "zod": "^4.0.17"
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "rollup -c",

package/src/browser.ts

@@ -7,3 +7,4 @@ export * from "./lib/abis/forwarderABI";
 export * from "./constants/addresses";
 export * from "./constants/weights";
 export * from "./constants/urls";
+export * from "./utils/stake-control";

package/src/index.ts

@@ -9,3 +9,4 @@ export {
 export { useForwarder } from "./lib/hooks/use-forwarder";
 export { ControlRouter } from "./lib/control-api/control-router";
 export { RegionRouter } from "./lib/control-api/region-router";
+export { KickstarterRouter } from "./lib/control-api/kickstarter-router";

package/src/lib/control-api/control-router.ts

@@ -114,6 +114,7 @@ export function ControlRouter(baseUrl: string) {
       const data = await request<{ transfers: PendingTransfer[] }>(
         `/transfers/pending${buildPaginationQuery(page, limit)}`
       );
+
       return data.transfers ?? [];
     } catch (error) {
       throw new Error(parseApiError(error));
@@ -192,14 +193,9 @@ export function ControlRouter(baseUrl: string) {
   let isUnstaking = false;
   let isRetryingFailedOperation = false;
 
-  const stakeGctl = async (
-    wallet: string,
-    regionId: number,
-    amount: string
-  ): Promise<boolean> => {
+  const stakeGctl = async (stakeRequest: StakeRequest): Promise<boolean> => {
     isStaking = true;
     try {
-      const stakeRequest: StakeRequest = { wallet, regionId, amount };
       await request(`/stake`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -214,13 +210,10 @@ export function ControlRouter(baseUrl: string) {
   };
 
   const unstakeGctl = async (
-    wallet: string,
-    regionId: number,
-    amount: string
+    unstakeRequest: StakeRequest
   ): Promise<boolean> => {
     isUnstaking = true;
     try {
-      const unstakeRequest: StakeRequest = { wallet, regionId, amount };
       await request(`/unstake`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },

package/src/lib/control-api/kickstarter-router.ts

@@ -0,0 +1,119 @@
+"use strict";
+
+import { regionMetadata } from "../region-metadata";
+import type {
+  Kickstarter,
+  CreateKickstarterPayload,
+  KickstarterCreateResponse,
+  CommitKickstarterPayload,
+  CommitKickstarterResponse,
+} from "../types";
+
+function parseApiError(error: unknown): string {
+  if (!error) return "Unknown error";
+  if (error instanceof Error) return error.message;
+  const possible: any = error;
+  return possible?.error?.message ?? possible?.message ?? "Unknown error";
+}
+
+export function KickstarterRouter(baseUrl: string) {
+  if (!baseUrl) throw new Error("CONTROL API base URL is not set");
+
+  const request = async <T>(path: string, init?: RequestInit): Promise<T> => {
+    const res = await fetch(`${baseUrl}${path}`, init);
+    if (!res.ok) {
+      const errData = await res.json().catch(() => ({}));
+      throw new Error(errData?.error || `Request to ${path} failed`);
+    }
+    return (await res.json()) as T;
+  };
+
+  let isCreatingKickstarter = false;
+
+  const fetchKickstarters = async (): Promise<Kickstarter[]> => {
+    try {
+      const data = await request<{ kickstarters: Kickstarter[] }>(
+        `/kickstarters`
+      );
+      return data.kickstarters ?? [];
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    }
+  };
+
+  const createKickstarter = async (
+    payload: CreateKickstarterPayload
+  ): Promise<KickstarterCreateResponse> => {
+    isCreatingKickstarter = true;
+    try {
+      const exists = Boolean(regionMetadata[payload.code]);
+      if (!exists) {
+        throw new Error(`Unknown region code: ${payload.code}`);
+      }
+      const data = await request<KickstarterCreateResponse>(`/kickstarters`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+      return data;
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    } finally {
+      isCreatingKickstarter = false;
+    }
+  };
+
+  const fetchKickstarter = async (idOrSlug: string): Promise<Kickstarter> => {
+    try {
+      const data = await request<{ kickstarter: Kickstarter }>(
+        `/kickstarters/${encodeURIComponent(idOrSlug)}`
+      );
+      return data.kickstarter;
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    }
+  };
+
+  const fetchKickstartersByWallet = async (
+    wallet: string
+  ): Promise<Kickstarter[]> => {
+    try {
+      const data = await request<{ kickstarters: Kickstarter[] }>(
+        `/kickstarters/by-wallet/${encodeURIComponent(wallet)}`
+      );
+      return data.kickstarters ?? [];
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    }
+  };
+
+  const commitKickstarter = async (
+    kickstarterId: string,
+    payload: CommitKickstarterPayload
+  ): Promise<CommitKickstarterResponse> => {
+    try {
+      const data = await request<CommitKickstarterResponse>(
+        `/kickstarters/commit/${encodeURIComponent(kickstarterId)}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        }
+      );
+      return data;
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    }
+  };
+
+  return {
+    fetchKickstarters,
+    fetchKickstarter,
+    fetchKickstartersByWallet,
+    commitKickstarter,
+    createKickstarter,
+    get isCreatingKickstarter() {
+      return isCreatingKickstarter;
+    },
+  } as const;
+}

package/src/lib/control-api/region-router.ts

@@ -6,10 +6,7 @@ import type {
   RegionWithMetadata,
   ActivationConfig,
   CreateRegionPayload,
-  CreateKickstarterPayload,
-  Kickstarter,
   ActivationEvent,
-  KickstarterCreateResponse,
   RegionVcr,
   SponsoredFarm,
 } from "../types";
@@ -47,7 +44,6 @@ export function RegionRouter(baseUrl: string) {
   let cachedRegions: RegionWithMetadata[] = [];
   let isLoading = false;
   let isCreatingRegion = false;
-  let isCreatingKickstarter = false;
 
   // -------------------------------------------------------------------------
   // Queries
@@ -112,17 +108,6 @@ export function RegionRouter(baseUrl: string) {
     }
   };
 
-  const fetchKickstarters = async (): Promise<Kickstarter[]> => {
-    try {
-      const data = await request<{ kickstarters: Kickstarter[] }>(
-        `/regions/kickstarters`
-      );
-      return data.kickstarters ?? [];
-    } catch (error) {
-      throw new Error(parseApiError(error));
-    }
-  };
-
   const fetchRegionSolarFarms = async (
     regionId: number
   ): Promise<SponsoredFarm[]> => {
@@ -156,56 +141,7 @@ export function RegionRouter(baseUrl: string) {
     }
   };
 
-  const createKickstarter = async (
-    payload: CreateKickstarterPayload
-  ): Promise<KickstarterCreateResponse> => {
-    isCreatingKickstarter = true;
-    try {
-      const exists = Boolean(regionMetadata[payload.code]);
-      if (!exists) {
-        throw new Error(`Unknown region code: ${payload.code}`);
-      }
-      const data = await request<KickstarterCreateResponse>(
-        `/regions/kickstarters`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(payload),
-        }
-      );
-      // A new region may have been created; refresh regions cache
-      await fetchRegions();
-      return data;
-    } catch (error) {
-      throw new Error(parseApiError(error));
-    } finally {
-      isCreatingKickstarter = false;
-    }
-  };
-
-  const fetchKickstarter = async (idOrSlug: string): Promise<Kickstarter> => {
-    try {
-      const data = await request<{ kickstarter: Kickstarter }>(
-        `/regions/kickstarters/${encodeURIComponent(idOrSlug)}`
-      );
-      return data.kickstarter;
-    } catch (error) {
-      throw new Error(parseApiError(error));
-    }
-  };
-
-  const fetchKickstartersByWallet = async (
-    wallet: string
-  ): Promise<Kickstarter[]> => {
-    try {
-      const data = await request<{ kickstarters: Kickstarter[] }>(
-        `/regions/kickstarters/by-wallet/${encodeURIComponent(wallet)}`
-      );
-      return data.kickstarters ?? [];
-    } catch (error) {
-      throw new Error(parseApiError(error));
-    }
-  };
+  // Kickstarter-related logic moved to kickstarter-router.ts
 
   // -------------------------------------------------------------------------
   // Helpers (derived)
@@ -239,10 +175,10 @@ export function RegionRouter(baseUrl: string) {
       isUs: metadata.isUs,
       isActive: false,
       stake: "0",
-      stakeThreshold: metadata.isUs ? "20000000000" : "2000000000000",
+      stakeThreshold: metadata.isUs ? "20000000000" : "200000000000",
       solarPanelsQuantity: 0,
-      solarFarmThreshold: 0,
-      installerThreshold: 0,
+      solarFarmThreshold: 10,
+      installerThreshold: 1,
       stakeProgress: 0,
       solarFarmCount: 0,
       solarFarmProgress: 0,
@@ -260,13 +196,9 @@ export function RegionRouter(baseUrl: string) {
     fetchActivationConfig,
     fetchActivationEvents,
     fetchRegionByIdOrSlug,
-    fetchKickstarters,
-    fetchKickstarter,
-    fetchKickstartersByWallet,
     fetchRegionSolarFarms,
     getRegionByCode,
     createRegion,
-    createKickstarter,
 
     // Cached data & flags
     get regions() {
@@ -278,8 +210,5 @@ export function RegionRouter(baseUrl: string) {
     get isCreatingRegion() {
       return isCreatingRegion;
     },
-    get isCreatingKickstarter() {
-      return isCreatingKickstarter;
-    },
   } as const;
 }

package/src/lib/types/index.ts

@@ -34,6 +34,7 @@ export interface PendingTransfer {
   applicationId?: string;
   farmId?: string;
   regionId?: number;
+  kickstarterId?: string;
 }
 
 export interface TransferDetails extends PendingTransfer {
@@ -79,6 +80,9 @@ export interface StakeRequest {
   wallet: string;
   regionId: number;
   amount: string; // Amount in atomic units (10^6 = 1 GCTL)
+  signature: string; // 0x-prefixed 65-byte hex signature
+  deadline: string; // unix timestamp (as string)
+  nonce: string; // stringified integer
 }
 
 export interface RegionStake {
@@ -114,14 +118,14 @@ export interface RegionWithMetadata extends Region {
   isActive: boolean;
   stake: string; // current GCTL stake (atomic units)
   stakeThreshold: string; // threshold required to activate
-  stakeProgress: number; // 0–1
+  stakeProgress: number; // stake / stakeThreshold (may exceed 1)
   solarFarmCount: number;
   solarPanelsQuantity: number;
-  solarFarmThreshold: number; // always 3
-  solarFarmProgress: number; // 0–1
+  solarFarmThreshold: number; // current minimum required (from constants)
+  solarFarmProgress: number; // solarFarmCount / solarFarmThreshold (may exceed 1)
   installerCount: number;
-  installerThreshold: number; // always 1
-  installerProgress: number; // 0 or 1
+  installerThreshold: number; // current minimum required (from constants)
+  installerProgress: number; // installerCount / installerThreshold (may exceed 1)
 }
 
 export interface ActivationConfig {
@@ -186,7 +190,7 @@ export interface Kickstarter {
   cancelledAt?: string; // ISO 8601
   expiredAt?: string; // ISO 8601
   deadline: string; // ISO 8601
-  stakeTargetGctl: string; // decimal string
+  stakeTargetGctl: string; // atomic units (GCTL scaled by 10^6)
   requiredFarmCount: number;
   requiredInstallerCount: number;
   stakeContributed: boolean;
@@ -197,6 +201,19 @@ export interface Kickstarter {
   kickoffStakeEventId?: string;
 }
 
+export interface CommitKickstarterPayload {
+  wallet: string; // 0x-prefixed 40-char hex
+  amount: string; // atomic GCTL, must equal stakeTargetGctl/KICKSTARTER_STAKE_PERCENTAGE
+  nonce: string; // uint256 as string
+  deadline: string; // unix seconds as string
+  signature: string; // 0x-prefixed 65-byte hex
+}
+
+export interface CommitKickstarterResponse {
+  success: true;
+  regionId: number;
+}
+
 export interface ActivationEvent {
   id: string;
   regionId: number;
@@ -249,6 +266,27 @@ export interface RegionVcr {
   carbonCreditsPerWeek: number;
 }
 
+// ----------------------------- API Responses --------------------------------
+export interface RegionsResponse {
+  regions: RegionWithMetadata[];
+}
+
+export interface RegionResponse {
+  region: RegionVcr;
+}
+
+export interface ActivationEventsResponse {
+  events: ActivationEvent[];
+}
+
+export interface RegionSolarFarmsResponse {
+  sponsoredFarms: SponsoredFarm[];
+}
+
+export interface FetchRegionsParams {
+  isActive?: boolean;
+}
+
 // ---------------------------------------------------------------------------
 // Barrel exports (convenience)
 // ---------------------------------------------------------------------------