596 multisig skeleton

cmd/main.go

@@ -7,6 +7,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/zoobc/zoobc-core/cmd/parser"
+
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/zoobc/zoobc-core/cmd/account"
@@ -48,6 +50,10 @@ func main() {
 			Use:   "generate",
 			Short: "generate command is a parent command for generating stuffs",
 		}
+		parserCmd = &cobra.Command{
+			Use:   "parser",
+			Short: "parse data to understandable struct",
+		}
 	)
 
 	sqliteDbInstance = database.NewSqliteDB()
@@ -67,9 +73,11 @@ func main() {
 	rootCmd.AddCommand(generateCmd)
 	rootCmd.AddCommand(genesisblock.Commands())
 	rootCmd.AddCommand(rollback.Commands(sqliteDB))
+	rootCmd.AddCommand(parserCmd)
 	generateCmd.AddCommand(account.Commands())
 	generateCmd.AddCommand(transaction.Commands(sqliteDB))
 	generateCmd.AddCommand(block.Commands())
+	parserCmd.AddCommand(parser.Commands())
 	_ = rootCmd.Execute()
 
 }

cmd/parser/cmd.go

@@ -0,0 +1,58 @@
+package parser
+
+import (
+	"encoding/hex"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/zoobc/zoobc-core/common/transaction"
+)
+
+var (
+	/*
+		Transaction Parser Command
+	*/
+	txParserCmd = &cobra.Command{
+		Use:   "tx",
+		Short: "parse transaction from its hex representation",
+		Long:  "transaction parser to check the content of your transaction hex",
+	}
+)
+
+func init() {
+	txParserCmd.Flags().StringVar(&parserTxHex, "transaction-hex", "", "hex string of the transaction bytes")
+	txParserCmd.Flags().StringVar(&parserTxBytes, "transaction-bytes", "", "transaction bytes separated by `, `. eg:"+
+		"--transaction-bytes='1, 222, 54, 12, 32'")
+}
+
+func Commands() *cobra.Command {
+	txParserCmd.Run = ParseTransaction
+	return txParserCmd
+}
+
+func ParseTransaction(*cobra.Command, []string) {
+	var txBytes []byte
+	if parserTxHex != "" {
+		txBytes, _ = hex.DecodeString(parserTxHex)
+	} else {
+		txByteCharSlice := strings.Split(parserTxBytes, ", ")
+		for _, v := range txByteCharSlice {
+			byteValue, err := strconv.Atoi(v)
+			if err != nil {
+				panic("failed to parse transaction bytes")
+			}
+			txBytes = append(txBytes, byte(byteValue))
+		}
+	}
+	tx, err := (&transaction.Util{}).ParseTransactionBytes(txBytes, false)
+	if err != nil {
+		panic("error parsing tx" + err.Error())
+	}
+	tx.TransactionBody, err = (&transaction.MultiSignatureTransaction{}).ParseBodyBytes(tx.TransactionBodyBytes)
+	if err != nil {
+		panic("error parsing tx body" + err.Error())
+	}
+	fmt.Printf("transaction:\n%v\n", tx)
+}

cmd/parser/const.go

@@ -0,0 +1,7 @@
+package parser
+
+var (
+	// txParser
+	parserTxHex   string
+	parserTxBytes string
+)

cmd/transaction/cmd.go

