Make CRN Credit Note use fixed currency value and add TransfersPermitted.

Author: KarlTheProgrammer

dist/golang/instruments/amendments.go

@@ -1807,6 +1807,7 @@ const (
 	CreditNoteFieldName                = uint32(1)
 	CreditNoteFieldFaceValue           = uint32(2)
 	CreditNoteFieldExpirationTimestamp = uint32(3)
+	CreditNoteFieldTransfersPermitted  = uint32(4)
 )
 
 // ApplyAmendment updates a CreditNote based on amendment data.
@@ -1824,7 +1825,7 @@ func (a *CreditNote) ApplyAmendment(fip permissions.FieldIndexPath, operation ui
 		a.Name = string(data)
 		return permissions.SubPermissions(fip, operation, false)
 
-	case CreditNoteFieldFaceValue: // CurrencyValueField
+	case CreditNoteFieldFaceValue: // FixedCurrencyValueField
 		if len(fip) == 1 && len(data) == 0 {
 			a.FaceValue = nil
 			return permissions.SubPermissions(fip[1:], operation, false)
@@ -1849,6 +1850,19 @@ func (a *CreditNote) ApplyAmendment(fip permissions.FieldIndexPath, operation ui
 		}
 		return permissions.SubPermissions(fip, operation, false)
 
+	case CreditNoteFieldTransfersPermitted: // bool
+		if len(fip) > 1 {
+			return nil, fmt.Errorf("Amendment field index path too deep for TransfersPermitted : %v", fip)
+		}
+		if len(data) != 1 {
+			return nil, fmt.Errorf("TransfersPermitted amendment value is wrong size : %d", len(data))
+		}
+		buf := bytes.NewBuffer(data)
+		if err := binary.Read(buf, binary.LittleEndian, &a.TransfersPermitted); err != nil {
+			return nil, fmt.Errorf("TransfersPermitted amendment value failed to deserialize : %s", err)
+		}
+		return permissions.SubPermissions(fip, operation, false)
+
 	}
 
 	return nil, fmt.Errorf("Unknown CreditNote amendment field index : %v", fip)
@@ -1875,7 +1889,7 @@ func (a *CreditNote) CreateAmendments(fip permissions.FieldIndexPath,
 		})
 	}
 
-	// FaceValue CurrencyValueField
+	// FaceValue FixedCurrencyValueField
 	fip = append(ofip, CreditNoteFieldFaceValue)
 
 	FaceValueAmendments, err := a.FaceValue.CreateAmendments(fip, newValue.FaceValue)
@@ -1898,6 +1912,20 @@ func (a *CreditNote) CreateAmendments(fip permissions.FieldIndexPath,
 		})
 	}
 
+	// TransfersPermitted bool
+	fip = append(ofip, CreditNoteFieldTransfersPermitted)
+	if a.TransfersPermitted != newValue.TransfersPermitted {
+		var buf bytes.Buffer
+		if err := binary.Write(&buf, binary.LittleEndian, newValue.TransfersPermitted); err != nil {
+			return nil, errors.Wrap(err, "TransfersPermitted")
+		}
+
+		result = append(result, &internal.Amendment{
+			FIP:  fip,
+			Data: buf.Bytes(),
+		})
+	}
+
 	return result, nil
 }
 
@@ -2242,6 +2270,112 @@ func (a *CurrencyValueField) CreateAmendments(fip permissions.FieldIndexPath,
 	return result, nil
 }
 
