Merge branch 'master' into ps/chore/upgrade-fuel-core-to-0.44.0

petertonysmith94 · web-flow · commit 44229fc19cb1 · 2025-06-12T13:16:11.000+01:00
diff --git a/.changeset/hungry-webs-join.md b/.changeset/hungry-webs-join.md
@@ -0,0 +1,6 @@
+---
+"@fuel-ts/account": patch
+"@fuel-ts/errors": patch
+---
+
+chore: handling for malformed response body
diff --git a/apps/docs/src/guide/errors/index.md b/apps/docs/src/guide/errors/index.md
@@ -353,3 +353,7 @@ This error occurs when there are duplicate entries for the same asset ID with di
 
 1. The `accountCoinQuantities` parameter contains multiple entries for the same asset ID
 2. Each entry specifies a different `changeOutputAccount` for the same asset ID
+
+### `RESPONSE_BODY_EMPTY`
+
+This error occurs when the response from the server has an empty body. The issue will generally lie with the connection setup from your environment and the RPC.
diff --git a/packages/account/src/providers/provider.test.ts b/packages/account/src/providers/provider.test.ts
@@ -45,16 +45,13 @@ import { serializeChain, serializeNodeInfo, serializeProviderCache } from './uti
 import type { ProviderCacheJson } from './utils/serialization';
 
 const getCustomFetch =
