@glowlabs-org/utils 0.2.92 → 0.2.94

package/src/lib/abis/forwarderABI.ts

@@ -3,6 +3,11 @@ export const FORWARDER_ABI = [
     inputs: [
       { internalType: "contract USDG", name: "_usdg", type: "address" },
       { internalType: "contract IERC20", name: "_usdc", type: "address" },
+      {
+        internalType: "contract CounterfactualHolderFactory",
+        name: "_cfhFactory",
+        type: "address",
+      },
     ],
     stateMutability: "payable",
     type: "constructor",
@@ -58,6 +63,11 @@ export const FORWARDER_ABI = [
       { internalType: "address", name: "token", type: "address" },
       { internalType: "address", name: "to", type: "address" },
       { internalType: "uint256", name: "amount", type: "uint256" },
+      {
+        internalType: "bool",
+        name: "sendToCounterfactualWallet",
+        type: "bool",
+      },
       { internalType: "string", name: "message", type: "string" },
     ],
     name: "forward",
@@ -65,6 +75,19 @@ export const FORWARDER_ABI = [
     stateMutability: "nonpayable",
     type: "function",
   },
+  {
+    inputs: [],
+    name: "i_CFHFactory",
+    outputs: [
+      {
+        internalType: "contract CounterfactualHolderFactory",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
   {
     inputs: [],
     name: "i_USDC",
@@ -90,6 +113,11 @@ export const FORWARDER_ABI = [
     inputs: [
       { internalType: "uint256", name: "amount", type: "uint256" },
       { internalType: "address", name: "to", type: "address" },
+      {
+        internalType: "bool",
+        name: "sendToCounterfactualWallet",
+        type: "bool",
+      },
       { internalType: "string", name: "message", type: "string" },
     ],
     name: "swapUSDCAndForwardUSDG",

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");
       }
@@ -340,7 +341,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
         if (!isAuditFees && currency === "USDC") {
           await forwarderContract
             .getFunction("swapUSDCAndForwardUSDG")
-            .staticCall(amount, ADDRESSES.FOUNDATION_WALLET, message, {
+            .staticCall(amount, ADDRESSES.FOUNDATION_WALLET, true, message, {
               from: owner,
             });
         } else {
@@ -352,6 +353,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
                 ? ADDRESSES.AUDIT_FEE_WALLET
                 : ADDRESSES.FOUNDATION_WALLET,
               amount,
+              true,
               message,
               { from: owner }
             );
@@ -366,6 +368,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
         tx = await forwarderContract.getFunction("swapUSDCAndForwardUSDG")(
           amount,
           ADDRESSES.FOUNDATION_WALLET,
+          true,
           message
         );
       } else {
@@ -375,6 +378,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
             ? ADDRESSES.AUDIT_FEE_WALLET
             : ADDRESSES.FOUNDATION_WALLET,
           amount,
+          true,
           message
         );
       }
@@ -410,7 +414,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 +440,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "SponsorProtocolFeeAndMintGCTLAndStake",
+      type: TRANSFER_TYPES.SponsorProtocolFeeAndMintGCTLAndStake,
       currency,
       applicationId,
     });
@@ -456,7 +460,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "PayProtocolFee",
+      type: TRANSFER_TYPES.PayProtocolFee,
       currency,
       applicationId,
     });
@@ -476,7 +480,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "SponsorProtocolFee",
+      type: TRANSFER_TYPES.SponsorProtocolFee,
       currency,
       applicationId,
     });
@@ -503,7 +507,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "MintGCTLAndStake",
+      type: TRANSFER_TYPES.MintGCTLAndStake,
       currency,
       regionId,
     });
@@ -529,7 +533,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "MintGCTL",
+      type: TRANSFER_TYPES.MintGCTL,
       currency,
     });
   }
@@ -547,7 +551,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 +571,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "BuySolarFarm",
+      type: TRANSFER_TYPES.BuySolarFarm,
       currency,
       farmId,
     });
@@ -591,7 +595,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     return forwardTokens({
       amount,
       userAddress,
-      type: "CommitKickstarter",
+      type: TRANSFER_TYPES.CommitKickstarter,
       currency,
       kickstarterId,
     });
@@ -614,7 +618,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");
       }
@@ -650,7 +654,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
         !isAuditFees && currency === "USDC"
           ? await forwarderContract
               .getFunction("swapUSDCAndForwardUSDG")
-              .estimateGas(amount, ADDRESSES.FOUNDATION_WALLET, message)
+              .estimateGas(amount, ADDRESSES.FOUNDATION_WALLET, true, message)
           : await forwarderContract
               .getFunction("forward")
               .estimateGas(
@@ -659,6 +663,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
                   ? ADDRESSES.AUDIT_FEE_WALLET
                   : ADDRESSES.FOUNDATION_WALLET,
                 amount,
+                true,
                 message
               );
       const estimatedCost: bigint = estimatedGas * gasPrice;

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;

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" };
+  }
+}