rename results operations

Author: zhangchiqing

engine/execution/state/bootstrap/bootstrap.go

@@ -107,7 +107,7 @@ func (b *Bootstrapper) BootstrapExecutionDatabase(
 				return fmt.Errorf("could not index initial genesis execution block: %w", err)
 			}
 
-			err = operation.IndexOwnOrSealedExecutionResult(lctx, rw, rootSeal.BlockID, rootSeal.ResultID)
+			err = operation.IndexTrustedExecutionResult(lctx, rw, rootSeal.BlockID, rootSeal.ResultID)
 			if err != nil {
 				return fmt.Errorf("could not index result for root result: %w", err)
 			}

state/protocol/badger/state.go

@@ -298,7 +298,7 @@ func bootstrapSealingSegment(
 			if err != nil {
 				return fmt.Errorf("could not insert execution result: %w", err)
 			}
-			err = operation.IndexOwnOrSealedExecutionResult(lctx, rw, result.BlockID, result.ID())
+			err = operation.IndexTrustedExecutionResult(lctx, rw, result.BlockID, result.ID())
 			if err != nil {
 				return fmt.Errorf("could not index execution result: %w", err)
 			}
@@ -457,7 +457,7 @@ func bootstrapSealingSegment(
 		// If the sealed root block is different from the finalized root block, then it means the node dynamically
 		// bootstrapped. In that case, we index the result of the latest sealed result, so that the EN is able
 		// to confirm that it is loading the correct state to execute the next block.
-		err = operation.IndexOwnOrSealedExecutionResult(lctx, rw, rootSeal.BlockID, rootSeal.ResultID)
+		err = operation.IndexTrustedExecutionResult(lctx, rw, rootSeal.BlockID, rootSeal.ResultID)
 		if err != nil {
 			return fmt.Errorf("could not index root result: %w", err)
 		}

storage/operation/receipts.go

@@ -27,11 +27,11 @@ func RetrieveExecutionReceiptStub(r storage.Reader, receiptID flow.Identifier, m
 	return RetrieveByKey(r, MakePrefix(codeExecutionReceiptMeta, receiptID), meta)
 }
 
-// IndexOwnExecutionReceipt indexes the Execution Node's OWN execution receipt by the executed block ID.
+// IndexMyExecutionReceipt indexes the Execution Node's OWN execution receipt by the executed block ID.
 //
 // Error returns:
 //   - [storage.ErrDataMismatch] if a *different* receipt has already been indexed for the same block
-func IndexOwnExecutionReceipt(lctx lockctx.Proof, rw storage.ReaderBatchWriter, blockID flow.Identifier, receiptID flow.Identifier) error {
+func IndexMyExecutionReceipt(lctx lockctx.Proof, rw storage.ReaderBatchWriter, blockID flow.Identifier, receiptID flow.Identifier) error {
 	if !lctx.HoldsLock(storage.LockInsertMyReceipt) {
 		return fmt.Errorf("cannot index own execution receipt without holding lock %s", storage.LockInsertMyReceipt)
 	}

storage/operation/receipts_test.go

@@ -41,7 +41,7 @@ func TestReceipts_Index(t *testing.T) {
 
 		err := storage.WithLock(lockManager, storage.LockInsertMyReceipt, func(lctx lockctx.Context) error {
 			return db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
-				return operation.IndexOwnExecutionReceipt(lctx, rw, blockID, expected)
+				return operation.IndexMyExecutionReceipt(lctx, rw, blockID, expected)
 			})
 		})
 		require.Nil(t, err)

storage/operation/results.go

@@ -27,7 +27,7 @@ func RetrieveExecutionResult(r storage.Reader, resultID flow.Identifier, result
 	return RetrieveByKey(r, MakePrefix(codeExecutionResult, resultID), result)
 }
 
-// IndexOwnOrSealedExecutionResult indexes the result of the given block.
+// IndexTrustedExecutionResult indexes the result of the given block.
 // It is used by the following scenarios:
 // 1. Execution Node indexes its own executed block's result when finish executing a block
 // 2. Execution Node indexes the sealed root block's result during bootstrapping
@@ -36,7 +36,7 @@ func RetrieveExecutionResult(r storage.Reader, resultID flow.Identifier, result
 //
 // It returns [storage.ErrDataMismatch] if there is already an indexed result for the given blockID,
 // but it is different from the given resultID.
-func IndexOwnOrSealedExecutionResult(lctx lockctx.Proof, rw storage.ReaderBatchWriter, blockID flow.Identifier, resultID flow.Identifier) error {
+func IndexTrustedExecutionResult(lctx lockctx.Proof, rw storage.ReaderBatchWriter, blockID flow.Identifier, resultID flow.Identifier) error {
 	// during bootstrapping, we index the sealed root block or the spork root block, which is not
 	// produced by the node itself, but we still need to index its execution result to be able to
 	// execute next block

storage/store/my_receipts.go

@@ -77,7 +77,7 @@ func (m *MyExecutionReceipts) BatchStoreMyReceipt(lctx lockctx.Proof, receipt *f
 	}
 
 	// require [storage.LockInsertMyReceipt] to be held
-	err = operation.IndexOwnExecutionReceipt(lctx, rw, blockID, receiptID)
+	err = operation.IndexMyExecutionReceipt(lctx, rw, blockID, receiptID)
 	if err != nil {
 		return err
 	}

storage/store/results.go

@@ -50,7 +50,7 @@ func NewExecutionResults(collector module.CacheMetrics, db storage.DB) *Executio
 			// this API is only used to fetch result for last executed block, so in happy case, it only need to be 1,
 			// we use 100 here to be more resilient to forks
 			withLimit[flow.Identifier, flow.Identifier](100),
-			withStoreWithLock(operation.IndexOwnOrSealedExecutionResult),
+			withStoreWithLock(operation.IndexTrustedExecutionResult),
 			withRetrieve(retrieveByBlockID),
 		),
 	}