feat: proper parsing for multiasset TX outputs

Fixes #209

fix: proper CBOR encoding for ByteString

feat: generic CBOR encode function

test: helper function for decoding hex string without capturing error

Author: agaffney

cbor/bytestring.go

@@ -19,15 +19,11 @@ import (
 )
 
 // Wrapper for bytestrings that allows them to be used as keys for a map
-type ByteString struct {
-	// We use a string because []byte isn't comparable, which means it can't be used as a map key
-	data string
-}
+// We use a string because []byte isn't comparable, which means it can't be used as a map key
+type ByteString string
 
 func NewByteString(data []byte) ByteString {
-	bs := ByteString{
-		data: string(data),
-	}
+	bs := ByteString(data)
 	return bs
 }
 
@@ -36,14 +32,18 @@ func (bs *ByteString) UnmarshalCBOR(data []byte) error {
 	if _, err := Decode(data, &tmpValue); err != nil {
 		return err
 	}
-	bs.data = string(tmpValue)
+	*bs = ByteString(tmpValue)
 	return nil
 }
 
+func (bs ByteString) MarshalCBOR() ([]byte, error) {
+	return Encode([]byte(bs))
+}
+
 func (bs ByteString) Bytes() []byte {
-	return []byte(bs.data)
+	return []byte(bs)
 }
 
 func (bs ByteString) String() string {
-	return hex.EncodeToString([]byte(bs.data))
+	return hex.EncodeToString([]byte(bs))
 }

cbor/encode.go

