Develop

app/node/[nodeEthAddr]/page.tsx → app/node/[nodeAddr]/page.tsx

@@ -6,7 +6,7 @@ import ErrorComponent from '@/app/server-components/shared/ErrorComponent';
 import config from '@/config';
 import { getNodeAvailability } from '@/lib/actions';
 import { getNodeLicenseDetails } from '@/lib/api/blockchain';
-import { isZeroAddress } from '@/lib/utils';
+import { internalNodeAddressToEthAddress, isZeroAddress } from '@/lib/utils';
 import * as types from '@/typedefs/blockchain';
 import { RiCloseLine } from 'react-icons/ri';
 import { isAddress } from 'viem';
@@ -18,18 +18,40 @@ const errorMetadata = {
     },
 };
 
+const resolveNodeEthAddress = (nodeAddress?: string): types.EthAddress | null => {
+    if (!nodeAddress) {
+        return null;
+    }
+
+    if (nodeAddress.startsWith('0xai_')) {
+        try {
+            const ethAddress = internalNodeAddressToEthAddress(nodeAddress);
+            return isZeroAddress(ethAddress) ? null : ethAddress;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    if (!isAddress(nodeAddress) || isZeroAddress(nodeAddress)) {
+        return null;
+    }
+
+    return nodeAddress;
+};
+
 export async function generateMetadata({ params }) {
-    const { nodeEthAddr } = await params;
+    const { nodeAddr } = await params;
+    const resolvedNodeEthAddr = resolveNodeEthAddress(nodeAddr);
 
-    if (!nodeEthAddr || !isAddress(nodeEthAddr) || isZeroAddress(nodeEthAddr)) {
-        console.log(`[Node Page] Invalid node address: ${nodeEthAddr}`);
+    if (!resolvedNodeEthAddr) {
+        console.log(`[Node Page] Invalid node address: ${nodeAddr}`);
         return errorMetadata;
     }
 
     let nodeResponse: types.OraclesAvailabilityResult & types.OraclesDefaultResult;
 
     try {
-        ({ nodeResponse } = await fetchLicenseDetailsAndNodeAvailability(nodeEthAddr, config.environment));
+        ({ nodeResponse } = await fetchLicenseDetailsAndNodeAvailability(resolvedNodeEthAddr, config.environment));
     } catch (error) {
         console.error(error);
         return errorMetadata;
@@ -54,11 +76,12 @@ const fetchLicenseDetailsAndNodeAvailability = async (
     nodeResponse: types.OraclesAvailabilityResult & types.OraclesDefaultResult;
 }> => {
     let nodeAddress: types.EthAddress,
-        totalAssignedAmount: bigint,
-        totalClaimedAmount: bigint,
-        lastClaimEpoch: bigint,
-        assignTimestamp: bigint,
-        lastClaimOracle: types.EthAddress,
+        totalAssignedAmount: bigint,
+        totalClaimedAmount: bigint,
+        firstMiningEpoch: bigint | undefined,
+        lastClaimEpoch: bigint,
+        assignTimestamp: bigint,
+        lastClaimOracle: types.EthAddress,
         isBanned: boolean,
         licenseId: bigint,
         licenseType: 'ND' | 'MND' | 'GND' | undefined,
@@ -67,12 +90,13 @@ const fetchLicenseDetailsAndNodeAvailability = async (
 
     try {
         ({
-            nodeAddress,
-            totalAssignedAmount,
-            totalClaimedAmount,
-            lastClaimEpoch,
-            assignTimestamp,
-            lastClaimOracle,
+            nodeAddress,
+            totalAssignedAmount,
+            totalClaimedAmount,
+            firstMiningEpoch,
+            lastClaimEpoch,
+            assignTimestamp,
+            lastClaimOracle,
             isBanned,
             licenseId,
             licenseType,
@@ -90,12 +114,13 @@ const fetchLicenseDetailsAndNodeAvailability = async (
     }
 
     const license: types.License = {
-        nodeAddress,
-        totalAssignedAmount,
-        totalClaimedAmount,
-        lastClaimEpoch,
-        assignTimestamp,
-        lastClaimOracle,
+        nodeAddress,
+        totalAssignedAmount,
+        totalClaimedAmount,
+        firstMiningEpoch,
+        lastClaimEpoch,
+        assignTimestamp,
+        lastClaimOracle,
         isBanned,
         owner,
         r1PoaiRewards,
@@ -113,9 +138,10 @@ const fetchLicenseDetailsAndNodeAvailability = async (
 };
 
 export default async function NodePage({ params }) {
-    const { nodeEthAddr } = await params;
+    const { nodeAddr } = await params;
+    const resolvedNodeEthAddr = resolveNodeEthAddress(nodeAddr);
 
-    if (!nodeEthAddr || !isAddress(nodeEthAddr) || isZeroAddress(nodeEthAddr)) {
+    if (!resolvedNodeEthAddr) {
         return <NotFound />;
     }
 
@@ -127,7 +153,7 @@ export default async function NodePage({ params }) {
 
     try {
         ({ license, licenseId, licenseType, owner, nodeResponse } = await fetchLicenseDetailsAndNodeAvailability(
-            nodeEthAddr,
+            resolvedNodeEthAddr,
             config.environment,
         ));
     } catch (error: any) {

lib/api/blockchain.ts

@@ -1,6 +1,7 @@
 'use server';
 
 import { ERC20Abi } from '@/blockchain/ERC20';
+import { MNDContractAbi } from '@/blockchain/MNDContract';
 import { NDContractAbi } from '@/blockchain/NDContract';
 import { ReaderAbi } from '@/blockchain/Reader';
 import config, { getCurrentEpoch, getEpochStartTimestamp, getNextEpochTimestamp } from '@/config';
@@ -66,10 +67,26 @@ export async function getNodeLicenseDetails(nodeAddress: types.EthAddress): Prom
             functionName: 'getNodeLicenseDetails',
             args: [nodeAddress],
         })
-        .then((result) => ({
-            ...result,
-            licenseType: [undefined, 'ND', 'MND', 'GND'][result.licenseType] as 'ND' | 'MND' | 'GND' | undefined,
-        }));
+        .then(async (result) => {
+            const licenseType = [undefined, 'ND', 'MND', 'GND'][result.licenseType] as 'ND' | 'MND' | 'GND' | undefined;
+            let firstMiningEpoch: bigint | undefined;
+            if (licenseType === 'MND') {
+                firstMiningEpoch = (
+                    await publicClient.readContract({
+                        address: config.mndContractAddress,
+                        abi: MNDContractAbi,
+                        functionName: 'licenses',
+                        args: [result.licenseId],
+                    })
+                )[3];
+            }
+
+            return {
+                ...result,
+                licenseType,
+                firstMiningEpoch,
+            };
+        });
 }
 
 export async function getLicense(licenseType: 'ND' | 'MND' | 'GND', licenseId: number | string): Promise<types.License> {
@@ -109,7 +126,7 @@ export async function getLicense(licenseType: 'ND' | 'MND' | 'GND', licenseId: n
                 functionName: 'getMndLicenseDetails',
                 args: [BigInt(licenseId)],
             })
-            .then((license) => {
+            .then(async (license) => {
                 const isLinked = !isZeroAddress(license.nodeAddress);
                 const licenseType = [undefined, 'ND', 'MND', 'GND'][license.licenseType] as 'ND' | 'MND' | 'GND' | undefined;
                 if (licenseType === undefined) {
@@ -118,11 +135,20 @@ export async function getLicense(licenseType: 'ND' | 'MND' | 'GND', licenseId: n
                 if (licenseType !== 'MND' && licenseType !== 'GND') {
                     throw new Error('Invalid license type');
                 }
+                const firstMiningEpoch = (
+                    await publicClient.readContract({
+                        address: config.mndContractAddress,
+                        abi: MNDContractAbi,
+                        functionName: 'licenses',
+                        args: [BigInt(licenseId)],
+                    })
+                )[3];
 
                 return {
                     ...license,
                     licenseType,
                     isLinked,
+                    firstMiningEpoch,
                 };
             });
     }
@@ -333,7 +359,7 @@ const getNdLicenseRewards = async (license: types.License, epochs: number[], epo
 };
 
 const getMndLicenseRewards = async (license: types.License, epochs: number[], epochs_vals: number[]): Promise<bigint> => {
-    return calculateLicenseRewards(license, epochs, epochs_vals, config.mndVestingEpochs, config.mndCliffEpochs);
+    return calculateMndLicenseRewards(license, epochs, epochs_vals);
 };
 
 const getGndLicenseRewards = async (license: types.License, epochs: number[], epochs_vals: number[]): Promise<bigint> => {
@@ -387,3 +413,62 @@ const calculateLicenseRewards = async (
     const maxRemainingClaimAmount = license.totalAssignedAmount - license.totalClaimedAmount;
     return rewards_amount < maxRemainingClaimAmount ? rewards_amount : maxRemainingClaimAmount;
 };
+
+const calculateMndLicenseRewards = async (license: types.License, epochs: number[], epochs_vals: number[]): Promise<bigint> => {
+    const currentEpoch = getCurrentEpoch();
+    const firstMiningEpoch = license.firstMiningEpoch;
+
+    if (firstMiningEpoch === undefined) {
+        throw new Error('First mining epoch is undefined for MND license');
+    }
+
+    const firstEpochToClaim =
+        Number(license.lastClaimEpoch) >= Number(firstMiningEpoch) ? Number(license.lastClaimEpoch) : Number(firstMiningEpoch);
+    const epochsToClaim = currentEpoch - firstEpochToClaim;
+
+    if (currentEpoch < Number(firstMiningEpoch) || !epochsToClaim) {
+        return 0n;
+    }
+
+    if (epochs.length && epochs[0] < firstEpochToClaim) {
+        const start = firstEpochToClaim - epochs[0];
+        epochs = epochs.slice(start);
+        epochs_vals = epochs_vals.slice(start);
+    }
+
+    if (epochsToClaim !== epochs.length || epochsToClaim !== epochs_vals.length) {
+        console.error(
+            `Invalid epochs array length. Received ${epochs.length} epochs, but there are ${epochsToClaim} epochs to claim.`,
+        );
+        return 0n;
+    }
+
+    let rewards_amount = 0n;
+    const logisticPlateau = 300_505239501691000000n; // 300.50
+    const licensePlateau = (license.totalAssignedAmount * BigInt(1e18)) / logisticPlateau;
+
+    for (let i = 0; i < epochsToClaim; i++) {
+        const maxRewardsPerEpoch = calculateMndMaxEpochRelease(epochs[i], firstMiningEpoch, licensePlateau);
+        rewards_amount += (maxRewardsPerEpoch * BigInt(epochs_vals[i])) / 255n;
+    }
+
+    const maxRemainingClaimAmount = license.totalAssignedAmount - license.totalClaimedAmount;
+    return rewards_amount > maxRemainingClaimAmount ? maxRemainingClaimAmount : rewards_amount;
+};
+
+const calculateMndMaxEpochRelease = (epoch: number, firstMiningEpoch: bigint, licensePlateau: bigint): bigint => {
+    let x = epoch - Number(firstMiningEpoch);
+    if (x > config.mndVestingEpochs) {
+        x = config.mndVestingEpochs;
+    }
+    const frac = logisticFraction(x);
+    return (licensePlateau * BigInt(frac * 1e18)) / BigInt(1e18);
+};
+
+const logisticFraction = (x: number): number => {
+    const length = config.mndVestingEpochs;
+    const k = 5.0;
+    const midPrc = 0.7;
+    const midpoint = length * midPrc;
+    return 1.0 / (1.0 + Math.exp((-k * (x - midpoint)) / length));
+};