+// FixedCurrencyValueField Permission / Amendment Field Indices
+const (
+	FixedCurrencyValueFieldValue        = uint32(1)
+	FixedCurrencyValueFieldCurrencyCode = uint32(2)
+	FixedCurrencyValueFieldPrecision    = uint32(3)
+)
+
+// ApplyAmendment updates a FixedCurrencyValueField based on amendment data.
+// Note: This does not check permissions or data validity. This does check data format.
+// fip must have at least one value.
+func (a *FixedCurrencyValueField) ApplyAmendment(fip permissions.FieldIndexPath, operation uint32,
+	data []byte, permissions permissions.Permissions) (permissions.Permissions, error) {
+
+	if len(fip) == 0 {
+		return nil, errors.New("Empty FixedCurrencyValue amendment field index path")
+	}
+
+	switch fip[0] {
+	case FixedCurrencyValueFieldValue: // uint64
+
+		if len(fip) > 1 {
+			return nil, fmt.Errorf("Amendment field index path too deep for Value : %v", fip)
+		}
+		buf := bytes.NewBuffer(data)
+		if value, err := bitcoin.ReadBase128VarInt(buf); err != nil {
+			return nil, fmt.Errorf("Value amendment value failed to deserialize : %s", err)
+		} else {
+			a.Value = uint64(value)
+		}
+		return permissions.SubPermissions(fip, operation, false)
+	case FixedCurrencyValueFieldCurrencyCode: // string
+
+		if CurrenciesData(a.CurrencyCode) == nil {
+			return nil, fmt.Errorf("Currencies resource value not defined : %v", a.CurrencyCode)
+		}
+		a.CurrencyCode = string(data)
+		return permissions.SubPermissions(fip, operation, false)
+	case FixedCurrencyValueFieldPrecision: // uint32
+
+		if len(fip) > 1 {
+			return nil, fmt.Errorf("Amendment field index path too deep for Precision : %v", fip)
+		}
+		buf := bytes.NewBuffer(data)
+		if value, err := bitcoin.ReadBase128VarInt(buf); err != nil {
+			return nil, fmt.Errorf("Precision amendment value failed to deserialize : %s", err)
+		} else {
+			a.Precision = uint32(value)
+		}
+		return permissions.SubPermissions(fip, operation, false)
+	}
+
+	return nil, fmt.Errorf("Unknown FixedCurrencyValue amendment field index : %v", fip)
+}
+
+// CreateAmendments determines the differences between two FixedCurrencyValues and returns
+// amendment data.
+func (a *FixedCurrencyValueField) CreateAmendments(fip permissions.FieldIndexPath,
+	newValue *FixedCurrencyValueField) ([]*internal.Amendment, error) {
+
+	if a.Equal(newValue) {
+		return nil, nil
+	}
+
+	var result []*internal.Amendment
+	ofip := fip.Copy() // save original to be appended for each field
+
+	// Value uint64
+	fip = append(ofip, FixedCurrencyValueFieldValue)
+	if a.Value != newValue.Value {
+		var buf bytes.Buffer
+		if err := bitcoin.WriteBase128VarInt(&buf, uint64(newValue.Value)); err != nil {
+			return nil, errors.Wrap(err, "Value")
+		}
+
+		result = append(result, &internal.Amendment{
+			FIP:  fip,
+			Data: buf.Bytes(),
+		})
+	}
+
+	// CurrencyCode string
+	fip = append(ofip, FixedCurrencyValueFieldCurrencyCode)
+	if a.CurrencyCode != newValue.CurrencyCode {
+		result = append(result, &internal.Amendment{
+			FIP:  fip,
+			Data: []byte(newValue.CurrencyCode),
+		})
+	}
+
+	// Precision uint32
+	fip = append(ofip, FixedCurrencyValueFieldPrecision)
+	if a.Precision != newValue.Precision {
+		var buf bytes.Buffer
+		if err := bitcoin.WriteBase128VarInt(&buf, uint64(newValue.Precision)); err != nil {
+			return nil, errors.Wrap(err, "Precision")
+		}
+
+		result = append(result, &internal.Amendment{
+			FIP:  fip,
+			Data: buf.Bytes(),
+		})
+	}
+
+	return result, nil
+}
+
 // RateField Permission / Amendment Field Indices
 const (
 	RateFieldPrecision = uint32(1)

dist/golang/instruments/binary_marshal.go

@@ -442,6 +442,39 @@ func (a *CurrencyValueField) UnmarshalBinary(data []byte) error {
 	return nil
 }
 
+func (a *FixedCurrencyValueField) MarshalBinary() (data []byte, err error) {
+	b, err := proto.Marshal(a)
+	if err != nil {
+		return nil, errors.Wrap(err, "marshal")
+	}
+
+	return append([]byte{binaryVersion}, b...), nil
+}
+
+func (a *FixedCurrencyValueField) UnmarshalBinary(data []byte) error {
+	if len(data) == 0 {
+		return nil // empty result
+	}
+
+	if len(data) == 1 && data[0] == bitcoin.OP_FALSE {
+		return nil // empty result
+	}
+
+	if len(data) < 2 {
+		return errors.New("Data too small, missing version or data")
+	}
+
+	if data[0] != binaryVersion {
+		return fmt.Errorf("Wrong data version: got %d, want %d", data[0], binaryVersion)
+	}
+
+	if err := proto.Unmarshal(data[1:], a); err != nil {
+		return errors.Wrap(err, "protobuf unmarshal")
+	}
+
+	return nil
+}
+
 func (a *RateField) MarshalBinary() (data []byte, err error) {
 	b, err := proto.Marshal(a)
 	if err != nil {

dist/golang/instruments/copy.go

@@ -298,12 +298,15 @@ func (a *CreditNote) Copy() *CreditNote {
 	// Field Name - varchar
 	result.Name = a.Name
 
-	// Field FaceValue - CurrencyValue
+	// Field FaceValue - FixedCurrencyValue
 	result.FaceValue = a.FaceValue.Copy()
 
 	// Field ExpirationTimestamp - uint
 	result.ExpirationTimestamp = a.ExpirationTimestamp
 
+	// Field TransfersPermitted - bool
+	result.TransfersPermitted = a.TransfersPermitted
+
 	return result
 }
 
@@ -367,6 +370,25 @@ func (a *CurrencyValueField) Copy() *CurrencyValueField {
 	return result
 }
 
+func (a *FixedCurrencyValueField) Copy() *FixedCurrencyValueField {
+	if a == nil {
+		return nil
+	}
+
+	result := &FixedCurrencyValueField{}
+
+	// Field Value - uint
+	result.Value = a.Value
+
+	// Field CurrencyCode - fixedchar
+	result.CurrencyCode = a.CurrencyCode
+
+	// Field Precision - uint
+	result.Precision = a.Precision
+
+	return result
+}
+
 func (a *RateField) Copy() *RateField {
 	if a == nil {
 		return nil

dist/golang/instruments/equal.go

@@ -536,7 +536,7 @@ func (l *CreditNote) Equal(right proto.Message) bool {
 		return false // fmt.Errorf("Name string mismatched")
 	}
 
-	// Field FaceValue - CurrencyValue
+	// Field FaceValue - FixedCurrencyValue
 	if !c.FaceValue.Equal(r.FaceValue) {
 		return false // fmt.Errorf("FaceValue : %s", err)
 	}
@@ -546,6 +546,11 @@ func (l *CreditNote) Equal(right proto.Message) bool {
 		return false // fmt.Errorf("ExpirationTimestamp integer mismatched")
 	}
 
+	// Field TransfersPermitted - bool
+	if c.TransfersPermitted != r.TransfersPermitted {
+		return false // fmt.Errorf("TransfersPermitted boolean mismatched")
+	}
+
 	return true
 }
 
@@ -659,6 +664,41 @@ func (l *CurrencyValueField) Equal(right proto.Message) bool {
 	return true
 }
 
+func (l *FixedCurrencyValueField) Equal(right proto.Message) bool {
+	c := l
+	if c == nil {
+		if right == nil {
+			return true
+		}
+		c = &FixedCurrencyValueField{}
+	}
+	r, ok := right.(*FixedCurrencyValueField)
+	if !ok {
+		return false
+	}
+
+	if r == nil {
+		r = &FixedCurrencyValueField{}
+	}
+
+	// Field Value - uint
+	if c.Value != r.Value {
+		return false // fmt.Errorf("Value integer mismatched")
+	}
+
+	// Field CurrencyCode - fixedchar
+	if c.CurrencyCode != r.CurrencyCode {
+		return false // fmt.Errorf("CurrencyCode string mismatched")
+	}
+
+	// Field Precision - uint
+	if c.Precision != r.Precision {
+		return false // fmt.Errorf("Precision integer mismatched")
+	}
+
+	return true
+}
+
 func (l *RateField) Equal(right proto.Message) bool {
 	c := l
 	if c == nil {