return error for metadata fetching failures

Author: aditya1702

internal/services/contract_metadata.go

@@ -126,15 +126,17 @@ func (s *contractMetadataService) FetchSep41Metadata(ctx context.Context, contra
 // FetchSACMetadata fetches metadata for SAC contracts by calling name() via RPC.
 // SAC contracts return "code:issuer" format from name() (or "native" for XLM).
 // Returns []*data.Contract with Code, Issuer, Name, Symbol, and Decimals=7 (hardcoded for Stellar assets).
+// This function fails fast if any contract metadata fetch fails - partial results are not returned.
 func (s *contractMetadataService) FetchSACMetadata(ctx context.Context, contractIDs []string) ([]*data.Contract, error) {
 	if len(contractIDs) == 0 {
 		return []*data.Contract{}, nil
 	}
 
 	start := time.Now()
 	var (
-		contracts []*data.Contract
-		mu        sync.Mutex
+		contracts   []*data.Contract
+		mu          sync.Mutex
+		fetchErrors []error
 	)
 
 	// Process in batches to avoid overwhelming the RPC
@@ -147,7 +149,9 @@ func (s *contractMetadataService) FetchSACMetadata(ctx context.Context, contract
 			group.Submit(func() {
 				contract, err := s.fetchSACMetadataForContract(ctx, contractID)
 				if err != nil {
-					log.Ctx(ctx).Warnf("Failed to fetch SAC metadata for contract %s: %v", contractID, err)
+					mu.Lock()
+					fetchErrors = append(fetchErrors, fmt.Errorf("contract %s: %w", contractID, err))
+					mu.Unlock()
 					return
 				}
 				mu.Lock()
@@ -157,7 +161,7 @@ func (s *contractMetadataService) FetchSACMetadata(ctx context.Context, contract
 		}
 
 		if err := group.Wait(); err != nil {
-			log.Ctx(ctx).Warnf("Error waiting for SAC metadata batch: %v", err)
+			return nil, fmt.Errorf("error in SAC metadata batch: %w", err)
 		}
 
 		// Sleep between batches to avoid overwhelming the RPC (skip for last batch)
@@ -166,6 +170,11 @@ func (s *contractMetadataService) FetchSACMetadata(ctx context.Context, contract
 		}
 	}
 
+	// Fail if any contract metadata fetch failed - partial results are not acceptable
+	if len(fetchErrors) > 0 {
+		return nil, fmt.Errorf("failed to fetch metadata for %d SAC contracts: %w", len(fetchErrors), errors.Join(fetchErrors...))
+	}
+
 	log.Ctx(ctx).Infof("Fetched metadata for %d SAC contracts in %.4f seconds", len(contracts), time.Since(start).Seconds())
 	return contracts, nil
 }

internal/services/contract_metadata_test.go

@@ -471,7 +471,7 @@ func TestFetchSACMetadata(t *testing.T) {
 		assert.Equal(t, uint32(7), contract.Decimals)
 	})
 
-	t.Run("skips contract with malformed name gracefully", func(t *testing.T) {
+	t.Run("returns error for contract with malformed name", func(t *testing.T) {
 		mockRPCService := NewRPCServiceMock(t)
 		mockContractModel := data.NewContractModelMock(t)
 		pool := pond.NewPool(5)
@@ -493,12 +493,14 @@ func TestFetchSACMetadata(t *testing.T) {
 
 		result, err := service.FetchSACMetadata(ctx, []string{contractID})
 
-		// Should not error, but skip the malformed contract
-		require.NoError(t, err)
-		assert.Empty(t, result)
+		// Should return error for malformed contract name
+		require.Error(t, err)
+		assert.Nil(t, result)
+		assert.Contains(t, err.Error(), "failed to fetch metadata")
+		assert.Contains(t, err.Error(), "malformed SAC name")
 	})
 
-	t.Run("skips contract when RPC fails gracefully", func(t *testing.T) {
+	t.Run("returns error when RPC fails", func(t *testing.T) {
 		mockRPCService := NewRPCServiceMock(t)
 		mockContractModel := data.NewContractModelMock(t)
 		pool := pond.NewPool(5)
@@ -515,9 +517,11 @@ func TestFetchSACMetadata(t *testing.T) {
 
 		result, err := service.FetchSACMetadata(ctx, []string{contractID})
 
-		// Should not error, but skip the failed contract
-		require.NoError(t, err)
-		assert.Empty(t, result)
+		// Should return error when RPC fails
+		require.Error(t, err)
+		assert.Nil(t, result)
+		assert.Contains(t, err.Error(), "failed to fetch metadata")
+		assert.Contains(t, err.Error(), "RPC timeout")
 	})
 
 	t.Run("processes multiple contracts successfully", func(t *testing.T) {
@@ -553,6 +557,38 @@ func TestFetchSACMetadata(t *testing.T) {
 		require.NoError(t, err)
 		assert.Len(t, result, 2)
 	})
+
+	t.Run("returns error and no partial results when one contract fails", func(t *testing.T) {
+		mockRPCService := NewRPCServiceMock(t)
+		mockContractModel := data.NewContractModelMock(t)
+		pool := pond.NewPool(5)
+		defer pool.Stop()
+
+		contractID1 := "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC"
+		contractID2 := "CA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUWDA"
+
+		// First contract succeeds, second fails
+		nameScVal1 := xdr.ScVal{Type: xdr.ScValTypeScvString, Str: ptrToScString("USDC:GCNY5OXYSY4FKHOPT2SPOQZAOEIGXB5LBYW3HVU3OWSTQITS65M5RCNY")}
+
+		mockRPCService.On("SimulateTransaction", mock.Anything, mock.Anything).Return(
+			entities.RPCSimulateTransactionResult{
+				Results: []entities.RPCSimulateHostFunctionResult{{XDR: nameScVal1}},
+			}, nil,
+		).Once()
+		mockRPCService.On("SimulateTransaction", mock.Anything, mock.Anything).Return(
+			entities.RPCSimulateTransactionResult{}, errors.New("RPC timeout"),
+		).Once()
+
+		service, err := NewContractMetadataService(mockRPCService, mockContractModel, pool)
+		require.NoError(t, err)
+
+		result, err := service.FetchSACMetadata(ctx, []string{contractID1, contractID2})
+
+		// Should return error and no partial results
+		require.Error(t, err)
+		assert.Nil(t, result)
+		assert.Contains(t, err.Error(), "failed to fetch metadata for 1 SAC contracts")
+	})
 }
 
 func TestFetchBatch(t *testing.T) {

internal/services/token_ingestion.go

@@ -254,7 +254,6 @@ func (s *tokenIngestionService) PopulateAccountTokens(ctx context.Context, check
 			}
 		}
 		if len(sacContractsNeedingMetadata) > 0 {
-			log.Ctx(ctx).Infof("Fetching metadata for %d SAC contracts via RPC", len(sacContractsNeedingMetadata))
 			sacContracts, txErr := s.contractMetadataService.FetchSACMetadata(ctx, sacContractsNeedingMetadata)
 			if txErr != nil {
 				return fmt.Errorf("fetching SAC metadata: %w", txErr)
@@ -792,11 +791,6 @@ func (s *tokenIngestionService) storeTokensInDB(
 		contractTokens = append(contractTokens, contract)
 	}
 	if len(contractTokens) > 0 {
-		for _, contract := range contractTokens {
-			if contract.Type == string(types.ContractTypeSAC) && contract.Code == nil {
-				log.Ctx(ctx).Warnf("Contract %s is missing code and issuer", contract.ID)
-			}
-		}
 		if err := s.contractModel.BatchInsert(ctx, dbTx, contractTokens); err != nil {
 			return fmt.Errorf("batch inserting contracts: %w", err)
 		}