Merge pull request #413 from blinklabs-io/feat/ledger-conway-era

feat: conway era support

Author: agaffney

ledger/block.go

@@ -52,6 +52,8 @@ func NewBlockFromCbor(blockType uint, data []byte) (Block, error) {
 		return NewAlonzoBlockFromCbor(data)
 	case BlockTypeBabbage:
 		return NewBabbageBlockFromCbor(data)
+	case BlockTypeConway:
+		return NewConwayBlockFromCbor(data)
 	}
 	return nil, fmt.Errorf("unknown node-to-client block type: %d", blockType)
 }
@@ -66,7 +68,7 @@ func NewBlockHeaderFromCbor(blockType uint, data []byte) (BlockHeader, error) {
 	// TODO: break into separate cases and parse as specific block header types
 	case BlockTypeShelley, BlockTypeAllegra, BlockTypeMary, BlockTypeAlonzo:
 		return NewShelleyBlockHeaderFromCbor(data)
-	case BlockTypeBabbage:
+	case BlockTypeBabbage, BlockTypeConway:
 		return NewBabbageBlockHeaderFromCbor(data)
 	}
 	return nil, fmt.Errorf("unknown node-to-node block type: %d", blockType)

ledger/conway.go

@@ -0,0 +1,204 @@
+// Copyright 2023 Blink Labs, LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ledger
+
+import (
+	"fmt"
+
+	"github.com/blinklabs-io/gouroboros/cbor"
+)
+
+const (
+	EraIdConway = 6
+
+	BlockTypeConway = 7
+
+	BlockHeaderTypeConway = 6
+
+	TxTypeConway = 6
+)
+
+type ConwayBlock struct {
+	cbor.StructAsArray
+	cbor.DecodeStoreCbor
+	Header                 *ConwayBlockHeader
+	TransactionBodies      []ConwayTransactionBody
+	TransactionWitnessSets []BabbageTransactionWitnessSet
+	TransactionMetadataSet map[uint]*cbor.Value
+	InvalidTransactions    []uint
+}
+
+func (b *ConwayBlock) UnmarshalCBOR(cborData []byte) error {
+	return b.UnmarshalCbor(cborData, b)
+}
+
+func (b *ConwayBlock) Hash() string {
+	return b.Header.Hash()
+}
+
+func (b *ConwayBlock) BlockNumber() uint64 {
+	return b.Header.BlockNumber()
+}
+
+func (b *ConwayBlock) SlotNumber() uint64 {
+	return b.Header.SlotNumber()
+}
+
+func (b *ConwayBlock) IssuerVkey() IssuerVkey {
+	return b.Header.IssuerVkey()
+}
+
+func (b *ConwayBlock) BlockBodySize() uint64 {
+	return b.Header.BlockBodySize()
+}
+
+func (b *ConwayBlock) Era() Era {
+	return eras[EraIdConway]
+}
+
+func (b *ConwayBlock) Transactions() []Transaction {
+	ret := []Transaction{}
+	for idx := range b.TransactionBodies {
+		tmpTransaction := ConwayTransaction{
+			Body:       b.TransactionBodies[idx],
+			WitnessSet: b.TransactionWitnessSets[idx],
+			TxMetadata: b.TransactionMetadataSet[uint(idx)],
+		}
+		isValid := true
+		for _, invalidTxIdx := range b.InvalidTransactions {
+			if invalidTxIdx == uint(idx) {
+				isValid = false
+				break
+			}
+		}
+		tmpTransaction.IsValid = isValid
+		ret = append(ret, &tmpTransaction)
+	}
+	return ret
+}
+
+type ConwayBlockHeader struct {
+	BabbageBlockHeader
+}
+
+func (h *ConwayBlockHeader) Era() Era {
+	return eras[EraIdConway]
+}
+
+type ConwayTransactionBody struct {
+	BabbageTransactionBody
+	VotingProcedures     *cbor.Value `cbor:"19,keyasint,omitempty"`
+	ProposalProcedures   *cbor.Value `cbor:"20,keyasint,omitempty"`
+	CurrentTreasuryValue int64       `cbor:"21,keyasint,omitempty"`
+	Donation             uint64      `cbor:"22,keyasint,omitempty"`
+}
+
+func (b *ConwayTransactionBody) UnmarshalCBOR(cborData []byte) error {
+	return b.UnmarshalCbor(cborData, b)
+}
+
+type ConwayTransaction struct {
+	cbor.StructAsArray
+	cbor.DecodeStoreCbor
+	Body       ConwayTransactionBody
+	WitnessSet BabbageTransactionWitnessSet
+	IsValid    bool
+	TxMetadata *cbor.Value
+}
+
+func (t ConwayTransaction) Hash() string {
+	return t.Body.Hash()
+}
+
+func (t ConwayTransaction) Inputs() []TransactionInput {
+	return t.Body.Inputs()
+}
+
+func (t ConwayTransaction) Outputs() []TransactionOutput {
+	return t.Body.Outputs()
+}
+
+func (t ConwayTransaction) Fee() uint64 {
+	return t.Body.Fee()
+}
+
+func (t ConwayTransaction) TTL() uint64 {
+	return t.Body.TTL()
+}
+
+func (t ConwayTransaction) Metadata() *cbor.Value {
+	return t.TxMetadata
+}
+
+func (t *ConwayTransaction) Cbor() []byte {
+	// Return stored CBOR if we have any
+	cborData := t.DecodeStoreCbor.Cbor()
+	if cborData != nil {
+		return cborData[:]
+	}
+	// Return immediately if the body CBOR is also empty, which implies an empty TX object
+	if t.Body.Cbor() == nil {
+		return nil
+	}
+	// Generate our own CBOR
+	// This is necessary when a transaction is put together from pieces stored separately in a block
+	tmpObj := []any{
+		cbor.RawMessage(t.Body.Cbor()),
+		cbor.RawMessage(t.WitnessSet.Cbor()),
+		t.IsValid,
+	}
+	if t.TxMetadata != nil {
+		tmpObj = append(tmpObj, cbor.RawMessage(t.TxMetadata.Cbor()))
+	} else {
+		tmpObj = append(tmpObj, nil)
+	}
+	// This should never fail, since we're only encoding a list and a bool value
+	cborData, _ = cbor.Encode(&tmpObj)
+	return cborData
+}
+
+func NewConwayBlockFromCbor(data []byte) (*ConwayBlock, error) {
+	var conwayBlock ConwayBlock
+	if _, err := cbor.Decode(data, &conwayBlock); err != nil {
+		return nil, fmt.Errorf("Conway block decode error: %s", err)
+	}
+	return &conwayBlock, nil
+}
+
+func NewConwayBlockHeaderFromCbor(data []byte) (*ConwayBlockHeader, error) {
+	var conwayBlockHeader ConwayBlockHeader
+	if _, err := cbor.Decode(data, &conwayBlockHeader); err != nil {
+		return nil, fmt.Errorf("Conway block header decode error: %s", err)
+	}
+	return &conwayBlockHeader, nil
+}
+
+func NewConwayTransactionBodyFromCbor(
+	data []byte,
+) (*ConwayTransactionBody, error) {
+	var conwayTx ConwayTransactionBody
+	if _, err := cbor.Decode(data, &conwayTx); err != nil {
+		return nil, fmt.Errorf("Conway transaction body decode error: %s", err)
+	}
+	return &conwayTx, nil
+}
+
+func NewConwayTransactionFromCbor(data []byte) (*ConwayTransaction, error) {
+	var conwayTx ConwayTransaction
+	if _, err := cbor.Decode(data, &conwayTx); err != nil {
+		return nil, fmt.Errorf("Conway transaction decode error: %s", err)
+	}
+	return &conwayTx, nil
+}

