latest wip

astria/execution/handler.go

@@ -5,7 +5,7 @@ import (
  "net"
  "sync"
 
- astriaGrpc "buf.build/gen/go/astria/astria/grpc/go/astria/execution/v1alpha2/executionv1alpha2grpc"
+ astriaGrpc "buf.build/gen/go/astria/execution-apis/grpc/go/astria/execution/v1alpha2/executionv1alpha2grpc"
  "google.golang.org/grpc"
 )
 

astria/execution/v1alpha2.go

@@ -3,16 +3,18 @@ package execution
 import (
  "context"
  "sync"
+ "time"
 
- astriaGrpc "buf.build/gen/go/astria/astria/grpc/go/astria/execution/v1alpha2/executionv1alpha2grpc"
- astriaPb "buf.build/gen/go/astria/astria/protocolbuffers/go/astria/execution/v1alpha2"
+ astriaGrpc "buf.build/gen/go/astria/execution-apis/grpc/go/astria/execution/v1alpha2/executionv1alpha2grpc"
+ astriaPb "buf.build/gen/go/astria/execution-apis/protocolbuffers/go/astria/execution/v1alpha2"
  cmbytes "github.com/cometbft/cometbft/libs/bytes"
  "github.com/cometbft/cometbft/libs/log"
  "github.com/rollkit/rollkit/block"
  "github.com/rollkit/rollkit/store"
  "github.com/rollkit/rollkit/types"
  codes "google.golang.org/grpc/codes"
  status "google.golang.org/grpc/status"
+ "google.golang.org/protobuf/encoding/protojson"
  "google.golang.org/protobuf/types/known/timestamppb"
 )
 
