feature: implement consensus Proposer interface

.github/workflows/benchmark-sync.yaml

@@ -0,0 +1,41 @@
+name: Benchmark Sync
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 0 * * 0' # Every Sunday at midnight UTC
+
+permissions:
+  contents: read
+
+env:
+  DOCKER_REGISTRY: nethermind.jfrog.io
+  IMAGE_REPO: nubia-oci-local-dev/juno
+  BENCHMARK_TAG: nubia-oci-local-dev/juno-benchmark:latest
+
+jobs:
+  sync-benchmark:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Extract Git version
+        id: extract_version
+        run: echo "version=$(git describe --tags)" >> $GITHUB_OUTPUT
+
+      - name: Setup Docker Buildx
+        uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2
+        id: buildx
+
+      - name: Login to registry
+        run: docker login ${{ env.DOCKER_REGISTRY }} -u ${{ secrets.ARTIFACTORY_NUBIA_USERNAME }} -p ${{ secrets.ARTIFACTORY_NUBIA_TOKEN_DEVELOPER }}
+
+      - name: Create benchmark tag
+        run: docker buildx imagetools create -t ${{ env.DOCKER_REGISTRY }}/${{ env.BENCHMARK_TAG }} ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_REPO }}:${{ steps.extract_version.outputs.version }}
+
+      - name: Log out from Docker registry
+        run: docker logout ${{ env.DOCKER_REGISTRY }}

.github/workflows/deploy-and-test.yaml

@@ -97,7 +97,7 @@ jobs:
     needs: [deploy]
     uses: ./.github/workflows/starknet-rs-tests.yml
     secrets:
-      STARKNET_RPC: ${{ secrets.RPC_URL }}/v0_7?apikey=${{ secrets.AUTH_TOKEN }}
+      STARKNET_RPC: ${{ secrets.RPC_URL }}/v0_8?apikey=${{ secrets.AUTH_TOKEN }}
 
   starknet-js:
     needs: [deploy]
@@ -123,7 +123,7 @@ jobs:
     needs: [deploy]
     uses: ./.github/workflows/starknet-go-tests.yml
     with:
-      ref: f8f0b717aa5b59c797540c0567f309ae78537e09
+      ref: 298264d89acbbd6611fcafa09c5b40acd9d35515
       rpc_version: v0_8
     secrets:
       TEST_RPC_URL: ${{ secrets.RPC_URL }}

.github/workflows/starknet-rs-tests.yml

@@ -14,7 +14,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: xJonathanLEI/starknet-rs
-          ref: starknet/v0.12.0
+          ref: starknet/v0.15.0
 
       - name: Setup Rust
         uses: actions-rs/toolchain@v1

blockchain/blockchain.go

@@ -622,8 +622,16 @@
 			Number:           0,
 			SequencerAddress: &felt.Zero,
 			EventsBloom:      core.EventsBloom(receipts),
-			L1GasPriceETH:    &felt.Zero,
-			L1GasPriceSTRK:   &felt.Zero,
+			L1GasPriceETH:    new(felt.Felt).SetUint64(1),
+			L1GasPriceSTRK:   new(felt.Felt).SetUint64(1),
+			L1DataGasPrice: &core.GasPrice{
+				PriceInWei: new(felt.Felt).SetUint64(1),
+				PriceInFri: new(felt.Felt).SetUint64(1),
+			},
+			L2GasPrice: &core.GasPrice{
+				PriceInWei: new(felt.Felt).SetUint64(1),
+				PriceInFri: new(felt.Felt).SetUint64(1),
+			},
 		},
 		Transactions: make([]core.Transaction, 0),
 		Receipts:     receipts,
@@ -638,3 +646,79 @@
 		return nil, nil
 	})
 }
+
+// Simulate returns what the new completed header and state update would be if the
+// provided block was added to the chain.
+func (b *Blockchain) Simulate(
+	block *core.Block,
+	stateUpdate *core.StateUpdate,
+	newClasses map[felt.Felt]core.Class,
+	sign BlockSignFunc,
+) (*core.Block, *core.StateUpdate, *core.BlockCommitments, *felt.Felt, error) {
+	var newBlock *core.Block
+	var newSU *core.StateUpdate
+	var newCommitments *core.BlockCommitments
+	var concatCount *felt.Felt
+
+	simulate := func(txn db.IndexedBatch) error {
+		if err := b.updateStateRoots(txn, block, stateUpdate, newClasses); err != nil {
+			return err
+		}
+		blockHash, commitments, err := core.BlockHash(
+			block,
+			stateUpdate.StateDiff,
+			b.network,
+			block.SequencerAddress)
+		if err != nil {
+			return err
+		}
+		block.Hash = blockHash
+		stateUpdate.BlockHash = blockHash
+
+		// Starknet consensus requires zero values for empty blocks
+		if block.TransactionCount == 0 {
+			newCommitments = &core.BlockCommitments{
+				TransactionCommitment: new(felt.Felt).SetUint64(0),
+				EventCommitment:       new(felt.Felt).SetUint64(0),
+				ReceiptCommitment:     new(felt.Felt).SetUint64(0),
+				StateDiffCommitment:   new(felt.Felt).SetUint64(0),
+			}
+			concatCount = new(felt.Felt).SetUint64(0)
+		} else {
+			newCommitments = commitments
+			concatCount = core.ConcatCounts(
+				block.TransactionCount,
+				block.EventCount,
+				stateUpdate.StateDiff.Length(),
+				block.L1DAMode)
+		}
+
+		if err := b.signBlock(block, stateUpdate, sign); err != nil {
+			return err
+		}
+
+		if err := b.storeBlockData(txn, block, stateUpdate, commitments); err != nil {
+			return err
+		}
+
+		block, err := core.GetBlockByNumber(txn, block.Number)
+		if err != nil {
+			return err
+		}
+		su, err := core.GetStateUpdateByBlockNum(txn, block.Number)
+		if err != nil {
+			return err
+		}
+		newBlock = block
+		newSU = su
+		return nil
+	}
+
+	// Simulate without commit
+	txn := b.database.NewIndexedBatch()
+	if err := simulate(txn); err != nil {
+		return nil, nil, nil, nil, err
+	}
+	txn.Reset()
+	return newBlock, newSU, newCommitments, concatCount, nil
+}

