bootstrap wip - pendidng state doens't seem to be written to

Author: rian

builder/bootstrap.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 
 	"github.com/NethermindEth/juno/core"
+	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/mempool"
 )
 
@@ -22,12 +23,21 @@ func (b *Builder) BootstrapChain() error {
 		}
 
 		for _, txn := range txns {
+			fmt.Println("--push", txn.Transaction.Hash())
 			b.pool.Push(txn)
 		}
+		if err := b.depletePool(context.Background()); err != nil {
+			if !errors.Is(err, db.ErrKeyNotFound) {
+				return err
+			}
+		}
+		fmt.Println("depletedPool")
 		if err := b.Finalise(); err != nil {
 			return err
 		}
-		b.log.Debugw(fmt.Sprintf("Bootstrapped block %d ", i))
+		fmt.Println("Finalised")
+		// fmt.Println(fmt.Sprintf("Bootstrapped block %d, %d", i, len(txns)))
+		// b.log.Debugw(fmt.Sprintf("Bootstrapped block %d ", i))
 	}
 	return nil
 }

builder/bootstrap_test.go

@@ -3,6 +3,8 @@ package builder_test
 import (
 	"context"
 	"crypto/rand"
+	"encoding/json"
+	"fmt"
 	"testing"
 	"time"
 
@@ -15,29 +17,30 @@ import (
 	"github.com/NethermindEth/juno/mocks"
 	adaptfeeder "github.com/NethermindEth/juno/starknetdata/feeder"
 	"github.com/NethermindEth/juno/utils"
+	"github.com/NethermindEth/juno/vm"
 	"github.com/consensys/gnark-crypto/ecc/stark-curve/ecdsa"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
 )
 
 func TestBootstrapChain(t *testing.T) {
 	testDB := pebble.NewMemTest(t)
 	mockCtrl := gomock.NewController(t)
-	mockVM := mocks.NewMockVM(mockCtrl)
+	// mockVM := mocks.NewMockVM(mockCtrl)
+	vm := vm.New(utils.NewNopZapLogger())
 	snData := mocks.NewMockStarknetData(mockCtrl)
 	network := &utils.Sepolia
 	client := feeder.NewTestClient(t, network)
 	gw := adaptfeeder.New(client)
 	bc := blockchain.New(testDB, network)
 	bc.StoreGenesis(core.EmptyStateDiff(), nil)
 
-	seqAddr := utils.HexToFelt(t, "0xDEADBEEF")
+	seqAddr := utils.HexToFelt(t, "0x1176a1bd84444c89232ec27754698e5d2e7e1a7f1539f12027f28b23ec9f3d8")
 	privKey, err := ecdsa.GenerateKey(rand.Reader)
 	require.NoError(t, err)
 	p := mempool.New(pebble.NewMemTest(t))
 
-	testBuilder := builder.New(privKey, seqAddr, bc, mockVM, time.Second*1, p,
+	testBuilder := builder.New(privKey, seqAddr, bc, vm, time.Second*1, p,
 		utils.NewNopZapLogger()).WithBootstrapToBlock(2).WithStarknetData(snData).WithBootstrap(true)
 
 	block0, err := gw.BlockByNumber(context.Background(), 0)
@@ -54,40 +57,29 @@ func TestBootstrapChain(t *testing.T) {
 	class2, err := gw.Class(context.Background(), classHash2)
 	require.NoError(t, err)
 
-	t.Run("successfully bootstrap Sepolias first two block", func(t *testing.T) {
+	t.Run("successfully bootcstrap Sepolias first two block", func(t *testing.T) {
 		require.NoError(t, err)
 		snData.EXPECT().BlockByNumber(context.Background(), uint64(0)).Return(block0, nil)
 		snData.EXPECT().BlockByNumber(context.Background(), uint64(1)).Return(block1, nil)
 		snData.EXPECT().Class(context.Background(), classHash0).Return(class0, nil)
 		snData.EXPECT().Class(context.Background(), classHash1).Return(class1, nil)
 		snData.EXPECT().Class(context.Background(), classHash2).Return(class2, nil)
-
+		// mockVM.EXPECT().Execute(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
+		// 	gomock.Any(), gomock.Any(), false, false, false, false).Return(
+		// 	[]*felt.Felt{&felt.Zero}, []*felt.Felt{}, []vm.TransactionTrace{{}}, executionErr,
+		// )
 		// ctx, cancel := context.WithCancel(context.Background())
-		// go func() {
-		// 	time.Sleep(3 * time.Second)
-		// 	fmt.Println("waking up")
-		// 	cancel()
-		// }()
-		// err = testBuilder.Run(ctx)
-		// require.NoError(t, err)
-
-		if err := testBuilder.InitPendingBlock(); err != nil {
-			panic(err)
-		}
-		defer func() {
-			if pErr := testBuilder.ClearPending(); pErr != nil {
-				panic(pErr)
-			}
-		}()
-
-		// doneListen := make(chan struct{})
-		// go func() {
-		// 	if pErr := b.listenPool(ctx); pErr != nil {
-		// 		b.log.Errorw("listening pool", "err", pErr)
-		// 	}
-		// 	close(doneListen)
-		// }()
+		// cancel()
+		err = testBuilder.Run(context.Background())
+		require.NoError(t, err)
 
-		assert.NoError(t, testBuilder.BootstrapChain(), "can't bootstrap if the network isn't specified", err.Error())
+		head, err := bc.BlockByNumber(0)
+		require.NoError(t, err)
+		qwe, err := json.MarshalIndent(head, "", "")
+		fmt.Println(string(qwe))
+		require.NoError(t, err)
+		require.Equal(t, uint64(1), head.Number)
+		require.Equal(t, block0.TransactionCount, head.TransactionCount, "TransactionCount diff")
+		require.Equal(t, block0.GlobalStateRoot.String(), head.GlobalStateRoot.String(), "GlobalStateRoot diff")
 	})
 }

builder/builder.go

@@ -3,6 +3,7 @@ package builder
 import (
 	"context"
 	"errors"
+	"fmt"
 	stdsync "sync"
 	"time"
 
@@ -96,26 +97,31 @@ func (b *Builder) Run(ctx context.Context) error {
 		}
 	}()
 
-	doneListen := make(chan struct{})
-	go func() {
-		if pErr := b.listenPool(ctx); pErr != nil {
-			b.log.Errorw("listening pool", "err", pErr)
-		}
-		close(doneListen)
-	}()
+	// doneListen := make(chan struct{})
+	// go func() {
+	// 	if pErr := b.listenPool(ctx); pErr != nil {
+	// 		b.log.Errorw("listening pool", "err", pErr)
+	// 	}
+	// 	close(doneListen)
+	// }()
 
 	if b.bootstrap {
+		fmt.Println("bootstrap")
 		b.log.Debugw("Starting process to bootstrap the Sequencer")
 		if err := b.BootstrapChain(); err != nil {
 			return err
 		}
 		b.log.Debugw("Finished process to bootstrap the Sequencer")
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithCancel(ctx)
+		cancel()
+		// close(doneListen)
 	}
 
 	for {
 		select {
 		case <-ctx.Done():
-			<-doneListen
+			// <-doneListen
 			return nil
 		case <-time.After(b.blockTime):
 			b.log.Debugw("Finalising new block")
@@ -166,6 +172,8 @@ func (b *Builder) Finalise() error {
 	if err := b.bc.Finalise(&b.pendingBlock, b.Sign); err != nil {
 		return err
 	}
+	fmt.Sprintln("Finalised block", "number", b.pendingBlock.Block.Number, "hash",
+		b.pendingBlock.Block.Hash.ShortString(), "state", b.pendingBlock.Block.GlobalStateRoot.ShortString())
 	b.log.Infow("Finalised block", "number", b.pendingBlock.Block.Number, "hash",
 		b.pendingBlock.Block.Hash.ShortString(), "state", b.pendingBlock.Block.GlobalStateRoot.ShortString())
 	b.listener.OnBlockFinalised(b.pendingBlock.Block.Header)
@@ -262,11 +270,18 @@ func Receipt(fee *felt.Felt, feeUnit core.FeeUnit, txHash *felt.Felt, trace *vm.
 
 func (b *Builder) listenPool(ctx context.Context) error {
 	for {
+		// select {
+		// case <-ctx.Done():
+		// 	fmt.Println("listenPool done")
+		// 	return nil
+		// default:
+		fmt.Println("listenPool bdepletePool ")
 		if err := b.depletePool(ctx); err != nil {
 			if !errors.Is(err, db.ErrKeyNotFound) {
 				return err
 			}
 		}
+		// }
 
 		select {
 		case <-ctx.Done():
@@ -280,6 +295,9 @@ func (b *Builder) listenPool(ctx context.Context) error {
 func (b *Builder) depletePool(ctx context.Context) error {
 	for {
 		userTxn, err := b.pool.Pop()
+		fmt.Println("userTxn", userTxn.Transaction.Hash(), err)
+		fmt.Println("b.pendingBlock.Block.Transactions", len(b.pendingBlock.Block.Transactions))
+		fmt.Println("b.pendingBlock.Block.DeployedContracts", b.pendingBlock.StateUpdate.StateDiff.DeployedContracts)
 		if err != nil {
 			return err
 		}
@@ -290,7 +308,7 @@ func (b *Builder) depletePool(ctx context.Context) error {
 			if !errors.As(err, &txnExecutionError) {
 				return err
 			}
-
+			fmt.Println("\n\nrunTxn err", err, "\n\n.")
 			b.log.Debugw("failed txn", "hash", userTxn.Transaction.Hash().String(), "err", err.Error())
 		}
 
@@ -323,6 +341,8 @@ func (b *Builder) runTxn(txn *mempool.BroadcastedTransaction) error {
 	}
 	fee, _, trace, err := b.vm.Execute([]core.Transaction{txn.Transaction}, classes, []*felt.Felt{}, blockInfo, state,
 		b.bc.Network(), false, false, false, false)
+	fmt.Println("execute", fee, trace, err)
+	fmt.Println("execute", state)
 	if err != nil {
 		return err
 	}