@glowlabs-org/utils 0.2.167 → 0.2.169

package/dist/esm/constants/addresses.d.ts

@@ -1,3 +1,5 @@
 export type ContractKeys = "USDC" | "FORWARDER" | "FOUNDATION_WALLET" | "GLW" | "USDG" | "USDG_REDEMPTION" | "IMPACT_CATALYST" | "AUDIT_FEE_WALLET" | "UNISWAP_V2_ROUTER" | "UNISWAP_V2_FACTORY" | "USDG_UNISWAP" | "GLW_UNISWAP" | "OFFCHAIN_FRACTIONS" | "COUNTERFACTUAL_HOLDER_FACTORY" | "FOUNDATION_HUB_MANAGER_WALLET" | "FOUNDATION_REWARDS_WALLET" | "ENDOWMENT_WALLET" | "REWARDS_KERNEL" | "FOUNDATION_HOT_WALLET_PD";
 export declare const getAddresses: (CHAIN_ID: number) => Record<ContractKeys, `0x${string}`>;
 export declare const DECIMALS_BY_TOKEN: Record<"USDC" | "USDG" | "GCTL" | "SGCTL" | "GLW", number>;
+export declare const SGCTL_OFFCHAIN_TOKEN_ADDRESS = "0xSGCTL0000000000000000000000000000000000";
+export declare const GCTL_OFFCHAIN_TOKEN_ADDRESS = "0xGCTL0000000000000000000000000000000000";

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 './calculate-farm-efficiency-HjxTADsE.js';
-export { C as ControlRouter, F as FarmsRouter, e as KICKSTARTER_STATUS, K as KickstarterRouter, O as OFF_CHAIN_PAYMENT_CURRENCIES, P as PAYMENT_CURRENCIES, d as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, T as TRANSFER_TYPES, W as WalletsRouter, f as calculateFarmEfficiency, c as configureSentry, u as useForwarder, a as useOffchainFractions, b as useRewardsKernel } from './calculate-farm-efficiency-HjxTADsE.js';
+import { H as HUB_URL, U as USDG_WEIGHT_DECIMAL_PRECISION, G as GLOW_WEIGHT_DECIMAL_PRECISION, M as MAX_WEIGHT } from './calculate-farm-efficiency-Cq10L_Uq.js';
+export { C as ControlRouter, F as FarmsRouter, e as KICKSTARTER_STATUS, K as KickstarterRouter, O as OFF_CHAIN_PAYMENT_CURRENCIES, P as PAYMENT_CURRENCIES, d as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, T as TRANSFER_TYPES, W as WalletsRouter, f as calculateFarmEfficiency, c as configureSentry, u as useForwarder, a as useOffchainFractions, b as useRewardsKernel } from './calculate-farm-efficiency-Cq10L_Uq.js';
 
 const GENESIS_TIMESTAMP = 1700352000;
 

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

@@ -22,6 +22,36 @@ export interface MigrateUserRequest {
 export interface MigrateUserResponse {
     success: true;
 }
+export interface DelegateSgctlRequest {
+    wallet: string;
+    applicationId: string;
+    fractionId: string;
+    amount: string;
+    signature: string;
+    deadline: string;
+    nonce: string;
+}
+export interface DelegateSgctlResponse {
+    success: true;
+    delegationId: string;
+}
+export interface RefundDelegationRequest {
+    fractionId: string;
+}
+export interface RefundDelegationResponse {
+    success: true;
+    fractionId: string;
+    processed: number;
+}
+export interface FinalizeDelegationRequest {
+    fractionId: string;
+    farmId: string;
+}
+export interface FinalizeDelegationResponse {
+    success: true;
+    fractionId: string;
+    processed: number;
+}
 export declare function ControlRouter(baseUrl: string): {
     readonly fetchGctlBalance: (wallet: string) => Promise<string>;
     readonly fetchCommittedBalance: (wallet: string) => Promise<string>;
@@ -48,10 +78,14 @@ export declare function ControlRouter(baseUrl: string): {
     readonly retryFailedOperation: (operationId: string) => Promise<RetryFailedOperationResponse>;
     readonly payProtocolDepositUsingStakedControl: (paymentRequest: PayProtocolDepositUsingStakedControlRequest) => Promise<PayProtocolDepositUsingStakedControlResponse>;
     readonly migrateUser: (migrateRequest: MigrateUserRequest) => Promise<MigrateUserResponse>;
+    readonly delegateSgctl: (delegationRequest: DelegateSgctlRequest) => Promise<DelegateSgctlResponse>;
+    readonly refundDelegation: (refundRequest: RefundDelegationRequest) => Promise<RefundDelegationResponse>;
+    readonly finalizeDelegation: (finalizeRequest: FinalizeDelegationRequest) => Promise<FinalizeDelegationResponse>;
     readonly isStaking: boolean;
     readonly isUnstaking: boolean;
     readonly isRestaking: boolean;
     readonly isRetryingFailedOperation: boolean;
     readonly isPayingProtocolDepositUsingStakedControl: boolean;
     readonly isMigratingUser: boolean;
+    readonly isDelegatingSgctl: boolean;
 };

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

@@ -122,6 +122,24 @@ export declare const verifyUserEIP712Types: {
         readonly type: "uint256";
     }];
 };