builder/builder.go

@@ -8,6 +8,7 @@
 	"sync/atomic"
 	"time"
 
+	"github.com/Masterminds/semver/v3"
 	"github.com/NethermindEth/juno/adapters/vm2core"
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/core"
@@ -52,10 +53,13 @@
 	headCloser   blockchain.StateCloser
 
 	finaliseMutex musync.RWMutex
+
+	protocolVersion semver.Version
 }
 
 func New(privKey *ecdsa.PrivateKey, ownAddr *felt.Felt, bc *blockchain.Blockchain, vm vm.VM,
 	blockTime time.Duration, mempool *mempool.Pool, log utils.Logger, disableFees bool, database db.KeyValueStore,
+	protocolVersion semver.Version,
 ) Builder {
 	return Builder{
 		ownAddress: *ownAddr,
@@ -72,6 +76,7 @@
 		subPendingBlock: feed.New[*core.Block](),
 		subReorgFeed:    feed.New[*sync.ReorgBlockRange](),
 		finaliseMutex:   musync.RWMutex{},
+		protocolVersion: protocolVersion,
 	}
 }
 
@@ -167,6 +172,7 @@
 	return nil
 }
 
+// The current gas strategy is to just use the values from the previous block
 func (b *Builder) InitPendingBlock() error {
 	header, err := b.bc.HeadsHeader()
 	if err != nil {
@@ -177,13 +183,12 @@
 			ParentHash:       header.Hash,
 			Number:           header.Number + 1,
 			SequencerAddress: &b.ownAddress,
-			L1GasPriceETH:    felt.One.Clone(),
-			L1GasPriceSTRK:   felt.One.Clone(),
-			L1DAMode:         core.Calldata,
-			L1DataGasPrice: &core.GasPrice{
-				PriceInWei: felt.One.Clone(),
-				PriceInFri: felt.One.Clone(),
-			},
+			ProtocolVersion:  b.protocolVersion.String(),
+			L1GasPriceETH:    header.L1GasPriceETH,
+			L1GasPriceSTRK:   header.L1GasPriceSTRK,
+			L1DAMode:         core.Blob,
+			L1DataGasPrice:   header.L1DataGasPrice,
+			L2GasPrice:       header.L2GasPrice,
 		},
 		Transactions: []core.Transaction{},
 		Receipts:     []*core.TransactionReceipt{},
@@ -297,7 +302,7 @@
 			return err
 		}
 		b.log.Debugw("running txns", userTxns)