@@ -16,8 +16,11 @@ package cbor
 
 import (
 	"bytes"
+	"fmt"
+	"reflect"
 
 	_cbor "github.com/fxamacker/cbor/v2"
+	"github.com/jinzhu/copier"
 )
 
 func Encode(data interface{}) ([]byte, error) {
@@ -30,3 +33,35 @@ func Encode(data interface{}) ([]byte, error) {
 	err = enc.Encode(data)
 	return buf.Bytes(), err
 }
+
+// EncodeGeneric encodes the specified object to CBOR without using the source object's
+// MarshalCBOR() function
+func EncodeGeneric(src interface{}) ([]byte, error) {
+	// Create a duplicate(-ish) struct from the destination
+	// We do this so that we can bypass any custom UnmarshalCBOR() function on the
+	// destination object
+	valueSrc := reflect.ValueOf(src)
+	if valueSrc.Kind() != reflect.Pointer || valueSrc.Elem().Kind() != reflect.Struct {
+		return nil, fmt.Errorf("source must be a pointer to a struct")
+	}
+	typeSrcElem := valueSrc.Elem().Type()
+	srcTypeFields := []reflect.StructField{}
+	for i := 0; i < typeSrcElem.NumField(); i++ {
+		tmpField := typeSrcElem.Field(i)
+		if tmpField.IsExported() && tmpField.Name != "DecodeStoreCbor" {
+			srcTypeFields = append(srcTypeFields, tmpField)
+		}
+	}
+	// Create temporary object with the type created above
+	tmpSrc := reflect.New(reflect.StructOf(srcTypeFields))
+	// Copy values from source object into temporary object
+	if err := copier.Copy(tmpSrc.Interface(), src); err != nil {
+		return nil, err
+	}
+	// Encode temporary object into CBOR
+	cborData, err := Encode(tmpSrc.Interface())
+	if err != nil {
+		return nil, err
+	}
+	return cborData, nil
+}

cbor/value.go

@@ -53,7 +53,7 @@ func (v *Value) UnmarshalCBOR(data []byte) error {
 		v.Value = tmpValue
 	case CBOR_TYPE_BYTE_STRING:
 		// Use our custom type which stores the bytestring in a way that allows it to be used as a map key
-		tmpValue := ByteString{}
+		var tmpValue ByteString
 		if _, err := Decode(data, &tmpValue); err != nil {
 			return err
 		}

internal/test/helpers.go

@@ -0,0 +1,19 @@
+package test
+
+import (
+	"encoding/hex"
+	"fmt"
+	"strings"
+)
+
+// DecodeHexString is a helper function for tests that decodes hex strings. It doesn't return
+// an error value, which makes it usable inline.
+func DecodeHexString(hexData string) []byte {
+	// Strip off any leading/trailing whitespace in hex string
+	hexData = strings.TrimSpace(hexData)
+	decoded, err := hex.DecodeString(hexData)
+	if err != nil {
+		panic(fmt.Sprintf("error decoding hex: %s", err))
+	}
+	return decoded
+}

ledger/alonzo.go

@@ -95,7 +95,7 @@ type AlonzoTransactionOutput struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
 	Address   Blake2b256
-	Amount    cbor.Value
+	Amount    MaryTransactionOutputValue
 	DatumHash Blake2b256
 }
 

ledger/babbage.go

@@ -136,10 +136,10 @@ func (b *BabbageTransactionBody) UnmarshalCBOR(cborData []byte) error {
 }
 
 type BabbageTransactionOutput struct {
-	Address      Blake2b256        `cbor:"0,keyasint,omitempty"`
-	Amount       cbor.Value        `cbor:"1,keyasint,omitempty"`
-	DatumOption  []cbor.RawMessage `cbor:"2,keyasint,omitempty"`
-	ScriptRef    cbor.Tag          `cbor:"3,keyasint,omitempty"`
+	Address      Blake2b256                 `cbor:"0,keyasint,omitempty"`
+	Amount       MaryTransactionOutputValue `cbor:"1,keyasint,omitempty"`
+	DatumOption  []cbor.RawMessage          `cbor:"2,keyasint,omitempty"`
+	ScriptRef    cbor.Tag                   `cbor:"3,keyasint,omitempty"`
 	legacyOutput bool
 }
 

ledger/mary.go

@@ -95,16 +95,34 @@ type MaryTransaction struct {
 	Metadata   cbor.Value
 }
 
-// TODO: support both forms
-/*
-transaction_output = [address, amount : value]
-value = coin / [coin,multiasset<uint>]
-*/
-
 type MaryTransactionOutput struct {
 	cbor.StructAsArray
 	Address Blake2b256
-	Amount  cbor.Value
+	Amount  MaryTransactionOutputValue
+}
+
+type MaryTransactionOutputValue struct {
+	cbor.StructAsArray
+	Amount uint64
+	Assets map[Blake2b224]map[cbor.ByteString]uint64
+}
+
+func (v *MaryTransactionOutputValue) UnmarshalCBOR(data []byte) error {
+	if _, err := cbor.Decode(data, &(v.Amount)); err == nil {
+		return nil
+	}
+	if err := cbor.DecodeGeneric(data, v); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (v *MaryTransactionOutputValue) MarshalCBOR() ([]byte, error) {
+	if v.Assets == nil {
+		return cbor.Encode(v.Amount)
+	} else {
+		return cbor.EncodeGeneric(v)
+	}
 }
 
 func NewMaryBlockFromCbor(data []byte) (*MaryBlock, error) {

ledger/mary_test.go

@@ -0,0 +1,99 @@
+// 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 (
+	"encoding/hex"
+	"reflect"
+	"testing"
+
+	"github.com/blinklabs-io/gouroboros/cbor"
+	"github.com/blinklabs-io/gouroboros/internal/test"
+)
+
+func createMaryTransactionOutputValueAssets(policyId []byte, assetName []byte, amount uint64) map[Blake2b224]map[cbor.ByteString]uint64 {
+	ret := map[Blake2b224]map[cbor.ByteString]uint64{}
+	policyIdKey := Blake2b224{}
+	copy(policyIdKey[:], policyId)
+	assetKey := cbor.ByteString(assetName)
+	ret[policyIdKey] = map[cbor.ByteString]uint64{
+		assetKey: amount,
+	}
+	return ret
+}
+
+func TestMaryTransactionOutputValueEncodeDecode(t *testing.T) {
+	var tests = []struct {
+		CborHex string
+		Object  interface{}
+	}{
+		{
+			CborHex: "1a02d71996",
+			Object:  MaryTransactionOutputValue{Amount: 47651222},
+		},
+		{
+			CborHex: "1b0000000129d2de56",
+			Object:  MaryTransactionOutputValue{Amount: 4996652630},
+		},
+		{
+			CborHex: "821a003d0900a1581c00000002df633853f6a47465c9496721d2d5b1291b8398016c0e87aea1476e7574636f696e01",
+			// [4000000, {h'00000002DF633853F6A47465C9496721D2D5B1291B8398016C0E87AE': {h'6E7574636F696E': 1}}]
+			Object: MaryTransactionOutputValue{
+				Amount: 4000000,
+				Assets: createMaryTransactionOutputValueAssets(
+					test.DecodeHexString("00000002DF633853F6A47465C9496721D2D5B1291B8398016C0E87AE"),
+					test.DecodeHexString("6E7574636F696E"),
+					1,
+				),
+			},
+		},
+		{
+			CborHex: "821a004986e3a1581c3a9241cd79895e3a8d65261b40077d4437ce71e9d7c8c6c00e3f658ea1494669727374636f696e01",
+			// [4818659, {h'3A9241CD79895E3A8D65261B40077D4437CE71E9D7C8C6C00E3F658E': {h'4669727374636F696E': 1}}]
+			Object: MaryTransactionOutputValue{
+				Amount: 4818659,
+				Assets: createMaryTransactionOutputValueAssets(
+					test.DecodeHexString("3A9241CD79895E3A8D65261B40077D4437CE71E9D7C8C6C00E3F658E"),
+					test.DecodeHexString("4669727374636F696E"),
+					1,
+				),
+			},
+		},
+	}
+	for _, test := range tests {
+		// Test decode
+		cborData, err := hex.DecodeString(test.CborHex)
+		if err != nil {
+			t.Fatalf("failed to decode CBOR hex: %s", err)
+		}
+		tmpObj := MaryTransactionOutputValue{}
+		_, err = cbor.Decode(cborData, &tmpObj)
+		if err != nil {
+			t.Fatalf("failed to decode CBOR: %s", err)
+		}
+		if !reflect.DeepEqual(tmpObj, test.Object) {
+			t.Fatalf("CBOR did not decode to expected object\n  got:    %#v\n  wanted: %#v", tmpObj, test.Object)
+		}
+		// Test encode
+		cborData, err = cbor.Encode(test.Object)
+		if err != nil {
+			t.Fatalf("failed to encode object to CBOR: %s", err)
+		}
+		cborHex := hex.EncodeToString(cborData)
+		if cborHex != test.CborHex {
+			t.Fatalf("object did not encode to expected CBOR\n  got:    %s\n  wanted: %s", cborHex, test.CborHex)
+		}
+	}
+}