Implement suggested changes.

types/signer.go

@@ -26,27 +26,36 @@ func NewSigner(seed string) (*Signer, error) {
 	}, nil
 }
 
-func (s *Signer) SignTx(tx *Transaction) error {
+// SignTx Returns the signed transaction. The original transaction object is not modified, and the returned value should be used after signing.
+func (s *Signer) SignTx(tx Transaction) (Transaction, error) {
 
 	if tx.SourcePublicKey != s.pubKey {
-		return errors.New("source public key does not match")
+		return Transaction{}, errors.New("source public key does not match signer")
 	}
 
 	subSeed, err := GetSubSeed(s.seed)
 	if err != nil {
-		return errors.Wrap(err, "getting sub-seed")
+		return Transaction{}, errors.Wrap(err, "getting sub-seed")
 	}
 
 	unsignedDigest, err := tx.GetUnsignedDigest()
 	if err != nil {
-		return errors.Wrap(err, "getting unsigned transaction digest")
+		return Transaction{}, errors.Wrap(err, "getting unsigned transaction digest")
 	}
 
 	signature, err := schnorrq.Sign(subSeed, tx.SourcePublicKey, unsignedDigest)
 	if err != nil {
-		return errors.Wrap(err, "creating signature")
+		return Transaction{}, errors.Wrap(err, "creating signature")
 	}
-	tx.Signature = signature
 
-	return nil
+	return Transaction{
+		SourcePublicKey:      tx.SourcePublicKey,
+		DestinationPublicKey: tx.DestinationPublicKey,
+		Amount:               tx.Amount,
+		Tick:                 tx.Tick,
+		InputType:            tx.InputType,
+		InputSize:            tx.InputSize,
+		Input:                tx.Input,
+		Signature:            signature,
+	}, nil
 }

types/signer_test.go

@@ -52,7 +52,7 @@ func TestSigner_SignTx(t *testing.T) {
 				t.Fatalf("creating signer: %s", err)
 			}
 
-			err = signer.SignTx(&tx)
+			tx, err = signer.SignTx(tx)
 			if err != nil {
 				t.Fatalf("signing tx: %s", err)
 			}

types/tx_asset_transfer.go

@@ -17,7 +17,7 @@ type AssetTransferPayload struct {
 	numberOfUnits        int64
 }
 
-func NewAssetTransferPayload(issuer, newOwnerAndPossessor, assetName string, numberOfUnits int64) (AssetTransferPayload, error) {
+func NewAssetTransferPayload(assetName, issuer, newOwnerAndPossessor string, numberOfUnits int64) (AssetTransferPayload, error) {
 
 	issuerIdentity := Identity(issuer)
 	issuerPubKey, err := issuerIdentity.ToPubKey(false)
@@ -31,8 +31,8 @@ func NewAssetTransferPayload(issuer, newOwnerAndPossessor, assetName string, num
 		return AssetTransferPayload{}, errors.Wrap(err, "failed to obtain new owner public key")
 	}
 
-	if len(assetName) > 8 {
-		return AssetTransferPayload{}, errors.Errorf("asset name '%s' is longer than 8", assetName)
+	if len(assetName) > 7 {
+		return AssetTransferPayload{}, errors.Errorf("asset name '%s' is longer than 7", assetName)
 	}
 
 	var assetNameBytes [8]byte
@@ -98,7 +98,7 @@ func NewAssetTransferTransaction(sourceID string, targetTick uint32, transferFee
 		Amount:               transferFee,
 		Tick:                 targetTick,
 		InputType:            QxTransferInputType,
-		InputSize:            QxTransferInputSize,
+		InputSize:            uint16(len(input)),
 		Input:                input,
 	}, nil
 

types/tx_asset_transfer_test.go

@@ -1,6 +1,8 @@
 package types
 
 import (
+	"bytes"
+	"encoding/binary"
 	"testing"
 )
 
@@ -14,6 +16,8 @@ func TestAssetTransaction(t *testing.T) {
 		assetName      string
 		newOwner       string
 		numberOfUnits  int64
+		transferFee    int64
+		targetTick     uint32
 	}{
 		{
 			name:           "TestAssetsTransfer_1",
@@ -23,27 +27,103 @@ func TestAssetTransaction(t *testing.T) {
 			assetName:      "CFB",
 			newOwner:       "UIJLDDELETUYEHFKZPQGVOOOTLHCNQWAZAXHLSXWMEDLRQEWKNSJVZIGFPBD",
 			numberOfUnits:  1,
+			transferFee:    100,
+			targetTick:     12332145,
 		},
 	}
 
 	for _, data := range testData {
 		t.Run(data.name, func(t *testing.T) {
 
-			payload, err := NewAssetTransferPayload(data.assetIssuer, data.newOwner, data.assetName, data.numberOfUnits)
+			payload, err := NewAssetTransferPayload(data.assetName, data.assetIssuer, data.newOwner, data.numberOfUnits)
 			if err != nil {
 				t.Fatalf("creating asset transfer payload: %s", err)
 			}
 
-			assetTransferTransaction, err := NewAssetTransferTransaction(data.senderIdentity, 0, 100, payload)
+			assetTransferTransaction, err := NewAssetTransferTransaction(data.senderIdentity, data.targetTick, data.transferFee, payload)
 			if err != nil {
 				t.Fatalf("creating asser transfer transaction: %s", err)
 			}
 
+			if data.transferFee != assetTransferTransaction.Amount {
+				t.Fatalf("asset transfer transaction amount does not match expected value. expected %d, got %d", data.transferFee, assetTransferTransaction.Amount)
+			}
+
+			if assetTransferTransaction.InputType != QxTransferInputType {
+				t.Fatalf("asset transfer transaction input type does not match expected value. expected %d, got %d", QxTransferInputType, assetTransferTransaction.InputType)
+			}
+
+			if assetTransferTransaction.InputSize != QxTransferInputSize {
+				t.Fatalf("asset transfer transaction input size does not match expected value. expected %d, got %d", QxTransferInputSize, assetTransferTransaction.InputSize)
+			}
+
+			if data.targetTick != assetTransferTransaction.Tick {
+				t.Fatalf("asset transfer target tick does not match expected value. expected %d, got %d", data.targetTick, assetTransferTransaction.Tick)
+			}
+
 			signer, _ := NewSigner(data.senderSeed)
-			err = signer.SignTx(&assetTransferTransaction)
+			assetTransferTransaction, err = signer.SignTx(assetTransferTransaction)
 			if err != nil {
 				t.Fatalf("signing asset transfer transaction: %s", err)
 			}
+
 		})
 	}
 }
+
+func TestAssetTransferPayload_MarshallBinary(t *testing.T) {
+
+	assetName := "CFB"
+	assetIssuer := "CFBMEMZOIDEXQAUXYYSZIURADQLAPWPMNJXQSNVQZAHYVOPYUKKJBJUCTVJL"
+	newOwner := "UIJLDDELETUYEHFKZPQGVOOOTLHCNQWAZAXHLSXWMEDLRQEWKNSJVZIGFPBD"
+	numberOfUnits := int64(123432123)
+
+	payload, err := NewAssetTransferPayload(assetName, assetIssuer, newOwner, numberOfUnits)
+	if err != nil {
+		t.Fatalf("creating asset transfer payload: %s", err)
+	}
+
+	binaryData, err := payload.MarshallBinary()
+	if err != nil {
+		t.Fatal("marshalling asset transfer payload to binary")
+	}
+
+	if len(binaryData) != 80 {
+		t.Fatal("binary asset transfer payload does not match the expected length")
+	}
+
+	assetIssuerIdentity := Identity(assetIssuer)
+	assetIssuerPublicKey, err := assetIssuerIdentity.ToPubKey(false)
+	if err != nil {
+		t.Fatalf("getting asset issuer public key: %s", err)
+	}
+
+	newOwnerIdentity := Identity(newOwner)
+	newOwnerPublicKey, err := newOwnerIdentity.ToPubKey(false)
+	if err != nil {
+		t.Fatalf("getting new asset owner public key: %s", err)
+	}
+
+	var assetNameBytes [8]byte
+	copy(assetNameBytes[:], assetName)
+
+	var numberOfUnitsBytes [8]byte
+	binary.LittleEndian.PutUint64(numberOfUnitsBytes[:], uint64(numberOfUnits)) // casting to uint64 works here, as it does not change the data, only the way it is interpreted
+
+	if !bytes.Equal(binaryData[:32], assetIssuerPublicKey[:]) {
+		t.Fatal("asset issuer public key does not match expected value")
+	}
+
+	if !bytes.Equal(binaryData[32:64], newOwnerPublicKey[:]) {
+		t.Fatal("new asset owner public key does not match expected value")
+	}
+
+	if !bytes.Equal(binaryData[64:72], assetNameBytes[:]) {
+		t.Fatal("asset name does not match expected value")
+	}
+
+	if !bytes.Equal(binaryData[72:80], numberOfUnitsBytes[:]) {
+		t.Fatal("number of units does not match expected value")
+	}
+
+}

types/tx_send_many_test.go

@@ -47,7 +47,7 @@ func TestSendManyTransaction(t *testing.T) {
 			}
 
 			signer, _ := NewSigner(data.senderSeed)
-			err = signer.SignTx(&sendManyTransaction)
+			sendManyTransaction, err = signer.SignTx(sendManyTransaction)
 			if err != nil {
 				t.Fatalf("signing send many transaction: %s", err)
 			}

types/tx_simple_test.go

@@ -27,7 +27,7 @@ func TestSimpleTransaction(t *testing.T) {
 			}
 
 			signer, _ := NewSigner(data.senderSeed)
-			err = signer.SignTx(&simpleTransaction)
+			simpleTransaction, err = signer.SignTx(simpleTransaction)
 			if err != nil {
 				t.Fatalf("signing simple transaction: %s", err)
 			}