@nosana/node 1.0.0-rc

package/dist/NodeManager/node/job/defination/JobDefinitionStrategy.js

@@ -0,0 +1,21 @@
+import ApiEventEmitter from '../../api/ApiEventEmitter.js';
+import { ApiListenJobDefinitionStrategy } from './strategy/ApiListenJobDefinitionStrategy.js';
+import { ApiJobDefinitionStrategy } from './strategy/ApiJobDefinitionStrategy.js';
+export class JobDefinitionStrategySelector {
+    constructor() { }
+    /**
+     * Selects the appropriate JobDefinitionStrategy based on the name.
+     * @param name - The name/type of the strategy ('api-listen' or 'api').
+     * @returns JobDefinitionStrategy
+     */
+    selectStrategy(name) {
+        switch (name) {
+            case 'api-listen':
+                return new ApiListenJobDefinitionStrategy(ApiEventEmitter.getInstance());
+            case 'api':
+                return new ApiJobDefinitionStrategy(); // assuming you have an ApiJobDefinitionStrategy
+            default:
+                throw new Error(`Unsupported strategy: ${name}`);
+        }
+    }
+}

package/dist/NodeManager/node/job/defination/strategy/ApiJobDefinitionStrategy.d.ts

@@ -0,0 +1,8 @@
+import { SendJobDefinationLogicstics, JobDefinition } from '@nosana/sdk';
+import { JobDefinitionStrategy } from '../JobDefinitionStrategy.js';
+export declare class ApiJobDefinitionStrategy implements JobDefinitionStrategy {
+    private attempts;
+    private jobDefinition;
+    private retrieveJobDefinition;
+    load(jobId: string, args: SendJobDefinationLogicstics['args']): Promise<JobDefinition>;
+}

package/dist/NodeManager/node/job/defination/strategy/ApiJobDefinitionStrategy.js

@@ -0,0 +1,40 @@
+import { sleep } from '@nosana/sdk';
+import { getSDK } from '../../../../sdk/index.js';
+export class ApiJobDefinitionStrategy {
+    constructor() {
+        this.attempts = 0;
+        this.jobDefinition = undefined;
+    }
+    async retrieveJobDefinition(endpoint, headers) {
+        if (this.attempts > 3)
+            return;
+        this.attempts += 1;
+        try {
+            const response = await fetch(endpoint, {
+                method: 'GET',
+                headers,
+            });
+            if (response.ok) {
+                this.jobDefinition = await response.json();
+            }
+        }
+        catch { }
+        if (!this.jobDefinition) {
+            await sleep(10);
+            await this.retrieveJobDefinition(endpoint, headers);
+        }
+    }
+    async load(jobId, args) {
+        if (!args.endpoint)
+            throw new Error('Api Job definition logistic requires an endpoint.');
+        const endpoint = args.endpoint.replace('%%global.job%%', jobId);
+        const headers = await getSDK().authorization.generateHeader(jobId, {
+            includeTime: true,
+        });
+        await this.retrieveJobDefinition(endpoint, headers);
+        if (!this.jobDefinition) {
+            throw new Error(`Failed to retrieve job definition from ${endpoint}.`);
+        }
+        return this.jobDefinition;
+    }
+}

package/dist/NodeManager/node/job/defination/strategy/ApiListenJobDefinitionStrategy.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { JobDefinitionStrategy } from '../JobDefinitionStrategy.js';
+import { JobDefinition } from '@nosana/sdk';
+export declare class ApiListenJobDefinitionStrategy implements JobDefinitionStrategy {
+    private eventEmitter;
+    constructor(eventEmitter: EventEmitter);
+    load(jobId: string): Promise<JobDefinition>;
+}

package/dist/NodeManager/node/job/defination/strategy/ApiListenJobDefinitionStrategy.js

@@ -0,0 +1,16 @@
+export class ApiListenJobDefinitionStrategy {
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
+    async load(jobId) {
+        return new Promise((resolve, reject) => {
+            const onJobDefinition = (data) => {
+                if (data.id === jobId) {
+                    resolve(data.jobDefinition);
+                    this.eventEmitter.removeListener('job-definition', onJobDefinition);
+                }
+            };
+            this.eventEmitter.on('job-definition', onJobDefinition);
+        });
+    }
+}

