@glowlabs-org/utils 0.2.154 → 0.2.156

package/src/lib/abis/rewardKernelABI.ts

@@ -0,0 +1,264 @@
+export const REWARDS_KERNEL_ABI = [
+  {
+    inputs: [
+      { internalType: "address", name: "_foundationMultisig", type: "address" },
+      { internalType: "address", name: "_rejectionMultisig", type: "address" },
+      {
+        internalType: "contract CounterfactualHolderFactory",
+        name: "f",
+        type: "address",
+      },
+      { internalType: "uint256", name: "_finality", type: "uint256" },
+    ],
+    stateMutability: "payable",
+    type: "constructor",
+  },
+  {
+    inputs: [{ internalType: "address", name: "target", type: "address" }],
+    name: "AddressEmptyCode",
+    type: "error",
+  },
+  {
+    inputs: [{ internalType: "address", name: "account", type: "address" }],
+    name: "AddressInsufficientBalance",
+    type: "error",
+  },
+  { inputs: [], name: "AlreadyClaimedNonce", type: "error" },
+  { inputs: [], name: "AlreadyFinalized", type: "error" },
+  { inputs: [], name: "AlreadyRejected", type: "error" },
+  { inputs: [], name: "CannotClaimFromRejectedNonce", type: "error" },
+  { inputs: [], name: "CannotPostZeroRoot", type: "error" },
+  { inputs: [], name: "DuplicateToken", type: "error" },
+  { inputs: [], name: "FailedInnerCall", type: "error" },
+  { inputs: [], name: "InvalidMerkleProof", type: "error" },
+  { inputs: [], name: "LengthsDontMatch", type: "error" },
+  { inputs: [], name: "MaxClaimedExceeded", type: "error" },
+  { inputs: [], name: "NonexistentDataAtNonce", type: "error" },
+  { inputs: [], name: "NotFoundationMultisig", type: "error" },
+  { inputs: [], name: "NotRejectionMultisig", type: "error" },
+  { inputs: [], name: "NotYetFinalized", type: "error" },
+  { inputs: [], name: "ReentrancyGuardReentrantCall", type: "error" },
+  {
+    inputs: [{ internalType: "address", name: "token", type: "address" }],
+    name: "SafeERC20FailedOperation",
+    type: "error",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "nonce",
+        type: "uint256",
+      },
+    ],
+    name: "NonceRejected",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "user", type: "address" },
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "nonce",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "from",
+        type: "address",
+      },
+      {
+        components: [
+          { internalType: "address", name: "token", type: "address" },
+          { internalType: "uint256", name: "amount", type: "uint256" },
+        ],
+        indexed: false,
+        internalType: "struct FoundationRewardKernel.TokenAndAmount[]",
+        name: "taa",
+        type: "tuple[]",
+      },
+      {
+        indexed: false,
+        internalType: "bool[]",
+        name: "isGuarded",
+        type: "bool[]",
+      },
+    ],
+    name: "RewardClaimed",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "nonce",
+        type: "uint256",
+      },
+      { indexed: true, internalType: "bytes32", name: "root", type: "bytes32" },
+      {
+        components: [
+          { internalType: "address", name: "token", type: "address" },
+          { internalType: "uint256", name: "amount", type: "uint256" },
+        ],
+        indexed: false,
+        internalType: "struct FoundationRewardKernel.TokenAndAmount[]",
+        name: "taa",
+        type: "tuple[]",
+      },
+    ],
+    name: "RootPosted",
+    type: "event",
+  },
+  {
+    inputs: [],
+    name: "$nextPostNonce",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "CFH_FACTORY",
+    outputs: [
+      {
+        internalType: "contract CounterfactualHolderFactory",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "FINALITY",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "FOUNDATION_MULTISIG",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "REJECTION_MULTISIG",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "nonce", type: "uint256" },
+      { internalType: "bytes32[]", name: "proof", type: "bytes32[]" },
+      {
+        components: [
+          { internalType: "address", name: "token", type: "address" },
+          { internalType: "uint256", name: "amount", type: "uint256" },
+        ],
+        internalType: "struct FoundationRewardKernel.TokenAndAmount[]",
+        name: "taa",
+        type: "tuple[]",
+      },
+      { internalType: "address", name: "from", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "bool[]", name: "isGuardedToken", type: "bool[]" },
+      { internalType: "bool[]", name: "toCounterfactual", type: "bool[]" },
+    ],
+    name: "claimPayout",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "nonce", type: "uint256" },
+      { internalType: "address", name: "token", type: "address" },
+    ],
+    name: "getAmountClaimed",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "nonce", type: "uint256" },
+      { internalType: "address", name: "token", type: "address" },
+    ],
+    name: "getMaxReward",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "nonce", type: "uint256" }],
+    name: "getRewardMeta",
+    outputs: [
+      { internalType: "bytes32", name: "merkleRoot", type: "bytes32" },
+      { internalType: "uint48", name: "pushTimestamp", type: "uint48" },
+      { internalType: "bool", name: "rejected", type: "bool" },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "user", type: "address" },
+      { internalType: "uint256", name: "nonce", type: "uint256" },
+    ],
+    name: "isClaimed",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "nonce", type: "uint256" }],
+    name: "isFinalized",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "bytes[]", name: "data", type: "bytes[]" }],
+    name: "multicall",
+    outputs: [{ internalType: "bytes[]", name: "results", type: "bytes[]" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "root", type: "bytes32" },
+      {
+        components: [
+          { internalType: "address", name: "token", type: "address" },
+          { internalType: "uint256", name: "amount", type: "uint256" },
+        ],
+        internalType: "struct FoundationRewardKernel.TokenAndAmount[]",
+        name: "taa",
+        type: "tuple[]",
+      },
+    ],
+    name: "postPayoutRoot",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "nonce", type: "uint256" }],
+    name: "rejectNonce",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+] as const;

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

