@glowlabs-org/utils 0.2.179 → 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-Per18qa5.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-Per18qa5.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/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/package.json

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

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,