603 multisig apply

api/service/transactionApiService.go

@@ -193,6 +193,7 @@ func (ts *TransactionService) GetTransactions(
 			&tx.Signature,
 			&tx.Version,
 			&tx.TransactionIndex,
+			&tx.MultisigChild,
 		)
 		if err != nil {
 			if err != sql.ErrNoRows {

api/service/transactionApiService_test.go

@@ -591,6 +591,7 @@ func (*mockQueryGetTransactionsSuccess) ExecuteSelect(qStr string, tx bool, args
 					[]byte{0, 0, 0, 0, 0, 0, 0},
 					1,
 					1,
+					false,
 				),
 			)
 	}
@@ -684,6 +685,7 @@ func TestTransactionService_GetTransactions(t *testing.T) {
 						Signature:               []byte{0, 0, 0, 0, 0, 0, 0},
 						Version:                 1,
 						TransactionIndex:        1,
+						MultisigChild:           false,
 					},
 				},
 			},
@@ -737,6 +739,7 @@ func (*mockQueryGetTransactionSuccess) ExecuteSelect(
 			8,
 			[]byte{1, 2, 3, 4, 5, 6, 7, 8},
 			[]byte{0, 0, 0, 0, 0, 0, 0}, 1, 1,
+			false,
 		),
 	)
 	return db.Query("")
@@ -759,6 +762,7 @@ func (*mockQueryGetTransactionSuccess) ExecuteSelectRow(qstr string, tx bool, ar
 				8,
 				[]byte{1, 2, 3, 4, 5, 6, 7, 8},
 				[]byte{0, 0, 0, 0, 0, 0, 0}, 1, 1,
+				false,
 			),
 	)
 	return db.QueryRow(""), nil
@@ -837,6 +841,7 @@ func TestTransactionService_GetTransaction(t *testing.T) {
 				Signature:               []byte{0, 0, 0, 0, 0, 0, 0},
 				Version:                 1,
 				TransactionIndex:        1,
+				MultisigChild:           false,
 			},
 		},
 	}

cmd/main.go