@@ -46,6 +46,8 @@ import type {
   FarmRewardSplit,
   MiningScoresBatchParams,
   MiningScoresBatchResponse,
+  FarmWeeklyRewardsResponse,
+  FarmWeeklyRewardsQuery,
 } from "../types";
 import {
   sentryAddBreadcrumb,
@@ -128,6 +130,36 @@ export function FarmsRouter(baseUrl: string) {
     }
   };
 
+  const fetchFarmWeeklyRewards = async (
+    farmId: string,
+    query?: FarmWeeklyRewardsQuery
+  ): Promise<FarmWeeklyRewardsResponse> => {
+    try {
+      if (!farmId) {
+        throw new Error("Farm ID is required");
+      }
+
+      const params = new URLSearchParams();
+      if (query?.startWeek !== undefined)
+        params.set("startWeek", query.startWeek.toString());
+      if (query?.endWeek !== undefined)
+        params.set("endWeek", query.endWeek.toString());
+      if (query?.paymentCurrency)
+        params.set("paymentCurrency", query.paymentCurrency);
+      if (query?.limit !== undefined)
+        params.set("limit", query.limit.toString());
+
+      const queryString = params.toString();
+      const path = `/farms/${encodeURIComponent(farmId)}/weekly-rewards${
+        queryString ? `?${queryString}` : ""
+      }`;
+
+      return await request<FarmWeeklyRewardsResponse>(path);
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    }
+  };
+
   const estimateRewardScore = async (
     params: EstimateRewardScoreParams
   ): Promise<RewardScoreResponse> => {
@@ -236,6 +268,7 @@ export function FarmsRouter(baseUrl: string) {
     fetchFarmRewardSplits,
     fetchSponsoredFarms,
     fetchWalletFarmsWithRewards,
+    fetchFarmWeeklyRewards,
     estimateRewardScore,
     estimateRewardScoresBatch,
     calculateMiningScoresBatch,

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

@@ -12,6 +12,8 @@ import type {
   RecentRegionActivityResponse,
   InstallerApplicationPayload,
   InstallerApplicationResponse,
+  RegionWeeklyRewardsResponse,
+  RegionWeeklyRewardsQuery,
 } from "../types";
 
 // ---------------------------------------------------------------------------
@@ -145,6 +147,32 @@ export function RegionRouter(baseUrl: string) {
       }
     };
 
+  const fetchRegionWeeklyRewards = async (
+    regionId: number,
+    query?: RegionWeeklyRewardsQuery
+  ): Promise<RegionWeeklyRewardsResponse> => {
+    try {
+      const params = new URLSearchParams();
+      if (query?.startWeek !== undefined)
+        params.set("startWeek", query.startWeek.toString());
+      if (query?.endWeek !== undefined)
+        params.set("endWeek", query.endWeek.toString());
+      if (query?.paymentCurrency)
+        params.set("paymentCurrency", query.paymentCurrency);
+      if (query?.limit !== undefined)
+        params.set("limit", query.limit.toString());
+
+      const queryString = params.toString();
+      const path = `/regions/weekly-rewards/${regionId}${
+        queryString ? `?${queryString}` : ""
+      }`;
+
+      return await request<RegionWeeklyRewardsResponse>(path);
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    }
+  };
+
   const applyInstallerCertification = async (
     payload: InstallerApplicationPayload
   ): Promise<InstallerApplicationResponse> => {
@@ -218,6 +246,7 @@ export function RegionRouter(baseUrl: string) {
     fetchRegionSolarFarms,
     fetchActiveSummary,
     fetchRecentActivity,
+    fetchRegionWeeklyRewards,
     getRegionByCode,
     applyInstallerCertification,
 

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

@@ -1,7 +1,14 @@
 "use strict";
 
-import type { ControlWallet, WalletsResponse, WalletDetails } from "../types";
-import type { MintedEvent, StakedEvent } from "../types";
+import type {
+  ControlWallet,
+  WalletsResponse,
+  WalletDetails,
+  MintedEvent,
+  StakedEvent,
+  WalletWeeklyRewardsResponse,
+  WeeklyRewardsQuery,
+} from "../types";
 
 function parseApiError(error: unknown): string {
   if (!error) return "Unknown error";
@@ -85,10 +92,37 @@ export function WalletsRouter(baseUrl: string) {
     }
   };
 
+  const fetchWalletWeeklyRewards = async (
+    wallet: string,
+    query?: WeeklyRewardsQuery
+  ): Promise<WalletWeeklyRewardsResponse> => {
+    try {
+      const params = new URLSearchParams();
+      if (query?.startWeek !== undefined)
+        params.set("startWeek", query.startWeek.toString());
+      if (query?.endWeek !== undefined)
+        params.set("endWeek", query.endWeek.toString());
+      if (query?.paymentCurrency)
+        params.set("paymentCurrency", query.paymentCurrency);
+      if (query?.limit !== undefined)
+        params.set("limit", query.limit.toString());
+
+      const queryString = params.toString();
+      const path = `/wallets/address/${encodeURIComponent(wallet)}/weekly-rewards${
+        queryString ? `?${queryString}` : ""
+      }`;
+
+      return await request<WalletWeeklyRewardsResponse>(path);
+    } catch (error) {
+      throw new Error(parseApiError(error));
+    }
+  };
+
   return {
     fetchAllWallets,
     fetchWalletByAddress,
     fetchWalletMintedEvents,
     fetchWalletStakeEvents,
+    fetchWalletWeeklyRewards,
   } as const;
 }