package/dist/NodeManager/node/job/defination/strategy/IpfsJobDefinitionStrategy.d.ts

@@ -0,0 +1,7 @@
+import { Client as SDK, JobDefinition } from '@nosana/sdk';
+import { JobDefinitionStrategy } from '../JobDefinitionStrategy.js';
+export declare class IpfsJobDefinitionStrategy implements JobDefinitionStrategy {
+    private sdk;
+    constructor(sdk: SDK);
+    load(id: string): Promise<JobDefinition>;
+}

package/dist/NodeManager/node/job/defination/strategy/IpfsJobDefinitionStrategy.js

@@ -0,0 +1,13 @@
+export class IpfsJobDefinitionStrategy {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async load(id) {
+        try {
+            return await this.sdk.ipfs.retrieve(id);
+        }
+        catch (e) {
+            throw new Error(`Failed to load job from IPFS: ${e.message}`);
+        }
+    }
+}

package/dist/NodeManager/node/job/jobExternalUtil.d.ts

@@ -0,0 +1,10 @@
+import { Job, Client as SDK, JobDefinition, FlowState } from '@nosana/sdk';
+import { NodeRepository } from '../../repository/NodeRepository.js';
+export declare class JobExternalUtil {
+    private sdk;
+    private repository;
+    constructor(sdk: SDK, repository: NodeRepository);
+    resolveJobDefinition(id: string, job: Job): Promise<JobDefinition | null>;
+    resolveResult(id: string, job: Job): Promise<FlowState>;
+    validate(id: string, jobDefinition: JobDefinition): Promise<boolean>;
+}

package/dist/NodeManager/node/job/jobExternalUtil.js

@@ -0,0 +1,82 @@
+import { validateJobDefinition } from '@nosana/sdk';
+import { JobDefinitionStrategySelector } from './defination/JobDefinitionStrategy.js';
+import { ResultReturnStrategySelector } from './result/ResultReturnStrategy.js';
+import { createInitialFlow } from '../task/helpers/createInitialFlow.js';
+export class JobExternalUtil {
+    constructor(sdk, repository) {
+        this.sdk = sdk;
+        this.repository = repository;
+    }
+    async resolveJobDefinition(id, job) {
+        let jobDefinition = await this.sdk.ipfs.retrieve(job.ipfsJob);
+        if (jobDefinition && jobDefinition.logistics?.send?.type) {
+            const strategySelector = new JobDefinitionStrategySelector();
+            const strategy = strategySelector.selectStrategy(jobDefinition.logistics.send.type);
+            this.repository.setflow(id, createInitialFlow(id, job.project.toString(), jobDefinition, [], 'waiting-for-job-definition', Date.now()));
+            try {
+                jobDefinition = await strategy.load(id, jobDefinition.logistics.send.args);
+            }
+            catch (error) {
+                jobDefinition = null;
+                this.repository.updateflowStateError(id, {
+                    status: 'logistics-error',
+                    error: error,
+                });
+            }
+        }
+        return jobDefinition;
+    }
+    async resolveResult(id, job) {
+        let result = this.repository.getFlowState(id);
+        let jobDefinition = await this.sdk.ipfs.retrieve(job.ipfsJob);
+        if (result) {
+            const orginalStatus = result.status;
+            if (jobDefinition.logistics?.receive?.type) {
+                const strategySelector = new ResultReturnStrategySelector();
+                const strategy = strategySelector.selectStrategy(jobDefinition.logistics.receive.type);
+                this.repository.updateflowState(id, {
+                    status: 'waiting-for-result',
+                });
+                const blankResult = {
+                    status: orginalStatus,
+                    startTime: result.startTime,
+                    endTime: result.endTime,
+                    opStates: [],
+                    errors: result.errors ?? [],
+                };
+                try {
+                    await strategy.load(id, jobDefinition.logistics.receive.args, result, orginalStatus);
+                }
+                catch (error) {
+                    this.repository.updateflowStateError(id, {
+                        error: error,
+                    });
+                    blankResult.errors?.push(error);
+                }
+                result = blankResult;
+            }
+            return result;
+        }
+        return {
+            status: '',
+            startTime: 0,
+            endTime: 0,
+            opStates: [],
+        };
+    }
+    async validate(id, jobDefinition) {
+        const validation = validateJobDefinition(jobDefinition);
+        if (!validation.success) {
+            this.repository.updateflowState(id, {
+                endTime: Date.now(),
+                status: 'failed',
+            });
+            this.repository.updateflowStateError(id, {
+                status: 'validation-error',
+                error: validation.errors,
+            });
+            return false;
+        }
+        return true;
+    }
+}

