@glowlabs-org/utils 0.2.178 → 0.2.180

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-BjXQqtxI.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-BjXQqtxI.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-CZbLTXjU.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-CZbLTXjU.js';
 
 const GENESIS_TIMESTAMP = 1700352000;
 

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

@@ -1,4 +1,4 @@
-import type { SponsoredFarm, EstimateRewardScoreParams, RewardScoreResponse, EstimateRewardScoresBatchParams, EstimateRewardScoresBatchResponse, FarmWithRewards, FarmRewardSplit, MiningScoresBatchParams, MiningScoresBatchResponse, FarmWeeklyRewardsResponse, FarmWeeklyRewardsQuery, FarmEfficiencyScore, FarmWeeklyRewardsBatchQuery, FarmWeeklyRewardsBatchResponse, WalletFarmRewardsHistoryQuery, WalletFarmRewardsHistoryResponse, WalletFarmRewardsHistoryBatchQuery, WalletFarmRewardsHistoryBatchResponse } from "../types";
+import type { SponsoredFarm, EstimateRewardScoreParams, RewardScoreResponse, EstimateRewardScoresBatchParams, EstimateRewardScoresBatchResponse, FarmWithRewards, FarmRewardSplit, MiningScoresBatchParams, MiningScoresBatchResponse, FarmWeeklyRewardsResponse, FarmWeeklyRewardsQuery, FarmEfficiencyScore, FarmWeeklyRewardsBatchQuery, FarmWeeklyRewardsBatchResponse, WalletFarmRewardsHistoryQuery, WalletFarmRewardsHistoryResponse, WalletFarmRewardsHistoryBatchQuery, WalletFarmRewardsHistoryBatchResponse, FarmImagesBatchQuery, FarmImagesBatchResponse } from "../types";
 export declare function FarmsRouter(baseUrl: string): {
     readonly fetchFarmRewardSplits: (farmId: string) => Promise<FarmRewardSplit[]>;
     readonly fetchSponsoredFarms: (sponsorWallet?: string) => Promise<SponsoredFarm[]>;
@@ -11,4 +11,5 @@ export declare function FarmsRouter(baseUrl: string): {
     readonly fetchFarmWeeklyRewardsBatch: (params: FarmWeeklyRewardsBatchQuery) => Promise<FarmWeeklyRewardsBatchResponse>;
     readonly fetchWalletFarmRewardsHistory: (walletAddress: string, query?: WalletFarmRewardsHistoryQuery) => Promise<WalletFarmRewardsHistoryResponse>;
     readonly fetchWalletFarmRewardsHistoryBatch: (params: WalletFarmRewardsHistoryBatchQuery) => Promise<WalletFarmRewardsHistoryBatchResponse>;
+    readonly fetchFarmImagesBatch: (params: FarmImagesBatchQuery) => Promise<FarmImagesBatchResponse>;
 };

package/dist/esm/lib/hooks/use-rewards-kernel.d.ts

@@ -26,8 +26,12 @@ export interface ClaimPayoutParams {
     isGuardedToken: boolean[];
     toCounterfactual: boolean[];
 }
+export interface ClaimPayoutsMulticallParams {
+    claims: ClaimPayoutParams[];
+}
 export declare function useRewardsKernel(walletClient: WalletClient | undefined, publicClient: PublicClient | undefined, CHAIN_ID: number): {
     claimPayout: (params: ClaimPayoutParams) => Promise<string>;
+    claimPayoutsMulticall: (params: ClaimPayoutsMulticallParams) => Promise<string>;
     getRewardMeta: (nonce: bigint) => Promise<RewardMeta>;
     getMaxReward: (nonce: bigint, token: `0x${string}`) => Promise<bigint>;
     getAmountClaimed: (nonce: bigint, token: `0x${string}`) => Promise<bigint>;

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

@@ -798,4 +798,14 @@ export interface WalletFarmRewardsHistoryBatchResult {
 export interface WalletFarmRewardsHistoryBatchResponse {
     results: Record<string, WalletFarmRewardsHistoryBatchResult>;
 }
+export interface FarmImagesBatchQuery {
+    farmIds: string[];
+}
+export interface FarmImageResult {
+    name: string;
+    imageUrl: string | null;
+}
+export interface FarmImagesBatchResponse {
+    results: Record<string, FarmImageResult>;
+}
 export type { MintedEvent as ControlMintedEvent };

package/package.json

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

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

@@ -26,6 +26,8 @@ import type {
   WalletFarmRewardsHistoryResponse,
   WalletFarmRewardsHistoryBatchQuery,
   WalletFarmRewardsHistoryBatchResponse,
+  FarmImagesBatchQuery,
+  FarmImagesBatchResponse,
 } from "../types";
 import {
   sentryAddBreadcrumb,
@@ -355,6 +357,39 @@ export function FarmsRouter(baseUrl: string) {
     }
   };
 
+  const fetchFarmImagesBatch = async (
+    params: FarmImagesBatchQuery
+  ): Promise<FarmImagesBatchResponse> => {
+    try {
+      sentryAddBreadcrumb({
+        category: "control-api",
+        message: "POST /farms/images/batch",
+        level: "info",
+        data: { baseUrl, farmsCount: params.farmIds?.length },
+      });
+
+      const data = await request<FarmImagesBatchResponse>(
+        "/farms/images/batch",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify(params),
+        }
+      );
+
+      return data;
+    } catch (error) {
+      sentryCaptureException(error, {
+        action: "fetchFarmImagesBatch",
+        baseUrl,
+        farmsCount: params.farmIds?.length,
+      });
+      throw new Error(parseApiError(error));
+    }
+  };
+
   return {
     fetchFarmRewardSplits,
     fetchSponsoredFarms,
@@ -367,5 +402,6 @@ export function FarmsRouter(baseUrl: string) {
     fetchFarmWeeklyRewardsBatch,
     fetchWalletFarmRewardsHistory,
     fetchWalletFarmRewardsHistoryBatch,
+    fetchFarmImagesBatch,
   } as const;
 }

package/src/lib/hooks/use-rewards-kernel.ts

@@ -2,6 +2,8 @@ import {
   type WalletClient,
   type PublicClient,
   type Address,
+  type Hex,
+  encodeFunctionData,
   formatEther,
 } from "viem";
 import { REWARDS_KERNEL_ABI } from "../abis/rewardKernelABI";
@@ -49,6 +51,10 @@ export interface ClaimPayoutParams {
   toCounterfactual: boolean[]; // Whether to send to counterfactual wallet
 }
 
+export interface ClaimPayoutsMulticallParams {
+  claims: ClaimPayoutParams[];
+}
+
 // Type-guard style helper to ensure a wallet client exists
 function assertWalletClient(
   maybeWalletClient: WalletClient | undefined
@@ -258,6 +264,162 @@ export function useRewardsKernel(
     }
   }
 
+  /**
+   * Claim payouts for multiple nonces in one transaction via multicall
+   */
+  async function claimPayoutsMulticall(
+    params: ClaimPayoutsMulticallParams
+  ): Promise<string> {
+    assertWalletClient(walletClient);
+    assertPublicClient(publicClient);
+
+    try {
+      setIsProcessing(true);
+
+      const { claims } = params;
+      if (!claims || claims.length === 0) {
+        throw new Error("At least one claim is required");
+      }
+
+      const owner = walletClient.account?.address;
+      if (!owner) {
+        throw new Error("No account found in wallet client");
+      }
+
+      sentryAddBreadcrumb({
+        category: "rewards-kernel",
+        message: "claimPayoutsMulticall.start",
+        level: "info",
+        data: {
+          chainId: walletClient?.chain?.id,
+          contract: ADDRESSES.REWARDS_KERNEL,
+          claimsCount: claims.length,
+          nonces: claims.map((claim) => claim.nonce.toString()),
+          to: claims[0]?.to,
+          from: claims[0]?.from,
+        },
+      });
+
+      const seenNonces = new Set<string>();
+      const callData: Hex[] = [];
+
+      for (const claim of claims) {
+        const {
+          nonce,
+          proof,
+          tokensAndAmounts,
+          from,
+          to,
+          isGuardedToken,
+          toCounterfactual,
+        } = claim;
+
+        const nonceStr = nonce.toString();
+        if (seenNonces.has(nonceStr)) {
+          throw new Error(`Duplicate nonce in multicall: ${nonceStr}`);
+        }
+        seenNonces.add(nonceStr);
+
+        if (!proof || proof.length === 0) {
+          throw new Error(`Merkle proof is required for nonce ${nonceStr}`);
+        }
+        if (!tokensAndAmounts || tokensAndAmounts.length === 0) {
+          throw new Error(
+            `Tokens and amounts are required for nonce ${nonceStr}`
+          );
+        }
+        if (isGuardedToken.length !== tokensAndAmounts.length) {
+          throw new Error(
+            `isGuardedToken length mismatch for nonce ${nonceStr}`
+          );
+        }
+        if (toCounterfactual.length !== tokensAndAmounts.length) {
+          throw new Error(
+            `toCounterfactual length mismatch for nonce ${nonceStr}`
+          );
+        }
+        if (!from || !to) {
+          throw new Error(
+            `${RewardsKernelError.INVALID_PARAMETERS} for nonce ${nonceStr}`
+          );
+        }
+
+        const alreadyClaimed = await isClaimed(owner, nonce);
+        if (alreadyClaimed) {
+          throw new Error(
+            `${RewardsKernelError.ALREADY_CLAIMED} (nonce ${nonceStr})`
+          );
+        }
+
+        const finalized = await isFinalized(nonce);
+        if (!finalized) {
+          throw new Error(`${RewardsKernelError.NOT_FINALIZED} (nonce ${nonceStr})`);
+        }
+
+        callData.push(
+          encodeFunctionData({
+            abi: REWARDS_KERNEL_ABI,
+            functionName: "claimPayout",
+            args: [
+              nonce,
+              proof as `0x${string}`[],
+              tokensAndAmounts as readonly {
+                token: `0x${string}`;
+                amount: bigint;
+              }[],
+              from as Address,
+              to as Address,
+              isGuardedToken,
+              toCounterfactual,
+            ],
+          })
+        );
+      }
+
+      try {
+        await publicClient.simulateContract({
+          address: ADDRESSES.REWARDS_KERNEL as Address,
+          abi: REWARDS_KERNEL_ABI,
+          functionName: "multicall",
+          args: [callData],
+          account: walletClient.account!,
+        });
+      } catch (simulationError) {
+        sentryCaptureException(simulationError, {
+          action: "claimPayoutsMulticall.simulate",
+          chainId: walletClient?.chain?.id,
+          contract: ADDRESSES.REWARDS_KERNEL,
+          claimsCount: claims.length,
+          nonces: claims.map((claim) => claim.nonce.toString()),
+        });
+        throw new Error(parseViemError(simulationError));
+      }
+
+      const hash = await walletClient.writeContract({
+        address: ADDRESSES.REWARDS_KERNEL as Address,
+        abi: REWARDS_KERNEL_ABI,
+        functionName: "multicall",
+        args: [callData],
+        chain: walletClient.chain,
+        account: walletClient.account!,
+      });
+
+      await waitForViemTransactionWithRetry(publicClient, hash);
+      return hash;
+    } catch (error) {
+      sentryCaptureException(error, {
+        action: "claimPayoutsMulticall",
+        chainId: walletClient?.chain?.id,
+        contract: ADDRESSES.REWARDS_KERNEL,
+        claimsCount: params.claims?.length ?? 0,
+        nonces: params.claims?.map((claim) => claim.nonce.toString()) ?? [],
+      });
+      throw new Error(parseViemError(error));
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
   /**
    * Get reward metadata for a specific nonce
    * @param nonce The nonce to query
@@ -547,6 +709,7 @@ export function useRewardsKernel(
   return {
     // Core contract functions
     claimPayout,
+    claimPayoutsMulticall,
 
     // View functions
     getRewardMeta,

package/src/lib/types/index.ts

@@ -965,6 +965,22 @@ export interface WalletFarmRewardsHistoryBatchResponse {
   results: Record<string, WalletFarmRewardsHistoryBatchResult>;
 }
 
+// ---------------------------------------------------------------------------
+// Farm Images Batch
+// ---------------------------------------------------------------------------
+export interface FarmImagesBatchQuery {
+  farmIds: string[];
+}
+
+export interface FarmImageResult {
+  name: string;
+  imageUrl: string | null;
+}
+
+export interface FarmImagesBatchResponse {
+  results: Record<string, FarmImageResult>;
+}
+
 // ---------------------------------------------------------------------------
 // Barrel exports (convenience)
 // ---------------------------------------------------------------------------