@nosana/node 1.1.14-rc → 1.1.15

package/dist/src/NodeManager/monitoring/log/console/ConsoleLogger.js

@@ -21,6 +21,9 @@ export class ConsoleLogger {
         this.kill = false;
         this.benchmarking = false;
         this.taskManagerActive = false;
+        this.taskManagerLabel = '  RUNNING JOB  ';
+        this.taskManagerStartMethod = 'TaskManager.start';
+        this.benchmarkProgress = { completed: 0, total: 0 };
         this.running = false;
     }
     addObserver() {
@@ -30,7 +33,7 @@ export class ConsoleLogger {
         return this.isNode;
     }
     update(log, isNode = true) {
-        const renderBase = `${chalk.bgGreenBright.black.bold('  RUNNING JOB  ')} ${chalk.reset('')}`;
+        const renderBase = `${chalk.bgGreenBright.black.bold(this.taskManagerLabel)} ${chalk.reset('')}`;
         if (!this.kill && log.type == 'kill-process') {
             if (this.pending) {
                 this.spinner.stop();
@@ -70,7 +73,9 @@ export class ConsoleLogger {
                 this.expiry = log.payload?.expiry;
             }
             // --- TaskManager quiet window ---
-            if (log.method === 'TaskManager.start' && log.type === 'process') {
+            if ((log.method === 'TaskManager.start' ||
+                log.method === 'BenchmarkTaskManager.start') &&
+                log.type === 'process') {
                 // Stop anything currently animating
                 if (this.pending)
                     this.spinner.stop();
@@ -78,11 +83,22 @@ export class ConsoleLogger {
                     this.progressBar.stop();
                 if (this.multiProgressBar)
                     this.multiProgressBar.stop();
+                this.taskManagerStartMethod = log.method;
+                this.taskManagerLabel =
+                    log.method === 'BenchmarkTaskManager.start'
+                        ? '  COLLECTING METRICS  '
+                        : '  RUNNING JOB  ';
+                const activeRenderBase = `${chalk.bgGreenBright.black.bold(this.taskManagerLabel)} ${chalk.reset('')}`;
                 this.taskManagerActive = true;
                 this.pending = true;
                 this.expiry = log.payload?.expiry;
                 const startTime = Date.now();
-                const renderBar = (duration = 0) => `${renderBase} ${chalk.bgYellow.black.bold(`  ⏱ Duration: ${formatTime(duration)}  `)} ${chalk.reset('')} ${chalk.bgBlue.black.bold(`  ⚡ Max Duration: ${formatTime(this.expiry ?? 0)}  `)}`;
+                const isBenchmark = log.method === 'BenchmarkTaskManager.start';
+                if (isBenchmark)
+                    this.benchmarkProgress = { completed: 0, total: 0 };
+                const renderBar = (duration = 0) => isBenchmark
+                    ? `${activeRenderBase} ${chalk.bgYellow.black.bold(`  Ops: ${this.benchmarkProgress.completed}/${this.benchmarkProgress.total}  `)} ${chalk.reset('')}`
+                    : `${activeRenderBase} ${chalk.bgYellow.black.bold(`  ⏱ Duration: ${formatTime(duration)}  `)} ${chalk.reset('')} ${chalk.bgBlue.black.bold(`  ⚡ Max Duration: ${formatTime(this.expiry ?? 0)}  `)}`;
                 this.spinner = ora(renderBar(0)).start();
                 this.taskManagerRunInterval = setInterval(() => {
                     if (this.taskManagerActive) {
@@ -98,12 +114,24 @@ export class ConsoleLogger {
             }
             // While TaskManager is active, swallow all logs except the stop signal
             if (this.taskManagerActive) {
-                if (log.method === 'TaskManager.start') {
-                    this.spinner.succeed(renderBase + ` Ending ${log.job}...`);
+                if (log.method === this.taskManagerStartMethod) {
+                    const endingSuffix = this.taskManagerStartMethod === 'BenchmarkTaskManager.start'
+                        ? ' Completed'
+                        : ` Ending ${log.job}...`;
+                    this.spinner.succeed(renderBase + endingSuffix);
                     this.taskManagerActive = false;
                     this.pending = false;
                     return;
                 }
+                if (log.method === 'BenchmarkTaskManager.progress' &&
+                    this.taskManagerStartMethod === 'BenchmarkTaskManager.start') {
+                    const { completed, total } = log.payload ?? {};
+                    if (typeof completed === 'number' && typeof total === 'number') {
+                        this.benchmarkProgress = { completed, total };
+                        this.spinner.text = `${renderBase} ${chalk.bgYellow.black.bold(`  Ops: ${completed}/${total}  `)} ${chalk.reset('')}`;
+                    }
+                    return;
+                }
                 // Still inside TaskManager window: block other logs
                 return;
             }

package/dist/src/NodeManager/monitoring/ping/PingHandler.d.ts

@@ -2,12 +2,10 @@ export declare const ping: () => Promise<PingHandler>;
 export declare class PingHandler {
     private timeoutId;
     private intervalSeconds;
-    private sdk;
-    private address;
-    constructor();
+    private stopped;
     start(): Promise<void>;
     private scheduleNextPing;
     private ping;
-    private getAuthSignature;
+    private getHeartbeatRetryAfterSeconds;
     stop(): void;
 }

package/dist/src/NodeManager/monitoring/ping/PingHandler.js

@@ -1,5 +1,4 @@
-import { getSDK } from '../../sdk/index.js';
-import { configs } from '../../configs/configs.js';
+import { HostManager } from '../../node/market/hostManager.js';
 export const ping = (() => {
     let instance = null;
     return async () => {
@@ -14,18 +13,20 @@ export class PingHandler {
     constructor() {
         this.timeoutId = null;
         this.intervalSeconds = 30;
-        this.sdk = getSDK();
-        this.address = this.sdk.solana.provider.wallet.publicKey;
+        this.stopped = false;
     }
     async start() {
         if (this.timeoutId)
             return;
-        // start with an immediate ping
+        this.stopped = false;
         await this.scheduleNextPing(Date.now());
     }
     async scheduleNextPing(expectedTime) {
-        await this.ping();
-        const nextExpected = expectedTime + this.intervalSeconds * 1000;
+        const { retryAfterSeconds } = await this.ping();
+        if (this.stopped)
+            return;
+        const intervalSeconds = retryAfterSeconds ?? this.intervalSeconds;
+        const nextExpected = expectedTime + intervalSeconds * 1000;
         const delay = Math.max(nextExpected - Date.now(), 0);
         this.timeoutId = setTimeout(() => {
             this.scheduleNextPing(nextExpected);
@@ -33,33 +34,37 @@ export class PingHandler {
     }
     async ping() {
         try {
-            const response = await fetch(`${configs().backendUrl}/nodes/heartbeat`, {
-                method: 'POST',
-                headers: {
-                    Authorization: `${this.address}:${await this.getAuthSignature()}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ ping: 'pong' }),
-            });
-            if (response.ok) {
-                const json = await response.json();
-                if (json.maxHeartbeatsPerDay) {
-                    const newInterval = Math.floor((24 * 60 * 60) / json.maxHeartbeatsPerDay);
-                    if (newInterval !== this.intervalSeconds) {
-                        this.intervalSeconds = newInterval;
-                    }
-                }
+            const response = await HostManager.sendHeartbeat();
+            if (response.maxHeartbeatsPerDay) {
+                this.intervalSeconds = Math.floor((24 * 60 * 60) / response.maxHeartbeatsPerDay);
             }
+            return {};
         }
         catch (err) {
+            if (err instanceof Error && err.message.includes('Node not found')) {
+                return {};
+            }
+            const retryAfterSeconds = this.getHeartbeatRetryAfterSeconds(err);
+            if (retryAfterSeconds !== null) {
+                return { retryAfterSeconds };
+            }
             console.error('Ping failed:', err);
+            return {};
         }
     }
-    async getAuthSignature() {
-        const signature = (await this.sdk.solana.signMessage(configs().signMessage));
-        return Buffer.from(signature).toString('base64');
+    getHeartbeatRetryAfterSeconds(err) {
+        if (!(err instanceof Error))
+            return null;
+        const match = err.message.match(/next heartbeat in (\d+) seconds/i);
+        if (!match)
+            return null;
+        const retryAfterSeconds = Number.parseInt(match[1], 10);
+        return Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0
+            ? retryAfterSeconds
+            : null;
     }
     stop() {
+        this.stopped = true;
         if (this.timeoutId) {
             clearTimeout(this.timeoutId);
             this.timeoutId = null;

package/dist/src/NodeManager/monitoring/proxy/loggingProxy.d.ts

@@ -9,7 +9,8 @@ export interface LogEntry {
     type: 'call' | 'return' | 'error';
     result?: any;
     error?: any;
+    payload?: any;
 }
 export declare function applyLoggingProxyToClass(instance: any): void;
-export declare function createLoggingProxy<T extends object>(target: T): T;
+export declare function createLoggingProxy<T extends object>(target: T, classNameOverride?: string): T;
 export declare function createFunctionLoggingProxy<T extends (...args: any[]) => any>(func: T, classLabel?: string): T;

package/dist/src/NodeManager/monitoring/proxy/loggingProxy.js

@@ -17,7 +17,6 @@ export function applyLoggingProxyToClass(instance) {
         'healthHandler',
         'stakeHandler',
         'expiryHandler',
-        'specsHandler',
         'progressBarReporter',
         'registerHandler',
     ];
@@ -28,8 +27,8 @@ export function applyLoggingProxyToClass(instance) {
         }
     });
 }
-export function createLoggingProxy(target) {
-    const className = Object.getPrototypeOf(target).constructor.name;
+export function createLoggingProxy(target, classNameOverride) {
+    const className = classNameOverride ?? Object.getPrototypeOf(target).constructor.name;
     const formatArguments = (args) => {
         return args.map((arg) => {
             if (typeof arg === 'function') {

package/dist/src/NodeManager/node/Node.d.ts

@@ -1,12 +1,11 @@
+import { Market } from '@nosana/sdk';
 import { ApiHandler } from './api/ApiHandler.js';
 export declare class BasicNode {
-    isOnboarded: boolean;
     private apiHandler;
     private balanceHandler;
     private runHandler;
     private marketHandler;
     private jobHandler;
-    private specsHandler;
     private keyHandler;
     private healthHandler;
     private expiryHandler;
@@ -22,9 +21,8 @@ export declare class BasicNode {
         [key: string]: any;
     });
     register(): Promise<void>;
-    healthcheck(market: string): Promise<boolean>;
-    specs(): Promise<boolean>;
-    recommend(): Promise<string>;
+    healthcheck(): Promise<boolean>;
+    requestMarket(market?: string): Promise<Market>;
     api(): ApiHandler;
     isApiActive(): Promise<boolean>;
     node(): string;
@@ -32,7 +30,7 @@ export declare class BasicNode {
     stop(): Promise<void>;
     clean(): Promise<void>;
     start(): Promise<void>;
-    setup(market: string): Promise<void>;
+    setup(market: Market): Promise<void>;
     run(): Promise<void>;
     pending(): Promise<boolean>;
     queue(market?: string): Promise<void>;

package/dist/src/NodeManager/node/Node.js

@@ -1,14 +1,13 @@
 import { getSDK } from '../sdk/index.js';
 import { MarketHandler } from './market/marketHandler.js';
+import { NodeNotRegisteredError } from '../errors/NodeNotRegisteredError.js';
 import { RunHandler } from './run/runHandler.js';
 import { JobHandler } from './job/jobHandler.js';
 import { DB } from '../db/index.js';
 import { Provider } from '../provider/Provider.js';
 import { applyLoggingProxyToClass } from '../monitoring/proxy/loggingProxy.js';
-import { isNodeOnboarded } from '../utils/utils.js';
 import { ApiHandler } from './api/ApiHandler.js';
 import { NodeRepository } from '../repository/NodeRepository.js';
-import { SpecsHandler } from './specs/specsHandler.js';
 import { HealthHandler } from './health/healthHandler.js';
 import { KeyHandler } from './key/keyHandler.js';
 import { ExpiryHandler } from './expiry/expiryHandler.js';
@@ -24,7 +23,6 @@ import { TaskManagerRegistry } from './task/TaskManagerRegistry.js';
 import { StopReasons } from './task/TaskManager.js';
 export class BasicNode {
     constructor(options) {
-        this.isOnboarded = false;
         this.exiting = false;
         this.sdk = getSDK();
         const db = new DB(options.config).db;
@@ -35,39 +33,35 @@ export class BasicNode {
         this.apiHandler = new ApiHandler(this.sdk, this.repository, this.provider, options.port);
         this.balanceHandler = new BalanceHandler(this.sdk);
         this.gridHandler = new GridHandler(this.sdk, this.repository);
-        this.specsHandler = new SpecsHandler(this.provider, this.repository, this.sdk);
         this.jobHandler = new JobHandler(this.sdk, this.provider, this.repository);
-        this.marketHandler = new MarketHandler(this.sdk);
+        this.marketHandler = new MarketHandler(this.sdk, this.provider, this.repository);
         this.runHandler = new RunHandler(this.sdk);
         this.keyHandler = new KeyHandler(this.sdk);
         this.healthHandler = new HealthHandler(this.sdk, this.containerOrchestration, this.marketHandler, this.keyHandler);
-        this.registerHandler = new RegisterHandler(this.sdk, this.provider, this.repository);
+        this.registerHandler = new RegisterHandler();
         this.expiryHandler = new ExpiryHandler(this.sdk);
         applyLoggingProxyToClass(this);
     }
     async register() {
         await this.registerHandler.register();
     }
-    async healthcheck(market) {
+    async healthcheck() {
         /**
          * run health check,
          */
-        return await this.healthHandler.run(market);
+        return await this.healthHandler.run();
     }
-    async specs() {
-        /**
-         * check the system using a premade job definitions
-         * run dependent on market status
-         */
-        return await this.specsHandler.check();
-    }
-    async recommend() {
-        /**
-         * this means even tho we have been onboarded there might be no market assigned to us
-         * or we need to check if we are still in the right market,
-         * so we need to get a recommended one and return it
-         */
-        return await this.gridHandler.recommend();
+    async requestMarket(market) {
+        try {
+            return await this.marketHandler.request(market);
+        }
+        catch (error) {
+            if (error instanceof NodeNotRegisteredError) {
+                await this.registerHandler.register();
+                return await this.marketHandler.request(market);
+            }
+            throw error;
+        }
     }
     api() {
         return this.apiHandler;
@@ -101,13 +95,6 @@ export class BasicNode {
         nodeAbortControllerSelector().refresh();
     }
     async start() {
-        /**
-         * we query the grid to find out if the node has already been onboarded
-         * if it has been onboarded it might have been assigned/recommended a market
-         * if it has not been onboarded quit the process
-         */
-        const nodeData = await this.gridHandler.getNodeStatus();
-        this.isOnboarded = isNodeOnboarded(nodeData.status);
         if (await this.balanceHandler.balance()) {
             await this.balanceHandler.check(true);
         }

package/dist/src/NodeManager/node/api/ApiHandler.js

@@ -6,8 +6,8 @@ import { configs } from '../../configs/configs.js';
 import { sleep } from '../../utils/utils.js';
 import { stateStreaming } from '../../monitoring/streaming/StateStreamer.js';
 import { applyLoggingProxyToClass } from '../../monitoring/proxy/loggingProxy.js';
-import { verifyBackendSignatureMiddleware, verifyJobOwnerSignatureMiddleware, verifyWSJobOwnerSignatureMiddleware, verifyWSNodeOrJobOwnerSignatureMiddleware, } from './middlewares/index.js';
-import { getNodeInfoRoute, getJobResultsRoute, getServiceUrlRoute, postJobDefinitionRoute, postServiceStopRoute, postNodeValidation, wssLogRoute, wssStatusRoute, getCurrentGroupStatusHandler, getGroupStatusHandler, getOperationsStatusHandler, getOperationStatusHandler, restartGroupOperationHandler, restartOperationHandler, stopGroupOperationHandler, stopOperationHandler, wssTaskManagerLogRoute, moveGroupOperationHandler, getJobDefinitionRoute, getJobInfoRoute, getJobStatsRoute, getJobStatsStreamRoute, } from './routes/index.js';
+import { verifyJobOwnerSignatureMiddleware, verifyWSJobOwnerSignatureMiddleware, verifyWSNodeOrJobOwnerSignatureMiddleware, } from './middlewares/index.js';
+import { getNodeInfoRoute, getJobResultsRoute, getServiceUrlRoute, postJobDefinitionRoute, postServiceStopRoute, wssLogRoute, wssStatusRoute, getCurrentGroupStatusHandler, getGroupStatusHandler, getOperationsStatusHandler, getOperationStatusHandler, restartGroupOperationHandler, restartOperationHandler, stopGroupOperationHandler, stopOperationHandler, wssTaskManagerLogRoute, moveGroupOperationHandler, getJobDefinitionRoute, getJobInfoRoute, getJobStatsRoute, getJobStatsStreamRoute, } from './routes/index.js';
 import { NodeAlreadyActiveError } from '../../errors/NodeAlreadyActiveError.js';
 export class ApiHandler {
     constructor(sdk, repository, provider, port) {
@@ -146,7 +146,6 @@ export class ApiHandler {
         this.api.get('/job/:jobId/stats', getJobStatsRoute);
         this.api.get('/job/:jobId/stats/stream', getJobStatsStreamRoute);
         // POST Routes
-        this.api.post('/node/validate', verifyBackendSignatureMiddleware, postNodeValidation);
         this.api.post('/job/:jobId/job-definition', postJobDefinitionRoute);
         this.api.post('/job/:jobId/group/:group/move', moveGroupOperationHandler);
         this.api.post('/job/:jobId/group/:group/operation/:opId/restart', restartOperationHandler);

package/dist/src/NodeManager/node/api/middlewares/index.d.ts

@@ -1,4 +1,3 @@
-export * from './rest/verifyBackendSignatureMiddleware.js';
 export * from './rest/verifyJobOwnerSignatureMiddleware.js';
 export * from './ws/verifyWSJobOwnerSignatureMiddleware.js';
 export * from './ws/verifyWSNodeOrJobOwnerSignatureMiddleware.js';

package/dist/src/NodeManager/node/api/middlewares/index.js

@@ -1,5 +1,4 @@
 // REST API MIDDLEWARE
-export * from './rest/verifyBackendSignatureMiddleware.js';
 export * from './rest/verifyJobOwnerSignatureMiddleware.js';
 // WEBSOCKET MIDDLEWARE
 export * from './ws/verifyWSJobOwnerSignatureMiddleware.js';

package/dist/src/NodeManager/node/api/routes/post/index.d.ts

@@ -1,4 +1,3 @@
-export * from './node-validation.js';
 export * from './job-definition.js';
 export * from './service-stop.js';
 export * from './job-operation-actions.js';

package/dist/src/NodeManager/node/api/routes/post/index.js

@@ -1,4 +1,3 @@
-export * from './node-validation.js';
 export * from './job-definition.js';
 export * from './service-stop.js';
 export * from './job-operation-actions.js';

package/dist/src/NodeManager/node/grid/gridHandler.d.ts

@@ -1,5 +1,5 @@
-import { Client as SDK } from '@nosana/sdk';
-import { NodeRepository } from '../../repository/NodeRepository.js';
+import { Client as SDK } from "@nosana/sdk";
+import { NodeRepository } from "../../repository/NodeRepository.js";
 export interface NodeData {
     market?: string;
     status: string;
@@ -9,11 +9,5 @@ export declare class GridHandler {
     private repository;
     private address;
     constructor(sdk: SDK, repository: NodeRepository);
-    private getAuthSignature;
     getNodeStatus(): Promise<NodeData>;
-    recommend(): Promise<any>;
-    private changeMarket;
-    private signAndSendTransaction;
-    private confirmTransaction;
-    private syncNodeAfterMint;
 }

package/dist/src/NodeManager/node/grid/gridHandler.js

@@ -1,8 +1,5 @@
-import { applyLoggingProxyToClass } from '../../monitoring/proxy/loggingProxy.js';
-import { VersionedTransaction, } from '@solana/web3.js';
-import { getRawTransaction } from '../../sdk/index.js';
-import { sleep } from '../../utils/utils.js';
-import { configs } from '../../configs/configs.js';
+import { applyLoggingProxyToClass } from "../../monitoring/proxy/loggingProxy.js";
+import { HostManager } from '../market/hostManager.js';
 export class GridHandler {
     constructor(sdk, repository) {
         this.sdk = sdk;
@@ -10,159 +7,29 @@ export class GridHandler {
         this.address = this.sdk.solana.provider.wallet.publicKey;
         applyLoggingProxyToClass(this);
     }
-    async getAuthSignature() {
-        const signature = (await this.sdk.solana.signMessage(configs().signMessage));
-        return Buffer.from(signature).toString('base64');
-    }
     async getNodeStatus() {
         try {
-            const response = await fetch(`${configs().backendUrl}/nodes/${this.address}`, {
-                method: 'GET',
-                headers: {
-                    Authorization: `${this.address}:${await this.getAuthSignature()}`,
-                    'Content-Type': 'application/json',
-                },
-            });
-            const data = await response.json();
-            if (!data || (data.name === 'Error' && data.message))
-                throw new Error(data.message);
+            const data = await HostManager.getNode(this.address.toString());
+            if (!data)
+                throw new Error('Node not found');
             return {
                 status: data.status,
-                market: data.marketAddress,
+                market: data.marketAddress ?? undefined,
             };
         }
         catch (error) {
             if (error instanceof Error &&
-                error.message.includes('Node not onboarded yet')) {
-                throw new Error('Node is still on the waitlist, wait until you are accepted.');
+                error.message.includes("Node not onboarded yet")) {
+                throw new Error("Node is still on the waitlist, wait until you are accepted.");
             }
             else if (error instanceof Error &&
-                !error.message.includes('Node not found')) {
+                !error.message.includes("Node not found")) {
                 throw error;
             }
             return {
-                status: 'not-found',
+                status: "not-found",
                 market: undefined,
             };
         }
     }
-    async recommend() {
-        const gpus = this.repository.getNodeInfo().gpus;
-        const signature = await this.getAuthSignature();
-        try {
-            const response = await fetch(`${configs().backendUrl}/nodes/${this.address}/check-market`, {
-                method: 'POST',
-                headers: {
-                    Authorization: `${this.address}:${signature}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ gpus: JSON.stringify(gpus) }),
-            });
-            let data = await response.json();
-            if (!data) {
-                throw new Error('Something went wrong with recommending the market, please try again.');
-            }
-            if (data.needsChangeMarket) {
-                data = await this.changeMarket();
-                return data.newMarket;
-            }
-            if (data.address) {
-                return data.address;
-            }
-            if (data.message) {
-                throw new Error(data.message);
-            }
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async changeMarket() {
-        try {
-            const response = await fetch(`${configs().backendUrl}/nodes/change-market`, {
-                method: 'POST',
-                headers: {
-                    Authorization: `${this.address}:${await this.getAuthSignature()}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ address: this.address }),
-            });
-            const data = await response.json();
-            if (!data || data.name === 'Error')
-                throw new Error(data.message);
-            // Incase of blockheight exceeded error, retry 3 times
-            for (let i = 0; i < 3; i++) {
-                try {
-                    const txnSignature = await this.signAndSendTransaction(data.tx);
-                    await this.confirmTransaction(txnSignature);
-                    break;
-                }
-                catch (error) {
-                    if (i === 2 ||
-                        !error?.message.includes('TransactionExpiredBlockheightExceededError')) {
-                        throw error;
-                    }
-                }
-            }
-            // TODO: verify tx result with code below
-            // const result = await this.sdk.solana.connection?.getTransaction(
-            //   txnSignature as string,
-            //   { maxSupportedTransactionVersion: 0 },
-            // );
-            // // @ts-ignore
-            // if (result?.meta?.status.Err) {
-            //   // @ts-ignore
-            //   throw new Error(JSON.stringify(result?.meta?.status.Err));
-            // }
-            await sleep(30);
-            await this.syncNodeAfterMint();
-            return data;
-        }
-        catch (error) {
-            throw new Error('Something went wrong with minting your access key, please try again. ' +
-                error);
-        }
-    }
-    async signAndSendTransaction(txData) {
-        const feePayer = (this.sdk.solana.provider?.wallet).payer;
-        const recoveredTransaction = await getRawTransaction(Uint8Array.from(Object.values(txData)));
-        if (recoveredTransaction instanceof VersionedTransaction) {
-            recoveredTransaction.sign([feePayer]);
-        }
-        else {
-            recoveredTransaction.partialSign(feePayer);
-        }
-        const txnSignature = await this.sdk.solana.connection?.sendRawTransaction(recoveredTransaction.serialize());
-        return txnSignature;
-    }
-    async confirmTransaction(txnSignature) {
-        const latestBlockHash = await this.sdk.solana.connection?.getLatestBlockhash();
-        if (latestBlockHash && txnSignature) {
-            const confirmStrategy = {
-                blockhash: latestBlockHash.blockhash,
-                lastValidBlockHeight: latestBlockHash.lastValidBlockHeight,
-                signature: txnSignature,
-            };
-            await this.sdk.solana.connection?.confirmTransaction(confirmStrategy);
-        }
-        else {
-            throw new Error('Could not confirm minting transaction');
-        }
-    }
-    async syncNodeAfterMint() {
-        try {
-            const response = await fetch(`${configs().backendUrl}/nodes/sync-node`, {
-                method: 'POST',
-                headers: {
-                    Authorization: `${this.address}:${await this.getAuthSignature()}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ address: this.address }),
-            });
-            return response.json();
-        }
-        catch (error) {
-            throw error;
-        }
-    }
 }

package/dist/src/NodeManager/node/health/healthHandler.d.ts

@@ -11,6 +11,6 @@ export declare class HealthHandler {
     private balanceHandler;
     private stakeHandler;
     constructor(sdk: SDK, containerOrchestration: ContainerOrchestrationInterface, marketHandler: MarketHandler, keyHandler: KeyHandler);
-    run(market: string): Promise<boolean>;
+    run(): Promise<boolean>;
     stake(market: Market): Promise<boolean>;
 }

package/dist/src/NodeManager/node/health/healthHandler.js

@@ -13,13 +13,13 @@ export class HealthHandler {
         this.stakeHandler = new StakeHandler(this.sdk);
         applyLoggingProxyToClass(this);
     }
-    async run(market) {
+    async run() {
         /**
          * market health check,
          *
          * check if the market supplied is valid and can be joined
          */
-        const marketAccount = await this.marketHandler.check(market);
+        const marketAccount = await this.marketHandler.getMarket();
         /**
          * balances (SOL) health check
          *
@@ -29,15 +29,17 @@ export class HealthHandler {
         if (await this.balanceHandler.balance()) {
             await this.balanceHandler.check();
         }
-        /**
-         * staking healtcheck, check if market can be joined or staking is needed
-         */
-        await this.stake(marketAccount);
-        /**
-         * health check on market access key
-         */
-        if (this.keyHandler.doesMarketNeedAccessKey(marketAccount)) {
-            await this.keyHandler.loadAccessKeyFromChain(marketAccount);
+        if (marketAccount) {
+            /**
+             * staking healtcheck, check if market can be joined or staking is needed
+             */
+            await this.stake(marketAccount);
+            /**
+             * health check on market access key
+             */
+            if (this.keyHandler.doesMarketNeedAccessKey(marketAccount)) {
+                await this.keyHandler.loadAccessKeyFromChain(marketAccount);
+            }
         }
         /**
          * health check for provider (docker or podman) health