@@ -2,6 +2,7 @@ package transaction
 
 import (
 	"database/sql"
+	"fmt"
 	"time"
 
 	"github.com/spf13/cobra"
@@ -54,6 +55,12 @@ var (
 		Short: "transaction sub command used to generate 'escrow approval' transaction",
 		Long:  "transaction sub command used to generate 'escrow approval' transaction. required transaction id and approval = true:false",
 	}
+	multiSigCmd = &cobra.Command{
+		Use:   "multi-signature",
+		Short: "transaction sub command used to generate 'multi signature' transaction",
+		Long: "transaction sub command used to generate 'multi signature' transaction that require multiple account to submit their signature " +
+			"before it is valid to be executed",
+	}
 )
 
 func init() {
@@ -124,6 +131,18 @@ func init() {
 	*/
 	escrowApprovalCmd.Flags().Int64Var(&transactionID, "transaction-id", 0, "escrow approval body field which is int64")
 	escrowApprovalCmd.Flags().BoolVar(&approval, "approval", false, "escrow approval body field which is bool")
+	/*
+		MultiSig Command
+	*/
+	multiSigCmd.Flags().StringSliceVar(&addresses, "addresses", []string{}, "list of participants "+
+		"--addresses='address1,address2'")
+	multiSigCmd.Flags().Int64Var(&nonce, "nonce", 0, "random number / access code for the multisig info")
+	multiSigCmd.Flags().Uint32Var(&minSignature, "min-signature", 0, "minimum number of signature required for the transaction "+
+		"to be valid")
+	multiSigCmd.Flags().StringVar(&unsignedTxHex, "unsigned-transaction", "", "hex string of the unsigned transaction bytes")
+	multiSigCmd.Flags().StringVar(&txHash, "transaction-hash", "", "hash of transaction being signed by address-signature list (hex)")
+	multiSigCmd.Flags().StringSliceVar(&addressSignatures, "address-signatures", []string{}, "address-signature list "+
+		"--address-signatures='address1-signature1,address2-signature2'")
 }
 
 // Commands set TXGeneratorCommandsInstance that will used by whole commands
@@ -148,6 +167,8 @@ func Commands(sqliteDB *sql.DB) *cobra.Command {
 	txCmd.AddCommand(removeAccountDatasetCmd)
 	escrowApprovalCmd.Run = txGeneratorCommandsInstance.EscrowApprovalProcess()
 	txCmd.AddCommand(escrowApprovalCmd)
+	multiSigCmd.Run = txGeneratorCommandsInstance.MultiSignatureProcess()
+	txCmd.AddCommand(multiSigCmd)
 	return txCmd
 }
 
@@ -258,3 +279,16 @@ func (*TXGeneratorCommands) EscrowApprovalProcess() RunCommand {
 		PrintTx(GenerateSignedTxBytes(tx, senderSeed), outputType)
 	}
 }
+
+// MultiSignatureProcess for generate TX MultiSignature type
+func (*TXGeneratorCommands) MultiSignatureProcess() RunCommand {
+	return func(ccmd *cobra.Command, args []string) {
+		tx := GenerateBasicTransaction(senderSeed, version, timestamp, fee, recipientAccountAddress)
+		tx = GeneratedMultiSignatureTransaction(tx, minSignature, nonce, unsignedTxHex, txHash, addressSignatures, addresses)
+		if tx == nil {
+			fmt.Printf("fail to generate transaction, please check the provided parameter")
+		} else {
+			PrintTx(GenerateSignedTxBytes(tx, senderSeed), outputType)
+		}
+	}
+}

cmd/transaction/const.go

@@ -12,6 +12,7 @@ var (
 		"setupAccountDataset":    {3, 0, 0, 0},
 		"removeAccountDataset":   {3, 1, 0, 0},
 		"approvalEscrow":         {4, 0, 0, 0},
+		"multiSignature":         {5, 0, 0, 0},
 	}
 	signature = &crypto.Signature{}
 
@@ -46,4 +47,12 @@ var (
 	// escrowApproval
 	approval      bool
 	transactionID int64
+
+	// multiSignature
+	unsignedTxHex     string
+	addressSignatures []string
+	txHash            string
+	addresses         []string
+	nonce             int64
+	minSignature      uint32
 )

cmd/transaction/generator.go

@@ -276,6 +276,7 @@ func GenerateSignedTxBytes(tx *model.Transaction, senderSeed string) []byte {
 		senderSeed,
 	)
 	signedTxBytes, _ := transactionUtil.GetTransactionBytes(tx, true)