package/dist/NodeManager/node/job/jobHandler.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { Job, Run, Client as SDK, JobDefinition } from '@nosana/sdk';
+import { Provider } from '../../provider/Provider.js';
+import { NodeRepository } from '../../repository/NodeRepository.js';
+import { StopReason } from '../task/TaskManager.js';
+export declare const jobEmitter: EventEmitter<[never]>;
+export declare class JobHandler {
+    private sdk;
+    private provider;
+    private repository;
+    private id;
+    private job;
+    private runSubscriptionId;
+    private jobExternalUtil;
+    private eventEmitter;
+    private finishing;
+    accountEmitter: EventEmitter;
+    constructor(sdk: SDK, provider: Provider, repository: NodeRepository);
+    /**
+     * Expose a method to allow external consumers to listen for events
+     */
+    on(event: string, listener: (...args: any[]) => void): void;
+    /**
+     * Expose a method to remove listeners
+     */
+    off(event: string, listener: (...args: any[]) => void): void;
+    get(): Job | undefined;
+    private jobId;
+    private getJobOrThrow;
+    clearJob(): void;
+    claim(jobAddress: string): Promise<Job>;
+    register(jobAddress: string, run: Run, job: Job): void;
+    deregister(jobAddress: string): void;
+    nodeStop(): Promise<void>;
+    validate(jobDefinition: JobDefinition): Promise<boolean>;
+    private listenForAccountChanges;
+    private stopListeningForAccountChanges;
+    start(job: Job): Promise<boolean>;
+    runWithErrorHandling(): Promise<void>;
+    finish(run: Run, reason: StopReason): Promise<void>;
+    clearOldJobs(): Promise<void>;
+}

package/dist/NodeManager/node/job/jobHandler.js

