Squashed commit of the following:

commit d5dda83
Author: wzrdx <128477299+wzrdx@users.noreply.github.com>
Date:   Fri Aug 29 18:07:50 2025 +0300

    hotfix: Fix fetchRunningJobsWithAliases when 2 apps are deployed on 2 nodes

commit d591348
Author: wzrdx <128477299+wzrdx@users.noreply.github.com>
Date:   Fri Aug 29 17:42:01 2025 +0300

    hotfix: Use getMultiNodeEpochsRange in fetchOraclesCount

commit 7118012
Merge: b0c3b3f 724652c
Author: wzrdx <128477299+wzrdx@users.noreply.github.com>
Date:   Fri Aug 29 17:20:55 2025 +0300

    Merge branch 'main' into develop

commit b0c3b3f
Author: wzrdx <128477299+wzrdx@users.noreply.github.com>
Date:   Thu Aug 28 17:50:32 2025 +0300

    hotfix: Use tunneling secrets from TunnelsContext, fix the UX of deleting a tunnel with hostname

commit 619c405
Author: wzrdx <128477299+wzrdx@users.noreply.github.com>
Date:   Thu Aug 28 15:46:19 2025 +0300

    hotfix: Always fetch secrets, modify secrets feature

Author: wzrdx

src/lib/api/oracles.tsx

@@ -26,12 +26,21 @@ export const getNodeInfo = (
     node_is_online: boolean;
 }> => getNodeLastEpoch(nodeAddress).then(({ node_alias, node_is_online }) => ({ node_alias, node_is_online }));
 