+	fmt.Printf("signedBytes: %v\n", len(signedTxBytes))
 	return signedTxBytes
 }
 
@@ -324,3 +325,77 @@ func GenerateEscrowedTransaction(
 	}
 	return tx
 }
+
+/*
+GeneratedMultiSignatureTransaction inject escrow. Need:
+		1. unsignedTxHex
+		2. signatures
+		3. multisigInfo:
+			- minSignature
+			- nonce
+			- addresses
+Invalid escrow validation when those fields has not set
+*/
+func GeneratedMultiSignatureTransaction(
+	tx *model.Transaction,
+	minSignature uint32,
+	nonce int64,
+	unsignedTxHex, txHash string,
+	addressSignatures, addresses []string,
+) *model.Transaction {
+	var (
+		signatures    = make(map[string][]byte)
+		signatureInfo *model.SignatureInfo
+		unsignedTx    []byte
+		multiSigInfo  *model.MultiSignatureInfo
+		err           error
+	)
+	if minSignature > 0 && len(addresses) > 0 {
+		multiSigInfo = &model.MultiSignatureInfo{
+			MinimumSignatures: minSignature,
+			Nonce:             nonce,
+			Addresses:         addresses,
+		}
+	}
+	if unsignedTxHex != "" {
+		unsignedTx, err = hex.DecodeString(unsignedTxHex)
+		if err != nil {
+			return nil
+		}
+	}
+
+	if txHash != "" {
+		transactionHash, err := hex.DecodeString(txHash)
+		if err != nil {
+			return nil
+		}
+		for _, v := range addressSignatures {
+			asig := strings.Split(v, "-")
+			if len(asig) < 2 {
+				return nil
+			}
+			signature, err := hex.DecodeString(asig[1])
+			if err != nil {
+				return nil
+			}
+			signatures[asig[0]] = signature
+		}
+		signatureInfo = &model.SignatureInfo{
+			TransactionHash: transactionHash,
+			Signatures:      signatures,
+		}
+	}
+
+	tx.TransactionType = util.ConvertBytesToUint32(txTypeMap["multiSignature"])
+	txBody := &model.MultiSignatureTransactionBody{
+		MultiSignatureInfo:       multiSigInfo,
+		UnsignedTransactionBytes: unsignedTx,
+		SignatureInfo:            signatureInfo,
+	}
+	tx.TransactionBodyBytes = (&transaction.MultiSignatureTransaction{
+		Body: txBody,
+	}).GetBodyBytes()
+	fmt.Printf("length: %v\n", len(tx.TransactionBodyBytes))
+	tx.TransactionBodyLength = uint32(len(tx.TransactionBodyBytes))
+	return tx
+}

common/constant/fieldsSize.go

@@ -35,4 +35,20 @@ var (
 	EscrowID                    uint32 = 8
 	EscrowApprovalBytesLength          = EscrowApproval + EscrowID
 	EscrowInstructionLength     uint32 = 4
+	MultisigFieldLength         uint32 = 4
+	// MultiSigFieldMissing indicate fields is missing, no need to read the bytes
+	MultiSigFieldMissing uint32
+	// MultiSigFieldPresent indicate fields is present, parse the byte accordingly
+	MultiSigFieldPresent           uint32 = 1
+	MultiSigAddressLength          uint32 = 4
+	MultiSigSignatureLength        uint32 = 4
+	MultiSigSignatureAddressLength uint32 = 4
+	MultiSigNumberOfAddress        uint32 = 4
+	MultiSigNumberOfSignatures     uint32 = 4
+	MultiSigUnsignedTxBytesLength  uint32 = 4
+	MultiSigInfoSize               uint32 = 4
+	MultiSigInfoSignatureInfoSize  uint32 = 4
+	MultiSigInfoNonce              uint32 = 8
+	MultiSigInfoMinSignature       uint32 = 4
+	MultiSigTransactionHash        uint32 = 32
 )