@@ -0,0 +1,193 @@
+import EventEmitter from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { validateJobDefinition } from '@nosana/sdk';
+import { applyLoggingProxyToClass, createLoggingProxy, } from '../../monitoring/proxy/loggingProxy.js';
+import { JobExternalUtil } from './jobExternalUtil.js';
+import { abortControllerSelector } from '../abort/abortControllerSelector.js';
+import { TaskManagerRegistry } from '../task/TaskManagerRegistry.js';
+import TaskManager, { StopReasons } from '../task/TaskManager.js';
+import { JobRegistry } from './JobRegistry.js';
+import { createInitialFlow } from '../task/helpers/createInitialFlow.js';
+export const jobEmitter = new EventEmitter();
+export class JobHandler {
+    constructor(sdk, provider, repository) {
+        this.sdk = sdk;
+        this.provider = provider;
+        this.repository = repository;
+        this.finishing = false;
+        this.jobExternalUtil = new JobExternalUtil(sdk, this.repository);
+        applyLoggingProxyToClass(this);
+        this.eventEmitter = new EventEmitter();
+        this.accountEmitter = new EventEmitter();
+    }
+    /**
+     * Expose a method to allow external consumers to listen for events
+     */
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+    /**
+     * Expose a method to remove listeners
+     */
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+    }
+    get() {
+        return this.job;
+    }
+    jobId() {
+        if (!this.id) {
+            throw new Error('Job ID is not set');
+        }
+        return this.id;
+    }
+    getJobOrThrow() {
+        if (!this.job) {
+            throw new Error('Job is not set');
+        }
+        return this.job;
+    }
+    clearJob() {
+        this.job = undefined;
+        this.finishing = false;
+    }
+    async claim(jobAddress) {
+        try {
+            const job = await this.sdk.jobs.get(jobAddress);
+            this.id = jobAddress;
+            this.job = job;
+            return job;
+        }
+        catch (_) {
+            throw new Error('could not start job');
+        }
+    }
+    register(jobAddress, run, job) {
+        JobRegistry.getInstance().register(jobAddress, run, job);
+    }
+    deregister(jobAddress) {
+        JobRegistry.getInstance().remove(jobAddress);
+    }
+    async nodeStop() {
+        await TaskManagerRegistry.getInstance().stop();
+        await JobRegistry.getInstance().stop(this.sdk, this.repository);
+        this.stopListeningForAccountChanges();
+        this.clearJob();
+    }
+    async validate(jobDefinition) {
+        const validation = validateJobDefinition(jobDefinition);
+        if (!validation.success) {
+            this.repository.updateflowStateError(this.jobId(), {
+                status: 'validation-error',
+                error: validation.errors,
+            });
+            return false;
+        }
+        return true;
+    }
+    listenForAccountChanges() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                await this.sdk.jobs.loadNosanaJobs();
+                this.runSubscriptionId = this.sdk.jobs.connection.onAccountChange(new PublicKey(this.jobId()), (accountInfo) => {
+                    const jobAccount = this.sdk.jobs.jobs.coder.accounts.decode(this.sdk.jobs.jobs.account.jobAccount.idlAccount.name, accountInfo.data);
+                    if (jobAccount.state >= 2) {
+                        this.finishing = true;
+                        this.accountEmitter.emit('stopped', jobAccount);
+                        resolve();
+                        return;
+                    }
+                    this.accountEmitter.emit('changed', jobAccount);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    stopListeningForAccountChanges() {
+        if (this.runSubscriptionId !== undefined) {
+            this.sdk.jobs.connection.removeProgramAccountChangeListener(this.runSubscriptionId);
+            this.runSubscriptionId = undefined;
+        }
+    }
+    async start(job) {
+        const flow = this.repository.getFlow(this.jobId());
+        if (!flow) {
+            const jobDefinition = await Promise.race([
+                this.jobExternalUtil.resolveJobDefinition(this.jobId(), job),
+                new Promise((resolve) => abortControllerSelector().signal.addEventListener('abort', () => resolve(null))),
+            ]);
+            if (!jobDefinition) {
+                return false;
+            }
+            if (!(await this.jobExternalUtil.validate(this.jobId(), jobDefinition))) {
+                return false;
+            }
+            try {
+                TaskManagerRegistry.getInstance().register(this.jobId(), createLoggingProxy(new TaskManager(this.provider, this.repository, this.jobId(), job.project.toString(), jobDefinition)));
+                const task = TaskManagerRegistry.getInstance().get(this.jobId());
+                task.bootstrap();
+            }
+            catch (error) {
+                this.repository.setflow(this.jobId(), createInitialFlow(this.jobId(), job.project.toString(), jobDefinition, [], 'init error', Date.now(), error));
+                TaskManagerRegistry.getInstance().remove(this.jobId());
+                return false;
+            }
+        }
+        else {
+            try {
+                TaskManagerRegistry.getInstance().register(this.jobId(), new TaskManager(this.provider, this.repository, this.jobId(), job.project.toString()));
+                const task = TaskManagerRegistry.getInstance().get(this.jobId());
+                task.bootstrap();
+            }
+            catch (error) {
+                this.repository.updateflowStateError(this.jobId(), {
+                    status: 'init error',
+                    error: error,
+                });
+                TaskManagerRegistry.getInstance().remove(this.jobId());
+                return false;
+            }
+        }
+        this.listenForAccountChanges();
+        return true;
+    }
+    async runWithErrorHandling() {
+        const task = TaskManagerRegistry.getInstance().get(this.jobId());
+        await task.start();
+        TaskManagerRegistry.getInstance().remove(this.jobId());
+        if (this.finishing) {
+            // We’ve already emitted 'stopped' (or are otherwise finishing).
+            return;
+        }
+        this.accountEmitter.emit('completed');
+    }
+    async finish(run, reason) {
+        try {
+            const jobId = this.jobId();
+            let result = await this.jobExternalUtil.resolveResult(jobId, this.get());
+            const ipfsResult = await this.sdk.ipfs.pin(result);
+            const bytesArray = this.sdk.ipfs.IpfsHashToByteArray(ipfsResult);
+            if (reason == StopReasons.STOPPED) {
+                await this.sdk.jobs.complete(bytesArray, jobId);
+            }
+            else {
+                await this.sdk.jobs.submitResult(bytesArray, run, this.getJobOrThrow().market.toString());
+            }
+        }
+        catch (e) {
+            throw new Error(`Failed to finish job: ${e}`);
+        }
+    }
+    async clearOldJobs() {
+        const date = new Date();
+        date.setDate(date.getDate() - 1);
+        for (const id in this.repository.getFlows()) {
+            const flow = this.repository.getFlow(id);
+            if (flow.state.endTime && flow.state.endTime < date.valueOf()) {
+                this.repository.deleteflow(id);
+            }
+        }
+    }
+}

package/dist/NodeManager/node/job/result/ResultReturnStrategy.d.ts

@@ -0,0 +1,13 @@
+import { FlowState, ReceiveJobResultLogicstics } from '@nosana/sdk';
+export interface ResultReturnStrategy {
+    load(jobId: string, args: ReceiveJobResultLogicstics['args'], results: FlowState, orginalState: string): Promise<boolean>;
+}
+export declare class ResultReturnStrategySelector {
+    constructor();
+    /**
+     * Selects the appropriate JobDefinitionStrategy based on the name.
+     * @param name - The name/type of the strategy ('api-listen' or 'api').
+     * @returns JobDefinitionStrategy
+     */
+    selectStrategy(name: string): ResultReturnStrategy;
+}

package/dist/NodeManager/node/job/result/ResultReturnStrategy.js

@@ -0,0 +1,21 @@
+import ApiEventEmitter from '../../api/ApiEventEmitter.js';
+import { ApiResultReturnStrategy } from './startegy/ApiResultReturnStrategy.js';
+import { ApiListenResultReturnStrategy } from './startegy/ApiListenResultReturnStrategy.js';
+export class ResultReturnStrategySelector {
+    constructor() { }
+    /**
+     * Selects the appropriate JobDefinitionStrategy based on the name.
+     * @param name - The name/type of the strategy ('api-listen' or 'api').
+     * @returns JobDefinitionStrategy
+     */
+    selectStrategy(name) {
+        switch (name) {
+            case 'api-listen':
+                return new ApiListenResultReturnStrategy(ApiEventEmitter.getInstance());
+            case 'api':
+                return new ApiResultReturnStrategy();
+            default:
+                throw new Error(`Unsupported strategy: ${name}`);
+        }
+    }
+}

package/dist/NodeManager/node/job/result/startegy/ApiListenResultReturnStrategy.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { ResultReturnStrategy } from '../ResultReturnStrategy.js';
+export declare class ApiListenResultReturnStrategy implements ResultReturnStrategy {
+    private eventEmitter;
+    constructor(eventEmitter: EventEmitter);
+    load(jobId: string): Promise<boolean>;
+}

package/dist/NodeManager/node/job/result/startegy/ApiListenResultReturnStrategy.js

@@ -0,0 +1,22 @@
+export class ApiListenResultReturnStrategy {
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
+    async load(jobId) {
+        return new Promise((resolve, reject) => {
+            const onResultReturn = (data) => {
+                if (data.id === jobId) {
+                    clearTimeout(timeout); // Clear the timeout if the result is received
+                    resolve(true);
+                    this.eventEmitter.removeListener('job-result', onResultReturn);
+                }
+            };
+            // Set a timeout to reject if the result isn't received within 1 minutes
+            const timeout = setTimeout(() => {
+                this.eventEmitter.removeListener('job-result', onResultReturn);
+                reject('Results were not collected before the timeout.');
+            }, 1 * 60 * 1000); // 2 * 60 * 1000 ms = 1 minutes
+            this.eventEmitter.on('job-result', onResultReturn);
+        });
+    }
+}

package/dist/NodeManager/node/job/result/startegy/ApiResultReturnStrategy.d.ts

@@ -0,0 +1,8 @@
+import { FlowState, ReceiveJobResultLogicstics } from '@nosana/sdk';
+import { ResultReturnStrategy } from '../ResultReturnStrategy.js';
+export declare class ApiResultReturnStrategy implements ResultReturnStrategy {
+    private attempts;
+    private success;
+    private postJobResults;
+    load(jobId: string, args: ReceiveJobResultLogicstics['args'], results: FlowState, orginalStatus: string): Promise<boolean>;
+}

package/dist/NodeManager/node/job/result/startegy/ApiResultReturnStrategy.js

@@ -0,0 +1,42 @@
+import { sleep, } from '@nosana/sdk';
+import { getSDK } from '../../../../sdk/index.js';
+export class ApiResultReturnStrategy {
+    constructor() {
+        this.attempts = 0;
+        this.success = false;
+    }
+    async postJobResults(endpoint, headers, body, orginalStatus) {
+        if (this.attempts > 3)
+            return;
+        this.attempts += 1;
+        try {
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ ...body, status: orginalStatus }),
+            });
+            if (response.ok) {
+                this.success = true;
+            }
+        }
+        catch { }
+        if (!this.success) {
+            await sleep(10);
+            await this.postJobResults(endpoint, headers, body, orginalStatus);
+        }
+    }
+    async load(jobId, args, results, orginalStatus) {
+        if (!args.endpoint)
+            throw new Error('Api result logictic requires an endpoint.');
+        const endpoint = args.endpoint.replace('%%global.job%%', jobId);
+        const headers = await getSDK().authorization.generateHeader(jobId, {
+            includeTime: true,
+        });
+        headers.append('Content-Type', 'application/json');
+        await this.postJobResults(endpoint, headers, results, orginalStatus);
+        if (!this.success) {
+            throw new Error(`Failed to post results to ${endpoint}.`);
+        }
+        return this.success;
+    }
+}

