@glowlabs-org/utils 0.2.132 → 0.2.133

package/dist/esm/index.js

@@ -13,8 +13,8 @@ import { parseUnits, formatUnits } from 'viem';
 import { MerkleTree } from 'merkletreejs';
 import { solidityPackedKeccak256, keccak256 } from 'ethers';
 import Decimal from 'decimal.js';
-import { H as HUB_URL, U as USDG_WEIGHT_DECIMAL_PRECISION, G as GLOW_WEIGHT_DECIMAL_PRECISION, M as MAX_WEIGHT } from './farms-router-DqPqj03h.js';
-export { C as ControlRouter, F as FarmsRouter, c as KICKSTARTER_STATUS, K as KickstarterRouter, O as OFF_CHAIN_PAYMENT_CURRENCIES, P as PAYMENT_CURRENCIES, b as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, T as TRANSFER_TYPES, W as WalletsRouter, u as useForwarder, a as useOffchainFractions } from './farms-router-DqPqj03h.js';
+import { H as HUB_URL, U as USDG_WEIGHT_DECIMAL_PRECISION, G as GLOW_WEIGHT_DECIMAL_PRECISION, M as MAX_WEIGHT } from './farms-router-CphuVUes.js';
+export { C as ControlRouter, F as FarmsRouter, c as KICKSTARTER_STATUS, K as KickstarterRouter, O as OFF_CHAIN_PAYMENT_CURRENCIES, P as PAYMENT_CURRENCIES, b as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, T as TRANSFER_TYPES, W as WalletsRouter, u as useForwarder, a as useOffchainFractions } from './farms-router-CphuVUes.js';
 
 const GENESIS_TIMESTAMP = 1700352000;
 

package/dist/esm/lib/control-api/control-router.d.ts

@@ -13,6 +13,15 @@ export interface PayProtocolDepositUsingStakedControlResponse {
     farmId: string;
     applicationId: string;
 }
+export interface MigrateUserRequest {
+    wallet: string;
+    signature: string;
+    deadline: string;
+    nonce: string;
+}
+export interface MigrateUserResponse {
+    success: true;
+}
 export declare function ControlRouter(baseUrl: string): {
     readonly fetchGctlBalance: (wallet: string) => Promise<string>;
     readonly fetchCommittedBalance: (wallet: string) => Promise<string>;
@@ -35,9 +44,11 @@ export declare function ControlRouter(baseUrl: string): {
     readonly restakeGctl: (restakeRequest: RestakeRequest) => Promise<boolean>;
     readonly retryFailedOperation: (operationId: string) => Promise<boolean>;
     readonly payProtocolDepositUsingStakedControl: (paymentRequest: PayProtocolDepositUsingStakedControlRequest) => Promise<PayProtocolDepositUsingStakedControlResponse>;
+    readonly migrateUser: (migrateRequest: MigrateUserRequest) => Promise<MigrateUserResponse>;
     readonly isStaking: boolean;
     readonly isUnstaking: boolean;
     readonly isRestaking: boolean;
     readonly isRetryingFailedOperation: boolean;
     readonly isPayingProtocolDepositUsingStakedControl: boolean;
+    readonly isMigratingUser: boolean;
 };

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

@@ -86,6 +86,18 @@ export declare const commitKickstarterEIP712Types: {
         readonly type: "uint256";
     }];
 };