common/model/transactionBody.go

@@ -12,3 +12,4 @@ func (*SendMoneyTransactionBody) isTransaction_TransactionBody()              {}
 func (*SetupAccountDatasetTransactionBody) isTransaction_TransactionBody()    {}
 func (*RemoveAccountDatasetTransactionBody) isTransaction_TransactionBody()   {}
 func (*ApprovalEscrowTransactionBody) isTransaction_TransactionBody()         {}
+func (*MultiSignatureTransactionBody) isTransaction_TransactionBody()         {}

common/transaction/multiSignature.go

@@ -0,0 +1,202 @@
+package transaction
+
+import (
+	"bytes"
+
+	"github.com/zoobc/zoobc-core/common/constant"
+	"github.com/zoobc/zoobc-core/common/fee"
+	"github.com/zoobc/zoobc-core/common/model"
+	"github.com/zoobc/zoobc-core/common/util"
+)
+
+type (
+	// MultiSignatureTransaction represent wrapper transaction type that require multiple signer to approve the transcaction
+	// wrapped
+	MultiSignatureTransaction struct {
+		Body      *model.MultiSignatureTransactionBody
+		NormalFee fee.FeeModelInterface
+	}
+)
+
+func (*MultiSignatureTransaction) ApplyConfirmed(blockTimestamp int64) error {
+	return nil
+}
+
+func (*MultiSignatureTransaction) ApplyUnconfirmed() error {
+	return nil
+}
+
+func (*MultiSignatureTransaction) UndoApplyUnconfirmed() error {
+	return nil
+}
+
+// Validate dbTx specify whether validation should read from transaction state or db state
+func (*MultiSignatureTransaction) Validate(dbTx bool) error {
+	return nil
+}
+
+func (tx *MultiSignatureTransaction) GetMinimumFee() (int64, error) {
+	minFee, err := tx.NormalFee.CalculateTxMinimumFee(tx.Body, nil)
+	if err != nil {
+		return 0, err
+	}
+	return minFee, err
+}
+
+func (*MultiSignatureTransaction) GetAmount() int64 {
+	return 0
+}
+
+func (tx *MultiSignatureTransaction) GetSize() uint32 {
+	var (
+		txByteSize, signaturesSize, multisigInfoSize uint32
+	)
+	// MultisigInfo
+	multisigInfo := tx.Body.GetMultiSignatureInfo()
+	multisigInfoSize += constant.MultisigFieldLength
+	if multisigInfo != nil {
+		multisigInfoSize += constant.MultiSigInfoMinSignature
+		multisigInfoSize += constant.MultiSigInfoNonce
+		multisigInfoSize += constant.MultiSigNumberOfAddress
+		for _, v := range multisigInfo.GetAddresses() {
+			multisigInfoSize += constant.MultiSigAddressLength
+			multisigInfoSize += uint32(len([]byte(v)))
+		}
+	}
+	// TransactionBytes
+	txByteSize = constant.MultiSigUnsignedTxBytesLength + uint32(len(tx.Body.GetUnsignedTransactionBytes()))
+	// SignatureInfo
+	signaturesSize += constant.MultisigFieldLength
+	if tx.Body.GetSignatureInfo() != nil {
+		signaturesSize += constant.MultiSigTransactionHash
+		signaturesSize += constant.MultiSigNumberOfSignatures
+		for address, sig := range tx.Body.SignatureInfo.Signatures {
+			signaturesSize += constant.MultiSigSignatureAddressLength
+			signaturesSize += uint32(len([]byte(address)))
+			signaturesSize += constant.MultiSigSignatureLength
+			signaturesSize += uint32(len(sig))
+		}
+	}
+
+	return txByteSize + signaturesSize + multisigInfoSize
+}
+
+func (tx *MultiSignatureTransaction) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error) {
+	var (
+		addresses     []string
+		signatures    = make(map[string][]byte)
+		multisigInfo  *model.MultiSignatureInfo
+		signatureInfo *model.SignatureInfo
+	)
+	bufferBytes := bytes.NewBuffer(txBodyBytes)
+	// MultisigInfo
+	multisigInfoPresent := util.ConvertBytesToUint32(bufferBytes.Next(int(constant.MultisigFieldLength)))
+	if multisigInfoPresent == constant.MultiSigFieldPresent {
+		minSignatures := util.ConvertBytesToUint32(bufferBytes.Next(int(constant.MultiSigInfoMinSignature)))
+		nonce := util.ConvertBytesToUint64(bufferBytes.Next(int(constant.MultiSigInfoNonce)))
+		addressesLength := util.ConvertBytesToUint32(bufferBytes.Next(int(constant.MultiSigNumberOfAddress)))
+		for i := 0; i < int(addressesLength); i++ {
+			addressLength := util.ConvertBytesToUint32(bufferBytes.Next(int(constant.MultiSigAddressLength)))
+			address, err := util.ReadTransactionBytes(bufferBytes, int(addressLength))
+			if err != nil {
+				return nil, err
+			}
+			addresses = append(addresses, string(address))
+		}
+		multisigInfo = &model.MultiSignatureInfo{
+			MinimumSignatures: minSignatures,
+			Nonce:             int64(nonce),
+			Addresses:         addresses,
+		}
+	}
+	// TransactionBytes
+	unsignedTxLength := util.ConvertBytesToUint32(bufferBytes.Next(int(constant.MultiSigUnsignedTxBytesLength)))
+	unsignedTx, err := util.ReadTransactionBytes(bufferBytes, int(unsignedTxLength))
+	if err != nil {
+		return nil, err
+	}
+	// SignatureInfo
+	signatureInfoPresent := util.ConvertBytesToUint32(bufferBytes.Next(int(constant.MultisigFieldLength)))
+	if signatureInfoPresent == constant.MultiSigFieldPresent {
+		transactionHash, err := util.ReadTransactionBytes(bufferBytes, int(constant.MultiSigTransactionHash))
+		if err != nil {
+			return nil, err
+		}
+		signaturesLength := util.ConvertBytesToUint32(bufferBytes.Next(int(constant.MultiSigNumberOfSignatures)))
+		for i := 0; i < int(signaturesLength); i++ {
+			addressLength := util.ConvertBytesToUint32(bufferBytes.Next(int(constant.MultiSigAddressLength)))
+			address, err := util.ReadTransactionBytes(bufferBytes, int(addressLength))
+			if err != nil {
+				return nil, err
+			}
+			signatureLength := util.ConvertBytesToUint32(bufferBytes.Next(int(constant.MultiSigSignatureLength)))
+			signature, err := util.ReadTransactionBytes(bufferBytes, int(signatureLength))
+			if err != nil {
+				return nil, err
+			}
+			signatures[string(address)] = signature
+		}
+		signatureInfo = &model.SignatureInfo{
+			TransactionHash: transactionHash,
+			Signatures:      signatures,
+		}
+	}
+
+	return &model.MultiSignatureTransactionBody{
+		MultiSignatureInfo:       multisigInfo,
+		UnsignedTransactionBytes: unsignedTx,
+		SignatureInfo:            signatureInfo,
+	}, nil
+}
+
+func (tx *MultiSignatureTransaction) GetBodyBytes() []byte {
+	var (
+		buffer = bytes.NewBuffer([]byte{})
+	)
+	// Multisig Info
+	if tx.Body.GetMultiSignatureInfo() != nil {
+		buffer.Write(util.ConvertUint32ToBytes(constant.MultiSigFieldPresent))
+		buffer.Write(util.ConvertUint32ToBytes(tx.Body.GetMultiSignatureInfo().GetMinimumSignatures()))
+		buffer.Write(util.ConvertUint64ToBytes(uint64(tx.Body.GetMultiSignatureInfo().GetNonce())))
+		buffer.Write(util.ConvertUint32ToBytes(uint32(len(tx.Body.GetMultiSignatureInfo().GetAddresses()))))
+		for _, v := range tx.Body.GetMultiSignatureInfo().GetAddresses() {
+			buffer.Write(util.ConvertUint32ToBytes(uint32(len([]byte(v)))))
+			buffer.Write([]byte(v))
+		}
+	} else {
+		buffer.Write(util.ConvertUint32ToBytes(constant.MultiSigFieldMissing))
+	}
+	// Transaction Bytes
+	buffer.Write(util.ConvertUint32ToBytes(uint32(len(tx.Body.GetUnsignedTransactionBytes()))))
+	buffer.Write(tx.Body.GetUnsignedTransactionBytes())
+	// SignatureInfo
+	if tx.Body.GetSignatureInfo() != nil {
+		buffer.Write(util.ConvertUint32ToBytes(constant.MultiSigFieldPresent))
+		buffer.Write(tx.Body.GetSignatureInfo().GetTransactionHash())
+		buffer.Write(util.ConvertUint32ToBytes(uint32(len(tx.Body.GetSignatureInfo().GetSignatures()))))
+		for address, sig := range tx.Body.GetSignatureInfo().GetSignatures() {
+			buffer.Write(util.ConvertUint32ToBytes(uint32(len([]byte(address)))))
+			buffer.Write([]byte(address))
+			buffer.Write(util.ConvertUint32ToBytes(uint32(len(sig))))
+			buffer.Write(sig)
+		}
+	} else {
+		buffer.Write(util.ConvertUint32ToBytes(constant.MultiSigFieldMissing))
+	}
+
+	return buffer.Bytes()
+}
+
+func (tx *MultiSignatureTransaction) GetTransactionBody(transaction *model.Transaction) {
+	transaction.TransactionBody = &model.Transaction_MultiSignatureTransactionBody{
+		MultiSignatureTransactionBody: tx.Body,
+	}
+}
+
+func (*MultiSignatureTransaction) SkipMempoolTransaction(selectedTransactions []*model.Transaction) (bool, error) {
+	return false, nil
+}
+
+func (*MultiSignatureTransaction) Escrowable() (EscrowTypeAction, bool) {
+	return nil, false
+}

