fix: skipping calling resolveEntityType if action is CREATE

Signed-off-by: Simeon Nakov <[email protected]>

Author: simzzz

packages/relay/src/lib/debug.ts

@@ -257,16 +257,18 @@ export class DebugImpl implements Debug {
   async formatActionsResult(result: any, requestDetails: RequestDetails): Promise<[] | any> {
     return await Promise.all(
       result.map(async (action, index) => {
-        const { resolvedFrom, resolvedTo } = await this.resolveMultipleAddresses(
-          action.from,
-          action.to,
-          requestDetails,
-        );
+        // Skip resolving entity type for CREATE operations with to=null (contract creation)
+        // MN responds with 400 for contracts/null; avoid querying in this case
+        const shouldSkipToResolution = action.call_operation_type === CallType.CREATE && !action.to;
+
+        // Resolve 'from' normally; resolve 'to' only if present to avoid MN lookups for CREATE with to=null
+        const resolvedFrom = await this.resolveAddress(action.from, requestDetails);
+        const resolvedTo = shouldSkipToResolution ? action.to : await this.resolveAddress(action.to, requestDetails);
 
         // The actions endpoint does not return input and output for the calls so we get them from another endpoint
         // The first one is excluded because we take its input and output from the contracts/results/{transactionIdOrHash} endpoint
         const contract =
-          index !== 0 && action.call_operation_type === CallType.CREATE
+          index !== 0 && action.call_operation_type === CallType.CREATE && action.to
             ? await this.mirrorNodeClient.getContract(action.to, requestDetails)
             : undefined;
 

packages/relay/tests/lib/debug.spec.ts

@@ -284,7 +284,7 @@ describe('Debug API Test Suite', async function () {
   });
 
   this.beforeEach(() => {
-    cacheService.clear(requestDetails);
+    cacheService.clear();
   });
 
   describe('debug_traceTransaction', async function () {
@@ -640,6 +640,81 @@ describe('Debug API Test Suite', async function () {
             expect(address).to.eq(accountAddress);
           });
         });
+
+        describe('formatActionsResult with CREATE actions', async function () {
+          it('should handle CREATE action with to=null without making MN lookup', async function () {
+            const createActionWithNullTo = {
+              actions: [
+                {
+                  call_depth: 0,
+                  call_operation_type: 'CREATE',
+                  call_type: 'CREATE',
+                  caller: '0.0.1016',
+                  caller_type: 'ACCOUNT',
+                  from: '0x00000000000000000000000000000000000003f8',
+                  gas: 247000,
+                  gas_used: 77324,
+                  index: 0,
+                  input: '0x608060405234801561001057600080fd5b50',
+                  recipient: '0.0.1033',
+                  recipient_type: 'CONTRACT',
+                  result_data: '0x',
+                  result_data_type: 'OUTPUT',
+                  timestamp: '1696438011.462526383',
+                  to: null, // This should not trigger MN lookup
+                  value: 0,
+                },
+              ],
+            };
+
+            restMock.onGet(SENDER_BY_ADDRESS).reply(200, JSON.stringify(accountsResult));
+
+            const result = await debugService.formatActionsResult(createActionWithNullTo.actions, requestDetails);
+
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0]).to.have.property('type', 'CREATE');
+            expect(result[0]).to.have.property('from', '0xc37f417fa09933335240fca72dd257bfbde9c275');
+            expect(result[0]).to.have.property('to', null);
+            expect(result[0]).to.have.property('input', '0x608060405234801561001057600080fd5b50');
+          });
+
+          it('should handle CREATE action with to=null and skip getContract call', async function () {
+            const createActionWithNullTo = {
+              actions: [
+                {
+                  call_depth: 0,
+                  call_operation_type: 'CREATE',
+                  call_type: 'CREATE',
+                  caller: '0.0.1016',
+                  caller_type: 'ACCOUNT',
+                  from: '0x00000000000000000000000000000000000003f8',
+                  gas: 247000,
+                  gas_used: 77324,
+                  index: 1, // Non-zero index to test getContract path
+                  input: '0x608060405234801561001057600080fd5b50',
+                  recipient: '0.0.1033',
+                  recipient_type: 'CONTRACT',
+                  result_data: '0x',
+                  result_data_type: 'OUTPUT',
+                  timestamp: '1696438011.462526383',
+                  to: null, // Should skip getContract call
+                  value: 0,
+                },
+              ],
+            };
+
+            restMock.onGet(SENDER_BY_ADDRESS).reply(200, JSON.stringify(accountsResult));
+            // No mock for getContract call - should not be called
+
+            const result = await debugService.formatActionsResult(createActionWithNullTo.actions, requestDetails);
+
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0]).to.have.property('type', 'CREATE');
+            expect(result[0]).to.have.property('to', null);
+            expect(result[0]).to.have.property('input', '0x608060405234801561001057600080fd5b50');
+            expect(result[0]).to.have.property('output', '0x');
+          });
+        });
       });
     });
   });
@@ -710,7 +785,7 @@ describe('Debug API Test Suite', async function () {
       sinon.restore();
       restMock.reset();
       web3Mock.reset();
-      cacheService.clear(requestDetails);
+      cacheService.clear();
     });
 
     withOverriddenEnvsInMochaTest({ DEBUG_API_ENABLED: undefined }, () => {
@@ -999,7 +1074,7 @@ describe('Debug API Test Suite', async function () {
       sinon.restore();
       restMock.reset();
       web3Mock.reset();
-      cacheService.clear(requestDetails);
+      cacheService.clear();
     });
 
     withOverriddenEnvsInMochaTest({ DEBUG_API_ENABLED: true }, () => {

packages/server/tests/acceptance/debug.spec.ts

@@ -319,6 +319,39 @@ describe('@debug API Acceptance Tests', function () {
         predefined.INVALID_PARAMETER("'tracer' for TracerConfigWrapper", 'Expected TracerType, value: InvalidTracer'),
       );
     });
+
+    it('@release should handle CREATE transactions with to=null in trace results', async function () {
+      // Just use the existing basic contract deployment to test CREATE transactions
+      // The deployment block should contain a CREATE transaction
+      const deploymentBlockHex = numberTo0x(deploymentBlockNumber);
+
+      // Call debug_traceBlockByNumber for the deployment block
+      const result = await relay.call(DEBUG_TRACE_BLOCK_BY_NUMBER, [
+        deploymentBlockHex,
+        TRACER_CONFIGS.CALL_TRACER_TOP_ONLY_FALSE,
+      ]);
+
+      expect(result).to.be.an('array');
+      expect(result.length).to.be.at.least(1);
+
+      // Find a CREATE transaction in the result (from contract deployment)
+      const createTxTrace = result.find((trace) => trace.result && trace.result.type === 'CREATE');
+      expect(createTxTrace).to.exist;
+      expect(createTxTrace.result).to.exist;
+
+      // Verify it's a CREATE transaction with proper structure
+      expect(createTxTrace.result.type).to.equal('CREATE');
+      expect(createTxTrace.result.from).to.exist;
+      expect(createTxTrace.result.to).to.exist;
+      expect(createTxTrace.result.gas).to.exist;
+      expect(createTxTrace.result.gasUsed).to.exist;
+      expect(createTxTrace.result.input).to.exist;
+      expect(createTxTrace.result.output).to.exist;
+
+      // This test verifies that CREATE actions with to=null don't cause Mirror Node lookup errors
+      // The main goal is that the debug_traceBlockByNumber call succeeds without throwing
+      // "Invalid parameter: contractid" errors when processing CREATE transactions
+    });
   });
 
   describe('debug_traceTransaction', () => {