-		if err = b.runTxns(userTxns, blockHashToBeRevealed); err != nil {
+		if _, err = b.runTxns(userTxns, blockHashToBeRevealed); err != nil {
 			b.log.Debugw("failed running txn", "err", err.Error())
 			var txnExecutionError vm.TransactionExecutionError
 			if !errors.As(err, &txnExecutionError) {
@@ -334,11 +339,11 @@
 
 // runTxns executes the provided transaction and applies the state changes
 // to the pending state
-func (b *Builder) runTxns(txns []mempool.BroadcastedTransaction, blockHashToBeRevealed *felt.Felt) error {
+func (b *Builder) runTxns(txns []mempool.BroadcastedTransaction, blockHashToBeRevealed *felt.Felt) (uint64, error) {
 	// Get the pending state
 	pending, err := b.Pending()
 	if err != nil {
-		return err
+		return 0, err
 	}
 
 	// Create a state writer for the transaction execution
@@ -371,15 +376,15 @@
 		b.bc.Network(),
 		false, false, false, true, false)
 	if err != nil {
-		return err
+		return 0, err
 	}
 
 	// Handle declared classes for declare transactions
 	for i, trace := range vmResults.Traces {
 		if trace.StateDiff.DeclaredClasses != nil ||
 			trace.StateDiff.DeprecatedDeclaredClasses != nil {
 			if err := b.processClassDeclaration(&txns[i], &state); err != nil {
-				return err
+				return 0, err
 			}
 		}
 	}
@@ -397,7 +402,11 @@
 	// Update pending block with transaction results
 	updatePendingBlock(pending, receipts, coreTxns, mergedStateDiff)
 
-	return b.StorePending(pending)
+	l2GasConsumed := uint64(1) // Todo: should be 0?? Blockifer seems to return 0..
+	for i := range vmResults.GasConsumed {
+		l2GasConsumed += vmResults.GasConsumed[i].L2Gas
+	}
+	return l2GasConsumed, b.StorePending(pending)
 }
 
 // processClassDeclaration handles class declaration storage for declare transactions
@@ -463,3 +472,43 @@
 func (b *Builder) SubscribePending() sync.PendingSubscription {
 	return sync.PendingSubscription{Subscription: b.subPendingBlock.Subscribe()}
 }
+
+func (b *Builder) MempoolIsEmpty() bool {
+	return b.mempool.Len() == 0
+}
+
+func (b *Builder) PopBatchTxns() ([]mempool.BroadcastedTransaction, error) {
+	return b.mempool.PopBatch(NumTxnsToBatchExecute)
+}
+
+func (b *Builder) ExecuteTxns(txns []mempool.BroadcastedTransaction) (uint64, error) {
+	b.finaliseMutex.RLock()
+	defer b.finaliseMutex.RUnlock()
+	b.log.Debugw("calling ExecuteTxns")
+	blockHashToBeRevealed, err := b.getRevealedBlockHash()
+	if err != nil {
+		return 0, err
+	}
+
+	l2gasConsumed := uint64(0)
+	l2gasConsumed, err = b.runTxns(txns, blockHashToBeRevealed)
+	if err != nil {
+		b.log.Debugw("failed running txn", "err", err.Error())
+		return 0, err
+	}
+	b.log.Debugw("running txns success")
+	return l2gasConsumed, nil
+}
+
+// ExecutePending updates the pending block and state-update
+func (b *Builder) ExecutePending() (*core.BlockCommitments, *felt.Felt, error) {
+	pending, err := b.Pending()
+	if err != nil {
+		return nil, nil, err
+	}
+	newBlock, newSU, commitments, concatCommitment, err := b.bc.Simulate(pending.Block, pending.StateUpdate, pending.NewClasses, nil)
+	pending.Block = newBlock
+	pending.StateUpdate = newSU
+	b.pendingBlock.Store(pending)
+	return commitments, concatCommitment, err
+}

builder/builder_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/Masterminds/semver/v3"
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/builder"
 	"github.com/NethermindEth/juno/core"
@@ -86,7 +87,8 @@ func TestSign(t *testing.T) {
 	privKey, err := ecdsa.GenerateKey(rand.Reader)
 	require.NoError(t, err)
 	p := mempool.New(memory.New(), bc, 1000, utils.NewNopZapLogger())
-	testBuilder := builder.New(privKey, seqAddr, bc, mockVM, 0, p, utils.NewNopZapLogger(), false, testDB)
+	pVersion := semver.New(0, 13, 2, "", "")
+	testBuilder := builder.New(privKey, seqAddr, bc, mockVM, 0, p, utils.NewNopZapLogger(), false, testDB, *pVersion)
 
 	_, err = testBuilder.Sign(new(felt.Felt), new(felt.Felt))
 	require.NoError(t, err)
@@ -106,7 +108,8 @@ func TestBuildTwoEmptyBlocks(t *testing.T) {
 	p := mempool.New(memory.New(), bc, 1000, utils.NewNopZapLogger())
 
 	minHeight := uint64(2)
-	testBuilder := builder.New(privKey, seqAddr, bc, mockVM, time.Millisecond, p, utils.NewNopZapLogger(), false, testDB)
+	pVersion := semver.New(0, 13, 2, "", "")
+	testBuilder := builder.New(privKey, seqAddr, bc, mockVM, time.Millisecond, p, utils.NewNopZapLogger(), false, testDB, *pVersion)
 
 	ctx, cancel := context.WithCancel(t.Context())
 	go func() {
@@ -195,7 +198,8 @@ func TestPrefundedAccounts(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, bc.StoreGenesis(&diff, classes))
 	blockTime := 100 * time.Millisecond
-	testBuilder := builder.New(privKey, seqAddr, bc, vm.New(false, log), blockTime, p, log, false, testDB)
+	pVersion := semver.New(0, 13, 2, "", "")
+	testBuilder := builder.New(privKey, seqAddr, bc, vm.New(false, log), blockTime, p, log, false, testDB, *pVersion)
 	rpcHandler := rpc.New(bc, nil, nil, "", log).WithMempool(p)
 	for _, txn := range expectedExnsInBlock {
 		_, rpcErr := rpcHandler.AddTransaction(t.Context(), txn)

consensus/proposer/init_test.go

@@ -0,0 +1,5 @@
+package proposer
+
+import (
+	_ "github.com/NethermindEth/juno/encoder/registry"
+)