ledger/era.go

@@ -44,6 +44,10 @@ var eras = map[uint8]Era{
 		Id:   EraIdBabbage,
 		Name: "Babbage",
 	},
+	EraIdConway: Era{
+		Id:   EraIdConway,
+		Name: "Conway",
+	},
 }
 
 func GetEraById(eraId uint8) *Era {

ledger/tx.go

@@ -64,6 +64,8 @@ func NewTransactionFromCbor(txType uint, data []byte) (Transaction, error) {
 		return NewAlonzoTransactionFromCbor(data)
 	case TxTypeBabbage:
 		return NewBabbageTransactionFromCbor(data)
+	case TxTypeConway:
+		return NewConwayTransactionFromCbor(data)
 	}
 	return nil, fmt.Errorf("unknown transaction type: %d", txType)
 }
@@ -85,6 +87,8 @@ func NewTransactionBodyFromCbor(
 		return NewAlonzoTransactionBodyFromCbor(data)
 	case TxTypeBabbage:
 		return NewBabbageTransactionBodyFromCbor(data)
+	case TxTypeConway:
+		return NewConwayTransactionBodyFromCbor(data)
 	}
 	return nil, fmt.Errorf("unknown transaction type: %d", txType)
 }
@@ -112,6 +116,9 @@ func DetermineTransactionType(data []byte) (uint, error) {
 	if _, err := NewBabbageTransactionFromCbor(data); err == nil {
 		return TxTypeBabbage, nil
 	}
+	if _, err := NewConwayTransactionFromCbor(data); err == nil {
+		return TxTypeConway, nil
+	}
 	return 0, fmt.Errorf("unknown transaction type")
 }
 

protocol/chainsync/client.go

@@ -282,6 +282,7 @@ func (c *Client) handleRollForward(msgGeneric protocol.Message) error {
 				ledger.BlockHeaderTypeMary:    ledger.BlockTypeMary,
 				ledger.BlockHeaderTypeAlonzo:  ledger.BlockTypeAlonzo,
 				ledger.BlockHeaderTypeBabbage: ledger.BlockTypeBabbage,
+				ledger.BlockHeaderTypeConway:  ledger.BlockTypeConway,
 			}
 			blockType = blockTypeMap[blockEra]
 			var err error