Add ExecutedBlock type

api/indexer/tx_indexer.go

@@ -25,8 +25,8 @@ const (
 )
 
 var (
-	_ event.SubscriptionFactory[*chain.StatefulBlock] = (*subscriptionFactory)(nil)
-	_ event.Subscription[*chain.StatefulBlock]        = (*txDBIndexer)(nil)
+	_ event.SubscriptionFactory[*chain.ExecutedBlock] = (*subscriptionFactory)(nil)
+	_ event.Subscription[*chain.ExecutedBlock]        = (*txDBIndexer)(nil)
 )
 
 type Config struct {
@@ -47,7 +47,7 @@ func OptionFunc(v *vm.VM, config Config) error {
 	if !config.Enabled {
 		return nil
 	}
-	dbPath := filepath.Join(v.DataDir, "indexer", "db")
+	dbPath := filepath.Join(v.DataDir, Namespace)
 	db, _, err := pebble.New(dbPath, pebble.NewDefaultConfig())
 	if err != nil {
 		return err
@@ -77,26 +77,24 @@ type subscriptionFactory struct {
 	indexer *txDBIndexer
 }
 
-func (s *subscriptionFactory) New() (event.Subscription[*chain.StatefulBlock], error) {
+func (s *subscriptionFactory) New() (event.Subscription[*chain.ExecutedBlock], error) {
 	return s.indexer, nil
 }
 
 type txDBIndexer struct {
 	db database.Database
 }
 
-func (t *txDBIndexer) Accept(blk *chain.StatefulBlock) error {
+func (t *txDBIndexer) Accept(blk *chain.ExecutedBlock) error {
 	batch := t.db.NewBatch()
 	defer batch.Reset()
 
-	timestamp := blk.GetTimestamp()
-	results := blk.Results()
 	for j, tx := range blk.Txs {
-		result := results[j]
+		result := blk.Results[j]
 		if err := t.storeTransaction(
 			batch,
 			tx.ID(),
-			timestamp,
+			blk.Tmstmp,
 			result.Success,
 			result.Units,
 			result.Fee,

api/ws/client.go

@@ -151,7 +151,11 @@ func (c *WebSocketClient) ListenBlock(
 ) (*chain.StatelessBlock, []*chain.Result, fees.Dimensions, error) {
 	select {
 	case msg := <-c.pendingBlocks:
-		return UnpackBlockMessage(msg, parser)
+		executedBlock, err := chain.UnmarshalExecutedBlock(msg, parser)
+		if err != nil {
+			return nil, nil, fees.Dimensions{}, err
+		}
+		return executedBlock.StatelessBlock, executedBlock.Results, executedBlock.UnitPrices, nil
 	case <-c.readStopped:
 		return nil, nil, fees.Dimensions{}, c.err
 	case <-ctx.Done():

api/ws/packer.go

@@ -11,57 +11,13 @@ import (
 	"github.com/ava-labs/hypersdk/chain"
 	"github.com/ava-labs/hypersdk/codec"
 	"github.com/ava-labs/hypersdk/consts"
-	"github.com/ava-labs/hypersdk/fees"
 )
 
 const (
 	BlockMode byte = 0
 	TxMode    byte = 1
 )
 
-func PackBlockMessage(b *chain.StatefulBlock) ([]byte, error) {
-	results := b.Results()
-	size := codec.BytesLen(b.Bytes()) + consts.IntLen + codec.CummSize(results) + fees.DimensionsLen
-	p := codec.NewWriter(size, consts.MaxInt)
-	p.PackBytes(b.Bytes())
-	mresults, err := chain.MarshalResults(results)
-	if err != nil {
-		return nil, err
-	}
-	p.PackBytes(mresults)
-	p.PackFixedBytes(b.FeeManager().UnitPrices().Bytes())
-	return p.Bytes(), p.Err()
-}
-
-func UnpackBlockMessage(
-	msg []byte,
-	parser chain.Parser,
-) (*chain.StatelessBlock, []*chain.Result, fees.Dimensions, error) {
-	p := codec.NewReader(msg, consts.MaxInt)
-	var blkMsg []byte
-	p.UnpackBytes(-1, true, &blkMsg)
-	blk, err := chain.UnmarshalBlock(blkMsg, parser)
-	if err != nil {
-		return nil, nil, fees.Dimensions{}, err
-	}
-	var resultsMsg []byte
-	p.UnpackBytes(-1, true, &resultsMsg)
-	results, err := chain.UnmarshalResults(resultsMsg)
-	if err != nil {
-		return nil, nil, fees.Dimensions{}, err
-	}
-	pricesMsg := make([]byte, fees.DimensionsLen)
-	p.UnpackFixedBytes(fees.DimensionsLen, &pricesMsg)
-	prices, err := fees.UnpackDimensions(pricesMsg)
-	if err != nil {
-		return nil, nil, fees.Dimensions{}, err
-	}
-	if !p.Empty() {
-		return nil, nil, fees.Dimensions{}, chain.ErrInvalidObject
-	}
-	return blk, results, prices, p.Err()
-}
-
 // Could be a better place for these methods
 // Packs an accepted block message
 func PackAcceptedTxMessage(txID ids.ID, result *chain.Result) ([]byte, error) {

api/ws/server.go

@@ -72,8 +72,8 @@ func OptionFunc(v *vm.VM, config Config) error {
 		},
 	}
 
-	blockSubscription := event.SubscriptionFuncFactory[*chain.StatefulBlock]{
-		AcceptF: func(event *chain.StatefulBlock) error {
+	blockSubscription := event.SubscriptionFuncFactory[*chain.ExecutedBlock]{
+		AcceptF: func(event *chain.ExecutedBlock) error {
 			return server.AcceptBlock(event)
 		},
 	}
@@ -193,9 +193,9 @@ func (w *WebSocketServer) setMinTx(t int64) error {
 	return nil
 }
 
-func (w *WebSocketServer) AcceptBlock(b *chain.StatefulBlock) error {
+func (w *WebSocketServer) AcceptBlock(b *chain.ExecutedBlock) error {
 	if w.blockListeners.Len() > 0 {
-		bytes, err := PackBlockMessage(b)
+		bytes, err := b.Marshal()
 		if err != nil {
 			return err
 		}
@@ -207,7 +207,7 @@ func (w *WebSocketServer) AcceptBlock(b *chain.StatefulBlock) error {
 
 	w.txL.Lock()
 	defer w.txL.Unlock()
-	results := b.Results()
+	results := b.Results
 	for i, tx := range b.Txs {
 		txID := tx.ID()
 		listeners, ok := w.txListeners[txID]

chain/block.go

@@ -26,6 +26,8 @@ import (
 	"github.com/ava-labs/hypersdk/internal/workers"
 	"github.com/ava-labs/hypersdk/state"
 	"github.com/ava-labs/hypersdk/utils"
+
+	publicfees "github.com/ava-labs/hypersdk/fees"
 )
 
 var (
@@ -894,6 +896,79 @@ func (b *StatefulBlock) FeeManager() *fees.Manager {
 	return b.feeManager
 }
 
+func (b *StatefulBlock) ExecutedBlock() *ExecutedBlock {
+	return &ExecutedBlock{
+		StatelessBlock: b.StatelessBlock,
+		Results:        b.results,
+		UnitPrices:     b.feeManager.UnitPrices(),
+		blockBytes:     b.Bytes(),
+		id:             b.ID(),
+	}
+}
+
+type ExecutedBlock struct {
+	*StatelessBlock `json:"block"`
+	Results         []*Result             `json:"results"`
+	UnitPrices      publicfees.Dimensions `json:"unitPrices"`
+
+	blockBytes []byte
+	id         ids.ID
+}
+
+func (b *ExecutedBlock) ID() ids.ID { return b.id }
+
+func (b *ExecutedBlock) Marshal() ([]byte, error) {
+	size := codec.BytesLen(b.blockBytes) + codec.CummSize(b.Results) + publicfees.DimensionsLen
+	writer := codec.NewWriter(size, consts.NetworkSizeLimit)
+
+	writer.PackBytes(b.blockBytes)
+	resultBytes, err := MarshalResults(b.Results)
+	if err != nil {
+		return nil, err
+	}
+	writer.PackBytes(resultBytes)
+	writer.PackFixedBytes(b.UnitPrices.Bytes())
+
+	return writer.Bytes(), writer.Err()
+}
+
+func UnmarshalExecutedBlock(bytes []byte, parser Parser) (*ExecutedBlock, error) {
+	reader := codec.NewReader(bytes, consts.NetworkSizeLimit)
+
+	var blkMsg []byte
+	reader.UnpackBytes(-1, true, &blkMsg)
+	blk, err := UnmarshalBlock(blkMsg, parser)
+	if err != nil {
+		return nil, err
+	}
+	var resultsMsg []byte
+	reader.UnpackBytes(-1, true, &resultsMsg)
+	results, err := UnmarshalResults(resultsMsg)
+	if err != nil {
+		return nil, err
+	}
+	unitPricesBytes := make([]byte, publicfees.DimensionsLen)
+	reader.UnpackFixedBytes(publicfees.DimensionsLen, &unitPricesBytes)
+	prices, err := publicfees.UnpackDimensions(unitPricesBytes)
+	if err != nil {
+		return nil, err
+	}
+	if !reader.Empty() {
+		return nil, ErrInvalidObject
+	}
+	blkID, err := blk.ID()
+	if err != nil {
+		return nil, err
+	}
+	return &ExecutedBlock{
+		StatelessBlock: blk,
+		Results:        results,
+		UnitPrices:     prices,
+		blockBytes:     blkMsg,
+		id:             blkID,
+	}, nil
+}
+
 type SyncableBlock struct {
 	*StatefulBlock
 }

extension/externalsubscriber/client.go

@@ -17,7 +17,7 @@ import (
 	pb "github.com/ava-labs/hypersdk/proto/pb/externalsubscriber"
 )
 
-var _ event.Subscription[*chain.StatefulBlock] = (*ExternalSubscriberClient)(nil)
+var _ event.Subscription[*chain.ExecutedBlock] = (*ExternalSubscriberClient)(nil)
 
 type ExternalSubscriberClient struct {
 	conn   *grpc.ClientConn
@@ -55,19 +55,14 @@ func NewExternalSubscriberClient(
 	}, nil
 }
 
-func (e *ExternalSubscriberClient) Accept(blk *chain.StatefulBlock) error {
+func (e *ExternalSubscriberClient) Accept(blk *chain.ExecutedBlock) error {
 	blockBytes, err := blk.Marshal()
 	if err != nil {
 		return err
 	}
-	resultsMarshaled, err := chain.MarshalResults(blk.Results())
-	if err != nil {
-		return err
-	}
 
 	req := &pb.BlockRequest{
 		BlockData: blockBytes,
-		Results:   resultsMarshaled,
 	}
 	e.log.Debug("sending accepted block to server",
 		zap.Stringer("blockID", blk.ID()),

extension/externalsubscriber/option.go

@@ -42,8 +42,8 @@ func OptionFunc(v *vm.VM, config Config) error {
 		return err
 	}
 
-	blockSubscription := event.SubscriptionFuncFactory[*chain.StatefulBlock]{
-		AcceptF: func(blk *chain.StatefulBlock) error {
+	blockSubscription := event.SubscriptionFuncFactory[*chain.ExecutedBlock]{
+		AcceptF: func(blk *chain.ExecutedBlock) error {
 			return server.Accept(blk)
 		},
 	}

extension/externalsubscriber/server.go

@@ -24,35 +24,18 @@ var (
 	ErrParserAlreadyInitialized = errors.New("parser already initialized")
 )
 
-// TODO: switch to eventually using chain.Stateless block
-// Wrapper to pass blocks + results to subscribers
-type ExternalSubscriberSubscriptionData struct {
-	Blk     *chain.StatelessBlock
-	Results []*chain.Result
-}
-
-func NewExternalSubscriberSubscriptionData(
-	blk *chain.StatelessBlock,
-	results []*chain.Result,
-) *ExternalSubscriberSubscriptionData {
-	return &ExternalSubscriberSubscriptionData{
-		Blk:     blk,
-		Results: results,
-	}
-}
-
 type ExternalSubscriberServer struct {
 	pb.ExternalSubscriberServer
 	parser              chain.Parser
 	createParser        CreateParser
-	acceptedSubscribers []event.Subscription[*ExternalSubscriberSubscriptionData]
+	acceptedSubscribers []event.Subscription[*chain.ExecutedBlock]
 	log                 logging.Logger
 }
 
 func NewExternalSubscriberServer(
 	logger logging.Logger,
 	createParser CreateParser,
-	acceptedSubscribers []event.Subscription[*ExternalSubscriberSubscriptionData],
+	acceptedSubscribers []event.Subscription[*chain.ExecutedBlock],
 ) *ExternalSubscriberServer {
 	return &ExternalSubscriberServer{
 		log:                 logger,
@@ -80,12 +63,7 @@ func (e *ExternalSubscriberServer) AcceptBlock(_ context.Context, b *pb.BlockReq
 	if e.parser == nil {
 		return &emptypb.Empty{}, ErrParserNotInitialized
 	}
-	blk, err := chain.UnmarshalBlock(b.BlockData, e.parser)
-	if err != nil {
-		return &emptypb.Empty{}, err
-	}
-
-	results, err := chain.UnmarshalResults(b.Results)
+	blk, err := chain.UnmarshalExecutedBlock(b.BlockData, e.parser)
 	if err != nil {
 		return &emptypb.Empty{}, err
 	}
@@ -94,10 +72,9 @@ func (e *ExternalSubscriberServer) AcceptBlock(_ context.Context, b *pb.BlockReq
 		zap.Uint64("height", blk.Hght),
 	)
 
-	// Forward block + results
-	externalSubscriberSubscriptionData := NewExternalSubscriberSubscriptionData(blk, results)
+	// Forward to subscribers
 	for _, s := range e.acceptedSubscribers {
-		if err := s.Accept(externalSubscriberSubscriptionData); err != nil {
+		if err := s.Accept(blk); err != nil {
 			return &emptypb.Empty{}, err
 		}
 	}

fees/dimension.go

@@ -104,9 +104,11 @@ func (d Dimensions) Greater(o Dimensions) bool {
 	return true
 }
 
+const dimensionsFormatter = "(Bandwidth=%d, Compute=%d, Storage(Read)=%d, Storage(Allocate)=%d, Storage(Write)=%d)"
+
 func (d Dimensions) String() string {
 	return fmt.Sprintf(
-		"bandwidth=%d compute=%d storage(read)=%d storage(allocate)=%d storage(write)=%d",
+		dimensionsFormatter,
 		d[Bandwidth],
 		d[Compute],
 		d[StorageRead],
@@ -115,6 +117,29 @@ func (d Dimensions) String() string {
 	)
 }
 
+func (d Dimensions) MarshalText() ([]byte, error) {
+	return []byte(d.String()), nil
+}
+
+func (d *Dimensions) UnmarshalText(b []byte) error {
+	n, err := fmt.Sscanf(
+		string(b),
+		dimensionsFormatter,
+		&d[Bandwidth],
+		&d[Compute],
+		&d[StorageRead],
+		&d[StorageAllocate],
+		&d[StorageWrite],
+	)
+	if err != nil {
+		return err
+	}
+	if n != FeeDimensions {
+		return fmt.Errorf("failed to parse %d successive dimensions, found %d", FeeDimensions, n)
+	}
+	return nil
+}
+
 func UnpackDimensions(raw []byte) (Dimensions, error) {
 	if len(raw) != DimensionsLen {
 		return Dimensions{}, fmt.Errorf("%w: found=%d wanted=%d", ErrWrongDimensionSize, len(raw), DimensionsLen)