+export const getMultiNodeEpochsRange = (nodesWithRanges: Record<types.EthAddress, [number, number]>) => {
+    return _doPost<types.OraclesDefaultResult & Record<types.EthAddress, types.OraclesAvailabilityResult>>(
+        '/multi_node_epochs_range',
+        {
+            dct_eth_nodes_request: nodesWithRanges,
+        },
+    );
+};
+
 // *****
 // INTERNAL HELPERS
 // *****
 
 async function _doGet<T>(endpoint: string) {
-    const { data } = await axiosOracles.get<{
+    const { data } = await axiosInstance.get<{
         result: (
             | {
                   error: string;
@@ -51,15 +60,32 @@ async function _doGet<T>(endpoint: string) {
     return data.result;
 }
 
-const axiosOracles = axios.create({
+async function _doPost<T>(endpoint: string, body: any) {
+    const { data } = await axiosInstance.post<{
+        result: types.OraclesDefaultResult &
+            (
+                | {
+                      error: string;
+                  }
+                | T
+            );
+        node_addr: `0xai${string}`;
+    }>(endpoint, body);
+    if ('error' in data.result) {
+        throw new Error(data.result.error);
+    }
+    return data.result;
+}
+
+const axiosInstance = axios.create({
     baseURL: oraclesUrl,
     headers: {
         Accept: 'application/json',
         'Content-Type': 'application/json',
     },
 });
 
-axiosOracles.interceptors.response.use(
+axiosInstance.interceptors.response.use(
     (response) => {
         return response;
     },

src/lib/config.ts

@@ -89,4 +89,4 @@ export const getDevAddress = (): {
     address: import.meta.env.VITE_DEV_ADDRESS,
 });
 
-export const isUsingDevAddress = process.env.NODE_ENV === 'development' && false; // TODO: false
+export const isUsingDevAddress = process.env.NODE_ENV === 'development' && true; // TODO: false

src/lib/contexts/deployment/deployment-provider.tsx

@@ -107,25 +107,34 @@ export const DeploymentProvider = ({ children }) => {
             functionName: 'getAllJobs',
         });
 
-        console.log('[DeploymentProvider] SC jobs', runningJobs);
+        console.log('[DeploymentProvider] Smart contract jobs', runningJobs);
+
+        const uniqueAppsWithAliases = _(Object.values(apps))
+            .map((nodeApps) => {
+                return Object.entries(nodeApps).map(([alias, app]) => {
+                    return {
+                        alias,
+                        ...app,
+                    };
+                });
+            })
+            .flatten()
+            .filter((app) => app.is_deeployed)
+            .uniqBy((app) => app.alias)
+            .value();
 
-        let jobsWithAliases: RunningJobWithAlias[] = _(Object.values(apps))
-            .map((app) => {
-                const alias: string = Object.keys(app)[0];
-                const isDeployed = app[alias].is_deeployed;
+        console.log('[DeploymentProvider] Unique deployed apps with aliases', uniqueAppsWithAliases);
 
-                if (!isDeployed) {
-                    console.log('[DeploymentProvider] Job not deployed yet, filtering out', app);
-                    return null;
-                }
-
-                const specs = app[alias].deeploy_specs;
+        const jobsWithAliases: RunningJobWithAlias[] = _(uniqueAppsWithAliases)
+            .map((appWithAlias) => {
+                const alias: string = appWithAlias.alias;
+                const specs = appWithAlias.deeploy_specs;
                 const jobId = specs.job_id;
 
                 const job = runningJobs.find((job) => Number(job.id) === jobId && job.projectHash === specs.project_id);
 
                 if (!job) {
-                    console.log('[DeploymentProvider] Job not found in SC, filtering out', alias, app);
+                    console.log(`[DeploymentProvider] App ${alias} has no matching job in the smart contract`, appWithAlias);
                     return null;
                 }
 
@@ -138,11 +147,7 @@ export const DeploymentProvider = ({ children }) => {
             .filter((job) => job !== null)
             .value();
 
-        console.log('[DeploymentProvider] Jobs before filtering for uniqueness', jobsWithAliases);
-
-        jobsWithAliases = _.uniqBy(jobsWithAliases, (job) => job.alias);
-
-        console.log('[DeploymentProvider] Unique jobs with running apps data', jobsWithAliases);
+        console.log('[DeploymentProvider] Running jobs with aliases', jobsWithAliases);
 
         return jobsWithAliases;
     };

src/pages/Login.tsx

@@ -3,11 +3,12 @@ import { PoAIManagerAbi } from '@blockchain/PoAIManager';
 import LoginCard from '@components/auth/LoginCard';
 import RestrictedAccess from '@components/auth/RestrictedAccess';
 import { Spinner } from '@heroui/spinner';
-import { getNodeLastEpoch } from '@lib/api/oracles';
-import { config, environment, getDevAddress, isUsingDevAddress } from '@lib/config';
+import { getMultiNodeEpochsRange } from '@lib/api/oracles';
+import { config, environment, getCurrentEpoch, getDevAddress, isUsingDevAddress } from '@lib/config';
 import { AuthenticationContextType, useAuthenticationContext } from '@lib/contexts/authentication';
 import { BlockchainContextType, useBlockchainContext } from '@lib/contexts/blockchain';
 import { DeploymentContextType, useDeploymentContext } from '@lib/contexts/deployment';
+import { isZeroAddress } from '@lib/utils';
 import { EthAddress } from '@typedefs/blockchain';
 import { ConnectKitButton, useModal } from 'connectkit';
 import { useEffect, useState } from 'react';
@@ -78,9 +79,26 @@ function Login() {
         }
 
         console.log('Checking oracle ownership...');
-        const licenses = await fetchLicenses();
-        const availabilities = await Promise.all(licenses.map((license) => getNodeLastEpoch(license.nodeAddress)));
+
+        const linkedLicenses = (await fetchLicenses()).filter((license) => !isZeroAddress(license.nodeAddress));
+        const currentEpoch = getCurrentEpoch();
+
+        const nodesWithRanges = linkedLicenses.reduce(
+            (acc, license) => {
+                acc[license.nodeAddress] = [currentEpoch - 1, currentEpoch - 1];
+                return acc;
+            },
+            {} as Record<EthAddress, [number, number]>,
+        );
+
+        if (Object.keys(nodesWithRanges).length === 0) {
+            return 0;
+        }
+
+        const response = await getMultiNodeEpochsRange(nodesWithRanges);
+        const availabilities = linkedLicenses.map((license) => response[license.nodeAddress]);
         const oracles = availabilities.filter((nodeResponse) => nodeResponse.node_is_oracle);
+
         console.log(`User owns ${oracles.length} oracle${oracles.length === 1 ? '' : 's'}`);
 
         return oracles.length;