@xgamesfun/solana 0.27.1 → 0.28.0

package/js/chain/rpc.js

@@ -2,6 +2,7 @@
 // (devnet: about 100 requests per 10 s per IP, 40 for any one method), so 429s are retried with backoff, and so are a
 // gateway's passing failures (502, 503, 504).
 import { fromBase64, toBase64 } from './bytes.js';
+import { transactionId } from './tx.js';
 
 // The options of a call made without any: read-only, and typed so the generated declarations take any option.
 const NO_OPTIONS = Object.freeze(/** @type {Record<string, any>} */ ({}));
@@ -21,11 +22,19 @@ const BEHIND = [-32005, -32016];
 
 /** A JSON-RPC failure, with the node's own message (and logs for a failed simulation). */
 export class RpcError extends Error {
-  constructor(message, { code, logs } = NO_OPTIONS) {
+  /**
+   * `code`: the node's own error code, when a node answered. `logs`: a failed dry run's program logs. `err`: the
+   * node's own name for why a transaction was refused ("BlockhashNotFound", "AlreadyProcessed", or the program's
+   * error as the chain writes it). `maybeTaken`: a send whose earlier try got no answer, so a node may have taken the
+   * transaction although the last try was refused.
+   */
+  constructor(message, { code, logs, err, maybeTaken } = NO_OPTIONS) {
     super(message);
     this.name = 'RpcError';
     this.code = code;
     this.logs = logs;
+    this.err = err;
+    this.maybeTaken = Boolean(maybeTaken);
   }
 }
 
@@ -72,10 +81,27 @@ export function programError(err, logs) {
   return last ?? (typeof err === 'string' ? err : JSON.stringify(err));
 }
 
+/**
+ * Whether a send was refused because the cluster has this very transaction already (it was sent before): the node's
+ * own word for it (`err`), or, from a node that gives only a sentence, its sentence. Never a program's log line: a
+ * dry run that failed inside a program is that program's refusal, whatever its words.
+ */
+export const alreadyProcessed = error =>
+  error?.err === 'AlreadyProcessed' ||
+  (error?.err === undefined &&
+    !error?.logs?.length &&
+    /this transaction has already been processed/i.test(String(error?.message ?? '')));
+
+/** Whether a send's refusal is the dry run not knowing the transaction's blockhash. */
+const blockhashNotFound = error =>
+  error?.data?.err === 'BlockhashNotFound' || /blockhash not found/i.test(String(error?.message ?? ''));
+
 /** A client for one RPC URL. `fetchImpl` and `sleepImpl` are for tests. */
 export function rpcClient(url, { fetchImpl = globalThis.fetch, sleepImpl = sleep } = {}) {
   let id = 0;
   async function call(method, params = []) {
+    // A try that got no answer (the connection dropped, a gateway failed): a node may have taken what it carried.
+    let unanswered = false;
     for (let attempt = 0; ; attempt++) {
       let response;
       try {
@@ -86,6 +112,7 @@ export function rpcClient(url, { fetchImpl = globalThis.fetch, sleepImpl = sleep
           signal: AbortSignal.timeout(TIMEOUT_MS),
         });
       } catch (error) {
+        unanswered = true;
         if (attempt < RETRIES) {
           await sleepImpl(500 * 2 ** attempt);
           continue;
@@ -98,6 +125,7 @@ export function rpcClient(url, { fetchImpl = globalThis.fetch, sleepImpl = sleep
         continue;
       }
       // Sending the same signed transaction again is safe: it has one signature, so it lands once at most.
+      if (PASSING.includes(response.status)) unanswered = true;
       if (PASSING.includes(response.status) && attempt < RETRIES) {
         await sleepImpl(500 * 2 ** attempt);
         continue;
@@ -115,13 +143,25 @@ export function rpcClient(url, { fetchImpl = globalThis.fetch, sleepImpl = sleep
           await sleepImpl(500 * 2 ** attempt);
           continue;
         }
+        // A send refused in its dry run for a blockhash this node has not seen yet ("Blockhash not found"): the node
+        // that gave the blockhash was a moment ahead of this one. Asked again, it (or another) knows it. A blockhash
+        // that is truly gone is refused the same way each time, and the last refusal is the answer.
+        if (method === 'sendTransaction' && blockhashNotFound(body?.error) && attempt < RETRIES) {
+          await sleepImpl(500 * 2 ** attempt);
+          continue;
+        }
         // A send whose preflight failed ("Transaction simulation failed: … custom program error: 0x17b5") carries the
         // logs, where the program says why in words.
         const logs = body?.error?.data?.logs;
         const said = logs?.length
           ? `The network refused this in a dry run: ${programError(body.error.data.err, logs)}`
           : message;
-        throw new RpcError(said, { code: body?.error?.code, logs });
+        throw new RpcError(said, {
+          code: body?.error?.code,
+          logs,
+          err: body?.error?.data?.err,
+          maybeTaken: method === 'sendTransaction' && unanswered,
+        });
       }
       return body.result;
     }
@@ -211,10 +251,17 @@ export function rpcClient(url, { fetchImpl = globalThis.fetch, sleepImpl = sleep
       };
     },
     async send(wire) {
-      return call('sendTransaction', [
-        toBase64(wire),
-        { encoding: 'base64', preflightCommitment: 'confirmed', maxRetries: 3 },
-      ]);
+      try {
+        return await call('sendTransaction', [
+          toBase64(wire),
+          { encoding: 'base64', preflightCommitment: 'confirmed', maxRetries: 3 },
+        ]);
+      } catch (e) {
+        // A transaction the cluster has taken already is refused as already processed: that is what a second send
+        // gets when the answer to the first was lost on its way back. It was sent; its signature is its first.
+        if (alreadyProcessed(e)) return transactionId(wire);
+        throw e;
+      }
     },
     signatureStatus,
     /** Wait until a sent transaction is confirmed; throws with the program's reason when it failed. */