refactor

Author: 0g-peterzhb

contract/contract.go

@@ -220,16 +220,16 @@ func TransactWithGasAdjustment(
 			}
 			tx, err := contract.FlowTransactor.contract.Transact(opts, method, params...)
 
-			var receipt *types.Receipt
 			if err == nil {
-				// Wait for successful execution
+				// Wait for successful execution in a separate goroutine.
+				// Use local variables to avoid racing with the outer loop's err.
 				go func() {
-					receipt, err = contract.WaitForReceipt(ctx, tx.Hash(), true, blockchain.RetryOption{NRetries: retryOpts.MaxNonGasRetries})
-					if err == nil {
-						receiptCh <- receipt
+					r, e := contract.WaitForReceipt(ctx, tx.Hash(), true, blockchain.RetryOption{NRetries: retryOpts.MaxNonGasRetries})
+					if e == nil {
+						receiptCh <- r
 						return
 					}
-					errCh <- err
+					errCh <- e
 				}()
 				// even if the receipt is received, this loop will continue until the context is canceled
 				time.Sleep(30 * time.Second)

core/merkle/proof.go

@@ -58,12 +58,12 @@ func (proof *Proof) ValidateHash(root, contentHash common.Hash, position, numLea
 	}
 
 	// content hash mismatch
-	if contentHash.Hex() != proof.Lemma[0].Hex() {
+	if contentHash != proof.Lemma[0] {
 		return errProofContentMismatch
 	}
 
 	// root mismatch
-	if len(proof.Lemma) > 1 && root.Hex() != proof.Lemma[len(proof.Lemma)-1].Hex() {
+	if len(proof.Lemma) > 1 && root != proof.Lemma[len(proof.Lemma)-1] {
 		return errProofRootMismatch
 	}
 
@@ -109,5 +109,5 @@ func (proof *Proof) validateRoot() bool {
 		}
 	}
 
-	return hash.Hex() == proof.Lemma[len(proof.Lemma)-1].Hex()
+	return hash == proof.Lemma[len(proof.Lemma)-1]
 }

indexer/client.go

@@ -184,30 +184,39 @@ func (c *Client) SplitableUpload(ctx context.Context, w3Client *web3go.Client, d
 
 // BatchUpload submit multiple data to 0g storage contract batchly in single on-chain transaction, then transfer the data to the storage nodes selected from indexer service.
 func (c *Client) BatchUpload(ctx context.Context, w3Client *web3go.Client, datas []core.IterableData, option ...transfer.BatchUploadOption) (eth_common.Hash, []eth_common.Hash, error) {
-	expectedReplica := uint(1)
+	var opts transfer.BatchUploadOption
 	if len(option) > 0 {
-		for _, opt := range option[0].DataOptions {
-			expectedReplica = max(expectedReplica, opt.ExpectedReplica)
-		}
+		opts = option[0]
+	}
+
+	expectedReplica := uint(1)
+	for _, opt := range opts.DataOptions {
+		expectedReplica = max(expectedReplica, opt.ExpectedReplica)
 	}
 	var maxSegNum uint64
 	for _, data := range datas {
 		maxSegNum = max(maxSegNum, data.NumSegments())
 	}
 	dropped := make([]string, 0)
+	maxRetry := 3
+	attempts := 0
 	for {
-		uploader, err := c.NewUploaderFromIndexerNodes(ctx, maxSegNum, w3Client, expectedReplica, dropped, option[0].Method, option[0].FullTrusted)
+		uploader, err := c.NewUploaderFromIndexerNodes(ctx, maxSegNum, w3Client, expectedReplica, dropped, opts.Method, opts.FullTrusted)
 		if err != nil {
 			return eth_common.Hash{}, nil, err
 		}
-		hash, roots, err := uploader.BatchUpload(ctx, datas, option...)
+		hash, roots, err := uploader.BatchUpload(ctx, datas, opts)
 		var rpcError *node.RPCError
 		if errors.As(err, &rpcError) {
 			dropped = append(dropped, rpcError.URL)
 			c.logger.Infof("dropped problematic node and retry: %v", rpcError.Error())
 		} else {
 			return hash, roots, err
 		}
+		attempts++
+		if attempts >= maxRetry {
+			return hash, roots, err
+		}
 	}
 }
 
@@ -245,28 +254,36 @@ func (c *Client) UploadFileSegments(
 		return errors.New("segment data is empty")
 	}
 
-	expectedReplica := uint(1)
+	var opt transfer.UploadOption
 	if len(option) > 0 {
-		expectedReplica = max(expectedReplica, option[0].ExpectedReplica)
+		opt = option[0]
 	}
 
+	expectedReplica := max(uint(1), opt.ExpectedReplica)
+
 	numSeg := core.NumSplits(int64(fileSeg.FileInfo.Tx.Size), core.DefaultSegmentSize)
 	dropped := make([]string, 0)
+	maxRetry := 3
+	attempts := 0
 	for {
-		uploaders, err := c.NewFileSegmentUploaderFromIndexerNodes(ctx, numSeg, expectedReplica, dropped, option[0].Method, true)
+		uploaders, err := c.NewFileSegmentUploaderFromIndexerNodes(ctx, numSeg, expectedReplica, dropped, opt.Method, true)
 		if err != nil {
 			return err
 		}
 
 		var rpcError *node.RPCError
 		for _, uploader := range uploaders {
-			if err := uploader.Upload(ctx, fileSeg, option...); errors.As(err, &rpcError) {
+			if err := uploader.Upload(ctx, fileSeg, opt); errors.As(err, &rpcError) {
 				dropped = append(dropped, rpcError.URL)
 				c.logger.Infof("dropped problematic node and retry: %v", rpcError.Error())
 			} else {
 				return err
 			}
 		}
+		attempts++
+		if attempts >= maxRetry {
+			return rpcError
+		}
 	}
 }
 

kv/builder.go

@@ -39,6 +39,16 @@ func newStreamDataBuilder(version uint64) *streamDataBuilder {
 	}
 }
 
+// compareStreamKey orders entries by (StreamId, Key) lexicographically.
+func compareStreamKey(idA common.Hash, keyA []byte, idB common.Hash, keyB []byte) bool {
+	hexA := idA.Hex()
+	hexB := idB.Hex()
+	if hexA == hexB {
+		return hexutil.Encode(keyA) < hexutil.Encode(keyB)
+	}
+	return hexA < hexB
+}
+
 // Build serialize all cached KV operations to StreamData.
 func (builder *streamDataBuilder) Build(sorted ...bool) (*StreamData, error) {
 	var err error
@@ -97,22 +107,10 @@ func (builder *streamDataBuilder) Build(sorted ...bool) (*StreamData, error) {
 	if len(sorted) > 0 {
 		if sorted[0] {
 			sort.SliceStable(data.Reads, func(i, j int) bool {
-				streamIdI := data.Reads[i].StreamId.Hex()
-				streamIdJ := data.Reads[j].StreamId.Hex()
-				if streamIdI == streamIdJ {
-					return hexutil.Encode(data.Reads[i].Key) < hexutil.Encode(data.Reads[j].Key)
-				} else {
-					return streamIdI < streamIdJ
-				}
+				return compareStreamKey(data.Reads[i].StreamId, data.Reads[i].Key, data.Reads[j].StreamId, data.Reads[j].Key)
 			})
 			sort.SliceStable(data.Writes, func(i, j int) bool {
-				streamIdI := data.Writes[i].StreamId.Hex()
-				streamIdJ := data.Writes[j].StreamId.Hex()
-				if streamIdI == streamIdJ {
-					return hexutil.Encode(data.Writes[i].Key) < hexutil.Encode(data.Writes[j].Key)
-				} else {
-					return streamIdI < streamIdJ
-				}
+				return compareStreamKey(data.Writes[i].StreamId, data.Writes[i].Key, data.Writes[j].StreamId, data.Writes[j].Key)
 			})
 		}
 	}

tests/config/cosmos-genesis.json

@@ -1,7 +1,7 @@
 {
   "app_name": "0gchaind",
   "app_version": "v0.2.0-alpha.4-892-g6b920eb40",
-  "genesis_time": "2026-02-24T02:16:23.477051Z",
+  "genesis_time": "2026-02-24T05:22:49.947997Z",
   "chain_id": "0gchaind-local",
   "initial_height": 1,
   "app_hash": null,

transfer/download/metadata.go

@@ -42,7 +42,7 @@ func LoadMetadata(file *os.File) (*Metadata, error) {
 		return nil, errors.Errorf("Read metadata length mismatch, expected = %v, actual = %v", MetadataSize, n)
 	}
 
-	metadata, err := DeserializeMedata(buf)
+	metadata, err := DeserializeMetadata(buf)
 	if err != nil {
 		return nil, errors.WithMessage(err, "Failed to deserialize metadata")
 	}
@@ -60,7 +60,7 @@ func (md *Metadata) Serialize() []byte {
 	return encoded
 }
 
-func DeserializeMedata(encoded []byte) (*Metadata, error) {
+func DeserializeMetadata(encoded []byte) (*Metadata, error) {
 	if len(encoded) != MetadataSize {
 		return nil, errors.Errorf("Invalid data length, expected = %v, actual = %v", MetadataSize, len(encoded))
 	}

transfer/download/metadata_test.go

@@ -19,7 +19,7 @@ func TestMetadataSerde(t *testing.T) {
 
 	encoded := md.Serialize()
 
-	md2, err := DeserializeMedata(encoded)
+	md2, err := DeserializeMetadata(encoded)
 	assert.NoError(t, err)
 	assert.Equal(t, md, *md2)
 }

transfer/upload_dir.go

@@ -28,7 +28,7 @@ func (uploader *Uploader) UploadDir(ctx context.Context, folder string, fragment
 		return n.Type == dir.FileTypeFile && n.Size > 0
 	})
 
-	logrus.Infof("Total %d files to be uploaded", len(nodes))
+	uploader.logger.Infof("Total %d files to be uploaded", len(nodes))
 
 	// Upload each file via SplitableUpload (handles encryption + splitting).
 	for i := range nodes {
@@ -51,7 +51,7 @@ func (uploader *Uploader) UploadDir(ctx context.Context, folder string, fragment
 		}
 		nodes[i].Roots = rootStrs
 
-		logrus.WithFields(logrus.Fields{
+		uploader.logger.WithFields(logrus.Fields{
 			"roots": rootStrs,
 			"path":  path,
 		}).Info("File uploaded successfully")