Update caching functions to accept environment as a parameter. Implement better error handling for getNodeLicenseDetails.

wzrdx · wzrdx · commit 711cdc2c6acc · 2025-06-17T14:46:42.000+03:00
diff --git a/app/accounts/page.tsx b/app/accounts/page.tsx
@@ -1,3 +1,4 @@
+import { getServerConfig } from '@/config/serverConfig';
 import { getSSURL } from '@/lib/actions';
 import * as types from '@/typedefs/blockchain';
 import { LicenseItem } from '@/typedefs/general';
@@ -16,8 +17,8 @@ export async function generateMetadata() {
     };
 }
 
-const fetchCachedLicenseHolders = cache(async () => {
-    const url = await getSSURL('license-holders');
+const fetchCachedLicenseHolders = cache(async (environment: 'mainnet' | 'testnet' | 'devnet') => {
+    const url = await getSSURL(`license-holders?env=${environment}`);
 
     const res = await fetch(url, {
         next: { revalidate: 3600 }, // Cache for 1 hour
@@ -44,6 +45,8 @@ export default async function AccountsPage(props: {
     const searchParams = await props.searchParams;
     const currentPage = Number(searchParams?.page) || 1;
 
+    const { config } = await getServerConfig();
+
     let ndHolders: {
             ethAddress: types.EthAddress;
             licenseId: number;
@@ -63,7 +66,7 @@ export default async function AccountsPage(props: {
     }[];
 
     try {
-        ({ ndHolders, mndHolders } = await fetchCachedLicenseHolders());
+        ({ ndHolders, mndHolders } = await fetchCachedLicenseHolders(config.environment));
 
         ndHolders.forEach((holder) => {
             if (!holders[holder.ethAddress]) {
diff --git a/app/license/[licenseType]/[licenseId]/page.tsx b/app/license/[licenseType]/[licenseId]/page.tsx
@@ -1,6 +1,7 @@
 import LicensePageNodeCardWrapper from '@/app/server-components/LicensePage/LicensePageNodeCardWrapper';
 import LicensePageNodePerformanceCardWrapper from '@/app/server-components/LicensePage/LicensePageNodePerformanceCardWrapper';
 import LicenseCard from '@/app/server-components/main-cards/LicenseCard';
+import { getServerConfig } from '@/config/serverConfig';
 import { getNodeAvailability } from '@/lib/actions';
 import { getLicense } from '@/lib/api/blockchain';
 import { isEmptyETHAddr } from '@/lib/utils';
@@ -11,6 +12,7 @@ import { cache, Suspense } from 'react';
 
 export async function generateMetadata({ params }) {
     const { licenseType, licenseId } = await params;
+    const { config } = await getServerConfig();
 
     if (!licenseType || !['ND', 'MND', 'GND'].includes(licenseType)) {
         return {
@@ -33,7 +35,7 @@ export async function generateMetadata({ params }) {
     }
 
     try {
-        await cachedGetLicense(licenseType, licenseId);
+        await cachedGetLicense(licenseType, licenseId, config.environment);
     } catch (error) {
         return {
             title: 'Error',
@@ -51,12 +53,15 @@ export async function generateMetadata({ params }) {
     };
 }
 
-const cachedGetLicense = cache(async (licenseType: 'ND' | 'MND' | 'GND', licenseId: string) => {
-    return await getLicense(licenseType, licenseId);
-});
+const cachedGetLicense = cache(
+    async (licenseType: 'ND' | 'MND' | 'GND', licenseId: string, _environment: 'mainnet' | 'testnet' | 'devnet') => {
+        return await getLicense(licenseType, licenseId);
+    },
+);
 
 export default async function LicensePage({ params }) {
     const { licenseType, licenseId } = await params;
+    const { config } = await getServerConfig();
 
     if (!licenseType || !['ND', 'MND', 'GND'].includes(licenseType)) {
         console.log(`[License Page] Invalid license type: ${licenseType}`);
@@ -73,7 +78,7 @@ export default async function LicensePage({ params }) {
     let license: types.License;
 
     try {
-        license = await cachedGetLicense(licenseType, licenseId);
+        license = await cachedGetLicense(licenseType, licenseId, config.environment);
     } catch (error) {
         console.error(error);
         console.log(`[License Page] Failed to fetch license: ${licenseType}-${licenseId}`);
diff --git a/app/node/[nodeEthAddr]/page.tsx b/app/node/[nodeEthAddr]/page.tsx
@@ -2,6 +2,7 @@ import LicenseCard from '@/app/server-components/main-cards/LicenseCard';
 import NodeCard from '@/app/server-components/main-cards/NodeCard';
 import NodePerformanceCard from '@/app/server-components/main-cards/NodePerformanceCard';
 import { DetailedAlert } from '@/app/server-components/shared/DetailedAlert';
+import { getServerConfig } from '@/config/serverConfig';
 import { getNodeAvailability } from '@/lib/actions';
 import { getNodeLicenseDetails } from '@/lib/api/blockchain';
 import { isEmptyETHAddr } from '@/lib/utils';
@@ -13,6 +14,7 @@ import { isAddress } from 'viem';
 
 export async function generateMetadata({ params }) {
     const { nodeEthAddr } = await params;
+    const { config } = await getServerConfig();
 
     if (!nodeEthAddr || !isAddress(nodeEthAddr) || isEmptyETHAddr(nodeEthAddr)) {
         console.log(`[Node Page] Invalid node address: ${nodeEthAddr}`);
@@ -22,7 +24,7 @@ export async function generateMetadata({ params }) {
     let nodeResponse: types.OraclesAvailabilityResult & types.OraclesDefaultResult;
 
     try {
-        ({ nodeResponse } = await getCachedLicenseDetailsAndNodeAvailability(nodeEthAddr));
+        ({ nodeResponse } = await getCachedLicenseDetailsAndNodeAvailability(nodeEthAddr, config.environment));
 
         if (!nodeResponse) {
             console.log(`[Node Page] No node response found for address: ${nodeEthAddr}`);
@@ -49,25 +51,42 @@ export async function generateMetadata({ params }) {
 const getCachedLicenseDetailsAndNodeAvailability = cache(
     async (
         nodeEthAddr: types.EthAddress,
+        _environment: 'mainnet' | 'testnet' | 'devnet',
     ): Promise<{
         license: types.License;
         licenseId: bigint;
         licenseType: 'ND' | 'MND' | 'GND';
         owner: types.EthAddress;
         nodeResponse: types.OraclesAvailabilityResult & types.OraclesDefaultResult;
     }> => {
-        const {
-            nodeAddress,
-            totalAssignedAmount,
-            totalClaimedAmount,
-            lastClaimEpoch,
-            assignTimestamp,
-            lastClaimOracle,
-            isBanned,
-            licenseId,
-            licenseType,
-            owner,
-        } = await getNodeLicenseDetails(nodeEthAddr);
+        let nodeAddress: types.EthAddress,
+            totalAssignedAmount: bigint,
+            totalClaimedAmount: bigint,
+            lastClaimEpoch: bigint,
+            assignTimestamp: bigint,
+            lastClaimOracle: types.EthAddress,
+            isBanned: boolean,
+            licenseId: bigint,
+            licenseType: 'ND' | 'MND' | 'GND' | undefined,
+            owner: types.EthAddress;
+
+        try {
+            ({
+                nodeAddress,
+                totalAssignedAmount,
+                totalClaimedAmount,
+                lastClaimEpoch,
+                assignTimestamp,
+                lastClaimOracle,
+                isBanned,
+                licenseId,
+                licenseType,
+                owner,
+            } = await getNodeLicenseDetails(nodeEthAddr));
+        } catch (error) {
+            console.error(error);
+            throw new Error('Failed to get node license details.');
+        }
 
         if (!licenseId || !licenseType) {
             throw new Error('License not found.');
@@ -98,6 +117,7 @@ const getCachedLicenseDetailsAndNodeAvailability = cache(
 
 export default async function NodePage({ params }) {
     const { nodeEthAddr } = await params;
+    const { config } = await getServerConfig();
 
     if (!nodeEthAddr || !isAddress(nodeEthAddr) || isEmptyETHAddr(nodeEthAddr)) {
         console.log(`[Node Page] Invalid node address in page component: ${nodeEthAddr}`);
@@ -111,8 +131,10 @@ export default async function NodePage({ params }) {
     let nodeResponse: types.OraclesAvailabilityResult & types.OraclesDefaultResult;
 
     try {
-        ({ license, licenseId, licenseType, owner, nodeResponse } =
-            await getCachedLicenseDetailsAndNodeAvailability(nodeEthAddr));
+        ({ license, licenseId, licenseType, owner, nodeResponse } = await getCachedLicenseDetailsAndNodeAvailability(
+            nodeEthAddr,
+            config.environment,
+        ));
     } catch (error: any) {
         console.error(error);
 
diff --git a/app/server-components/Nodes/Node.tsx b/app/server-components/Nodes/Node.tsx
@@ -11,12 +11,19 @@ import { BorderedCard } from '../shared/cards/BorderedCard';
 import LicenseSmallCard from '../shared/Licenses/LicenseSmallCard';
 
 export default async function Node({ ratio1Addr, node }: { ratio1Addr: R1Address; node: NodeState }) {
-    const { licenseId, licenseType, owner, totalAssignedAmount, totalClaimedAmount, isBanned } = await getNodeLicenseDetails(
-        node.eth_addr,
-    );
+    let licenseId: bigint | undefined,
+        licenseType: 'ND' | 'MND' | 'GND' | undefined,
+        owner: string | undefined,
+        totalAssignedAmount: bigint | undefined,
+        totalClaimedAmount: bigint | undefined,
+        isBanned: boolean | undefined;
 
-    // The node will soon be disconnected by dAuth
-    if (!licenseId) {
+    try {
+        ({ licenseId, licenseType, owner, totalAssignedAmount, totalClaimedAmount, isBanned } = await getNodeLicenseDetails(
+            node.eth_addr,
+        ));
+    } catch (error) {
+        console.error(error);
         return null;
     }
 
diff --git a/app/server-components/R1MintedLastEpoch.tsx b/app/server-components/R1MintedLastEpoch.tsx
@@ -1,12 +1,12 @@
-import { getNextEpochTimestamp } from '@/config';
+import { Config, getNextEpochTimestamp } from '@/config';
 import { getServerConfig } from '@/config/serverConfig';
 import { getSSURL } from '@/lib/actions';
 import { differenceInSeconds } from 'date-fns';
+import { cache } from 'react';
 import { formatUnits } from 'viem';
 
-const fetchCachedR1MintedLastEpoch = async () => {
-    const url = await getSSURL('r1-minted-last-epoch');
-    const { config } = await getServerConfig();
+const fetchCachedR1MintedLastEpoch = cache(async (config: Config) => {
+    const url = await getSSURL(`r1-minted-last-epoch?env=${config.environment}`);
 
     const res = await fetch(url, {
         next: { revalidate: differenceInSeconds(getNextEpochTimestamp(config), new Date()) + 1 },
@@ -17,13 +17,15 @@ const fetchCachedR1MintedLastEpoch = async () => {
     } = await res.json();
 
     return data.value;
-};
+});
 
 export default async function R1MintedLastEpoch() {
+    const { config } = await getServerConfig();
+
     let value: string | undefined;
 
     try {
-        value = await fetchCachedR1MintedLastEpoch();
+        value = await fetchCachedR1MintedLastEpoch(config);
     } catch (error) {
         console.error(error);
         return <div className="text-lg md:text-xl">—</div>;
diff --git a/config/index.ts b/config/index.ts
@@ -134,5 +134,5 @@ export const getEnvironment = (hostname: string | null): 'mainnet' | 'testnet' |
           ? ('testnet' as const)
           : hostname === domains.devnet
             ? ('devnet' as const)
-            : ('devnet' as const);
+            : ('mainnet' as const);
 };
