@glowlabs-org/utils 0.2.23 → 0.2.26

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

@@ -6,6 +6,10 @@ import type {
   RegionWithMetadata,
   ActivationConfig,
   CreateRegionPayload,
+  CreateKickstarterPayload,
+  Kickstarter,
+  ActivationEvent,
+  KickstarterCreateResponse,
 } from "../types";
 
 // ---------------------------------------------------------------------------
@@ -41,6 +45,7 @@ export function RegionRouter(baseUrl: string) {
   let cachedRegions: Region[] = [];
   let isLoading = false;
   let isCreatingRegion = false;
+  let isCreatingKickstarter = false;
 
   // -------------------------------------------------------------------------
   // Queries
@@ -70,6 +75,20 @@ export function RegionRouter(baseUrl: string) {
     }
   };
 
+  const fetchActivationEvents = async (
+    regionId?: number
+  ): Promise<ActivationEvent[]> => {
+    try {
+      const query = typeof regionId === "number" ? `?regionId=${regionId}` : "";
+      const data = await request<{ events: ActivationEvent[] }>(
+        `/regions/activation-events${query}`
+      );
+      return data.events ?? [];
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    }
+  };
+
   // -------------------------------------------------------------------------
   // Mutations
   // -------------------------------------------------------------------------
@@ -90,6 +109,40 @@ export function RegionRouter(baseUrl: string) {
     }
   };
 
+  const createKickstarter = async (
+    payload: CreateKickstarterPayload
+  ): Promise<KickstarterCreateResponse> => {
+    isCreatingKickstarter = true;
+    try {
+      const data = await request<KickstarterCreateResponse>(
+        `/regions/kickstarters`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        }
+      );
+      // A new region may have been created; refresh regions cache
+      await fetchRegions();
+      return data;
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    } finally {
+      isCreatingKickstarter = false;
+    }
+  };
+
+  const fetchKickstarter = async (idOrSlug: string): Promise<Kickstarter> => {
+    try {
+      const data = await request<{ kickstarter: Kickstarter }>(
+        `/regions/kickstarters/${encodeURIComponent(idOrSlug)}`
+      );
+      return data.kickstarter;
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    }
+  };
+
   // -------------------------------------------------------------------------
   // Helpers (derived)
   // -------------------------------------------------------------------------
@@ -136,8 +189,11 @@ export function RegionRouter(baseUrl: string) {
     // Data access
     fetchRegions,
     fetchActivationConfig,
+    fetchActivationEvents,
+    fetchKickstarter,
     getRegionByCode,
     createRegion,
+    createKickstarter,
 
     // Cached data & flags
     get regions() {
@@ -149,5 +205,8 @@ export function RegionRouter(baseUrl: string) {
     get isCreatingRegion() {
       return isCreatingRegion;
     },
+    get isCreatingKickstarter() {
+      return isCreatingKickstarter;
+    },
   } as const;
 }

package/src/lib/create-weekly-report/index.ts

@@ -1,7 +1,7 @@
 import axios from "axios";
 import { formatUnits, parseUnits } from "viem";
 import { MerkleTree } from "merkletreejs";
-import { BigNumber, ethers } from "ethers";
+import { keccak256 } from "ethers";
 import { greaterThanMaxDeviation } from "./utils/greater-than-max-deviation";
 import { customToFixed } from "./utils/custom-to-fixed";
 import { HUB_URL } from "../../constants/urls";
@@ -202,22 +202,22 @@ export async function createWeeklyReportLegacy(args: CreateWeeklyReportArgs) {
     })
   );
 
-  const tree = new MerkleTree(leaves, ethers.utils.keccak256, { sort: true });
+  const tree = new MerkleTree(leaves, keccak256, { sort: true });
   const root = tree.getHexRoot();
 
   const totalGlowWeightFinalizedLeavesSum = finalLeaves.reduce(
-    (acc, { glowWeight }) => acc.add(glowWeight),
-    ethers.BigNumber.from(0)
+    (acc, { glowWeight }) => acc + BigInt(glowWeight),
+    0n
   );
   const totalGCCWeightFinalizedLeavesSum = finalLeaves.reduce(
-    (acc, { usdgWeight }) => acc.add(usdgWeight),
-    ethers.BigNumber.from(0)
+    (acc, { usdgWeight }) => acc + BigInt(usdgWeight),
+    0n
   );
 
