evm-gateway-demo: clean port from chase + SDK baebbe88 + PR #185 review items

SDK upgrade (relative to chase):
- Bump fabric-x-sdk to baebbe88 (persistent streams + native ArMA Send→Recv ordering)
- Add context.Context arg to NewSubmitter calls (breaking API change)
- Drop custom ArMASubmitter: SDK now handles ordering correctly
- Switch perf test to NewFabricXTestHarnessWithFactory (fabric-x staging)
- Add FABX_CONFIG_PATH env support (Ansible sets per-replica path)
- Add PERF_PROCESSING_WORKERS / PERF_SUBMITTING_WORKERS env vars

Ported from PR #185:
- Dockerfile: mkdir /data && chmod 777 /data (busybox has no /data)
- endorser/versioned_db_wrapper.go: NewSnapshot(0) resolves to latest committed
  block (was reading genesis state for "latest")
- gateway/api/models.go: gasPrice nil fix for EIP-1559 receipts
- integration/test_helpers.go: waitUntilSynced in NewFabricXTestHarnessWithFactory
  (60s timeout) so tests don't start before gateway is synced
- integration/perf/replay_json_dataset_test.go: require.NoError for harness setup
- endorser/testimpl/balance_priming_statedb.go: SetSender now actually sets
  senderAddr and balanceSlot; GetState only intercepts the specific balance slot
  (was intercepting ALL contract storage and returning primeValue, which made
  _paused/_blacklisted/etc. read as non-zero and revert every transfer)
- endorser/testimpl/balance_priming_executor.go: recover real sender from tx
  and pass to SetSender (was passing zero address); convert vm.ErrExecutionReverted
  into ExecutionResult{Status:201} so reverts commit and the test can detect them

Code review items addressed:
- replay_json_dataset_test.go: switch polling from TransactionByHash to
  TransactionReceipt; check receipt.Status (1=success, 0=EVM revert) for
  correct failure accounting — this also exposed the priming bug above
- gateway/app/app.go: default SyncTimeout 5m → 60s
- gateway/storage/store.go + gateway/core/chain.go: parameterize TruncateBlocks
  frequency via Store.BlockTruncationInterval (was hardcoded 1000)

Tooling:
- scripts/run-demo.sh: add --submitting-workers, --processing-workers flags;
  quiet-mode uses ssh -T instead of -tt (no PTY CR/LF corruption) and surfaces
  section headers, replica progress, and demo result lines

Docs:
- integration/perf/USDC_deployment.md: trim stale troubleshooting entries and
  duplicate command examples; collapse output-format section to essentials

Author: kushnireyal

Dockerfile

@@ -9,6 +9,7 @@ RUN CGO_ENABLED=0 go build -trimpath -o /fxevm ./cmd/fxevm
 FROM docker.io/library/busybox
 
 COPY --from=build /fxevm /usr/local/bin/fxevm
+RUN mkdir /data && chmod 777 /data
 EXPOSE 8545
 HEALTHCHECK --interval=30s --timeout=5s --retries=3 --start-period=30s \
     CMD ["fxevm", "healthcheck"]

endorser/testimpl/balance_priming_executor.go

@@ -10,9 +10,12 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+	fxcommon "github.com/hyperledger/fabric-x-evm/common"
 	"github.com/hyperledger/fabric-x-evm/endorser"
 	"github.com/hyperledger/fabric-x-evm/utils"
 	"github.com/hyperledger/fabric-x-sdk/endorsement"
