RequestBlockTransactions must include escrow part

common/query/transactionQuery.go

@@ -84,14 +84,17 @@ func (tq *TransactionQuery) GetTransactionsByBlockID(blockID int64) (str string,
 }
 
 func (tq *TransactionQuery) GetTransactionsByIds(txIds []int64) (str string, args []interface{}) {
-	var txIdsStr []string
 
-	for _, txID := range txIds {
-		txIdsStr = append(txIdsStr, fmt.Sprintf("%d", txID))
+	for _, id := range txIds {
+		args = append(args, id)
 	}
-	query := fmt.Sprintf("SELECT %s FROM %s WHERE multisig_child = false AND id in (%s)",
-		strings.Join(tq.Fields, ", "), tq.getTableName(), strings.Join(txIdsStr, ","))
-	return query, []interface{}{}
+	return fmt.Sprintf(
+			"SELECT %s FROM %s WHERE multisig_child = false AND id IN(?%s)",
+			strings.Join(tq.Fields, ", "),
+			tq.getTableName(),
+			strings.Repeat(", ?", len(txIds)-1),
+		),
+		args
 }
 
 // ExtractModel extract the model struct fields to the order of TransactionQuery.Fields

common/query/transactionQuery_test.go

@@ -231,13 +231,6 @@ func TestTransactionQuery_GetTransactionsByBlockID(t *testing.T) {
 }
 
 func TestTransactionQuery_GetTransactionsByIds(t *testing.T) {
-	var (
-		txIdsStr []string
-		txIds    = []int64{1, 2, 3, 4}
-	)
-	for _, txID := range txIds {
-		txIdsStr = append(txIdsStr, fmt.Sprintf("%d", txID))
-	}
 
 	type fields struct {
 		Fields    []string
@@ -257,12 +250,16 @@ func TestTransactionQuery_GetTransactionsByIds(t *testing.T) {
 		{
 			name:   "wantSuccess",
 			fields: fields(*mockTransactionQuery),
-			args:   args{txIds: txIds},
-			wantStr: fmt.Sprintf("SELECT %s FROM \"transaction\" WHERE multisig_child = false AND id in (%s)",
-				strings.Join(mockTransactionQuery.Fields, ", "),
-				strings.Join(txIdsStr, ","),
-			),
-			wantArgs: []interface{}{},
+			args:   args{txIds: []int64{1, 2, 3, 4}},
+			wantStr: "SELECT id, block_id, block_height, sender_account_address, recipient_account_address, transaction_type, fee, timestamp, " +
+				"transaction_hash, transaction_body_length, transaction_body_bytes, signature, version, transaction_index, multisig_child " +
+				"FROM \"transaction\" WHERE multisig_child = false AND id IN(?, ?, ?, ?)",
+			wantArgs: []interface{}{
+				int64(1),
+				int64(2),
+				int64(3),
+				int64(4),
+			},
 		},
 	}
 	for _, tt := range tests {

common/transaction/fixtureGenerator.go

@@ -245,6 +245,7 @@ func GetFixturesForTransaction(
 	}
 	if escrow {
 		tx.Escrow = &model.Escrow{
+			ID:              tx.GetID(),
 			ApproverAddress: "BCZD_VxfO2S9aziIL3cn_cXW7uPDVPOrnXuP98GEAUC7",
 			Commission:      1,
 			Timeout:         100,

core/service/mempoolCoreService.go

@@ -6,7 +6,7 @@ import (
 	"sort"
 	"time"
 
-	badger "github.com/dgraph-io/badger/v2"
+	"github.com/dgraph-io/badger/v2"
 	log "github.com/sirupsen/logrus"
 	"github.com/zoobc/zoobc-core/common/blocker"
 	"github.com/zoobc/zoobc-core/common/chaintype"
@@ -16,7 +16,6 @@ import (
 	"github.com/zoobc/zoobc-core/common/model"
 	"github.com/zoobc/zoobc-core/common/query"
 	"github.com/zoobc/zoobc-core/common/transaction"
-	"github.com/zoobc/zoobc-core/common/util"
 	commonUtils "github.com/zoobc/zoobc-core/common/util"
 	coreUtil "github.com/zoobc/zoobc-core/core/util"
 	"github.com/zoobc/zoobc-core/observer"
@@ -232,7 +231,7 @@ func (mps *MempoolService) ReceivedTransaction(
 	}
 
 	mempoolTx = &model.MempoolTransaction{
-		FeePerByte:              util.FeePerByteTransaction(receivedTx.GetFee(), receivedTxBytes),
+		FeePerByte:              commonUtils.FeePerByteTransaction(receivedTx.GetFee(), receivedTxBytes),
 		ID:                      receivedTx.ID,
 		TransactionBytes:        receivedTxBytes,
 		ArrivalTimestamp:        time.Now().Unix(),
@@ -288,7 +287,7 @@ func (mps *MempoolService) ProcessReceivedTransaction(
 		return nil, nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 	mempoolTx = &model.MempoolTransaction{
-		FeePerByte:              util.FeePerByteTransaction(receivedTx.GetFee(), receivedTxBytes),
+		FeePerByte:              commonUtils.FeePerByteTransaction(receivedTx.GetFee(), receivedTxBytes),
 		ID:                      receivedTx.ID,
 		TransactionBytes:        receivedTxBytes,
 		ArrivalTimestamp:        time.Now().Unix(),

core/service/transactionCoreService.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"database/sql"
+	"fmt"
 	"strconv"
 
 	"github.com/sirupsen/logrus"
@@ -56,22 +57,56 @@ func NewTransactionCoreService(
 
 func (tg *TransactionCoreService) GetTransactionsByIds(transactionIds []int64) ([]*model.Transaction, error) {
 	var (
-		rows *sql.Rows
-		err  error
+		transactions []*model.Transaction
+		escrows      []*model.Escrow
+		txMap        = make(map[int64]*model.Transaction)
+		rows         *sql.Rows
+		err          error
 	)
-	txQuery, _ := tg.TransactionQuery.GetTransactionsByIds(transactionIds)
-	rows, err = tg.QueryExecutor.ExecuteSelect(txQuery, false)
+
+	transactions, err = func() ([]*model.Transaction, error) {
+		txQuery, args := tg.TransactionQuery.GetTransactionsByIds(transactionIds)
+		rows, err = tg.QueryExecutor.ExecuteSelect(txQuery, false, args...)
+		if err != nil {
+			return nil, err
+		}
+		defer rows.Close()
+
+		return tg.TransactionQuery.BuildModel(transactions, rows)
+	}()
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
 
-	var transactions []*model.Transaction
-	transactions, err = tg.TransactionQuery.BuildModel(transactions, rows)
-	if err != nil {
-		return nil, err
+	var ids []string
+	for _, tx := range transactions {
+		txMap[tx.GetID()] = tx
+		ids = append(ids, strconv.FormatInt(tx.GetID(), 10))
 	}
+	if len(ids) > 0 {
+		escrows, err = func() ([]*model.Escrow, error) {
+			escrowQ := tg.EscrowTransactionQuery.GetEscrowTransactionsByTransactionIdsAndStatus(ids, model.EscrowStatus_Pending)
+			rows, err = tg.QueryExecutor.ExecuteSelect(escrowQ, false)
+			if err != nil {
+				return nil, err
+			}
+			defer rows.Close()
 
+			return tg.EscrowTransactionQuery.BuildModels(rows)
+
+		}()
+		if err != nil {
+			return nil, err
+		}
+
+		for _, escrow := range escrows {
+			if _, ok := txMap[escrow.GetID()]; ok {
+				txMap[escrow.GetID()].Escrow = escrow
+			} else {
+				return nil, fmt.Errorf("escrow ID and Transaction ID Did not match")
+			}
+		}
+	}
 	return transactions, nil
 }
 

core/service/transactionCoreService_test.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"reflect"
 	"regexp"
+	"strings"
 	"testing"
 
 	"github.com/DATA-DOG/go-sqlmock"
@@ -28,6 +29,9 @@ type (
 	mockGetTransactionsByIdsTransactionQueryBuildSuccess struct {
 		query.TransactionQuery
 	}
+	mockGetTransactionsByIdsExecutorSelectWithEscrowSuccess struct {
+		query.Executor
+	}
 	// GetTransactionsByIds mocks
 	// GetTransactionsByBlockID mocks
 	mockGetTransactionsByBlockIDExecutorFail struct {
@@ -81,13 +85,18 @@ func (*mockGetTransactionsByIdsExecutorFail) ExecuteSelect(query string, tx bool
 	return nil, errors.New("mockedError")
 }
 
-func (*mockGetTransactionsByIdsExecutorSuccess) ExecuteSelect(query string, tx bool, args ...interface{}) (*sql.Rows, error) {
+func (*mockGetTransactionsByIdsExecutorSuccess) ExecuteSelect(q string, _ bool, _ ...interface{}) (*sql.Rows, error) {
 	db, mock, _ := sqlmock.New()
 	defer db.Close()
-	mock.ExpectQuery(regexp.QuoteMeta("MOCKQUERY")).WillReturnRows(sqlmock.NewRows([]string{
-		"dummyColumn"}).AddRow(
-		[]byte{1}))
-	rows, _ := db.Query("MOCKQUERY")
+	switch {
+	case strings.Contains(q, "FROM \"transaction\""):
+		mock.ExpectQuery(regexp.QuoteMeta(q)).WillReturnRows(sqlmock.NewRows([]string{
+			"dummyColumn"}).AddRow(
+			[]byte{1}))
+	default:
+		mock.ExpectQuery(regexp.QuoteMeta(q)).WillReturnRows(mock.NewRows(query.NewEscrowTransactionQuery().Fields))
+	}
+	rows, _ := db.Query(q)
 	return rows, nil
 }
 
@@ -101,6 +110,49 @@ func (*mockGetTransactionsByIdsTransactionQueryBuildSuccess) BuildModel(
 	return mockGetTransactionByIdsResult, nil
 }
 
+func (*mockGetTransactionsByIdsExecutorSelectWithEscrowSuccess) ExecuteSelect(q string, _ bool, _ ...interface{}) (*sql.Rows, error) {
+	db, mock, _ := sqlmock.New()
+	defer db.Close()
+	mockedTX := transaction.GetFixturesForTransaction(12345678, "A", "B", true)
+	switch {
+	case strings.Contains(q, "FROM \"transaction\""):
+		mock.ExpectQuery(regexp.QuoteMeta(q)).WillReturnRows(mock.NewRows(query.NewTransactionQuery(chaintype.GetChainType(0)).Fields).AddRow(
+			mockedTX.GetID(),
+			mockedTX.GetBlockID(),
+			mockedTX.GetHeight(),
+			mockedTX.GetSenderAccountAddress(),
+			mockedTX.GetRecipientAccountAddress(),
+			mockedTX.GetTransactionType(),
+			mockedTX.GetFee(),
+			mockedTX.GetTimestamp(),
+			mockedTX.GetTransactionHash(),
+			mockedTX.GetTransactionBodyLength(),
+			mockedTX.GetTransactionBodyBytes(),
+			mockedTX.GetSignature(),
+			mockedTX.GetVersion(),
+			mockedTX.GetTransactionIndex(),
+			mockedTX.GetMultisigChild(),
+		))
+	default:
+		mockedEscrow := mockedTX.GetEscrow()
+		mock.ExpectQuery(regexp.QuoteMeta(q)).WillReturnRows(mock.NewRows(query.NewEscrowTransactionQuery().Fields).AddRow(
+			mockedEscrow.GetID(),
+			mockedEscrow.GetSenderAddress(),
+			mockedEscrow.GetRecipientAddress(),
+			mockedEscrow.GetApproverAddress(),
+			mockedEscrow.GetAmount(),
+			mockedEscrow.GetCommission(),
+			mockedEscrow.GetTimeout(),
+			mockedEscrow.GetStatus(),
+			mockedEscrow.GetBlockHeight(),
+			mockedEscrow.GetLatest(),
+			mockedEscrow.GetInstruction(),
+		))
+	}
+	rows, _ := db.Query(q)
+	return rows, nil
+}
+
 func (*mockGetTransactionsByBlockIDExecutorFail) ExecuteSelect(query string, tx bool, args ...interface{}) (*sql.Rows, error) {
 	return nil, errors.New("mockedError")
 }
@@ -137,8 +189,9 @@ func (*mockGetTransactionsByBlockIDTransactionQueryBuildSuccess) BuildModel(
 
 func TestTransactionCoreService_GetTransactionsByIds(t *testing.T) {
 	type fields struct {
-		TransactionQuery query.TransactionQueryInterface
-		QueryExecutor    query.ExecutorInterface
+		TransactionQuery       query.TransactionQueryInterface
+		EscrowTransactionQuery query.EscrowTransactionQueryInterface
+		QueryExecutor          query.ExecutorInterface
 	}
 	type args struct {
 		transactionIds []int64
@@ -174,11 +227,26 @@ func TestTransactionCoreService_GetTransactionsByIds(t *testing.T) {
 			want:    nil,
 			wantErr: true,
 		},
+		{
+			name: "GetTransactionsByIds-Escrow",
+			fields: fields{
+				TransactionQuery:       query.NewTransactionQuery(chaintype.GetChainType(0)),
+				QueryExecutor:          &mockGetTransactionsByIdsExecutorSelectWithEscrowSuccess{},
+				EscrowTransactionQuery: query.NewEscrowTransactionQuery(),
+			},
+			args: args{
+				transactionIds: []int64{1},
+			},
+			want: []*model.Transaction{
+				transaction.GetFixturesForTransaction(12345678, "A", "B", true),
+			},
+		},
 		{
 			name: "GetTransactionByIds-BuildModel-Success",
 			fields: fields{
-				TransactionQuery: &mockGetTransactionsByIdsTransactionQueryBuildSuccess{},
-				QueryExecutor:    &mockGetTransactionsByIdsExecutorSuccess{},
+				TransactionQuery:       &mockGetTransactionsByIdsTransactionQueryBuildSuccess{},
+				QueryExecutor:          &mockGetTransactionsByIdsExecutorSuccess{},
+				EscrowTransactionQuery: query.NewEscrowTransactionQuery(),
 			},
 			args: args{
 				transactionIds: []int64{1},
@@ -190,8 +258,9 @@ func TestTransactionCoreService_GetTransactionsByIds(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			tg := &TransactionCoreService{
-				TransactionQuery: tt.fields.TransactionQuery,
-				QueryExecutor:    tt.fields.QueryExecutor,
+				TransactionQuery:       tt.fields.TransactionQuery,
+				QueryExecutor:          tt.fields.QueryExecutor,
+				EscrowTransactionQuery: tt.fields.EscrowTransactionQuery,
 			}
 			got, err := tg.GetTransactionsByIds(tt.args.transactionIds)
 			if (err != nil) != tt.wantErr {