package/dist/NodeManager/node/key/keyHandler.d.ts

@@ -0,0 +1,16 @@
+import { Market, Client as SDK } from '@nosana/sdk';
+import { PublicKey } from '@solana/web3.js';
+export declare class KeyHandler {
+    private sdk;
+    private address;
+    private key;
+    private market;
+    constructor(sdk: SDK);
+    getMarket(): PublicKey | undefined;
+    setMarket(market?: PublicKey): void;
+    getAccessKey(): PublicKey | undefined;
+    setAccessKey(key?: PublicKey): void;
+    doesMarketNeedAccessKey(market: Market): boolean;
+    loadAccessKeyFromChain(market: Market): Promise<PublicKey | undefined>;
+    join(): Promise<void>;
+}

package/dist/NodeManager/node/key/keyHandler.js

@@ -0,0 +1,74 @@
+import { PublicKey } from '@solana/web3.js';
+import { EMPTY_ADDRESS } from '../../jobs/index.js';
+import { configs } from '../../configs/configs.js';
+import { isNodeOnboarded } from '../../utils/utils.js';
+export class KeyHandler {
+    constructor(sdk) {
+        this.sdk = sdk;
+        this.address = this.sdk.solana.provider.wallet.publicKey;
+    }
+    getMarket() {
+        return this.market;
+    }
+    setMarket(market) {
+        this.market = market;
+    }
+    getAccessKey() {
+        return this.key;
+    }
+    setAccessKey(key) {
+        this.key = key;
+    }
+    doesMarketNeedAccessKey(market) {
+        if (market.nodeAccessKey.toString() === EMPTY_ADDRESS.toString()) {
+            return false;
+        }
+        return true;
+    }
+    async loadAccessKeyFromChain(market) {
+        try {
+            this.key = await this.sdk.solana.getNftFromCollection(this.address, market.nodeAccessKey.toString());
+            if (!this.key) {
+                throw new Error('Could not find access key');
+            }
+            return this.key;
+        }
+        catch (error) {
+            throw new Error(`error loading Access Key from chain: ${error}`);
+        }
+    }
+    async join() {
+        const signature = (await this.sdk.solana.signMessage(configs().signMessage));
+        const base64Signature = Buffer.from(signature).toString('base64');
+        // If we don't specify a market, try to get the correct market from the backend
+        try {
+            // Check if node is onboarded and has received access key
+            // if not call onboard endpoint to create access key tx
+            const response = await fetch(`${configs().backendUrl}/nodes/${this.address}`, {
+                method: 'GET',
+                headers: {
+                    Authorization: `${this.address}:${base64Signature}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            const result = await response.json();
+            if (!result || (result && result.name === 'Error')) {
+                throw new Error(result.message);
+            }
+            if (!isNodeOnboarded(result.status)) {
+                throw new Error('Node not onboarded yet');
+            }
+            this.key = new PublicKey(result.accessKeyMint);
+            this.market = new PublicKey(result.marketAddress);
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.includes('Node not onboarded yet')) {
+                throw new Error('Node is still on the waitlist, wait until you are accepted.');
+            }
+            else if (e instanceof Error && e.message.includes('Node not found')) {
+                throw new Error('Node is not registred yet. To register run the `node join` command.');
+            }
+            throw e;
+        }
+    }
+}