refactor: TransactionTypes hashmap between ObjectTag identifiers and …

…Tx structs; DeserializeTx(), GetTransactionType(), Transaction interface

aeternity/identifiers.go

@@ -147,3 +147,24 @@ const (
 	ObjectTagMicroBody                           uint = 101
 	ObjectTagLightMicroBlock                     uint = 102
 )
+
+// TransactionTypes is a map between the ObjectTags defined above and the
+// corresponding Tx struct
+// TODO why can't this be a const?
+var TransactionTypes = map[uint]Transaction{
+	ObjectTagSignedTransaction:                   &SignedTx{},
+	ObjectTagSpendTransaction:                    &SpendTx{},
+	ObjectTagNameServiceClaimTransaction:         &NameClaimTx{},
+	ObjectTagNameServicePreclaimTransaction:      &NamePreclaimTx{},
+	ObjectTagNameServiceUpdateTransaction:        &NameUpdateTx{},
+	ObjectTagNameServiceRevokeTransaction:        &NameRevokeTx{},
+	ObjectTagNameServiceTransferTransaction:      &NameTransferTx{},
+	ObjectTagOracleRegisterTransaction:           &OracleRegisterTx{},
+	ObjectTagOracleQueryTransaction:              &OracleQueryTx{},
+	ObjectTagOracleResponseTransaction:           &OracleRespondTx{},
+	ObjectTagOracleExtendTransaction:             &OracleExtendTx{},
+	ObjectTagContractCreateTransaction:           &ContractCreateTx{},
+	ObjectTagContractCallTransaction:             &ContractCallTx{},
+	ObjectTagGeneralizedAccountAttachTransaction: &GAAttachTx{},
+	ObjectTagGeneralizedAccountMetaTransaction:   &GAMetaTx{},
+}

aeternity/transactions.go

@@ -10,6 +10,11 @@ import (
 	rlp "github.com/randomshinichi/rlpae"
 )
 
+// Transaction describes what every transaction struct should be able to do
+type Transaction interface {
+	rlp.Encoder
+}
+
 // Sign calculates the signature of the SignedTx.Tx. Although it does not use
 // the SignedTx itself, it takes a SignedTx as an argument because if it took a
 // rlp.Encoder as an interface, one might expect the signature to be of the
@@ -155,6 +160,28 @@ func SerializeTx(tx rlp.Encoder) (string, error) {
 	return txStr, nil
 }
 
+// DeserializeTx takes a tx_ string and returns the corresponding Tx struct
+func DeserializeTx(txRLP string) (Transaction, error) {
+	rawRLP, err := Decode(txRLP)
+	if err != nil {
+		return nil, err
+	}
+
+	tx, err := GetTransactionType(rawRLP)
+	if err != nil {
+		return nil, err
+	}
+	err = rlp.DecodeBytes(rawRLP, tx)
+	return tx, err
+}
+
+// GetTransactionType reads the RLP input and returns a blank Tx struct of the correct type
+func GetTransactionType(rawRLP []byte) (tx Transaction, err error) {
+	f := DecodeRLPMessage(rawRLP)[0] // [33] interface, needs to be cast to []uint8
+	objTag := uint(f.([]uint8)[0])   // [33] cast to []uint8, get rid of the slice, cast to uint
+	return TransactionTypes[objTag], nil
+}
+
 // SignedTx wraps around other Tx structs to hold the signature.
 type SignedTx struct {
 	Signatures [][]byte