@glowlabs-org/utils 0.2.50 → 0.2.52

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

@@ -1,9 +1,9 @@
 import z from "zod";
-export declare const stakeControlEIP712Domain: {
-    readonly name: "ControlManager";
-    readonly version: "1";
-    readonly chainId: number;
-    readonly verifyingContract: "0x0000000000000000000000000000000000000000";
+export declare const stakeControlEIP712Domain: (chainId: number) => {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: "0x0000000000000000000000000000000000000000";
 };
 export declare const stakeEIP712Types: {
     readonly Stake: readonly [{
@@ -71,6 +71,21 @@ export declare const restakeEIP712Types: {
         readonly type: "uint256";
     }];
 };
+export declare const commitKickstarterEIP712Types: {
+    readonly CommitKickstarter: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "kickstarterId";
+        readonly type: "string";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
 export declare const stakeSignatureRequestSchema: z.ZodObject<{
     wallet: z.ZodString;
     signature: z.ZodString;
@@ -105,10 +120,19 @@ export declare const restakeSignatureRequestSchema: z.ZodObject<{
     toZoneId: z.ZodString;
     deadline: z.ZodString;
 }, z.core.$strip>;
+export declare const commitKickstarterSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    amount: z.ZodString;
+    kickstarterId: 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 CommitKickstarterSignatureRequest = z.infer<typeof commitKickstarterSignatureRequestSchema>;
 export type StakeMessage = {
     nonce: bigint;
     amount: bigint;
@@ -135,6 +159,12 @@ export type RestakeMessage = {
     toZoneId: bigint;
     deadline: bigint;
 };
+export type CommitKickstarterMessage = {
+    nonce: bigint;
+    amount: bigint;
+    kickstarterId: string;
+    deadline: bigint;
+};
 export type SignatureValidationReason = "deadline_expired" | "signature_failed" | "signer_mismatch" | null;
 export type SignatureValidationResult = {
     valid: boolean;
@@ -145,12 +175,15 @@ type StakeMessageInput = Pick<StakeSignatureRequest, "nonce" | "amount" | "toZon
 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">;
+type CommitKickstarterMessageInput = Pick<CommitKickstarterSignatureRequest, "nonce" | "amount" | "kickstarterId" | "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 declare function buildCommitKickstarterMessage(req: CommitKickstarterMessageInput): CommitKickstarterMessage;
+export declare function validateStakeSignature(input: StakeSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
+export declare function validateUnstakeUnlockSignature(input: UnstakeUnlockSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
+export declare function validateUnstakeMoveSignature(input: UnstakeMoveSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
+export declare function validateRestakeSignature(input: RestakeSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
+export declare function validateCommitKickstarterSignature(input: CommitKickstarterSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glowlabs-org/utils",
-  "version": "0.2.50",
+  "version": "0.2.52",
   "description": "A library containing all typechain types and addresses relating to the glow guarded launch",
   "keywords": [],
   "author": "",

package/src/utils/stake-control.ts

@@ -1,12 +1,12 @@
 import { verifyTypedData, type Hex } from "viem";
 import z from "zod";
 
-export const stakeControlEIP712Domain = {
+export const stakeControlEIP712Domain = (chainId: number) => ({
   name: "ControlManager",
   version: "1",
-  chainId: Number(process.env.CHAIN_ID) || 1,
+  chainId,
   verifyingContract: "0x0000000000000000000000000000000000000000" as const,
-} as const;
+});
 
 // Distinct EIP-712 type sets for stake vs unstake
 export const stakeEIP712Types = {
@@ -48,6 +48,15 @@ export const restakeEIP712Types = {
   ],
 } as const;
 
+export const commitKickstarterEIP712Types = {
+  CommitKickstarter: [
+    { name: "nonce", type: "uint256" },
+    { name: "amount", type: "uint256" },
+    { name: "kickstarterId", type: "string" },
+    { name: "deadline", type: "uint256" },
+  ],
+} as const;
+
 // Separate request schemas for clarity between stake and unstake
 export const stakeSignatureRequestSchema = z.object({
   wallet: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
@@ -87,6 +96,15 @@ export const restakeSignatureRequestSchema = z.object({
   deadline: z.string(),
 });
 
+export const commitKickstarterSignatureRequestSchema = z.object({
+  wallet: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+  signature: z.string().regex(/^0x[a-fA-F0-9]{130}$/),
+  nonce: z.string(),
+  amount: z.string(),
+  kickstarterId: z.string(),
+  deadline: z.string(),
+});
+
 export type StakeSignatureRequest = z.infer<typeof stakeSignatureRequestSchema>;
 export type UnstakeUnlockSignatureRequest = z.infer<
   typeof unstakeUnlockSignatureRequestSchema
@@ -97,6 +115,9 @@ export type UnstakeMoveSignatureRequest = z.infer<
 export type RestakeSignatureRequest = z.infer<
   typeof restakeSignatureRequestSchema
 >;
+export type CommitKickstarterSignatureRequest = z.infer<
+  typeof commitKickstarterSignatureRequestSchema
+>;
 
 export type StakeMessage = {
   nonce: bigint;
@@ -128,6 +149,13 @@ export type RestakeMessage = {
   deadline: bigint;
 };
 
+export type CommitKickstarterMessage = {
+  nonce: bigint;
+  amount: bigint;
+  kickstarterId: string;
+  deadline: bigint;
+};
+
 export type SignatureValidationReason =
   | "deadline_expired"
   | "signature_failed"
@@ -163,6 +191,11 @@ type RestakeMessageInput = Pick<
   "nonce" | "amount" | "fromZoneId" | "toZoneId" | "deadline"
 >;
 
+type CommitKickstarterMessageInput = Pick<
+  CommitKickstarterSignatureRequest,
+  "nonce" | "amount" | "kickstarterId" | "deadline"
+>;
+
 export function buildStakeMessage(req: StakeMessageInput): StakeMessage {
   const nonce = BigInt(req.nonce);
   const amount = BigInt(req.amount);
@@ -219,10 +252,26 @@ export function buildRestakeMessage(req: RestakeMessageInput): RestakeMessage {
   return { nonce, amount, fromZoneId, toZoneId, deadline };
 }
 
+export function buildCommitKickstarterMessage(
+  req: CommitKickstarterMessageInput
+): CommitKickstarterMessage {
+  const nonce = BigInt(req.nonce);
+  const amount = BigInt(req.amount);
+  const deadline = BigInt(req.deadline);
+  const kickstarterId = req.kickstarterId;
+  if (nonce < 0n) throw new Error("Nonce must be non-negative");
+  if (amount < 0n) throw new Error("Amount must be non-negative");
+  if (deadline < 0n) throw new Error("Deadline must be non-negative");
+  if (!kickstarterId) throw new Error("kickstarterId must be non-empty");
+  return { nonce, amount, kickstarterId, deadline };
+}
+
 // Helper to validate the signature using viem
 export async function validateStakeSignature(
   input: StakeSignatureRequest,
-  domain: typeof stakeControlEIP712Domain = stakeControlEIP712Domain
+  domain: ReturnType<
+    typeof stakeControlEIP712Domain
+  > = stakeControlEIP712Domain(1)
 ): Promise<SignatureValidationResult> {
   const message = buildStakeMessage({
     nonce: input.nonce,
@@ -252,7 +301,9 @@ export async function validateStakeSignature(
 
 export async function validateUnstakeUnlockSignature(
   input: UnstakeUnlockSignatureRequest,
-  domain: typeof stakeControlEIP712Domain = stakeControlEIP712Domain
+  domain: ReturnType<
+    typeof stakeControlEIP712Domain
+  > = stakeControlEIP712Domain(1)
 ): Promise<SignatureValidationResult> {
   const message = buildUnstakeUnlockMessage({
     nonce: input.nonce,
@@ -282,7 +333,9 @@ export async function validateUnstakeUnlockSignature(
 
 export async function validateUnstakeMoveSignature(
   input: UnstakeMoveSignatureRequest,
-  domain: typeof stakeControlEIP712Domain = stakeControlEIP712Domain
+  domain: ReturnType<
+    typeof stakeControlEIP712Domain
+  > = stakeControlEIP712Domain(1)
 ): Promise<SignatureValidationResult> {
   const message = buildUnstakeMoveMessage({
     nonce: input.nonce,
@@ -313,7 +366,9 @@ export async function validateUnstakeMoveSignature(
 
 export async function validateRestakeSignature(
   input: RestakeSignatureRequest,
-  domain: typeof stakeControlEIP712Domain = stakeControlEIP712Domain
+  domain: ReturnType<
+    typeof stakeControlEIP712Domain
+  > = stakeControlEIP712Domain(1)
 ): Promise<SignatureValidationResult> {
   const message = buildRestakeMessage({
     nonce: input.nonce,
@@ -341,3 +396,35 @@ export async function validateRestakeSignature(
     return { valid: false, recovered: null, reason: "signature_failed" };
   }
 }
+
+export async function validateCommitKickstarterSignature(
+  input: CommitKickstarterSignatureRequest,
+  domain: ReturnType<
+    typeof stakeControlEIP712Domain
+  > = stakeControlEIP712Domain(1)
+): Promise<SignatureValidationResult> {
+  const message = buildCommitKickstarterMessage({
+    nonce: input.nonce,
+    amount: input.amount,
+    kickstarterId: input.kickstarterId,
+    deadline: input.deadline,
+  });
+  if (isDeadlineExpired(message.deadline)) {
+    return { valid: false, recovered: null, reason: "deadline_expired" };
+  }
+  try {
+    const verified = await verifyTypedData({
+      address: input.wallet as Hex,
+      domain,
+      types: commitKickstarterEIP712Types,
+      primaryType: "CommitKickstarter",
+      message,
+      signature: input.signature as Hex,
+    });
+    return verified
+      ? { valid: true, recovered: input.wallet, reason: null }
+      : { valid: false, recovered: null, reason: "signer_mismatch" };
+  } catch (_) {
+    return { valid: false, recovered: null, reason: "signature_failed" };
+  }
+}