@glowlabs-org/utils 0.2.91 → 0.2.93

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

@@ -1,4 +1,18 @@
 import type { StakeRequest, RegionStake, WalletRegionStake, WalletRegionUnlocked, TransferDetails, GlwRegionRewardsResponse, MintedEventsResponse, StakeEventsResponse, FailedOperationsResponse, PendingTransfersResponse, PendingTransferType, RestakeRequest } from "../types";
+export interface PayProtocolDepositUsingStakedControlRequest {
+    wallet: string;
+    regionId: number;
+    applicationId: string;
+    amount: string;
+    signature: string;
+    deadline: string;
+    nonce: string;
+}
+export interface PayProtocolDepositUsingStakedControlResponse {
+    success: true;
+    farmId: string;
+    applicationId: string;
+}
 export declare function ControlRouter(baseUrl: string): {
     readonly fetchGctlBalance: (wallet: string) => Promise<string>;
     readonly fetchGctlPrice: () => Promise<string>;
@@ -18,8 +32,10 @@ export declare function ControlRouter(baseUrl: string): {
     readonly unstakeGctl: (unstakeRequest: StakeRequest) => Promise<boolean>;
     readonly restakeGctl: (restakeRequest: RestakeRequest) => Promise<boolean>;
     readonly retryFailedOperation: (operationId: string) => Promise<boolean>;
+    readonly payProtocolDepositUsingStakedControl: (paymentRequest: PayProtocolDepositUsingStakedControlRequest) => Promise<PayProtocolDepositUsingStakedControlResponse>;
     readonly isStaking: boolean;
     readonly isUnstaking: boolean;
     readonly isRestaking: boolean;
     readonly isRetryingFailedOperation: boolean;
+    readonly isPayingProtocolDepositUsingStakedControl: boolean;
 };

package/dist/esm/lib/types/index.d.ts

@@ -34,8 +34,19 @@ export interface PendingTransfer {
     regionId?: number;
     kickstarterId?: string;
 }
-export declare const TRANSFER_TYPES: readonly ["PayProtocolFeeAndMintGCTLAndStake", "PayProtocolFee", "PayAuditFees", "CommitKickstarter", "MintGCTLAndStake", "MintGCTL", "BuySolarFarm", "SponsorProtocolFee", "SponsorProtocolFeeAndMintGCTLAndStake"];
-export type PendingTransferType = (typeof TRANSFER_TYPES)[number];
+export declare const TRANSFER_TYPES: {
+    readonly PayProtocolFeeAndMintGCTLAndStake: "PayProtocolFeeAndMintGCTLAndStake";
+    readonly PayProtocolFee: "PayProtocolFee";
+    readonly PayAuditFees: "PayAuditFees";
+    readonly CommitKickstarter: "CommitKickstarter";
+    readonly MintGCTLAndStake: "MintGCTLAndStake";
+    readonly MintGCTL: "MintGCTL";
+    readonly BuySolarFarm: "BuySolarFarm";
+    readonly SponsorProtocolFee: "SponsorProtocolFee";
+    readonly SponsorProtocolFeeAndMintGCTLAndStake: "SponsorProtocolFeeAndMintGCTLAndStake";
+    readonly PayProtocolDepositUsingStakedControl: "PayProtocolDepositUsingStakedControl";
+};
+export type PendingTransferType = (typeof TRANSFER_TYPES)[keyof typeof TRANSFER_TYPES];
 export interface TransferDetails extends PendingTransfer {
     blockNumber: string;
     failureInfo?: {
@@ -190,6 +201,7 @@ export interface KickstarterDetails extends Kickstarter {
     contributorsCount: number;
     farmCount: number;
     solarFarmApplications: SolarFarmApplication[];
+    sponsoredFarms: SponsoredFarm[];
 }
 export interface CommitKickstarterPayload {
     wallet: string;

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

@@ -86,6 +86,21 @@ export declare const commitKickstarterEIP712Types: {
         readonly type: "uint256";
     }];
 };
+export declare const payProtocolDepositUsingStakedControlEIP712Types: {
+    readonly PayProtocolDepositUsingStakedControl: readonly [{
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "applicationId";
+        readonly type: "string";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
 export declare const stakeSignatureRequestSchema: z.ZodObject<{
     wallet: z.ZodString;
     signature: z.ZodString;
@@ -128,11 +143,20 @@ export declare const commitKickstarterSignatureRequestSchema: z.ZodObject<{
     kickstarterId: z.ZodString;
     deadline: z.ZodString;
 }, z.core.$strip>;
+export declare const payProtocolDepositUsingStakedControlSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    amount: z.ZodString;
+    applicationId: 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 PayProtocolDepositUsingStakedControlSignatureRequest = z.infer<typeof payProtocolDepositUsingStakedControlSignatureRequestSchema>;
 export type StakeMessage = {
     nonce: bigint;
     amount: bigint;
@@ -165,6 +189,12 @@ export type CommitKickstarterMessage = {
     kickstarterId: string;
     deadline: bigint;
 };
+export type PayProtocolDepositUsingStakedControlMessage = {
+    amount: bigint;
+    applicationId: string;
+    nonce: bigint;
+    deadline: bigint;
+};
 export type SignatureValidationReason = "deadline_expired" | "signature_failed" | "signer_mismatch" | null;
 export type SignatureValidationResult = {
     valid: boolean;
@@ -176,14 +206,17 @@ 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 PayProtocolDepositUsingStakedControlMessageInput = Pick<PayProtocolDepositUsingStakedControlSignatureRequest, "amount" | "applicationId" | "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 buildPayProtocolDepositUsingStakedControlMessage(req: PayProtocolDepositUsingStakedControlMessageInput): PayProtocolDepositUsingStakedControlMessage;
 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 validatePayProtocolDepositUsingStakedControlSignature(input: PayProtocolDepositUsingStakedControlSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glowlabs-org/utils",
-  "version": "0.2.91",
+  "version": "0.2.93",
   "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

@@ -19,6 +19,22 @@ import type {
   RestakeRequest,
 } from "../types";
 
+export interface PayProtocolDepositUsingStakedControlRequest {
+  wallet: string;
+  regionId: number;
+  applicationId: string;
+  amount: string;
+  signature: string;
+  deadline: string;
+  nonce: string;
+}
+
+export interface PayProtocolDepositUsingStakedControlResponse {
+  success: true;
+  farmId: string;
+  applicationId: string;
+}
+
 // --------------------------------------------------------------------------
 
 /**
@@ -229,6 +245,7 @@ export function ControlRouter(baseUrl: string) {
   let isUnstaking = false;
   let isRestaking = false;
   let isRetryingFailedOperation = false;
+  let isPayingProtocolDepositUsingStakedControl = false;
 
   const stakeGctl = async (stakeRequest: StakeRequest): Promise<boolean> => {
     isStaking = true;
@@ -299,6 +316,28 @@ export function ControlRouter(baseUrl: string) {
     }
   };
 
+  const payProtocolDepositUsingStakedControl = async (
+    paymentRequest: PayProtocolDepositUsingStakedControlRequest
+  ): Promise<PayProtocolDepositUsingStakedControlResponse> => {
+    isPayingProtocolDepositUsingStakedControl = true;
+    try {
+      const response =
+        await request<PayProtocolDepositUsingStakedControlResponse>(
+          `/pay-protocol-deposit-staked`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(paymentRequest),
+          }
+        );
+      return response;
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    } finally {
+      isPayingProtocolDepositUsingStakedControl = false;
+    }
+  };
+
   // --------------------------- Public API ----------------------------------
   return {
     // Queries
@@ -322,6 +361,7 @@ export function ControlRouter(baseUrl: string) {
     unstakeGctl,
     restakeGctl,
     retryFailedOperation,
+    payProtocolDepositUsingStakedControl,
 
     // Processing flags
     get isStaking() {
@@ -336,5 +376,8 @@ export function ControlRouter(baseUrl: string) {
     get isRetryingFailedOperation() {
       return isRetryingFailedOperation;
     },
+    get isPayingProtocolDepositUsingStakedControl() {
+      return isPayingProtocolDepositUsingStakedControl;
+    },
   } as const;
 }

package/src/lib/hooks/use-forwarder.ts

@@ -3,7 +3,7 @@ import { FORWARDER_ABI } from "../abis/forwarderABI";
 import { ERC20_ABI } from "../abis/erc20.abi";
 import { getAddresses } from "../../constants/addresses";
 import { formatEther } from "viem";
-import { PendingTransferType } from "../types";
+import { PendingTransferType, TRANSFER_TYPES } from "../types";
 
 export enum ForwarderError {
   CONTRACT_NOT_AVAILABLE = "Contract not available",
@@ -96,55 +96,55 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     } = params;
 
     switch (type) {
-      case "PayProtocolFeeAndMintGCTLAndStake":
+      case TRANSFER_TYPES.PayProtocolFeeAndMintGCTLAndStake:
         if (!applicationId) {
           throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
         }
         return `PayProtocolFeeAndMintGCTLAndStake::${applicationId}`;
 
-      case "PayProtocolFee":
+      case TRANSFER_TYPES.PayProtocolFee:
         if (!applicationId) {
           throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
         }
         return `PayProtocolFee::${applicationId}`;
 
-      case "SponsorProtocolFee":
+      case TRANSFER_TYPES.SponsorProtocolFee:
         if (!applicationId) {
           throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
         }
         return `SponsorProtocolFee::${applicationId}`;
 
-      case "SponsorProtocolFeeAndMintGCTLAndStake":
+      case TRANSFER_TYPES.SponsorProtocolFeeAndMintGCTLAndStake:
         if (!applicationId) {
           throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
         }
         return `SponsorProtocolFeeAndMintGCTLAndStake::${applicationId}`;
 
-      case "MintGCTLAndStake":
+      case TRANSFER_TYPES.MintGCTLAndStake:
         if (!regionId) {
           throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
         }
         return `MintGCTLAndStake::${regionId}`;
 
-      case "MintGCTL":
+      case TRANSFER_TYPES.MintGCTL:
         if (!userAddress) {
           throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
         }
         return `MintGCTL::${userAddress}`;
 
-      case "BuySolarFarm":
+      case TRANSFER_TYPES.BuySolarFarm:
         if (!farmId) {
           throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
         }
         return `BuySolarFarm::${farmId}`;
 
-      case "PayAuditFees":
+      case TRANSFER_TYPES.PayAuditFees:
         if (!applicationId) {
           throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
         }
         return `PayAuditFees::${applicationId}`;
 
-      case "CommitKickstarter":
+      case TRANSFER_TYPES.CommitKickstarter:
         if (!kickstarterId) {
           throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
         }
@@ -288,13 +288,14 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
       const message = constructForwardMessage(params);
 
       // Special handling: PayAuditFees can ONLY be USDC, and must call forward()
-      const isAuditFees = params.type === "PayAuditFees";
+      const isAuditFees = params.type === TRANSFER_TYPES.PayAuditFees;
       if (isAuditFees && currency !== "USDC") {
         throw new Error("PayAuditFees only supports USDC");
       }
 
       // CommitKickstarter supports only USDC or USDG (GLW not allowed)
-      const isCommitKickstarter = params.type === "CommitKickstarter";
+      const isCommitKickstarter =
+        params.type === TRANSFER_TYPES.CommitKickstarter;
       if (isCommitKickstarter && currency === "GLW") {
         throw new Error("CommitKickstarter supports only USDC or USDG");
       }
@@ -410,7 +411,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "PayProtocolFeeAndMintGCTLAndStake",
+      type: TRANSFER_TYPES.PayProtocolFeeAndMintGCTLAndStake,
       currency,
       applicationId,
       regionId,
@@ -436,7 +437,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "SponsorProtocolFeeAndMintGCTLAndStake",
+      type: TRANSFER_TYPES.SponsorProtocolFeeAndMintGCTLAndStake,
       currency,
       applicationId,
     });
@@ -456,7 +457,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "PayProtocolFee",
+      type: TRANSFER_TYPES.PayProtocolFee,
       currency,
       applicationId,
     });
@@ -476,7 +477,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "SponsorProtocolFee",
+      type: TRANSFER_TYPES.SponsorProtocolFee,
       currency,
       applicationId,
     });
@@ -503,7 +504,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "MintGCTLAndStake",
+      type: TRANSFER_TYPES.MintGCTLAndStake,
       currency,
       regionId,
     });
@@ -529,7 +530,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "MintGCTL",
+      type: TRANSFER_TYPES.MintGCTL,
       currency,
     });
   }
@@ -547,7 +548,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "PayAuditFees",
+      type: TRANSFER_TYPES.PayAuditFees,
       currency: "USDC",
       applicationId,
     });
@@ -567,7 +568,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "BuySolarFarm",
+      type: TRANSFER_TYPES.BuySolarFarm,
       currency,
       farmId,
     });
@@ -591,7 +592,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "CommitKickstarter",
+      type: TRANSFER_TYPES.CommitKickstarter,
       currency,
       kickstarterId,
     });
@@ -614,7 +615,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
         throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
 
       const { amount, currency = "USDC" } = params;
-      const isAuditFees = params.type === "PayAuditFees";
+      const isAuditFees = params.type === TRANSFER_TYPES.PayAuditFees;
       if (isAuditFees && currency !== "USDC") {
         throw new Error("PayAuditFees only supports USDC");
       }

package/src/lib/types/index.ts

@@ -51,20 +51,23 @@ export interface PendingTransfer {
   kickstarterId?: string;
 }
 
-export const TRANSFER_TYPES = [
-  "PayProtocolFeeAndMintGCTLAndStake",
-  "PayProtocolFee",
-  "PayAuditFees",
-  "CommitKickstarter",
-  "MintGCTLAndStake",
-  "MintGCTL",
-  "BuySolarFarm",
-  "SponsorProtocolFee",
-  "SponsorProtocolFeeAndMintGCTLAndStake",
-] as const;
+export const TRANSFER_TYPES = {
+  PayProtocolFeeAndMintGCTLAndStake: "PayProtocolFeeAndMintGCTLAndStake",
+  PayProtocolFee: "PayProtocolFee",
+  PayAuditFees: "PayAuditFees",
+  CommitKickstarter: "CommitKickstarter",
+  MintGCTLAndStake: "MintGCTLAndStake",
+  MintGCTL: "MintGCTL",
+  BuySolarFarm: "BuySolarFarm",
+  SponsorProtocolFee: "SponsorProtocolFee",
+  SponsorProtocolFeeAndMintGCTLAndStake:
+    "SponsorProtocolFeeAndMintGCTLAndStake",
+  PayProtocolDepositUsingStakedControl: "PayProtocolDepositUsingStakedControl",
+} as const;
 
 // Pending transfer type filter for listing endpoint
-export type PendingTransferType = (typeof TRANSFER_TYPES)[number];
+export type PendingTransferType =
+  (typeof TRANSFER_TYPES)[keyof typeof TRANSFER_TYPES];
 
 export interface TransferDetails extends PendingTransfer {
   blockNumber: string;
@@ -251,6 +254,7 @@ export interface KickstarterDetails extends Kickstarter {
   contributorsCount: number;
   farmCount: number;
   solarFarmApplications: SolarFarmApplication[];
+  sponsoredFarms: SponsoredFarm[];
 }
 
 export interface CommitKickstarterPayload {

package/src/utils/stake-control.ts

@@ -1,4 +1,5 @@
-import { verifyTypedData, type Hex } from "viem";
+import { TRANSFER_TYPES } from "src/browser";
+import { verifyTypedData, type Hex, getAddress } from "viem";
 import z from "zod";
 
 export const stakeControlEIP712Domain = (chainId: number) => ({
@@ -57,6 +58,15 @@ export const commitKickstarterEIP712Types = {
   ],
 } as const;
 
+export const payProtocolDepositUsingStakedControlEIP712Types = {
+  PayProtocolDepositUsingStakedControl: [
+    { name: "amount", type: "uint256" },
+    { name: "applicationId", type: "string" },
+    { 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}$/),
@@ -105,6 +115,16 @@ export const commitKickstarterSignatureRequestSchema = z.object({
   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(),
+    deadline: z.string(),
+  });
+
 export type StakeSignatureRequest = z.infer<typeof stakeSignatureRequestSchema>;
 export type UnstakeUnlockSignatureRequest = z.infer<
   typeof unstakeUnlockSignatureRequestSchema
@@ -118,6 +138,9 @@ export type RestakeSignatureRequest = z.infer<
 export type CommitKickstarterSignatureRequest = z.infer<
   typeof commitKickstarterSignatureRequestSchema
 >;
+export type PayProtocolDepositUsingStakedControlSignatureRequest = z.infer<
+  typeof payProtocolDepositUsingStakedControlSignatureRequestSchema
+>;
 
 export type StakeMessage = {
   nonce: bigint;
@@ -156,6 +179,13 @@ export type CommitKickstarterMessage = {
   deadline: bigint;
 };
 
+export type PayProtocolDepositUsingStakedControlMessage = {
+  amount: bigint;
+  applicationId: string;
+  nonce: bigint;
+  deadline: bigint;
+};
+
 export type SignatureValidationReason =
   | "deadline_expired"
   | "signature_failed"
@@ -196,6 +226,11 @@ type CommitKickstarterMessageInput = Pick<
   "nonce" | "amount" | "kickstarterId" | "deadline"
 >;
 
+type PayProtocolDepositUsingStakedControlMessageInput = Pick<
+  PayProtocolDepositUsingStakedControlSignatureRequest,
+  "amount" | "applicationId" | "nonce" | "deadline"
+>;
+
 export function buildStakeMessage(req: StakeMessageInput): StakeMessage {
   const nonce = BigInt(req.nonce);
   const amount = BigInt(req.amount);
@@ -266,6 +301,20 @@ export function buildCommitKickstarterMessage(
   return { nonce, amount, kickstarterId, deadline };
 }
 
+export function buildPayProtocolDepositUsingStakedControlMessage(
+  req: PayProtocolDepositUsingStakedControlMessageInput
+): PayProtocolDepositUsingStakedControlMessage {
+  const amount = BigInt(req.amount);
+  const nonce = BigInt(req.nonce);
+  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 (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 };
+}
+
 // Helper to validate the signature using viem
 export async function validateStakeSignature(
   input: StakeSignatureRequest,
@@ -428,3 +477,35 @@ export async function validateCommitKickstarterSignature(
     return { valid: false, recovered: null, reason: "signature_failed" };
   }
 }
+
+export async function validatePayProtocolDepositUsingStakedControlSignature(
+  input: PayProtocolDepositUsingStakedControlSignatureRequest,
+  domain: ReturnType<
+    typeof stakeControlEIP712Domain
+  > = stakeControlEIP712Domain(1)
+): Promise<SignatureValidationResult> {
+  const message = buildPayProtocolDepositUsingStakedControlMessage({
+    amount: input.amount,
+    applicationId: input.applicationId,
+    nonce: input.nonce,
+    deadline: input.deadline,
+  });
+  if (isDeadlineExpired(message.deadline)) {
+    return { valid: false, recovered: null, reason: "deadline_expired" };
+  }
+  try {
+    const verified = await verifyTypedData({
+      address: getAddress(input.wallet as Hex),
+      domain,
+      types: payProtocolDepositUsingStakedControlEIP712Types,
+      primaryType: TRANSFER_TYPES.PayProtocolDepositUsingStakedControl,
+      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" };
+  }
+}