+export declare const delegateSgctlEIP712Types: {
+    readonly DelegateSgctl: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "applicationId";
+        readonly type: "string";
+    }, {
+        readonly name: "fractionId";
+        readonly type: "string";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
 export declare const stakeSignatureRequestSchema: z.ZodObject<{
     wallet: z.ZodString;
     signature: z.ZodString;
@@ -185,6 +203,15 @@ export declare const verifyUserSignatureRequestSchema: z.ZodObject<{
     nonce: z.ZodString;
     deadline: z.ZodString;
 }, z.core.$strip>;
+export declare const delegateSgctlSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    amount: z.ZodString;
+    applicationId: z.ZodString;
+    fractionId: 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>;
@@ -193,6 +220,7 @@ export type CommitKickstarterSignatureRequest = z.infer<typeof commitKickstarter
 export type ApplyCertifiedInstallerSignatureRequest = z.infer<typeof applyCertifiedInstallerSignatureRequestSchema>;
 export type PayProtocolDepositUsingStakedControlSignatureRequest = z.infer<typeof payProtocolDepositUsingStakedControlSignatureRequestSchema>;
 export type VerifyUserSignatureRequest = z.infer<typeof verifyUserSignatureRequestSchema>;
+export type DelegateSgctlSignatureRequest = z.infer<typeof delegateSgctlSignatureRequestSchema>;
 export type StakeMessage = {
     nonce: bigint;
     amount: bigint;
@@ -247,6 +275,13 @@ export type VerifyUserMessage = {
     nonce: bigint;
     deadline: bigint;
 };
+export type DelegateSgctlMessage = {
+    nonce: bigint;
+    amount: bigint;
+    applicationId: string;
+    fractionId: string;
+    deadline: bigint;
+};
 export type SignatureValidationReason = "deadline_expired" | "signature_failed" | "signer_mismatch" | null;
 export type SignatureValidationResult = {
     valid: boolean;
@@ -261,6 +296,7 @@ type CommitKickstarterMessageInput = Pick<CommitKickstarterSignatureRequest, "no
 type ApplyCertifiedInstallerMessageInput = Pick<ApplyCertifiedInstallerSignatureRequest, "nonce" | "regionId" | "deadline">;
 type PayProtocolDepositUsingStakedControlMessageInput = Pick<PayProtocolDepositUsingStakedControlSignatureRequest, "amount" | "applicationId" | "nonce" | "deadline">;
 type VerifyUserMessageInput = Pick<VerifyUserSignatureRequest, "nonce" | "deadline">;
+type DelegateSgctlMessageInput = Pick<DelegateSgctlSignatureRequest, "nonce" | "amount" | "applicationId" | "fractionId" | "deadline">;
 export declare function buildStakeMessage(req: StakeMessageInput): StakeMessage;
 export declare function buildUnstakeUnlockMessage(req: UnstakeUnlockMessageInput): UnstakeUnlockMessage;
 export declare function buildUnstakeMoveMessage(req: UnstakeMoveMessageInput): UnstakeMoveMessage;
@@ -269,6 +305,7 @@ export declare function buildCommitKickstarterMessage(req: CommitKickstarterMess
 export declare function buildApplyCertifiedInstallerMessage(req: ApplyCertifiedInstallerMessageInput): ApplyCertifiedInstallerMessage;
 export declare function buildPayProtocolDepositUsingStakedControlMessage(req: PayProtocolDepositUsingStakedControlMessageInput): PayProtocolDepositUsingStakedControlMessage;
 export declare function buildVerifyUserMessage(req: VerifyUserMessageInput): VerifyUserMessage;
+export declare function buildDelegateSgctlMessage(req: DelegateSgctlMessageInput): DelegateSgctlMessage;
 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>;
@@ -277,4 +314,5 @@ export declare function validateCommitKickstarterSignature(input: CommitKickstar
 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 declare function validateDelegateSgctlSignature(input: DelegateSgctlSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export {};

package/package.json

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

package/src/constants/addresses.ts

@@ -90,3 +90,8 @@ export const DECIMALS_BY_TOKEN: Record<
   SGCTL: 6,
   GLW: 18,
 };
+
+export const SGCTL_OFFCHAIN_TOKEN_ADDRESS =
+  "0xSGCTL0000000000000000000000000000000000";
+export const GCTL_OFFCHAIN_TOKEN_ADDRESS =
+  "0xGCTL0000000000000000000000000000000000";

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

@@ -65,6 +65,42 @@ export interface MigrateUserResponse {
   success: true;
 }
 
+export interface DelegateSgctlRequest {
+  wallet: string;
+  applicationId: string;
+  fractionId: string;
+  amount: string;
+  signature: string;
+  deadline: string;
+  nonce: string;
+}
+
+export interface DelegateSgctlResponse {
+  success: true;
+  delegationId: string;
+}
+
+export interface RefundDelegationRequest {
+  fractionId: string;
+}
+
+export interface RefundDelegationResponse {
+  success: true;
+  fractionId: string;
+  processed: number;
+}
+
+export interface FinalizeDelegationRequest {
+  fractionId: string;
+  farmId: string;
+}
+
+export interface FinalizeDelegationResponse {
+  success: true;
+  fractionId: string;
+  processed: number;
+}
+
 // --------------------------------------------------------------------------
 
 /**
@@ -328,6 +364,7 @@ export function ControlRouter(baseUrl: string) {
   let isRetryingFailedOperation = false;
   let isPayingProtocolDepositUsingStakedControl = false;
   let isMigratingUser = false;
+  let isDelegatingSgctl = false;
 
   const stakeGctl = async (stakeRequest: StakeRequest): Promise<boolean> => {
     isStaking = true;
@@ -555,6 +592,110 @@ export function ControlRouter(baseUrl: string) {
     }
   };
 
+  const delegateSgctl = async (
+    delegationRequest: DelegateSgctlRequest
+  ): Promise<DelegateSgctlResponse> => {
+    isDelegatingSgctl = true;
+    try {
+      sentryAddBreadcrumb({
+        category: "control-api",
+        message: "POST /delegate-sgctl",
+        level: "info",
+        data: {
+          baseUrl,
+          wallet: delegationRequest.wallet,
+          applicationId: delegationRequest.applicationId,
+          fractionId: delegationRequest.fractionId,
+          amount: delegationRequest.amount,
+        },
+      });
+      const response = await request<DelegateSgctlResponse>(`/delegate-sgctl`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(delegationRequest),
+      });
+      return response;
+    } catch (error) {
+      sentryCaptureException(error, {
+        action: "delegateSgctl",
+        baseUrl,
+        wallet: delegationRequest.wallet,
+        applicationId: delegationRequest.applicationId,
+        fractionId: delegationRequest.fractionId,
+        amount: delegationRequest.amount,
+      });
+      throw new Error(parseApiError(error));
+    } finally {
+      isDelegatingSgctl = false;
+    }
+  };
+
+  const refundDelegation = async (
+    refundRequest: RefundDelegationRequest
+  ): Promise<RefundDelegationResponse> => {
+    try {
+      sentryAddBreadcrumb({
+        category: "control-api",
+        message: "POST /delegate-sgctl/refund",
+        level: "info",
+        data: {
+          baseUrl,
+          fractionId: refundRequest.fractionId,
+        },
+      });
+      const response = await request<RefundDelegationResponse>(
+        `/delegate-sgctl/refund`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(refundRequest),
+        }
+      );
+      return response;
+    } catch (error) {
+      sentryCaptureException(error, {
+        action: "refundDelegation",
+        baseUrl,
+        fractionId: refundRequest.fractionId,
+      });
+      throw new Error(parseApiError(error));
+    }
+  };
+
+  const finalizeDelegation = async (
+    finalizeRequest: FinalizeDelegationRequest
+  ): Promise<FinalizeDelegationResponse> => {
+    try {
+      sentryAddBreadcrumb({
+        category: "control-api",
+        message: "POST /delegate-sgctl/finalize",
+        level: "info",
+        data: {
+          baseUrl,
+          fractionId: finalizeRequest.fractionId,
+          farmId: finalizeRequest.farmId,
+        },
+      });
+      const response = await request<FinalizeDelegationResponse>(
+        `/delegate-sgctl/finalize`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(finalizeRequest),
+        }
+      );
+      return response;
+    } catch (error) {
+      sentryCaptureException(error, {
+        action: "finalizeDelegation",
+        baseUrl,
+        fractionId: finalizeRequest.fractionId,
+        farmId: finalizeRequest.farmId,
+      });
+      throw new Error(parseApiError(error));
+    }
+  };
+
   // --------------------------- Public API ----------------------------------
   return {
     // Queries
@@ -585,6 +726,9 @@ export function ControlRouter(baseUrl: string) {
     retryFailedOperation,
     payProtocolDepositUsingStakedControl,
     migrateUser,
+    delegateSgctl,
+    refundDelegation,
+    finalizeDelegation,
 
     // Processing flags
     get isStaking() {
@@ -605,5 +749,8 @@ export function ControlRouter(baseUrl: string) {
     get isMigratingUser() {
       return isMigratingUser;
     },
+    get isDelegatingSgctl() {
+      return isDelegatingSgctl;
+    },
   } as const;
 }

package/src/utils/stake-control.ts

@@ -82,6 +82,16 @@ export const verifyUserEIP712Types = {
   ],
 } as const;
 
+export const delegateSgctlEIP712Types = {
+  DelegateSgctl: [
+    { name: "nonce", type: "uint256" },
+    { name: "amount", type: "uint256" },
+    { name: "applicationId", type: "string" },
+    { name: "fractionId", 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}$/),
@@ -155,6 +165,16 @@ export const verifyUserSignatureRequestSchema = z.object({
   deadline: z.string(),
 });
 
+export const delegateSgctlSignatureRequestSchema = 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(),
+  fractionId: z.string(),
+  deadline: z.string(),
+});
+
 export type StakeSignatureRequest = z.infer<typeof stakeSignatureRequestSchema>;
 export type UnstakeUnlockSignatureRequest = z.infer<
   typeof unstakeUnlockSignatureRequestSchema
@@ -179,6 +199,10 @@ export type VerifyUserSignatureRequest = z.infer<
   typeof verifyUserSignatureRequestSchema
 >;
 
+export type DelegateSgctlSignatureRequest = z.infer<
+  typeof delegateSgctlSignatureRequestSchema
+>;
+
 export type StakeMessage = {
   nonce: bigint;
   amount: bigint;
@@ -242,6 +266,14 @@ export type VerifyUserMessage = {
   deadline: bigint;
 };
 
+export type DelegateSgctlMessage = {
+  nonce: bigint;
+  amount: bigint;
+  applicationId: string;
+  fractionId: string;
+  deadline: bigint;
+};
+
 export type SignatureValidationReason =
   | "deadline_expired"
   | "signature_failed"
@@ -297,6 +329,11 @@ type VerifyUserMessageInput = Pick<
   "nonce" | "deadline"
 >;
 
+type DelegateSgctlMessageInput = Pick<
+  DelegateSgctlSignatureRequest,
+  "nonce" | "amount" | "applicationId" | "fractionId" | "deadline"
+>;
+
 export function buildStakeMessage(req: StakeMessageInput): StakeMessage {
   const nonce = BigInt(req.nonce);
   const amount = BigInt(req.amount);
@@ -403,6 +440,22 @@ export function buildVerifyUserMessage(
   return { nonce, deadline };
 }
 
+export function buildDelegateSgctlMessage(
+  req: DelegateSgctlMessageInput
+): DelegateSgctlMessage {
+  const nonce = BigInt(req.nonce);
+  const amount = BigInt(req.amount);
+  const deadline = BigInt(req.deadline);
+  const applicationId = req.applicationId;
+  const fractionId = req.fractionId;
+  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");
+  if (!fractionId) throw new Error("fractionId must be non-empty");
+  return { nonce, amount, applicationId, fractionId, deadline };
+}
+
 // Helper to validate the signature using viem
 export async function validateStakeSignature(
   input: StakeSignatureRequest,
@@ -658,3 +711,36 @@ export async function validateVerifyUserSignature(
     return { valid: false, recovered: null, reason: "signature_failed" };
   }
 }
+
+export async function validateDelegateSgctlSignature(
+  input: DelegateSgctlSignatureRequest,
+  domain: ReturnType<
+    typeof stakeControlEIP712Domain
+  > = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)
+): Promise<SignatureValidationResult> {
+  const message = buildDelegateSgctlMessage({
+    nonce: input.nonce,
+    amount: input.amount,
+    applicationId: input.applicationId,
+    fractionId: input.fractionId,
+    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: delegateSgctlEIP712Types,
+      primaryType: "DelegateSgctl",
+      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" };
+  }
+}