feat:add Mary protocol parameters support

ledger/mary.go

@@ -39,7 +39,7 @@ type MaryBlock struct {
 	cbor.DecodeStoreCbor
 	Header                 *MaryBlockHeader
 	TransactionBodies      []MaryTransactionBody
-	TransactionWitnessSets []ShelleyTransactionWitnessSet
+	TransactionWitnessSets []MaryTransactionWitnessSet
 	TransactionMetadataSet map[uint]*cbor.Value
 }
 
@@ -115,6 +115,11 @@ func (h *MaryBlockHeader) Era() Era {
 
 type MaryTransactionBody struct {
 	AllegraTransactionBody
+	Update struct {
+		cbor.StructAsArray
+		ProtocolParamUpdates map[Blake2b224]MaryProtocolParameterUpdate
+		Epoch                uint64
+	} `cbor:"6,keyasint,omitempty"`
 	TxOutputs []MaryTransactionOutput        `cbor:"1,keyasint,omitempty"`
 	Mint      MultiAsset[MultiAssetTypeMint] `cbor:"9,keyasint,omitempty"`
 }
@@ -136,10 +141,16 @@ type MaryTransaction struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
 	Body       MaryTransactionBody
-	WitnessSet ShelleyTransactionWitnessSet
+	WitnessSet MaryTransactionWitnessSet
 	TxMetadata *cbor.Value
 }
 
+type MaryTransactionWitnessSet struct {
+	ShelleyTransactionWitnessSet
+	Script        []interface{} `cbor:"4,keyasint,omitempty"`
+	PlutusScripts []interface{} `cbor:"5,keyasint,omitempty"`
+}
+
 func (t MaryTransaction) Hash() string {
 	return t.Body.Hash()
 }
@@ -275,6 +286,14 @@ func (v *MaryTransactionOutputValue) MarshalCBOR() ([]byte, error) {
 	}
 }
 
+type MaryProtocolParameters struct {
+	AllegraProtocolParameters
+}
+
+type MaryProtocolParameterUpdate struct {
+	AllegraProtocolParameterUpdate
+}
+
 func NewMaryBlockFromCbor(data []byte) (*MaryBlock, error) {
 	var maryBlock MaryBlock
 	if _, err := cbor.Decode(data, &maryBlock); err != nil {

ledger/shelley.go

@@ -432,7 +432,7 @@ type ShelleyProtocolParameterUpdate struct {
 	Rho                *cbor.Rat `cbor:"10,keyasint"`
 	Tau                *cbor.Rat `cbor:"11,keyasint"`
 	Decentralization   *cbor.Rat `cbor:"12,keyasint"`
-	Nonce              *cbor.Rat `cbor:"13,keyasint"`
+	Nonce              *Nonce    `cbor:"13,keyasint"`
 	ProtocolVersion    struct {
 		cbor.StructAsArray
 		Major uint
@@ -441,6 +441,39 @@ type ShelleyProtocolParameterUpdate struct {
 	MinUtxoValue uint `cbor:"15,keyasint"`
 }
 
+const (
+	NonceType0 = 0
+	NonceType1 = 1
+)
+
+type Nonce struct {
+	cbor.StructAsArray
+	Type  uint
+	Value [32]byte
+}
+
+func (n *Nonce) UnmarshalCBOR(data []byte) error {
+	nonceType, err := cbor.DecodeIdFromList(data)
+	if err != nil {
+		return err
+	}
+
+	n.Type = uint(nonceType)
+
+	switch nonceType {
+	case NonceType0:
+		// Value uses default value
+	case NonceType1:
+		if err := cbor.DecodeGeneric(data, n); err != nil {
+			fmt.Printf("Nonce decode error: %+v\n", data)
+			return err
+		}
+	default:
+		return fmt.Errorf("unsupported nonce type %d", nonceType)
+	}
+	return nil
+}
+
 func NewShelleyBlockFromCbor(data []byte) (*ShelleyBlock, error) {
 	var shelleyBlock ShelleyBlock
 	if _, err := cbor.Decode(data, &shelleyBlock); err != nil {

ledger/shelley_test.go

@@ -0,0 +1,41 @@
+package ledger
+
+import (
+	"testing"
+)
+
+func TestNonceUnmarshalCBOR(t *testing.T) {
+	testCases := []struct {
+		name        string
+		data        []byte
+		expectedErr string
+	}{
+		{
+			name: "NonceType0",
+			data: []byte{0x81, 0x00},
+		},
+		{
+			name: "NonceType1",
+			data: []byte{0x82, 0x01, 0x42, 0x01, 0x02},
+		},
+		{
+			name:        "UnsupportedNonceType",
+			data:        []byte{0x82, 0x02},
+			expectedErr: "unsupported nonce type 2",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			n := &Nonce{}
+			err := n.UnmarshalCBOR(tc.data)
+			if err != nil {
+				if tc.expectedErr == "" || err.Error() != tc.expectedErr {
+					t.Errorf("unexpected error: %v", err)
+				}
+			} else if tc.expectedErr != "" {
+				t.Errorf("expected error: %v, got nil", tc.expectedErr)
+			}
+		})
+	}
+}

protocol/localstatequery/client.go

@@ -354,6 +354,12 @@ func (c *Client) GetCurrentProtocolParams() (CurrentProtocolParamsResult, error)
 			return nil, err
 		}
 		return result[0], nil
+	case ledger.EraIdMary:
+		result := []ledger.MaryProtocolParameters{}
+		if err := c.runQuery(query, &result); err != nil {
+			return nil, err
+		}
+		return result[0], nil
 	case ledger.EraIdAllegra:
 		result := []ledger.AllegraProtocolParameters{}
 		if err := c.runQuery(query, &result); err != nil {