@nosana/node 1.1.57 → 1.1.58

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nosana/node",
-    "version": "1.1.57",
+    "version": "1.1.58",
     "description": "",
     "bin": {
         "nosana-node": "./dist/src/index.js"

package/dist/src/NodeManager/node/market/hostManager.d.ts

@@ -7,6 +7,7 @@ export type NodeMetricsResponse = operations["getNodesByIdMetrics"]["responses"]
 type RequiredResourcesResponse = operations["getMarketsByIdRequired-resources"]["responses"][200]["content"]["application/json"];
 type HeartbeatResponse = operations["postNodesHeartbeat"]["responses"][200]["content"]["application/json"];
 type ErrorReportBody = operations["postErrorsReport"]["requestBody"]["content"]["application/json"];
+type SubmitAccessKeyTxResponse = operations["postNodesAccess-keySubmit"]["responses"][200]["content"]["application/json"];
 export type FeedbackReport = NonNullable<RequestMarketResponse["feedbackReport"]>;
 export type RequestMarketResult = Pick<RequestMarketResponse, "status" | "market" | "feedbackReport"> & {
     notRegistered?: true;
@@ -74,7 +75,7 @@ export declare class HostManager {
             };
         };
     }, `${string}/${string}`>>;
-    static syncNodeAfterMint(address: string): Promise<void>;
+    static submitAccessKeyTx(signedTx: string): Promise<SubmitAccessKeyTxResponse>;
     static getNode(address: string): Promise<GetNodeResponse | null>;
     static getNodeMetrics(address: string): Promise<NodeMetricsResponse | null>;
     static getMarketRequiredResources(marketId: string): Promise<RequiredResourcesResponse | null>;

package/dist/src/NodeManager/node/market/hostManager.js

@@ -43,7 +43,7 @@ export class HostManager {
         if (data.market) {
             result.market = {
                 address: data.market.address,
-                sftTx: data.market.sftTx ?? undefined,
+                accessKeyTx: data.market.accessKeyTx ?? undefined,
             };
         }
         if (data.nextTestAt) {
@@ -64,13 +64,14 @@ export class HostManager {
         }
         return data;
     }
-    static async syncNodeAfterMint(address) {
-        const { error } = await hostManagerClientSelector().POST("/nodes/sync-node", {
-            body: { address },
+    static async submitAccessKeyTx(signedTx) {
+        const { data, error } = await hostManagerClientSelector().POST("/nodes/access-key/submit", {
+            body: { signedTx },
         });
-        if (error) {
-            throw new Error(`Error syncing node after mint: ${error}`);
+        if (error || !data) {
+            throw new Error(`Error submitting access key transaction: ${JSON.stringify(error)}`);
         }
+        return data;
     }
     static async getNode(address) {
         const { data, error, response } = await hostManagerClientSelector().GET("/nodes/{id}", {

package/dist/src/NodeManager/node/market/marketAccess.d.ts

@@ -1,8 +1,11 @@
 import { Client as SDK } from '@nosana/sdk';
+/**
+ * The host-manager builds the access-key transaction, co-signs it with the
+ * mint authority and submits it. We only sign it as fee payer.
+ */
 export declare class MarketAccessHandler {
     private sdk;
     constructor(sdk: SDK);
-    mintAccessKey(sftTxBase64: string): Promise<string>;
-    private signAndSendTransaction;
-    private confirmTransaction;
+    submitAccessKey(accessKeyTx: string): Promise<string>;
+    private signAsFeePayer;
 }

package/dist/src/NodeManager/node/market/marketAccess.js

@@ -1,53 +1,24 @@
-import { VersionedTransaction, } from '@solana/web3.js';
-import { getRawTransaction } from '../../sdk/index.js';
+import { VersionedTransaction } from '@solana/web3.js';
+import { HostManager } from './hostManager.js';
+/**
+ * The host-manager builds the access-key transaction, co-signs it with the
+ * mint authority and submits it. We only sign it as fee payer.
+ */
 export class MarketAccessHandler {
     constructor(sdk) {
         this.sdk = sdk;
     }
-    async mintAccessKey(sftTxBase64) {
-        // Incase of blockheight exceeded error, retry 3 times
-        for (let i = 0; i < 3; i++) {
-            try {
-                const txnSignature = await this.signAndSendTransaction(sftTxBase64);
-                await this.confirmTransaction(txnSignature);
-                if (!txnSignature) {
-                    throw new Error("Transaction signature is undefined");
-                }
-                return txnSignature;
-            }
-            catch (error) {
-                if (i === 2 ||
-                    !error?.message.includes("TransactionExpiredBlockheightExceededError")) {
-                    throw error;
-                }
-            }
+    async submitAccessKey(accessKeyTx) {
+        const result = await HostManager.submitAccessKeyTx(this.signAsFeePayer(accessKeyTx));
+        if (result.status !== 'confirmed' || !result.signature) {
+            throw new Error(`Access key transaction ${result.status}${result.reason ? `: ${result.reason}` : ''}`);
         }
-        throw new Error("Failed to mint access key after 3 retries");
+        return result.signature;
     }
-    async signAndSendTransaction(txData) {
+    signAsFeePayer(txBase64) {
         const feePayer = (this.sdk.solana.provider?.wallet).payer;
-        const recoveredTransaction = await getRawTransaction(Buffer.from(txData, 'base64'));
-        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");
-        }
+        const transaction = VersionedTransaction.deserialize(Buffer.from(txBase64, 'base64'));
+        transaction.sign([feePayer]);
+        return Buffer.from(transaction.serialize()).toString('base64');
     }
 }

package/dist/src/NodeManager/node/market/marketHandler.js

@@ -44,11 +44,9 @@ export class MarketHandler {
             // host issued so lifecycle metrics aren't re-requested on the retry.
             return await this.request(requestedMarket, result.session ?? session, benchmarkRetries);
         }
-        // Sign and send SFT mint/burn transaction if provided
-        if (result.market?.sftTx) {
-            await this.marketAccessHandler.mintAccessKey(result.market.sftTx);
-            await sleep(30);
-            await HostManager.syncNodeAfterMint(this.address.toString());
+        // Sign as fee payer; the host-manager submits and confirms it.
+        if (result.market?.accessKeyTx) {
+            await this.marketAccessHandler.submitAccessKey(result.market.accessKeyTx);
         }
         await this.logLatestMeasurements();
         if (result.feedbackReport) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@nosana/node",
-  "version": "1.1.57",
+  "version": "1.1.58",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@nosana/node",
-      "version": "1.1.57",
+      "version": "1.1.58",
       "license": "ISC",
       "dependencies": {
         "@coral-xyz/anchor": "^0.28.1-beta.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nosana/node",
-  "version": "1.1.57",
+  "version": "1.1.58",
   "description": "",
   "bin": {
     "nosana-node": "./dist/src/index.js"