-  if (totalGlowWeightFinalizedLeavesSum.toBigInt() > MAX_WEIGHT) {
+  if (totalGlowWeightFinalizedLeavesSum > MAX_WEIGHT) {
     throw new Error("Total glow weight is greater than max weight");
   }
-  if (totalGCCWeightFinalizedLeavesSum.toBigInt() > MAX_WEIGHT) {
+  if (totalGCCWeightFinalizedLeavesSum > MAX_WEIGHT) {
     throw new Error("Total gcc weight is greater than max weight");
   }
 
@@ -257,14 +257,12 @@ export async function createWeeklyReportLegacy(args: CreateWeeklyReportArgs) {
     };
   });
 
-  let forLoopedGlowWeightSum: ethers.BigNumber = ethers.BigNumber.from(0);
+  let forLoopedGlowWeightSum = 0n;
   for (const leafProof of farmsWithMerkleProofs) {
-    forLoopedGlowWeightSum = forLoopedGlowWeightSum.add(
-      BigNumber.from(leafProof.glowWeight)
-    );
+    forLoopedGlowWeightSum += BigInt(leafProof.glowWeight);
   }
 
-  if (!forLoopedGlowWeightSum.eq(totalGlowWeightFinalizedLeavesSum)) {
+  if (forLoopedGlowWeightSum !== totalGlowWeightFinalizedLeavesSum) {
     console.error("Glow Weight Sum Mismatch:");
     console.error("Sum from loop:", forLoopedGlowWeightSum.toString());
     console.error(
@@ -274,14 +272,12 @@ export async function createWeeklyReportLegacy(args: CreateWeeklyReportArgs) {
     throw new Error("Glow weight sum is not equal");
   }
 
-  let forLoopedGCCWeightSum: ethers.BigNumber = ethers.BigNumber.from(0);
+  let forLoopedGCCWeightSum = 0n;
   for (const leafProof of farmsWithMerkleProofs) {
-    forLoopedGCCWeightSum = forLoopedGCCWeightSum.add(
-      BigNumber.from(leafProof.usdgWeight)
-    );
+    forLoopedGCCWeightSum += BigInt(leafProof.usdgWeight);
   }
 
-  if (!forLoopedGCCWeightSum.eq(totalGCCWeightFinalizedLeavesSum)) {
+  if (forLoopedGCCWeightSum !== totalGCCWeightFinalizedLeavesSum) {
     console.error("USDG Weight Sum Mismatch:");
     console.error("Sum from loop:", forLoopedGCCWeightSum.toString());
     console.error(
@@ -597,25 +593,25 @@ export async function createWeeklyReport({
   );
 
   // Build the Merkle tree.
-  const merkleTree = new MerkleTree(hashedLeaves, ethers.utils.keccak256, {
+  const merkleTree = new MerkleTree(hashedLeaves, keccak256, {
     sort: true, // Ensure consistent tree structure.
   });
   const merkleRoot = merkleTree.getHexRoot(); // Get the root hash.
 
   // Calculate the total weights across all finalized leaves.
   const totalGlowWeight = finalizedLeaves.reduce(
-    (acc, { glowWeight }) => acc.add(glowWeight),
-    ethers.BigNumber.from(0)
+    (acc, { glowWeight }) => acc + BigInt(glowWeight),
+    0n
   );
   const totalUSDGWeight = finalizedLeaves.reduce(
-    (acc, { usdgWeight }) => acc.add(usdgWeight),
-    ethers.BigNumber.from(0)
+    (acc, { usdgWeight }) => acc + BigInt(usdgWeight),
+    0n
   );
 
   // Total Weight Overflow Checks: Ensure sums don't exceed maximum.
-  if (totalGlowWeight.toBigInt() > MAX_WEIGHT)
+  if (totalGlowWeight > MAX_WEIGHT)
     throw new Error("Total glow weight overflow");
-  if (totalUSDGWeight.toBigInt() > MAX_WEIGHT)
+  if (totalUSDGWeight > MAX_WEIGHT)
     throw new Error("Total USDG weight overflow");
 
   // Generate Merkle proofs for each leaf and verify them.
@@ -636,10 +632,10 @@ export async function createWeeklyReport({
 
   // Verify that summing weights from leavesWithProofs matches the earlier reduce calculation.
   const glowSumProofLoop = leavesWithProofs.reduce(
-    (acc, l) => acc.add(l.glowWeight),
-    ethers.BigNumber.from(0)
+    (acc, l) => acc + BigInt(l.glowWeight),
+    0n
   );
-  if (!glowSumProofLoop.eq(totalGlowWeight)) {
+  if (glowSumProofLoop !== totalGlowWeight) {
     console.error("Glow Weight Sum Mismatch (Post-73):");
     console.error("Sum from loop:", glowSumProofLoop.toString());
     console.error("Sum from reduce:", totalGlowWeight.toString());
@@ -647,10 +643,10 @@ export async function createWeeklyReport({
   }
 
   const usdgSumProofLoop = leavesWithProofs.reduce(
-    (acc, l) => acc.add(l.usdgWeight),
-    ethers.BigNumber.from(0)
+    (acc, l) => acc + BigInt(l.usdgWeight),
+    0n
   );
-  if (!usdgSumProofLoop.eq(totalUSDGWeight)) {
+  if (usdgSumProofLoop !== totalUSDGWeight) {
     console.error("USDG Weight Sum Mismatch (Post-73):");
     console.error("Sum from loop:", usdgSumProofLoop.toString());
     console.error("Sum from reduce:", totalUSDGWeight.toString());
@@ -665,10 +661,7 @@ export async function createWeeklyReport({
 
   // Convert total USDG weight back to human-readable decimal for deviation check.
   const totalUSDGWeightHuman = new Decimal(
-    formatUnits(
-      BigInt(totalUSDGWeight.toString()),
-      USDG_WEIGHT_DECIMAL_PRECISION
-    )
+    formatUnits(totalUSDGWeight, USDG_WEIGHT_DECIMAL_PRECISION)
   );
   // Check deviation between total adjusted credits used and the final sum of USDG weights.
   if (
@@ -689,10 +682,7 @@ export async function createWeeklyReport({
 
   // Convert total Glow weight back to human-readable decimal.
   const totalGlowWeightHuman = new Decimal(
-    formatUnits(
-      BigInt(totalGlowWeight.toString()),
-      GLOW_WEIGHT_DECIMAL_PRECISION
-    )
+    formatUnits(totalGlowWeight, GLOW_WEIGHT_DECIMAL_PRECISION)
   );
   // Sum the original weekly protocol fee payments from farm data.
   const totalProtocolFeePayments = farms.reduce(
@@ -723,7 +713,7 @@ export async function createWeeklyReport({
     weekNumber: week,
     totalCreditsProduced: formatUnits(totalCreditsProduced18dp, 18), // Original reported total
     totalCreditsProducedBN: totalCreditsProduced18dp.toString(),
-    totalGlowWeightInFinalized: totalGlowWeight.toString(), // Total weight as BigNumber string
+    totalGlowWeightInFinalized: totalGlowWeight.toString(), // Total weight as bigint string
     totalGlowWeightHuman: totalGlowWeightHuman.toString(), // Total weight as human-readable decimal
     totalUSDGWeightInFinalized: totalUSDGWeight.toString(),
     totalUSDGWeightHuman: totalUSDGWeightHuman.toString(),

package/src/lib/create-weekly-report/utils/hashLeaf.ts

@@ -1,4 +1,4 @@
-import { ethers } from "ethers";
+import { solidityPackedKeccak256 } from "ethers";
 const leafTypes = ["address", "uint256", "uint256"];
 
 type HashLeafArgs = {
@@ -11,7 +11,7 @@ export function hashLeaf({
   glowWeight,
   usdcWeight,
 }: HashLeafArgs): string {
-  const hash = ethers.utils.solidityKeccak256(leafTypes, [
+  const hash = solidityPackedKeccak256(leafTypes, [
     address,
     glowWeight,
     usdcWeight,

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

@@ -1,4 +1,4 @@
-import { BigNumber, constants, Contract, providers } from "ethers";
+import { Contract, MaxUint256, type BigNumberish, type Signer } from "ethers";
 import { FORWARDER_ABI } from "../abis/forwarderABI";
 import { ERC20_ABI } from "../abis/erc20.abi";
 import { getAddresses } from "../../constants/addresses";
@@ -26,7 +26,7 @@ export type Currency = "USDC" | "GLW" | "USDG";
 
 // Forward parameters interface
 export interface ForwardParams {
-  amount: BigNumber;
+  amount: bigint;
   userAddress: string;
   type: ForwardType;
   currency?: Currency;
@@ -63,17 +63,14 @@ function parseEthersError(error: unknown): string {
 
 // Type-guard style helper to ensure a signer exists throughout the rest of the function.
 function assertSigner(
-  maybeSigner: providers.JsonRpcSigner | undefined
-): asserts maybeSigner is providers.JsonRpcSigner {
+  maybeSigner: Signer | undefined
+): asserts maybeSigner is Signer {
   if (!maybeSigner) {
     throw new Error(ForwarderError.SIGNER_NOT_AVAILABLE);
   }
 }
 
-export function useForwarder(
-  signer: providers.JsonRpcSigner | undefined,
-  CHAIN_ID: number
-) {
+export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
   // Use dynamic addresses based on chain configuration
   const ADDRESSES = getAddresses(CHAIN_ID);
 
@@ -171,7 +168,7 @@ export function useForwarder(
   async function checkTokenAllowance(
     owner: string,
     currency: Currency = "USDC"
-  ): Promise<BigNumber> {
+  ): Promise<bigint> {
     assertSigner(signer);
 
     try {
@@ -179,7 +176,7 @@ export function useForwarder(
       if (!tokenContract)
         throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
 
-      const allowance: BigNumber = await tokenContract.allowance(
+      const allowance: bigint = await tokenContract.allowance(
         owner,
         ADDRESSES.FORWARDER
       );
@@ -197,7 +194,7 @@ export function useForwarder(
   async function checkTokenBalance(
     owner: string,
     currency: Currency = "USDC"
-  ): Promise<BigNumber> {
+  ): Promise<bigint> {
     assertSigner(signer);
 
     try {
@@ -205,7 +202,7 @@ export function useForwarder(
       if (!tokenContract)
         throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
 
-      const balance: BigNumber = await tokenContract.balanceOf(owner);
+      const balance: bigint = await tokenContract.balanceOf(owner);
       return balance;
     } catch (error) {
       throw new Error(parseEthersError(error));
@@ -218,7 +215,7 @@ export function useForwarder(
    * @param currency The currency to approve
    */
   async function approveToken(
-    amount: BigNumber,
+    amount: BigNumberish,
     currency: Currency = "USDC"
   ): Promise<boolean> {
     assertSigner(signer);
@@ -276,16 +273,16 @@ export function useForwarder(
       }
 
       // Check allowance and approve if necessary
-      const allowance: BigNumber = await tokenContract.allowance(
+      const allowance: bigint = await tokenContract.allowance(
         owner,
         ADDRESSES.FORWARDER
       );
 
-      if (allowance.lt(amount)) {
+      if (allowance < amount) {
         try {
           const approveTx = await tokenContract.approve(
             ADDRESSES.FORWARDER,
-            constants.MaxUint256
+            MaxUint256
           );
           await approveTx.wait();
         } catch (approveError) {
@@ -311,26 +308,26 @@ export function useForwarder(
           throw new Error(`Unsupported currency for forwarding: ${currency}`);
       }
 
-      // Run a static call first to surface any revert reason
+      // Run a static call first to surface any revert reason (ethers v6)
       try {
-        // If PayAuditFees, call forward() even for USDC
         if (!isAuditFees && currency === "USDC") {
-          await forwarderContract.callStatic.swapUSDCAndForwardUSDG(
-            amount,
-            ADDRESSES.FOUNDATION_WALLET,
-            message,
-            { from: owner }
-          );
+          await forwarderContract
+            .getFunction("swapUSDCAndForwardUSDG")
+            .staticCall(amount, ADDRESSES.FOUNDATION_WALLET, message, {
+              from: owner,
+            });
         } else {
-          await forwarderContract.callStatic.forward(
-            tokenAddress,
-            isAuditFees
-              ? ADDRESSES.AUDIT_FEE_WALLET
-              : ADDRESSES.FOUNDATION_WALLET,
-            amount,
-            message,
-            { from: owner }
-          );
+          await forwarderContract
+            .getFunction("forward")
+            .staticCall(
+              tokenAddress,
+              isAuditFees
+                ? ADDRESSES.AUDIT_FEE_WALLET
+                : ADDRESSES.FOUNDATION_WALLET,
+              amount,
+              message,
+              { from: owner }
+            );
         }
       } catch (staticError) {
         throw new Error(parseEthersError(staticError));
@@ -339,13 +336,13 @@ export function useForwarder(
       // Execute the forward transaction
       let tx;
       if (!isAuditFees && currency === "USDC") {
-        tx = await forwarderContract.swapUSDCAndForwardUSDG(
+        tx = await forwarderContract.getFunction("swapUSDCAndForwardUSDG")(
           amount,
           ADDRESSES.FOUNDATION_WALLET,
           message
         );
       } else {
-        tx = await forwarderContract.forward(
+        tx = await forwarderContract.getFunction("forward")(
           tokenAddress,
           isAuditFees
             ? ADDRESSES.AUDIT_FEE_WALLET
@@ -368,7 +365,7 @@ export function useForwarder(
    * Forward tokens for protocol fee payment and GCTL minting with staking
    */
   async function payProtocolFeeAndMintGCTLAndStake(
-    amount: BigNumber,
+    amount: bigint,
     userAddress: string,
     applicationId: string,
     regionId?: number,
@@ -397,7 +394,7 @@ export function useForwarder(
    * Forward tokens for protocol fee payment only
    */
   async function payProtocolFee(
-    amount: BigNumber,
+    amount: bigint,
     userAddress: string,
     applicationId: string,
     currency: Currency = "USDC"
@@ -417,7 +414,7 @@ export function useForwarder(
    * Forward USDC to mint GCTL and stake to a region
    */
   async function mintGCTLAndStake(
-    amount: BigNumber,
+    amount: bigint,
     userAddress: string,
     regionId?: number,
     currency: Currency = "USDC"
@@ -444,7 +441,7 @@ export function useForwarder(
    * Forward USDC to mint GCTL (existing functionality, keeping for compatibility)
    */
   async function mintGCTL(
-    amount: BigNumber,
+    amount: bigint,
     userAddress: string,
     currency: Currency = "USDC"
   ): Promise<string> {
@@ -469,7 +466,7 @@ export function useForwarder(
    * Forward tokens to pay audit fees (USDC only, calls forward())
    */
   async function payAuditFees(
-    amount: BigNumber,
+    amount: bigint,
     userAddress: string,
     applicationId: string
   ): Promise<string> {
@@ -488,7 +485,7 @@ export function useForwarder(
    * Forward tokens to buy a solar farm
    */
   async function buySolarFarm(
-    amount: BigNumber,
+    amount: bigint,
     userAddress: string,
     farmId: string,
     currency: Currency = "USDC"
@@ -547,27 +544,31 @@ export function useForwarder(
           );
       }
 
-      const gasPrice = await signer.getGasPrice();
-      const estimatedGas =
-        // If PayAuditFees, always use forward() even with USDC
+      const feeData = await signer.provider?.getFeeData();
+      const gasPrice =
+        feeData?.gasPrice ?? feeData?.maxFeePerGas ?? (0n as bigint);
+      if (gasPrice === 0n) {
+        throw new Error("Could not fetch gas price to estimate cost.");
+      }
+      const estimatedGas: bigint =
         !isAuditFees && currency === "USDC"
-          ? await forwarderContract.estimateGas.swapUSDCAndForwardUSDG(
-              amount,
-              ADDRESSES.FOUNDATION_WALLET,
-              message
-            )
-          : await forwarderContract.estimateGas.forward(
-              tokenAddress,
-              isAuditFees
-                ? ADDRESSES.AUDIT_FEE_WALLET
-                : ADDRESSES.FOUNDATION_WALLET,
-              amount,
-              message
-            );
-      const estimatedCost = estimatedGas.mul(gasPrice);
+          ? await forwarderContract
+              .getFunction("swapUSDCAndForwardUSDG")
+              .estimateGas(amount, ADDRESSES.FOUNDATION_WALLET, message)
+          : await forwarderContract
+              .getFunction("forward")
+              .estimateGas(
+                tokenAddress,
+                isAuditFees
+                  ? ADDRESSES.AUDIT_FEE_WALLET
+                  : ADDRESSES.FOUNDATION_WALLET,
+                amount,
+                message
+              );
+      const estimatedCost: bigint = estimatedGas * gasPrice;
 
       if (ethPriceInUSD) {
-        const estimatedCostInEth = formatEther(estimatedCost.toBigInt());
+        const estimatedCostInEth = formatEther(estimatedCost);
         const estimatedCostInUSD = (
           parseFloat(estimatedCostInEth) * ethPriceInUSD
         ).toFixed(2);
@@ -588,7 +589,7 @@ export function useForwarder(
    * @param recipient Address to mint USDC to
    */
   async function mintTestUSDC(
-    amount: BigNumber,
+    amount: bigint,
     recipient: string
   ): Promise<string> {
     assertSigner(signer);

package/src/lib/types/index.ts

@@ -152,6 +152,70 @@ export interface RegionMetadata {
   flag?: string;
 }
 
+// ----------------------------- Kickstarters ---------------------------------
+export type KickstarterStatus =
+  | "draft"
+  | "awaiting-kickoff"
+  | "collecting-support"
+  | "ready-to-activate"
+  | "completed"
+  | "expired"
+  | "cancelled"
+  | "suspended";
+
+export interface CreateKickstarterPayload {
+  creatorWallet: string;
+  regionName: string;
+  isUs?: boolean;
+  title: string;
+  description: string;
+  stakeTargetGctl: string; // decimal string
+  requiredFarmCount?: number; // defaults server-side
+  requiredInstallerCount?: number; // defaults server-side
+}
+
+export interface KickstarterCreateResponse {
+  success: true;
+  id: string;
+}
+
+export interface Kickstarter {
+  id: string;
+  regionId: number;
+  creatorWallet: string;
+  title: string;
+  description: string;
+  slug: string;
+  status: KickstarterStatus | string;
+  createdAt: string; // ISO 8601
+  updatedAt: string; // ISO 8601
+  publishedAt?: string; // ISO 8601
+  completedAt?: string; // ISO 8601
+  cancelledAt?: string; // ISO 8601
+  expiredAt?: string; // ISO 8601
+  deadline: string; // ISO 8601
+  stakeTargetGctl: string; // decimal string
+  requiredFarmCount: number;
+  requiredInstallerCount: number;
+  stakeContributed: boolean;
+  farmProvided: boolean;
+  installerCertified: boolean;
+  kickoffTransferTxId?: string;
+  kickoffMintTxId?: string;
+  kickoffStakeEventId?: string;
+}
+
+export interface ActivationEvent {
+  id: string;
+  regionId: number;
+  epoch: number;
+  stakeThresholdMet: boolean;
+  solarFarmRequirementMet: boolean;
+  installerRequirementMet: boolean;
+  activated: boolean;
+  ts: string; // ISO 8601
+}
+
 // ---------------------------------------------------------------------------
 // Barrel exports (convenience)
 // ---------------------------------------------------------------------------

package/src/utils/hash-leaf.ts

@@ -1,4 +1,4 @@
-import { ethers } from "ethers";
+import { solidityPackedKeccak256 } from "ethers";
 const leafTypes = ["address", "uint256", "uint256"];
 
 type HashLeafArgs = {
@@ -11,7 +11,7 @@ export function hashLeaf({
   glowWeight,
   usdcWeight,
 }: HashLeafArgs): string {
-  const hash = ethers.utils.solidityKeccak256(leafTypes, [
+  const hash = solidityPackedKeccak256(leafTypes, [
     address,
     glowWeight,
     usdcWeight,