@@ -96,24 +99,42 @@ func NewBalancePrimingExecutor(
 
 // Execute runs a state-changing transaction with SenderAware notification.
 func (e *BalancePrimingExecutor) Execute(tx *types.Transaction) (endorsement.ExecutionResult, error) {
-	// Extract the sender to notify SenderAware wrappers
-	// This replicates the logic from the original Executor.Send
-
-	// Notify NonceAware wrappers of the expected nonce for this transaction
+	// Notify NonceAware wrappers of the expected nonce for this transaction.
 	if na, ok := e.state.(NonceAware); ok {
 		na.SetExpectedNonce(tx.Nonce())
 	}
 
-	// Notify SenderAware wrappers of the transaction sender
+	// Notify SenderAware wrappers of the actual transaction sender so that
+	// balance priming targets the correct storage slot.
+	// e.Executor.ChainCfg is the same chain config used by Executor.Send, so
+	// the recovered address will match the one the EVM uses.
 	if sa, ok := e.state.(SenderAware); ok {
-		sa.SetSender(common.Address{})
+		signer := types.LatestSignerForChainID(e.Executor.ChainCfg.ChainID)
+		from, err := types.Sender(signer, tx)
+		if err != nil {
+			return endorsement.ExecutionResult{}, fmt.Errorf("recover sender: %w", err)
+		}
+		sa.SetSender(from)
 	}
 
 	// Execute the transaction using the base Executor
 	ret, err := e.Executor.Send(tx)
-	if err != nil {
+	if err != nil && !errors.Is(err, vm.ErrExecutionReverted) {
 		return endorsement.ExecutionResult{}, err
 	}
+	if errors.Is(err, vm.ErrExecutionReverted) {
+		event, mErr := fxcommon.MarshalRevert(ret, "", tx.Hash().Hex())
+		if mErr != nil {
+			return endorsement.ExecutionResult{}, fmt.Errorf("marshal revert event: %w", mErr)
+		}
+		return endorsement.ExecutionResult{
+			RWS:     e.state.Result(),
+			Event:   event,
+			Status:  201,
+			Message: err.Error(),
+			Payload: ret,
+		}, nil
+	}
 
 	// Marshal logs if any
 	var logs []byte

endorser/testimpl/balance_priming_statedb.go

@@ -7,7 +7,6 @@ SPDX-License-Identifier: LGPL-3.0-or-later
 package testimpl
 
 import (
-	"fmt"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -42,56 +41,30 @@ func NewBalancePrimingWrapper(stateDB endorser.ExtendedStateDB, contractAddr com
 	}
 }
 
-// SetSender sets the sender address and calculates the balance slot.
+// SetSender sets the sender address and calculates the balance slot for priming.
+// Only the sender's balance slot will be primed; all other contract storage is
+// passed through unchanged so that fields like _paused, _blacklisted, etc. are
+// not accidentally set to a non-zero value.
 func (w *BalancePrimingWrapper) SetSender(sender common.Address) {
 	w.enabled = true
-
-	if false {
-		fmt.Printf("[BalancePriming] SetSender called: sender=%s, balanceSlot=%s, contractAddr=%s\n",
-			sender.Hex(), w.balanceSlot.Hex(), w.contractAddr.Hex())
-	}
+	w.senderAddr = sender
+	w.balanceSlot = GetERC20BalanceSlot(sender, w.mappingPosition)
 }
 
-// GetState intercepts storage reads and primes the balance slot if needed.
+// GetState intercepts storage reads and primes the sender's balance slot if needed.
+// Only the slot computed from the sender address (set via SetSender) is intercepted;
+// all other slots are passed through unchanged. This avoids incorrectly priming
+// boolean/address slots such as _paused or _blacklisted.
 func (w *BalancePrimingWrapper) GetState(addr common.Address, slot common.Hash) common.Hash {
-	// Check if this is a read of our target balance slot
-	if w.enabled && addr == w.contractAddr {
-		if false {
-			fmt.Printf("[BalancePriming] GetState intercepted: addr=%s, slot=%s (matches target)\n",
-				addr.Hex(), slot.Hex())
-		}
-
-		// Get the current value
-		currentValue := w.ExtendedStateDB.GetState(addr, slot)
-
-		if false {
-			fmt.Printf("[BalancePriming] Current value: %s\n", currentValue.Hex())
-		}
-
-		// If it's zero, prime it with a high value
-		if currentValue == (common.Hash{}) {
-			if false {
-				fmt.Printf("[BalancePriming] *** PRIMING BALANCE *** sender=%s, slot=%s, value=%s\n",
-					w.senderAddr.Hex(), slot.Hex(), primeValue.String())
-			}
-
-			// Intentionally not calling SetState here. Writing the primed value to the
-			// StateDB would include it in the transaction's write set and commit a fake
-			// balance to the ledger, affecting future transactions. Returning it only
-			// from GetState keeps the priming invisible to the ledger while still
-			// allowing the EVM execution to proceed with a non-zero balance.
-
-			// Return the primed value
-			return common.BytesToHash(primeValue.Bytes())
-		} else {
-			if false {
-				fmt.Printf("[BalancePriming] Balance already set, not priming\n")
-			}
-		}
+	result := w.ExtendedStateDB.GetState(addr, slot)
+	// Only intercept the specific balance slot for the known sender.
+	if w.enabled && addr == w.contractAddr && slot == w.balanceSlot && result == (common.Hash{}) {
+		// Return a synthetic high balance. The EVM will write the decremented balance
+		// (primeValue - amount) via SetState, which is fine. Not writing the raw
+		// primeValue keeps the ledger clean.
+		return common.BytesToHash(primeValue.Bytes())
 	}
-
-	// Otherwise, just pass through to the underlying StateDB
-	return w.ExtendedStateDB.GetState(addr, slot)
+	return result
 }
 
 // SetExpectedNonce stores the nonce the current transaction expects.

endorser/versioned_db_wrapper.go

@@ -30,8 +30,15 @@ func NewVersionedDBWrapper(db *state.VersionedDB) *VersionedDBWrapper {
 
 // NewSnapshot creates a new snapshot of the state at the specified block number.
 // It returns a VersionedDBSnapshot that will use this block number for all Get operations,
-// providing snapshot isolation.
+// providing snapshot isolation. If blockNumber is 0 it resolves to the latest committed block.
 func (w *VersionedDBWrapper) NewSnapshot(blockNumber uint64) (ReadStore, error) {
+	if blockNumber == 0 {
+		latest, err := w.db.BlockNumber(context.Background())
+		if err != nil {
+			return nil, err
+		}
+		blockNumber = latest
+	}
 	return &VersionedDBSnapshot{
 		db:          w.db,
 		blockNumber: blockNumber,

gateway/api/models.go

@@ -116,6 +116,11 @@ func (r *RPCTransaction) MarshalJSON() ([]byte, error) {
 	// Remove internal go-ethereum fields that shouldn't be exposed
 	delete(m, "ignore")
 
+	// gasPrice must always be a hex string; EIP-1559 txs leave it null in go-ethereum's marshaler
+	if m["gasPrice"] == nil {
+		m["gasPrice"] = (*hexutil.Big)(big.NewInt(0))
+	}
+
 	// Add block metadata and sender - these override any fields from the transaction
 	m["from"] = r.From
 	m["blockHash"] = r.BlockHash

gateway/app/app.go

@@ -104,9 +104,9 @@ func buildApp(cfg config.Config, gwSigner sdk.Signer, logger sdk.Logger, endorse
 	var submitter core.Submitter
 	switch cfg.Network.Protocol {
 	case "fabric":
-		submitter, err = nfab.NewSubmitter(orderers, gwSigner, 0, logger)
+		submitter, err = nfab.NewSubmitter(context.Background(), orderers, gwSigner, 0, logger)
 	case "fabric-x", "":
-		submitter, err = nfabx.NewSubmitter(orderers, gwSigner, 0, logger)
+		submitter, err = nfabx.NewSubmitter(context.Background(), orderers, gwSigner, 0, logger)
 	default:
 		return nil, fmt.Errorf("unsupported protocol: %q", cfg.Network.Protocol)
 	}
@@ -198,7 +198,7 @@ func (a *App) Run(ctx context.Context) error {
 	// Wait for initial sync before serving traffic
 	syncTimeout := a.cfg.Gateway.SyncTimeout
 	if syncTimeout == 0 {
-		syncTimeout = 5 * time.Minute
+		syncTimeout = 60 * time.Second
 	}
 	for i, sync := range a.endorserSyncs {
 		if err := waitUntilSynced(gctx, sync, syncTimeout); err != nil {

gateway/core/chain.go

@@ -118,7 +118,7 @@ func (c *Chain) Handle(ctx context.Context, b blocks.Block) error {
 		return err
 	}
 
-	if c.Store.BlockRetention > 0 && ebl.BlockNumber%1000 == 0 {
+	if c.Store.BlockRetention > 0 && c.Store.BlockTruncationInterval > 0 && ebl.BlockNumber%c.Store.BlockTruncationInterval == 0 {
 		if err := c.Store.TruncateBlocks(ctx, c.Store.BlockRetention); err != nil {
 			logger.Warnf("block DB truncation failed at block %d: %v", ebl.BlockNumber, err)
 		}

gateway/storage/store.go

@@ -21,19 +21,24 @@ import (
 var ddl string
 
 type Store struct {
-	queries           *Queries
-	DB                *sql.DB
-	CachedBlockNumber atomic.Uint64 // cached block number for fast reads
-	BlockRetention    int           // number of recent blocks to keep; 0 disables truncation
+	queries                 *Queries
+	DB                      *sql.DB
+	CachedBlockNumber       atomic.Uint64 // cached block number for fast reads
+	BlockRetention          int           // number of recent blocks to keep; 0 disables truncation
+	BlockTruncationInterval uint64        // run truncation every N blocks; 0 disables truncation
 }
 
-const DefaultBlockRetention = 10000
+const (
+	DefaultBlockRetention          = 10000
+	DefaultBlockTruncationInterval = 1000
+)
 
 func NewStore(db *sql.DB) *Store {
 	return &Store{
-		queries:        New(db),
-		DB:             db,
-		BlockRetention: DefaultBlockRetention,
+		queries:                 New(db),
+		DB:                      db,
+		BlockRetention:          DefaultBlockRetention,
+		BlockTruncationInterval: DefaultBlockTruncationInterval,
 	}
 }
 

go.mod

@@ -17,7 +17,7 @@ require (
 	github.com/hyperledger/fabric-lib-go v1.1.3
 	github.com/hyperledger/fabric-protos-go-apiv2 v0.3.7
 	github.com/hyperledger/fabric-x-common v0.1.1-0.20260219094834-26c5a49ed548
-	github.com/hyperledger/fabric-x-sdk v0.0.0-20260521090010-c60d735b6023
+	github.com/hyperledger/fabric-x-sdk v0.0.0-20260529170509-baebbe88ff86
 	github.com/spf13/cobra v1.10.2
 	github.com/stretchr/testify v1.11.1
 	golang.org/x/crypto v0.50.0

go.sum

@@ -982,8 +982,8 @@ github.com/hyperledger/fabric-x-committer v0.1.9 h1:3lgl1g3FkONogjJraRzhrD7gr89X
 github.com/hyperledger/fabric-x-committer v0.1.9/go.mod h1:MjD6yyRfnCk3QjmwbKySoApvQerfnR++f0exQyFcZNw=
 github.com/hyperledger/fabric-x-common v0.1.1-0.20260219094834-26c5a49ed548 h1:KTmH/ZtM43z39lcLxGm7G3I5iC7J7iZSVHqbCFcUUNo=
 github.com/hyperledger/fabric-x-common v0.1.1-0.20260219094834-26c5a49ed548/go.mod h1:+VPYRRCGAZo7+rlT55yK3aRmUbRJwQGlWg7lz0SLdMY=
-github.com/hyperledger/fabric-x-sdk v0.0.0-20260521090010-c60d735b6023 h1:TzPwU9TF6QdolKRcmWp38NEDG7EBB3CjzXyEsHKa2UM=
-github.com/hyperledger/fabric-x-sdk v0.0.0-20260521090010-c60d735b6023/go.mod h1:fOMpy5+efegUsET0d7RMH+CENyTpjZOD5D1bpZBWzos=
+github.com/hyperledger/fabric-x-sdk v0.0.0-20260529170509-baebbe88ff86 h1:dRYhIRAmiKWF7OsSi+SQGpha85K1/0yf8LzI1JqbNyo=
+github.com/hyperledger/fabric-x-sdk v0.0.0-20260529170509-baebbe88ff86/go.mod h1:fOMpy5+efegUsET0d7RMH+CENyTpjZOD5D1bpZBWzos=
 github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=