-  (expectedOperationName: string, expectedResponse: object) =>
+  (expectedOperationName: string, expectedBody?: BodyInit | null) =>
   async (url: string, options: RequestInit | undefined) => {
     const graphqlRequest = JSON.parse(options?.body as string);
     const { operationName } = graphqlRequest;
 
     if (operationName === expectedOperationName) {
-      const responseText = JSON.stringify({
-        data: expectedResponse,
-      });
-      const response = Promise.resolve(new Response(responseText, options));
+      const response = Promise.resolve(new Response(expectedBody, options));
 
       return response;
     }
@@ -244,13 +241,16 @@ describe('Provider', () => {
     using launched = await setupTestProviderAndWallets();
     const { provider } = launched;
 
-    const mockProvider = new Provider(provider.url, {
-      fetch: getCustomFetch('getTransaction', {
+    const expectedBody = JSON.stringify({
+      data: {
         transaction: {
           id: '0x1234567890abcdef',
           rawPayload: MOCK_TX_UNKNOWN_RAW_PAYLOAD, // Unknown transaction type
         },
-      }),
+      },
+    });
+    const mockProvider = new Provider(provider.url, {
+      fetch: getCustomFetch('getTransaction', expectedBody),
     });
 
     // Spy on console.warn
@@ -273,9 +273,8 @@ describe('Provider', () => {
     using launched = await setupTestProviderAndWallets();
     const { provider: nodeProvider } = launched;
 
-    // Create a mock provider with custom getTransactions operation
-    const mockProvider = new Provider(nodeProvider.url, {
-      fetch: getCustomFetch('getTransactions', {
+    const expectedBody = JSON.stringify({
+      data: {
         transactions: {
           edges: [
             {
@@ -298,7 +297,12 @@ describe('Provider', () => {
             endCursor: null,
           },
         },
-      }),
+      },
+    });
+
+    // Create a mock provider with custom getTransactions operation
+    const mockProvider = new Provider(nodeProvider.url, {
+      fetch: getCustomFetch('getTransactions', expectedBody),
     });
 
     // Spy on console.warn
@@ -476,7 +480,10 @@ describe('Provider', () => {
     const providerUrl = providerForUrl.url;
 
     const provider = new Provider(providerUrl, {
-      fetch: getCustomFetch('getVersion', { nodeInfo: { nodeVersion: '0.30.0' } }),
+      fetch: getCustomFetch(
+        'getVersion',
+        JSON.stringify({ data: { nodeInfo: { nodeVersion: '0.30.0' } } })
+      ),
     });
 
     expect(await provider.getVersion()).toEqual('0.30.0');
@@ -515,7 +522,10 @@ describe('Provider', () => {
     fetchChainAndNodeInfo.mockRestore();
 
     await provider.connect(providerUrl, {
-      fetch: getCustomFetch('getVersion', { nodeInfo: { nodeVersion: '0.30.0' } }),
+      fetch: getCustomFetch(
+        'getVersion',
+        JSON.stringify({ data: { nodeInfo: { nodeVersion: '0.30.0' } } })
+      ),
     });
 
     expect(await provider.getVersion()).toEqual('0.30.0');
@@ -851,10 +861,10 @@ describe('Provider', () => {
 
     const provider = new Provider(nodeProvider.url, {
       fetch: async (url, options) =>
-        getCustomFetch('getMessageProof', { messageProof: MESSAGE_PROOF_RAW_RESPONSE })(
-          url,
-          options
-        ),
+        getCustomFetch(
+          'getMessageProof',
+          JSON.stringify({ data: { messageProof: MESSAGE_PROOF_RAW_RESPONSE } })
+        )(url, options),
     });
 
     const transactionId = '0x79c54219a5c910979e5e4c2728df163fa654a1fe03843e6af59daa2c3fcd42ea';
@@ -874,7 +884,10 @@ describe('Provider', () => {
 
     const provider = new Provider(nodeProvider.url, {
       fetch: async (url, options) =>
-        getCustomFetch('getMessageStatus', { messageStatus: messageStatusResponse })(url, options),
+        getCustomFetch(
+          'getMessageStatus',
+          JSON.stringify({ data: { messageStatus: messageStatusResponse } })
+        )(url, options),
     });
     const messageStatus = await provider.getMessageStatus(
       '0x0000000000000000000000000000000000000000000000000000000000000008'
@@ -2656,6 +2669,137 @@ describe('Provider', () => {
     vi.restoreAllMocks();
   });
 
+  describe('Non-populated response body', () => {
+    // Reset back to default
+    afterAll(() => {
+      Provider.ENABLE_RPC_CONSISTENCY = true;
+    });
+
+    describe('ENABLE_RPC_CONSISTENCY = false', () => {
+      beforeAll(() => {
+        Provider.ENABLE_RPC_CONSISTENCY = false;
+      });
+
+      it(
+        'should not fall over if the response body is null [non-subscription]',
+        { timeout: 20000 },
+        async () => {
+          using launched = await setupTestProviderAndWallets();
+          const {
+            provider: { url },
+          } = launched;
+          const provider = new Provider(url, {
+            fetch: getCustomFetch('estimateGasPrice', null),
+          });
+
+          await expectToThrowFuelError(() => provider.estimateGasPrice(10), {
+            code: ErrorCode.RESPONSE_BODY_EMPTY,
+            message: 'The response from the server is missing the body',
+            metadata: {
+              timestamp: expect.any(String),
+              request: expect.any(Object),
+              response: expect.any(Object),
+            },
+          });
+        }
+      );
+
+      it(
+        'should not fall over if the response body is null [subscription]',
+        { timeout: 20000 },
+        async () => {
+          using launched = await setupTestProviderAndWallets();
+          const {
+            provider: { url },
+          } = launched;
+          const provider = new Provider(url, {
+            fetch: getCustomFetch('submitAndAwaitStatus', null),
+          });
+
+          const request = new ScriptTransactionRequest();
+
+          await expectToThrowFuelError(
+            () =>
+              provider.operations.submitAndAwaitStatus({
+                encodedTransaction: hexlify(request.toTransactionBytes()),
+              }),
+            {
+              code: ErrorCode.RESPONSE_BODY_EMPTY,
+              message: 'The response from the server is missing the body',
+              metadata: {
+                timestamp: expect.any(String),
+                request: expect.any(Object),
+                response: expect.any(Object),
+              },
+            }
+          );
+        }
+      );
+    });
+
+    describe('ENABLE_RPC_CONSISTENCY = true', () => {
+      beforeAll(() => {
+        Provider.ENABLE_RPC_CONSISTENCY = true;
+      });
+
+      it(
+        'should not fall over if the response body is null [non-subscription]',
+        { timeout: 20000 },
+        async () => {
+          using launched = await setupTestProviderAndWallets();
+          const {
+            provider: { url },
+          } = launched;
+          const provider = new Provider(url, {
+            fetch: getCustomFetch('estimateGasPrice', null),
+          });
+
+          await expectToThrowFuelError(() => provider.estimateGasPrice(10), {
+            code: ErrorCode.RESPONSE_BODY_EMPTY,
+            message: 'The response from the server is missing the body',
+            metadata: {
+              timestamp: expect.any(String),
+              request: expect.any(Object),
+              response: expect.any(Object),
+            },
+          });
+        }
+      );
+
+      it(
+        'should not fall over if the response body is null [subscription]',
+        { timeout: 20000 },
+        async () => {
+          using launched = await setupTestProviderAndWallets();
+          const {
+            provider: { url },
+          } = launched;
+          const provider = new Provider(url, {
+            fetch: getCustomFetch('submitAndAwaitStatus', null),
+          });
+
+          const request = new ScriptTransactionRequest();
+
+          await expectToThrowFuelError(
+            () =>
+              provider.operations.submitAndAwaitStatus({
+                encodedTransaction: hexlify(request.toTransactionBytes()),
+              }),
+            {
+              code: ErrorCode.RESPONSE_BODY_EMPTY,
+              message: 'The response from the server is missing the body',
+              metadata: {
+                timestamp: expect.any(String),
+                request: expect.any(Object),
+                response: expect.any(Object),
+              },
+            }
+          );
+        }
+      );
+    });
+  });
+
   describe('Waiting for transaction statuses', () => {
     const PreconfirmationSuccessStatus = 'PreconfirmationSuccessStatus';
     const SuccessStatus = 'SuccessStatus';
diff --git a/packages/account/src/providers/provider.ts b/packages/account/src/providers/provider.ts
@@ -566,7 +566,16 @@ export default class Provider {
         Provider.applyBlockHeight(fullRequest, url);
       }
 
-      return Provider.fetchAndProcessBlockHeight(url, fullRequest, options);
+      const response = await Provider.fetchAndProcessBlockHeight(url, fullRequest, options);
+      if (response.body === null) {
+        throw new FuelError(
+          ErrorCode.RESPONSE_BODY_EMPTY,
+          'The response from the server is missing the body',
+          { timestamp: new Date().toISOString(), request, response }
+        );
+      }
+
+      return response;
     }, retryOptions);
   }
 
@@ -607,14 +616,16 @@ export default class Provider {
     };
 
     for (let retriesLeft = retryOptions.maxRetries; retriesLeft > 0; --retriesLeft) {
-      const { extensions } = await parseGraphqlResponse({
-        response,
-        isSubscription: url.endsWith('-sub'),
-      });
-      Provider.setCurrentBlockHeight(url, extensions?.current_fuel_block_height);
+      if (response.body) {
+        const { extensions } = await parseGraphqlResponse({
+          response,
+          isSubscription: url.endsWith('-sub'),
+        });
+        Provider.setCurrentBlockHeight(url, extensions?.current_fuel_block_height);
 
-      if (!extensions?.fuel_block_height_precondition_failed) {
-        break;
+        if (!extensions?.fuel_block_height_precondition_failed) {
+          break;
+        }
       }
 
       const retryAttempt = retryOptions.maxRetries - retriesLeft + 1;
diff --git a/packages/errors/src/error-codes.ts b/packages/errors/src/error-codes.ts
@@ -37,6 +37,7 @@ export enum ErrorCode {
   CONNECTION_REFUSED = 'connection-refused',
   INVALID_URL = 'invalid-url',
   UNSUPPORTED_FEATURE = 'unsupported-feature',
+  RESPONSE_BODY_EMPTY = 'response-body-empty',
 
   // wallet
   INVALID_PUBLIC_KEY = 'invalid-public-key',