@@ -37,21 +39,25 @@ func NewExecutionServiceServerV1Alpha2(blockManager *block.SSManager, store stor
 
 // GetBlock retrieves a block by its identifier.
 func (s *ExecutionServiceServerV1Alpha2) GetBlock(ctx context.Context, req *astriaPb.GetBlockRequest) (*astriaPb.Block, error) {
- s.logger.Info("GetBlock called", "request", req)
+ reqJson, _ := protojson.Marshal(req)
+ s.logger.Info("GetBlock called", "request", reqJson)
 
  res, err := s.getBlockFromIdentifier(ctx, req.GetIdentifier())
  if err != nil {
  s.logger.Error("failed finding block", err)
  return nil, err
  }
 
- s.logger.Info("GetBlock completed", "request", req, "response", res)
+ resJson, _ := protojson.Marshal(res)
+ s.logger.Info("GetBlock completed", "response", resJson)
  return res, nil
 }
 
 // BatchGetBlocks will return an array of Blocks given an array of block identifiers.
 func (s *ExecutionServiceServerV1Alpha2) BatchGetBlocks(ctx context.Context, req *astriaPb.BatchGetBlocksRequest) (*astriaPb.BatchGetBlocksResponse, error) {
- s.logger.Info("BatchGetBlocks called", "request", req)
+ reqJson, _ := protojson.Marshal(req)
+ s.logger.Info("BatchGetBlocks called", "request", reqJson)
+
  var blocks []*astriaPb.Block
 
  ids := req.GetIdentifiers()
@@ -69,7 +75,8 @@ func (s *ExecutionServiceServerV1Alpha2) BatchGetBlocks(ctx context.Context, req
  Blocks: blocks,
  }
 
- s.logger.Info("BatchGetBlocks completed", "request", req, "response", res)
+ resJson, _ := protojson.Marshal(res)
+ s.logger.Info("BatchGetBlocks completed", "response", resJson)
  return res, nil
 }
 
@@ -81,7 +88,8 @@ func (s *ExecutionServiceServerV1Alpha2) ExecuteBlock(ctx context.Context, req *
  default:
  }
 
- s.logger.Info("ExecuteBlock called", "request", req)
+ reqJson, _ := protojson.Marshal(req)
+ s.logger.Info("ExecuteBlock called", "request", reqJson)
 
  s.blockExecutionLock.Lock()
  defer s.blockExecutionLock.Unlock()
@@ -93,31 +101,81 @@ func (s *ExecutionServiceServerV1Alpha2) ExecuteBlock(ctx context.Context, req *
 
  block, err := s.blockManager.PublishBlock(ctx, types.Hash(req.PrevBlockHash), req.Timestamp.AsTime(), txs)
  if err != nil {
- s.logger.Error("failed to publish block to chain", "hash", block.Hash(), "prevHash", req.PrevBlockHash, "err", err)
+ s.logger.Error("Failed to publish block to chain", "hash", block.Hash(), "prevHash", types.Hash(req.PrevBlockHash), "err", err)
  return nil, status.Error(codes.Internal, "failed to insert block to chain")
  }
 
+ s.logger.Info("Published block", "height", block.Height(), "timestamp", block.Time(), "hash", block.Hash(), "parent_hash", block.LastHeader())
+
+ parentHash := block.LastHeader()
+ if block.Height() == 1 {
+ zeroHash := [32]byte{0x0}
+ parentHash = types.Hash(zeroHash[:])
+ }
+
  res := &astriaPb.Block{
  Number: uint32(block.Height()),
  Hash: cmbytes.HexBytes(block.Hash()),
- ParentBlockHash: cmbytes.HexBytes(block.LastHeader()),
+ ParentBlockHash: cmbytes.HexBytes(parentHash),
  Timestamp: timestamppb.New(block.Time()),
  }
 
- s.logger.Info("ExecuteBlock completed", "request", req, "response", res)
+ resJson, _ := protojson.Marshal(res)
+ s.logger.Info("ExecuteBlock completed", "response", resJson)
  return res, nil
 }
 
 // GetCommitmentState fetches the current CommitmentState of the chain.
 func (s *ExecutionServiceServerV1Alpha2) GetCommitmentState(ctx context.Context, req *astriaPb.GetCommitmentStateRequest) (*astriaPb.CommitmentState, error) {
- s.logger.Info("GetCommitmentState called", "request", req)
- return nil, nil
+ reqJson, _ := protojson.Marshal(req)
+ s.logger.Info("GetCommitmentState called", "request", reqJson)
+
+ var res *astriaPb.CommitmentState
+
+ height := s.blockManager.GetStoreHeight()
+
+ if height == 0 {
+ genHash := [32]byte{0x0}
+ pbGenBlock := &astriaPb.Block{
+ Number: uint32(0),
+ Hash: genHash[:],
+ ParentBlockHash: genHash[:],
+ Timestamp: timestamppb.New(time.Now()),
+ }
+ res = &astriaPb.CommitmentState{
+ Soft: pbGenBlock,
+ Firm: pbGenBlock,
+ }
+ } else {
+ block, err := s.store.GetBlock(ctx, height)
+ if err != nil {
+ s.logger.Error("failed finding block with height", "height", height, "error", err)
+ return nil, err
+ }
+
+ pbBlock := &astriaPb.Block{
+ Number: uint32(block.Height()),
+ Hash: cmbytes.HexBytes(block.Hash()),
+ ParentBlockHash: cmbytes.HexBytes(block.LastHeader()),
+ Timestamp: timestamppb.New(block.Time()),
+ }
+
+ res = &astriaPb.CommitmentState{
+ Soft: pbBlock,
+ Firm: pbBlock,
+ }
+ }
+
+ resJson, _ := protojson.Marshal(res)
+ s.logger.Info("GetCommitmentState completed", "response", resJson)
+ return res, nil
 }
 
 // UpdateCommitmentState replaces the whole CommitmentState with a new CommitmentState.
 func (s *ExecutionServiceServerV1Alpha2) UpdateCommitmentState(ctx context.Context, req *astriaPb.UpdateCommitmentStateRequest) (*astriaPb.CommitmentState, error) {
- s.logger.Info("UpdateCommitmentState called", "request", req)
- return nil, nil
+ reqJson, _ := protojson.Marshal(req)
+ s.logger.Info("UpdateCommitmentState called", "request", reqJson)
+ return req.CommitmentState, nil
 }
 
 func (s *ExecutionServiceServerV1Alpha2) getBlockFromIdentifier(ctx context.Context, identifier *astriaPb.BlockIdentifier) (*astriaPb.Block, error) {

astria/mempool/reaper.go

@@ -4,25 +4,26 @@ import (
  "fmt"
  "sync"
 
- "github.com/rollkit/rollkit/mempool"
- "github.com/rollkit/rollkit/types"
-
+ "github.com/cometbft/cometbft/libs/log"
  "github.com/rollkit/rollkit/astria/sequencer"
+ "github.com/rollkit/rollkit/mempool"
 )
 
 type MempoolReaper struct {
  c *sequencer.Client
  mempool *mempool.CListMempool
+ logger log.Logger
 
  mu sync.Mutex
  started bool
  stopCh chan struct{}
 }
 
-func NewMempoolReaper(client *sequencer.Client, mempool *mempool.CListMempool) *MempoolReaper {
+func NewMempoolReaper(client *sequencer.Client, mempool *mempool.CListMempool, logger log.Logger) *MempoolReaper {
  return &MempoolReaper{
  c: client,
  mempool: mempool,
+ logger: logger,
  started: false,
  stopCh: make(chan struct{}),
  }
@@ -47,10 +48,12 @@ func (mr *MempoolReaper) Reap() {
  case <-mr.stopCh:
  return
  default:
- mempoolTx := tx0.Value.(*mempoolTx)
+ mempoolTx := tx0.Value.(*mempool.MempoolTx)
+
+ mr.logger.Info("reaped tx from mempool", "tx", mempoolTx.Tx())
 
  // submit to shared sequencer
- res, err := mr.c.BroadcastTx(mempoolTx.tx)
+ res, err := mr.c.BroadcastTx(mempoolTx.Tx())
  if err != nil {
  panic(fmt.Sprintf("error sending message: %s\n", err))
  }
@@ -95,17 +98,3 @@ func (mr *MempoolReaper) Stop() error {
  mr.started = false
  return nil
 }
-
-// copied from rollkit clist_mempool.go
-//--------------------------------------------------------------------------------
-
-// mempoolTx is a transaction that successfully ran
-type mempoolTx struct {
- height uint64 // height that this tx had been validated in
- gasWanted int64 // amount of gas this tx states it will require
- tx types.Tx //
-
- // ids of peers who've sent us this tx (as a map for quick lookups).
- // senders: PeerID -> bool
- senders sync.Map
-}

astria/sequencer/client.go

@@ -8,6 +8,7 @@ import (
  astriaPb "buf.build/gen/go/astria/astria/protocolbuffers/go/astria/sequencer/v1alpha1"
  "github.com/astriaorg/go-sequencer-client/client"
  tendermintPb "github.com/cometbft/cometbft/rpc/core/types"
+ "google.golang.org/protobuf/encoding/protojson"
 )
 
 // SequencerClient is a client for interacting with the sequencer.
@@ -51,7 +52,8 @@ func (c *Client) BroadcastTx(tx []byte) (*tendermintPb.ResultBroadcastTx, error)
  return nil, err
  }
 
- fmt.Printf("submitting tx to sequencer: %s\n", tx)
+ signedJson, _ := protojson.Marshal(signed)
+ fmt.Printf("submitting tx to sequencer: %s\n", signedJson)
 
  resp, err := c.Client.BroadcastTxSync(context.Background(), signed)
  if err != nil {

block/ss_manager.go

@@ -68,6 +68,7 @@ func NewSSManager(
 
  exec := state.NewBlockExecutor(proposerAddress, genesis.ChainID, mempool, proxyApp, eventBus, logger, execMetrics)
  if s.LastBlockHeight+1 == uint64(genesis.InitialHeight) {
+ logger.Info("Initializing chain")
  res, err := exec.InitChain(genesis)
  if err != nil {
  return nil, err

config/defaults.go

@@ -11,7 +11,7 @@ const (
  DefaultListenAddress = "/ip4/0.0.0.0/tcp/7676"
  // Version is the current rollkit version
  // Please keep updated with each new release
- Version = "0.12.0"
+ Version = "0.13.0"
 )
 
 // DefaultNodeConfig keeps default values of NodeConfig

go.mod

@@ -33,19 +33,15 @@ require (
 )
 
 require (
+ buf.build/gen/go/astria/astria/protocolbuffers/go v1.32.0-20240208041217-cec081a8099b.1
+ buf.build/gen/go/astria/execution-apis/grpc/go v1.3.0-20240207231045-2f6384a93a8d.2
+ buf.build/gen/go/astria/execution-apis/protocolbuffers/go v1.32.0-20240207231045-2f6384a93a8d.1
+ github.com/astriaorg/go-sequencer-client v0.0.0-20231201013457-0df599de8e74
  github.com/celestiaorg/go-header v0.5.2
  github.com/ipfs/go-ds-badger4 v0.1.5
 )
 
 require (
- buf.build/gen/go/astria/astria/grpc/go v1.3.0-20240207143250-56389ebbf26d.2 // indirect
- buf.build/gen/go/astria/astria/protocolbuffers/go v1.31.0-20231130012811-2fd7e6d46ebd.2 // indirect
- buf.build/gen/go/cosmos/cosmos-proto/protocolbuffers/go v1.31.0-20211202220400-1935555c206d.2 // indirect
- buf.build/gen/go/cosmos/cosmos-sdk/protocolbuffers/go v1.31.0-20230719110346-aa25660f4ff7.2 // indirect
- buf.build/gen/go/cosmos/gogo-proto/protocolbuffers/go v1.31.0-20230509103710-5e5b9fdd0180.2 // indirect
- buf.build/gen/go/cosmos/ibc/protocolbuffers/go v1.31.0-20230913112312-7ab44ae956a0.2 // indirect
- buf.build/gen/go/penumbra-zone/penumbra/protocolbuffers/go v1.31.0-20231120132728-bc443669626d.2 // indirect
- github.com/astriaorg/go-sequencer-client v0.0.0-20231201013457-0df599de8e74 // indirect
  github.com/benbjohnson/clock v1.3.5 // indirect
  github.com/beorn7/perks v1.0.1 // indirect
  github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
@@ -184,8 +180,6 @@ require (
  golang.org/x/text v0.14.0 // indirect
  golang.org/x/tools v0.16.0 // indirect
  gonum.org/v1/gonum v0.12.0 // indirect
- google.golang.org/genproto v0.0.0-20231106174013-bbf56f31fb17 // indirect
- google.golang.org/genproto/googleapis/api v0.0.0-20231106174013-bbf56f31fb17 // indirect
  google.golang.org/genproto/googleapis/rpc v0.0.0-20231120223509-83a465c0220f // indirect
  gopkg.in/ini.v1 v1.67.0 // indirect
  gopkg.in/yaml.v3 v3.0.1 // indirect