+export declare const applyCertifiedInstallerEIP712Types: {
+    readonly ApplyCertifiedInstaller: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "regionId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
 export declare const payProtocolDepositUsingStakedControlEIP712Types: {
     readonly PayProtocolDepositUsingStakedControl: readonly [{
         readonly name: "amount";
@@ -101,6 +113,15 @@ export declare const payProtocolDepositUsingStakedControlEIP712Types: {
         readonly type: "uint256";
     }];
 };
+export declare const verifyUserEIP712Types: {
+    readonly VerifyUser: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
 export declare const stakeSignatureRequestSchema: z.ZodObject<{
     wallet: z.ZodString;
     signature: z.ZodString;
@@ -143,12 +164,25 @@ export declare const commitKickstarterSignatureRequestSchema: z.ZodObject<{
     kickstarterId: z.ZodString;
     deadline: z.ZodString;
 }, z.core.$strip>;
-export declare const payProtocolDepositUsingStakedControlSignatureRequestSchema: z.ZodObject<{
+export declare const applyCertifiedInstallerSignatureRequestSchema: z.ZodObject<{
     wallet: z.ZodString;
     signature: z.ZodString;
     nonce: z.ZodString;
+    regionId: z.ZodString;
+    deadline: z.ZodString;
+}, z.core.$strip>;
+export declare const payProtocolDepositUsingStakedControlSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
     amount: z.ZodString;
     applicationId: z.ZodString;
+    nonce: z.ZodString;
+    deadline: z.ZodString;
+}, z.core.$strip>;
+export declare const verifyUserSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
     deadline: z.ZodString;
 }, z.core.$strip>;
 export type StakeSignatureRequest = z.infer<typeof stakeSignatureRequestSchema>;
@@ -156,7 +190,9 @@ export type UnstakeUnlockSignatureRequest = z.infer<typeof unstakeUnlockSignatur
 export type UnstakeMoveSignatureRequest = z.infer<typeof unstakeMoveSignatureRequestSchema>;
 export type RestakeSignatureRequest = z.infer<typeof restakeSignatureRequestSchema>;
 export type CommitKickstarterSignatureRequest = z.infer<typeof commitKickstarterSignatureRequestSchema>;
+export type ApplyCertifiedInstallerSignatureRequest = z.infer<typeof applyCertifiedInstallerSignatureRequestSchema>;
 export type PayProtocolDepositUsingStakedControlSignatureRequest = z.infer<typeof payProtocolDepositUsingStakedControlSignatureRequestSchema>;
+export type VerifyUserSignatureRequest = z.infer<typeof verifyUserSignatureRequestSchema>;
 export type StakeMessage = {
     nonce: bigint;
     amount: bigint;
@@ -189,12 +225,28 @@ export type CommitKickstarterMessage = {
     kickstarterId: string;
     deadline: bigint;
 };
+export type ApplyCertifiedInstallerMessage = {
+    nonce: bigint;
+    regionId: bigint;
+    deadline: bigint;
+};
 export type PayProtocolDepositUsingStakedControlMessage = {
     amount: bigint;
     applicationId: string;
     nonce: bigint;
     deadline: bigint;
 };
+export type PayProtocolDepositMessage = {
+    nonce: bigint;
+    amount: bigint;
+    regionId: bigint;
+    applicationId: string;
+    deadline: bigint;
+};
+export type VerifyUserMessage = {
+    nonce: bigint;
+    deadline: bigint;
+};
 export type SignatureValidationReason = "deadline_expired" | "signature_failed" | "signer_mismatch" | null;
 export type SignatureValidationResult = {
     valid: boolean;
@@ -206,17 +258,23 @@ type UnstakeUnlockMessageInput = Pick<UnstakeUnlockSignatureRequest, "nonce" | "
 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">;
+type ApplyCertifiedInstallerMessageInput = Pick<ApplyCertifiedInstallerSignatureRequest, "nonce" | "regionId" | "deadline">;
 type PayProtocolDepositUsingStakedControlMessageInput = Pick<PayProtocolDepositUsingStakedControlSignatureRequest, "amount" | "applicationId" | "nonce" | "deadline">;
+type VerifyUserMessageInput = Pick<VerifyUserSignatureRequest, "nonce" | "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 buildCommitKickstarterMessage(req: CommitKickstarterMessageInput): CommitKickstarterMessage;
+export declare function buildApplyCertifiedInstallerMessage(req: ApplyCertifiedInstallerMessageInput): ApplyCertifiedInstallerMessage;
 export declare function buildPayProtocolDepositUsingStakedControlMessage(req: PayProtocolDepositUsingStakedControlMessageInput): PayProtocolDepositUsingStakedControlMessage;
+export declare function buildVerifyUserMessage(req: VerifyUserMessageInput): VerifyUserMessage;
 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 declare function validateApplyCertifiedInstallerSignature(input: ApplyCertifiedInstallerSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export declare function validatePayProtocolDepositUsingStakedControlSignature(input: PayProtocolDepositUsingStakedControlSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
+export declare function validateVerifyUserSignature(input: VerifyUserSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export {};

package/package.json

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

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

@@ -36,6 +36,17 @@ export interface PayProtocolDepositUsingStakedControlResponse {
   applicationId: string;
 }
 
+export interface MigrateUserRequest {
+  wallet: string;
+  signature: string;
+  deadline: string;
+  nonce: string;
+}
+
+export interface MigrateUserResponse {
+  success: true;
+}
+
 // --------------------------------------------------------------------------
 
 /**
@@ -271,6 +282,7 @@ export function ControlRouter(baseUrl: string) {
   let isRestaking = false;
   let isRetryingFailedOperation = false;
   let isPayingProtocolDepositUsingStakedControl = false;
+  let isMigratingUser = false;
 
   const stakeGctl = async (stakeRequest: StakeRequest): Promise<boolean> => {
     isStaking = true;
@@ -363,6 +375,24 @@ export function ControlRouter(baseUrl: string) {
     }
   };
 
+  const migrateUser = async (
+    migrateRequest: MigrateUserRequest
+  ): Promise<MigrateUserResponse> => {
+    isMigratingUser = true;
+    try {
+      const response = await request<MigrateUserResponse>(`/migrate-user`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(migrateRequest),
+      });
+      return response;
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    } finally {
+      isMigratingUser = false;
+    }
+  };
+
   // --------------------------- Public API ----------------------------------
   return {
     // Queries
@@ -389,6 +419,7 @@ export function ControlRouter(baseUrl: string) {
     restakeGctl,
     retryFailedOperation,
     payProtocolDepositUsingStakedControl,
+    migrateUser,
 
     // Processing flags
     get isStaking() {
@@ -406,5 +437,8 @@ export function ControlRouter(baseUrl: string) {
     get isPayingProtocolDepositUsingStakedControl() {
       return isPayingProtocolDepositUsingStakedControl;
     },
+    get isMigratingUser() {
+      return isMigratingUser;
+    },
   } as const;
 }

package/src/utils/stake-control.ts

@@ -1,5 +1,5 @@
 import { TRANSFER_TYPES } from "src/browser";
-import { verifyTypedData, type Hex, getAddress } from "viem";
+import { verifyTypedData, type Hex, checksumAddress } from "viem";
 import z from "zod";
 
 export const stakeControlEIP712Domain = (chainId: number) => ({
@@ -58,6 +58,14 @@ export const commitKickstarterEIP712Types = {
   ],
 } as const;
 
+export const applyCertifiedInstallerEIP712Types = {
+  ApplyCertifiedInstaller: [
+    { name: "nonce", type: "uint256" },
+    { name: "regionId", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+  ],
+} as const;
+
 export const payProtocolDepositUsingStakedControlEIP712Types = {
   PayProtocolDepositUsingStakedControl: [
     { name: "amount", type: "uint256" },
@@ -67,6 +75,13 @@ export const payProtocolDepositUsingStakedControlEIP712Types = {
   ],
 } as const;
 
+export const verifyUserEIP712Types = {
+  VerifyUser: [
+    { name: "nonce", type: "uint256" },
+    { 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}$/),
@@ -115,16 +130,31 @@ export const commitKickstarterSignatureRequestSchema = z.object({
   deadline: z.string(),
 });
 
+export const applyCertifiedInstallerSignatureRequestSchema = 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(),
+  regionId: z.string(),
+  deadline: z.string(),
+});
+
 export const payProtocolDepositUsingStakedControlSignatureRequestSchema =
   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(),
     applicationId: z.string(),
+    nonce: z.string(),
     deadline: z.string(),
   });
 
+export const verifyUserSignatureRequestSchema = 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(),
+  deadline: z.string(),
+});
+
 export type StakeSignatureRequest = z.infer<typeof stakeSignatureRequestSchema>;
 export type UnstakeUnlockSignatureRequest = z.infer<
   typeof unstakeUnlockSignatureRequestSchema
@@ -138,10 +168,17 @@ export type RestakeSignatureRequest = z.infer<
 export type CommitKickstarterSignatureRequest = z.infer<
   typeof commitKickstarterSignatureRequestSchema
 >;
+export type ApplyCertifiedInstallerSignatureRequest = z.infer<
+  typeof applyCertifiedInstallerSignatureRequestSchema
+>;
 export type PayProtocolDepositUsingStakedControlSignatureRequest = z.infer<
   typeof payProtocolDepositUsingStakedControlSignatureRequestSchema
 >;
 
+export type VerifyUserSignatureRequest = z.infer<
+  typeof verifyUserSignatureRequestSchema
+>;
+
 export type StakeMessage = {
   nonce: bigint;
   amount: bigint;
@@ -179,6 +216,12 @@ export type CommitKickstarterMessage = {
   deadline: bigint;
 };
 
+export type ApplyCertifiedInstallerMessage = {
+  nonce: bigint;
+  regionId: bigint;
+  deadline: bigint;
+};
+
 export type PayProtocolDepositUsingStakedControlMessage = {
   amount: bigint;
   applicationId: string;
@@ -186,6 +229,19 @@ export type PayProtocolDepositUsingStakedControlMessage = {
   deadline: bigint;
 };
 
+export type PayProtocolDepositMessage = {
+  nonce: bigint;
+  amount: bigint;
+  regionId: bigint;
+  applicationId: string;
+  deadline: bigint;
+};
+
+export type VerifyUserMessage = {
+  nonce: bigint;
+  deadline: bigint;
+};
+
 export type SignatureValidationReason =
   | "deadline_expired"
   | "signature_failed"
@@ -226,11 +282,21 @@ type CommitKickstarterMessageInput = Pick<
   "nonce" | "amount" | "kickstarterId" | "deadline"
 >;
 
+type ApplyCertifiedInstallerMessageInput = Pick<
+  ApplyCertifiedInstallerSignatureRequest,
+  "nonce" | "regionId" | "deadline"
+>;
+
 type PayProtocolDepositUsingStakedControlMessageInput = Pick<
   PayProtocolDepositUsingStakedControlSignatureRequest,
   "amount" | "applicationId" | "nonce" | "deadline"
 >;
 
+type VerifyUserMessageInput = Pick<
+  VerifyUserSignatureRequest,
+  "nonce" | "deadline"
+>;
+
 export function buildStakeMessage(req: StakeMessageInput): StakeMessage {
   const nonce = BigInt(req.nonce);
   const amount = BigInt(req.amount);
@@ -301,26 +367,48 @@ export function buildCommitKickstarterMessage(
   return { nonce, amount, kickstarterId, deadline };
 }
 
+export function buildApplyCertifiedInstallerMessage(
+  req: ApplyCertifiedInstallerMessageInput
+): ApplyCertifiedInstallerMessage {
+  const nonce = BigInt(req.nonce);
+  const deadline = BigInt(req.deadline);
+  const regionId = req.regionId;
+  if (nonce < 0n) throw new Error("Nonce must be non-negative");
+  if (deadline < 0n) throw new Error("Deadline must be non-negative");
+  if (!regionId) throw new Error("regionId must be non-empty");
+  return { nonce, regionId: BigInt(regionId), deadline };
+}
+
 export function buildPayProtocolDepositUsingStakedControlMessage(
   req: PayProtocolDepositUsingStakedControlMessageInput
 ): PayProtocolDepositUsingStakedControlMessage {
-  const amount = BigInt(req.amount);
   const nonce = BigInt(req.nonce);
+  const amount = BigInt(req.amount);
   const deadline = BigInt(req.deadline);
   const applicationId = req.applicationId;
-  if (amount < 0n) throw new Error("Amount must be non-negative");
   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 (!applicationId) throw new Error("applicationId must be non-empty");
   return { amount, applicationId, nonce, deadline };
 }
 
+export function buildVerifyUserMessage(
+  req: VerifyUserMessageInput
+): VerifyUserMessage {
+  const nonce = BigInt(req.nonce);
+  const deadline = BigInt(req.deadline);
+  if (nonce < 0n) throw new Error("Nonce must be non-negative");
+  if (deadline < 0n) throw new Error("Deadline must be non-negative");
+  return { nonce, deadline };
+}
+
 // Helper to validate the signature using viem
 export async function validateStakeSignature(
   input: StakeSignatureRequest,
   domain: ReturnType<
     typeof stakeControlEIP712Domain
-  > = stakeControlEIP712Domain(1)
+  > = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)
 ): Promise<SignatureValidationResult> {
   const message = buildStakeMessage({
     nonce: input.nonce,
@@ -333,7 +421,7 @@ export async function validateStakeSignature(
   }
   try {
     const verified = await verifyTypedData({
-      address: input.wallet as Hex,
+      address: checksumAddress(input.wallet as Hex),
       domain,
       types: stakeEIP712Types,
       primaryType: "Stake",
@@ -352,7 +440,7 @@ export async function validateUnstakeUnlockSignature(
   input: UnstakeUnlockSignatureRequest,
   domain: ReturnType<
     typeof stakeControlEIP712Domain
-  > = stakeControlEIP712Domain(1)
+  > = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)
 ): Promise<SignatureValidationResult> {
   const message = buildUnstakeUnlockMessage({
     nonce: input.nonce,
@@ -365,7 +453,7 @@ export async function validateUnstakeUnlockSignature(
   }
   try {
     const verified = await verifyTypedData({
-      address: input.wallet as Hex,
+      address: checksumAddress(input.wallet as Hex),
       domain,
       types: unstakeUnlockEIP712Types,
       primaryType: "Unstake",
@@ -384,7 +472,7 @@ export async function validateUnstakeMoveSignature(
   input: UnstakeMoveSignatureRequest,
   domain: ReturnType<
     typeof stakeControlEIP712Domain
-  > = stakeControlEIP712Domain(1)
+  > = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)
 ): Promise<SignatureValidationResult> {
   const message = buildUnstakeMoveMessage({
     nonce: input.nonce,
@@ -398,7 +486,7 @@ export async function validateUnstakeMoveSignature(
   }
   try {
     const verified = await verifyTypedData({
-      address: input.wallet as Hex,
+      address: checksumAddress(input.wallet as Hex),
       domain,
       types: unstakeMoveEIP712Types,
       primaryType: "UnstakeMove",
@@ -417,7 +505,7 @@ export async function validateRestakeSignature(
   input: RestakeSignatureRequest,
   domain: ReturnType<
     typeof stakeControlEIP712Domain
-  > = stakeControlEIP712Domain(1)
+  > = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)
 ): Promise<SignatureValidationResult> {
   const message = buildRestakeMessage({
     nonce: input.nonce,
@@ -431,7 +519,7 @@ export async function validateRestakeSignature(
   }
   try {
     const verified = await verifyTypedData({
-      address: input.wallet as Hex,
+      address: checksumAddress(input.wallet as Hex),
       domain,
       types: restakeEIP712Types,
       primaryType: "Restake",
@@ -450,7 +538,7 @@ export async function validateCommitKickstarterSignature(
   input: CommitKickstarterSignatureRequest,
   domain: ReturnType<
     typeof stakeControlEIP712Domain
-  > = stakeControlEIP712Domain(1)
+  > = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)
 ): Promise<SignatureValidationResult> {
   const message = buildCommitKickstarterMessage({
     nonce: input.nonce,
@@ -463,7 +551,7 @@ export async function validateCommitKickstarterSignature(
   }
   try {
     const verified = await verifyTypedData({
-      address: input.wallet as Hex,
+      address: checksumAddress(input.wallet as Hex),
       domain,
       types: commitKickstarterEIP712Types,
       primaryType: "CommitKickstarter",
@@ -478,11 +566,42 @@ export async function validateCommitKickstarterSignature(
   }
 }
 
+export async function validateApplyCertifiedInstallerSignature(
+  input: ApplyCertifiedInstallerSignatureRequest,
+  domain: ReturnType<
+    typeof stakeControlEIP712Domain
+  > = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)
+): Promise<SignatureValidationResult> {
+  const message = buildApplyCertifiedInstallerMessage({
+    nonce: input.nonce,
+    regionId: input.regionId,
+    deadline: input.deadline,
+  });
+  if (isDeadlineExpired(message.deadline)) {
+    return { valid: false, recovered: null, reason: "deadline_expired" };
+  }
+  try {
+    const verified = await verifyTypedData({
+      address: checksumAddress(input.wallet as Hex),
+      domain,
+      types: applyCertifiedInstallerEIP712Types,
+      primaryType: "ApplyCertifiedInstaller",
+      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" };
+  }
+}
+
 export async function validatePayProtocolDepositUsingStakedControlSignature(
   input: PayProtocolDepositUsingStakedControlSignatureRequest,
   domain: ReturnType<
     typeof stakeControlEIP712Domain
-  > = stakeControlEIP712Domain(1)
+  > = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)
 ): Promise<SignatureValidationResult> {
   const message = buildPayProtocolDepositUsingStakedControlMessage({
     amount: input.amount,
@@ -495,7 +614,7 @@ export async function validatePayProtocolDepositUsingStakedControlSignature(
   }
   try {
     const verified = await verifyTypedData({
-      address: getAddress(input.wallet as Hex),
+      address: checksumAddress(input.wallet as Hex),
       domain,
       types: payProtocolDepositUsingStakedControlEIP712Types,
       primaryType: TRANSFER_TYPES.PayProtocolDepositUsingStakedControl,
@@ -509,3 +628,33 @@ export async function validatePayProtocolDepositUsingStakedControlSignature(
     return { valid: false, recovered: null, reason: "signature_failed" };
   }
 }
+
+export async function validateVerifyUserSignature(
+  input: VerifyUserSignatureRequest,
+  domain: ReturnType<
+    typeof stakeControlEIP712Domain
+  > = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)
+): Promise<SignatureValidationResult> {
+  const message = buildVerifyUserMessage({
+    nonce: input.nonce,
+    deadline: input.deadline,
+  });
+  if (isDeadlineExpired(message.deadline)) {
+    return { valid: false, recovered: null, reason: "deadline_expired" };
+  }
+  try {
+    const verified = await verifyTypedData({
+      address: checksumAddress(input.wallet as Hex),
+      domain,
+      types: verifyUserEIP712Types,
+      primaryType: "VerifyUser",
+      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" };
+  }
+}