common/transaction/multiSignature_test.go

@@ -0,0 +1,247 @@
+package transaction
+
+import (
+	"math/rand"
+	"reflect"
+	"testing"
+
+	"github.com/zoobc/zoobc-core/common/constant"
+
+	"github.com/zoobc/zoobc-core/common/fee"
+	"github.com/zoobc/zoobc-core/common/model"
+)
+
+func TestMultiSignatureTransaction_GetSize(t *testing.T) {
+	type fields struct {
+		Body      *model.MultiSignatureTransactionBody
+		NormalFee fee.FeeModelInterface
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   uint32
+	}{
+		{
+			name: "GetSize-Success-no_addresses-no_signatures-no_transactionBytes",
+			fields: fields{
+				Body: &model.MultiSignatureTransactionBody{
+					MultiSignatureInfo: &model.MultiSignatureInfo{
+						MinimumSignatures: rand.Uint32(),
+						Nonce:             rand.Int63(),
+						Addresses:         nil,
+					},
+					UnsignedTransactionBytes: nil,
+					SignatureInfo:            nil,
+				},
+				NormalFee: nil,
+			},
+			want: constant.MultisigFieldLength + constant.MultiSigInfoMinSignature + constant.MultiSigInfoNonce +
+				constant.MultiSigNumberOfAddress + constant.MultiSigUnsignedTxBytesLength + constant.MultisigFieldLength,
+		},
+		{
+			name: "GetSize-Success-with_addresses-no_signatures-no_transactionBytes",
+			fields: fields{
+				Body: &model.MultiSignatureTransactionBody{
+					MultiSignatureInfo: &model.MultiSignatureInfo{
+						MinimumSignatures: rand.Uint32(),
+						Nonce:             rand.Int63(),
+						Addresses: []string{
+							"A",
+						},
+					},
+					UnsignedTransactionBytes: nil,
+					SignatureInfo:            nil,
+				},
+				NormalFee: nil,
+			},
+			want: constant.MultisigFieldLength + constant.MultiSigInfoMinSignature + constant.MultiSigInfoNonce +
+				constant.MultiSigNumberOfAddress + constant.MultiSigUnsignedTxBytesLength + constant.MultisigFieldLength +
+				constant.MultiSigAddressLength + uint32(len([]byte("A"))),
+		},
+		{
+			name: "GetSize-Success-with_addresses-with_signatures-no_transactionBytes",
+			fields: fields{
+				Body: &model.MultiSignatureTransactionBody{
+					MultiSignatureInfo: &model.MultiSignatureInfo{
+						MinimumSignatures: rand.Uint32(),
+						Nonce:             rand.Int63(),
+						Addresses: []string{
+							"A",
+						},
+					},
+					UnsignedTransactionBytes: nil,
+					SignatureInfo: &model.SignatureInfo{
+						TransactionHash: make([]byte, constant.MultiSigTransactionHash),
+						Signatures: map[string][]byte{
+							"A": make([]byte, 64),
+						},
+					},
+				},
+				NormalFee: nil,
+			},
+			want: constant.MultisigFieldLength + constant.MultiSigInfoMinSignature + constant.MultiSigInfoNonce +
+				constant.MultiSigNumberOfAddress + constant.MultiSigAddressLength + uint32(len([]byte("A"))) +
+				constant.MultiSigUnsignedTxBytesLength + constant.MultisigFieldLength + constant.MultiSigTransactionHash +
+				constant.MultiSigNumberOfSignatures + constant.MultiSigAddressLength + uint32(len([]byte("A"))) +
+				constant.MultiSigSignatureLength + 64,
+		},
+		{
+			name: "GetSize-Success-with_addresses-with_signatures-with_transactionBytes",
+			fields: fields{
+				Body: &model.MultiSignatureTransactionBody{
+					MultiSignatureInfo: &model.MultiSignatureInfo{
+						MinimumSignatures: rand.Uint32(),
+						Nonce:             rand.Int63(),
+						Addresses: []string{
+							"A",
+						},
+					},
+					UnsignedTransactionBytes: make([]byte, 120),
+					SignatureInfo: &model.SignatureInfo{
+						TransactionHash: make([]byte, constant.MultiSigTransactionHash),
+						Signatures: map[string][]byte{
+							"A": make([]byte, 64),
+						},
+					},
+				},
+				NormalFee: nil,
+			},
+			want: constant.MultisigFieldLength + constant.MultiSigInfoMinSignature + constant.MultiSigInfoNonce +
+				constant.MultiSigNumberOfAddress + constant.MultiSigAddressLength + uint32(len([]byte("A"))) +
+				constant.MultisigFieldLength + constant.MultiSigTransactionHash + constant.MultiSigNumberOfSignatures +
+				constant.MultiSigAddressLength + uint32(len([]byte("A"))) +
+				constant.MultiSigSignatureLength + 64 +
+				constant.MultiSigUnsignedTxBytesLength + 120,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tx := &MultiSignatureTransaction{
+				Body:      tt.fields.Body,
+				NormalFee: tt.fields.NormalFee,
+			}
+			if got := tx.GetSize(); got != tt.want {
+				t.Errorf("GetSize() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+var (
+	// mock for GetBodyBytes & ParseBodyBytes
+	mockMultipleSignatureBody = &model.MultiSignatureTransactionBody{
+		MultiSignatureInfo: &model.MultiSignatureInfo{
+			MinimumSignatures: 2,
+			Nonce:             1,
+			Addresses: []string{
+				"A",
+				"B",
+				"C",
+			},
+		},
+		UnsignedTransactionBytes: make([]byte, 120),
+		SignatureInfo: &model.SignatureInfo{
+			TransactionHash: make([]byte, constant.MultiSigTransactionHash),
+			Signatures: map[string][]byte{
+				"A": make([]byte, 64),
+			},
+		},
+	}
+	mockMultipleSignatureBodyBytes = []byte{
+		1, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 65, 1, 0, 0, 0, 66, 1, 0, 0, 0,
+		67, 120, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 65, 64, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	}
+	// mock for GetBodyBytes & ParseBodyBytes
+)
+
+func TestMultiSignatureTransaction_GetBodyBytes(t *testing.T) {
+	type fields struct {
+		Body      *model.MultiSignatureTransactionBody
+		NormalFee fee.FeeModelInterface
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   []byte
+	}{
+		{
+			name: "GetBodyBytes-Success",
+			fields: fields{
+				Body:      nil,
+				NormalFee: nil,
+			},
+			want: make([]byte, 12),
+		},
+		{
+			name: "GetBodyBytes-Success-Complete",
+			fields: fields{
+				Body:      mockMultipleSignatureBody,
+				NormalFee: nil,
+			},
+			want: mockMultipleSignatureBodyBytes,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tx := &MultiSignatureTransaction{
+				Body:      tt.fields.Body,
+				NormalFee: tt.fields.NormalFee,
+			}
+			if got := tx.GetBodyBytes(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GetBodyBytes() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestMultiSignatureTransaction_ParseBodyBytes(t *testing.T) {
+	type fields struct {
+		Body      *model.MultiSignatureTransactionBody
+		NormalFee fee.FeeModelInterface
+	}
+	type args struct {
+		txBodyBytes []byte
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    model.TransactionBodyInterface
+		wantErr bool
+	}{
+		{
+			name: "ParseBodyBytes-success",
+			fields: fields{
+				Body:      nil,
+				NormalFee: nil,
+			},
+			args: args{
+				txBodyBytes: mockMultipleSignatureBodyBytes,
+			},
+			want:    mockMultipleSignatureBody,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tx := &MultiSignatureTransaction{
+				Body:      tt.fields.Body,
+				NormalFee: tt.fields.NormalFee,
+			}
+			got, err := tx.ParseBodyBytes(tt.args.txBodyBytes)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ParseBodyBytes() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("ParseBodyBytes() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

common/transaction/transaction.go

@@ -224,7 +224,20 @@ func (ts *TypeSwitcher) GetTransactionType(tx *model.Transaction) (TypeAction, e
 		default:
 			return nil, nil
 		}
-
+	case 5:
+		switch buf[1] {
+		case 0:
+			multiSigTransactionBody, err := new(MultiSignatureTransaction).ParseBodyBytes(tx.GetTransactionBodyBytes())
+			if err != nil {
+				return nil, err
+			}
+			return &MultiSignatureTransaction{
+				Body:      multiSigTransactionBody.(*model.MultiSignatureTransactionBody),
+				NormalFee: fee.NewConstantFeeModel(constant.OneZBC / 100),
+			}, nil
+		default:
+			return nil, nil
+		}
 	default:
 		return nil, nil
 	}

common/transaction/transactionGeneral.go

@@ -147,7 +147,6 @@ func (tu *Util) ParseTransactionBytes(transactionBytes []byte, sign bool) (*mode
 		return nil, err
 	}
 	transaction.TransactionBodyLength = util.ConvertBytesToUint32(chunkedBytes)
-
 	transaction.TransactionBodyBytes, err = util.ReadTransactionBytes(buffer, int(transaction.TransactionBodyLength))
 	if err != nil {
 		return nil, err