@@ -7,6 +7,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/zoobc/zoobc-core/cmd/signature"
+
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/zoobc/zoobc-core/cmd/account"
@@ -73,6 +75,7 @@ func main() {
 	rootCmd.AddCommand(genesisblock.Commands())
 	rootCmd.AddCommand(rollback.Commands(sqliteDB))
 	rootCmd.AddCommand(parserCmd)
+	rootCmd.AddCommand(signature.Commands())
 	generateCmd.AddCommand(account.Commands())
 	generateCmd.AddCommand(transaction.Commands(sqliteDB))
 	generateCmd.AddCommand(block.Commands())

cmd/readme.md

@@ -103,7 +103,7 @@ ofiness deviation starved"
 
 ### Account Generating multisig
 ```bash
-go run main.go generate account multisig --addresses BCZnSfqpP5tqFQlMTYkDeBVFWnbyVK7vLr5ORFpTjgtN --addresses BCZD_VxfO2S9aziIL3cn_cXW7uPDVPOrnXuP98GEAUC7 --addresses BCZKLvgUYZ1KKx-jtF9KoJskjVPvB9jpIjfzzI6zDW0J —min-sigs 2 —nonce 3
+go run main.go generate account multisig --addresses BCZnSfqpP5tqFQlMTYkDeBVFWnbyVK7vLr5ORFpTjgtN --addresses BCZD_VxfO2S9aziIL3cn_cXW7uPDVPOrnXuP98GEAUC7 --addresses BCZKLvgUYZ1KKx-jtF9KoJskjVPvB9jpIjfzzI6zDW0J —-min-sigs=2 --nonce=3
 ```
 
 ### Account Generate with spesific signature type

cmd/signature/cmd.go

@@ -0,0 +1,71 @@
+package signature
+
+import (
+	"encoding/hex"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/zoobc/zoobc-core/common/model"
+
+	"github.com/zoobc/zoobc-core/common/crypto"
+	"golang.org/x/crypto/sha3"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	/*
+		Signer command line tools
+	*/
+	signerCmd = &cobra.Command{
+		Use:   "sign",
+		Short: "sign provided data",
+		Long:  "sign any provided data by using the --seed parameter",
+	}
+)
+
+func init() {
+	signerCmd.Flags().StringVar(&dataHex, "data-hex", "", "hex string of the data to sign")
+	signerCmd.Flags().StringVar(&dataBytes, "data-bytes", "", "data bytes separated by `, `. eg:"+
+		"--data-bytes='1, 222, 54, 12, 32'")
+	signerCmd.Flags().StringVar(&seed, "seed", "", "your secret phrase")
+	signerCmd.Flags().BoolVar(&hash, "hash", false, "turn this flag on to hash the data before signing")
+}
+
+func Commands() *cobra.Command {
+	signerCmd.Run = SignData
+	return signerCmd
+}
+
+func SignData(*cobra.Command, []string) {
+	var (
+		unsignedBytes       []byte
+		hashedUnsignedBytes [32]byte
+		signature           []byte
+	)
+	if dataHex != "" {
+		unsignedBytes, _ = hex.DecodeString(dataHex)
+	} else {
+		txByteCharSlice := strings.Split(dataBytes, ", ")
+		for _, v := range txByteCharSlice {
+			byteValue, err := strconv.Atoi(v)
+			if err != nil {
+				panic("failed to parse transaction bytes")
+			}
+			unsignedBytes = append(unsignedBytes, byte(byteValue))
+		}
+	}
+	if hash {
+		hashedUnsignedBytes = sha3.Sum256(unsignedBytes)
+		signature, _ = (&crypto.Signature{}).Sign(hashedUnsignedBytes[:], model.SignatureType_DefaultSignature, seed)
+	} else {
+		signature, _ = (&crypto.Signature{}).Sign(unsignedBytes, model.SignatureType_DefaultSignature, seed)
+	}
+	edUtil := crypto.NewEd25519Signature()
+	fmt.Printf("account-address:\t%v\n", edUtil.GetAddressFromSeed(seed))
+	fmt.Printf("transaction-bytes:\t%v\n", unsignedBytes)
+	fmt.Printf("transaction-hash:\t%v\n", hex.EncodeToString(hashedUnsignedBytes[:]))
+	fmt.Printf("signature-bytes:\t%v\n", signature)
+	fmt.Printf("signature-hex:\t%v\n", hex.EncodeToString(signature))
+}

cmd/signature/const.go

@@ -0,0 +1,8 @@
+package signature
+
+var (
+	seed      string
+	dataHex   string
+	dataBytes string
+	hash      bool
+)

cmd/transaction/cmd.go

@@ -78,6 +78,7 @@ func init() {
 	txCmd.PersistentFlags().Int64Var(&fee, "fee", 1, "defines the fee of the transaction")
 	txCmd.PersistentFlags().BoolVar(&post, "post", false, "post generated bytes to [127.0.0.1:7000](default)")
 	txCmd.PersistentFlags().StringVar(&postHost, "post-host", "127.0.0.1:7000", "destination of post action")
+	txCmd.PersistentFlags().StringVar(&senderAddress, "sender-address", "", "transaction's sender address")
 	txCmd.PersistentFlags().Int32Var(
 		&senderSignatureType,
 		"sender-signature-type",
@@ -150,8 +151,8 @@ func init() {
 		"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'")
+	multiSigCmd.Flags().StringToStringVar(&addressSignatures, "address-signatures", make(map[string]string), "address:signature list "+
+		"--address1='signature1' --address2='signature2'")
 }
 
 // Commands set TXGeneratorCommandsInstance that will used by whole commands

cmd/transaction/const.go

@@ -27,6 +27,7 @@ var (
 	fee                     int64
 	post                    bool
 	postHost                string
+	senderAddress           string
 	senderSignatureType     int32
 
 	// Send money transaction
@@ -55,7 +56,7 @@ var (
 
 	// multiSignature
 	unsignedTxHex     string
-	addressSignatures []string
+	addressSignatures map[string]string
 	txHash            string
 	addresses         []string
 	nonce             int64

cmd/transaction/generator.go

@@ -239,22 +239,28 @@ func GenerateBasicTransaction(
 	timestamp, fee int64,
 	recipientAccountAddress string,
 ) *model.Transaction {
-	var senderAccountAddress string
-	switch model.SignatureType(senderSignatureType) {
-	case model.SignatureType_DefaultSignature:
-		senderAccountAddress = crypto.NewEd25519Signature().GetAddressFromSeed(senderSeed)
-	case model.SignatureType_BitcoinSignature:
-		var (
-			bitcoinSig = crypto.NewBitcoinSignature(crypto.DefaultBitcoinNetworkParams(), crypto.DefaultBitcoinCurve())
-			pubKey     = bitcoinSig.GetPublicKeyFromSeed(senderSeed, crypto.DefaultBitcoinPublicKeyFormat())
-			err        error
-		)
-		senderAccountAddress, err = bitcoinSig.GetAddressPublicKey(pubKey)
-		if err != nil {
-			fmt.Println("GenerateBasicTransaction-BitcoinSignature-Failed GetPublicKey")
+	var (
+		senderAccountAddress string
+	)
+	if senderSeed == "" {
+		senderAccountAddress = senderAddress
+	} else {
+		switch model.SignatureType(senderSignatureType) {
+		case model.SignatureType_DefaultSignature:
+			senderAccountAddress = crypto.NewEd25519Signature().GetAddressFromSeed(senderSeed)
+		case model.SignatureType_BitcoinSignature:
+			var (
+				bitcoinSig = crypto.NewBitcoinSignature(crypto.DefaultBitcoinNetworkParams(), crypto.DefaultBitcoinCurve())
+				pubKey     = bitcoinSig.GetPublicKeyFromSeed(senderSeed, crypto.DefaultBitcoinPublicKeyFormat())
+				err        error
+			)
+			senderAccountAddress, err = bitcoinSig.GetAddressPublicKey(pubKey)
+			if err != nil {
+				fmt.Println("GenerateBasicTransaction-BitcoinSignature-Failed GetPublicKey")
+			}
+		default:
+			panic("GenerateBasicTransaction-Invalid Signature Type")
 		}
-	default:
-		panic("GenerateBasicTransaction-Invalid Signature Type")
 	}
 
 	if timestamp <= 0 {
@@ -318,6 +324,9 @@ func GenerateSignedTxBytes(tx *model.Transaction, senderSeed string, signatureTy
 	tx.Fee += minimumFee
 
 	unsignedTxBytes, _ := transactionUtil.GetTransactionBytes(tx, false)
+	if senderSeed == "" {
+		return unsignedTxBytes
+	}
 	tx.Signature, _ = signature.Sign(
 		unsignedTxBytes,
 		model.SignatureType(signatureType),
@@ -388,7 +397,7 @@ func GeneratedMultiSignatureTransaction(
 	minSignature uint32,
 	nonce int64,
 	unsignedTxHex, txHash string,
-	addressSignatures, addresses []string,
+	addressSignatures map[string]string, addresses []string,
 ) *model.Transaction {
 	var (
 		signatures    = make(map[string][]byte)
@@ -410,29 +419,31 @@ func GeneratedMultiSignatureTransaction(
 			return nil
 		}
 	}
+	fmt.Printf("signatures: %v\n\n\n", addressSignatures)
 
 	if txHash != "" {
 		transactionHash, err := hex.DecodeString(txHash)
 		if err != nil {
+			fmt.Printf("hahaha %v\n\n\n", err)
 			return nil
 		}
-		for _, v := range addressSignatures {
-			asig := strings.Split(v, "-")
-			if len(asig) < 2 {
-				return nil
+		for k, v := range addressSignatures {
+			if k == "" {
+				sigType := util.ConvertUint32ToBytes(2)
+				signatures[k] = sigType
+			} else {
+				signature, err := hex.DecodeString(v)
+				if err != nil {
+					return nil
+				}
+				signatures[k] = signature
 			}
-			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,

common/crypto/signature.go

@@ -129,6 +129,8 @@ func (*Signature) VerifySignature(payload, signature []byte, accountAddress stri
 			)
 		}
 		return nil
+	case model.SignatureType_MultisigSignature: // multisig validation-only
+		return nil
 	default:
 		return blocker.NewBlocker(
 			blocker.ValidationErr,

common/database/migration.go

@@ -278,20 +278,23 @@ func (m *Migration) Init() error {
 			`,
 			`
 			CREATE TABLE IF NOT EXISTS "pending_transaction" (
+				"sender_address" TEXT,			-- sender of transaction 
 				"transaction_hash" BLOB,		-- transaction hash of pending transaction
 				"transaction_bytes" BLOB,		-- full transaction bytes of the pending transaction
 				"status" INTEGER,			-- execution status of the pending transaction
 				"block_height" INTEGER,			-- height when pending transaction inserted/updated
+				"latest" INTEGER,			-- latest flag for pending transaction
 				PRIMARY KEY("transaction_hash", "block_height")
 			)
 			`,
 			`
 			CREATE TABLE IF NOT EXISTS "pending_signature" (
-				"transaction_hash" INTEGER,		-- transaction hash of pending transaction being signed
+				"transaction_hash" BLOB,		-- transaction hash of pending transaction being signed
 				"account_address" TEXT,			-- account address of the respective signature
 				"signature" BLOB,			-- full transaction bytes of the pending transaction
 				"block_height" INTEGER,			-- height when pending signature inserted/updated
-				PRIMARY KEY("account_address", "transaction_hash")
+				"latest" INTEGER,			-- latest flag for pending signature 
+				PRIMARY KEY("account_address", "transaction_hash", "block_height")
 			)
 			`,
 			`
@@ -301,10 +304,15 @@ func (m *Migration) Init() error {
 				"nonce" INTEGER,			-- full transaction bytes of the pending transaction
 				"addresses" TEXT,			-- list of addresses / participants of the multisig account
 				"block_height" INTEGER,			-- height when multisignature_info inserted / updated
+				"latest" INTEGER,			-- latest flag for pending signature
 				PRIMARY KEY("multisig_address", "block_height")
 			)
 			`,
 			`
+			ALTER TABLE "transaction"
+				ADD COLUMN "multisig_child" INTEGER DEFAULT 0
+			`,
+			`
 			CREATE INDEX "node_registry_height_idx" ON "node_registry" ("height")
 			`,
 			`