634 multisig api

api/api.go

@@ -156,7 +156,17 @@ func startGrpcServer(
 	rpcService.RegisterEscrowTransactionServiceServer(grpcServer, &handler.EscrowTransactionHandler{
 		Service: service.NewEscrowTransactionService(queryExecutor),
 	})
-
+	// Set GRPC handler for multisig information request
+	rpcService.RegisterMultisigServiceServer(grpcServer, &handler.MultisigHandler{
+		MultisigService: service.NewMultisigService(
+			queryExecutor,
+			blockServices[(&chaintype.MainChain{}).GetTypeInt()],
+			query.NewPendingTransactionQuery(),
+			query.NewPendingSignatureQuery(),
+			query.NewMultisignatureInfoQuery(),
+		)})
+	// Set GRPC handler for health check
+	rpcService.RegisterHealthCheckServiceServer(grpcServer, &handler.HealthCheckHandler{})
 	// run grpc-gateway handler
 	go func() {
 		if err := grpcServer.Serve(serv); err != nil {
@@ -231,5 +241,7 @@ func runProxy(apiPort, rpcPort int) error {
 	_ = rpcService.RegisterTransactionServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts)
 	_ = rpcService.RegisterAccountLedgerServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts)
 	_ = rpcService.RegisterEscrowTransactionServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts)
+	_ = rpcService.RegisterMultisigServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts)
+	_ = rpcService.RegisterHealthCheckServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts)
 	return http.ListenAndServe(fmt.Sprintf(":%d", apiPort), mux)
 }

api/client/GetPendingTransactionByAddress/client.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/spf13/viper"
+	rpc_model "github.com/zoobc/zoobc-core/common/model"
+	rpc_service "github.com/zoobc/zoobc-core/common/service"
+	"github.com/zoobc/zoobc-core/common/util"
+	"google.golang.org/grpc"
+)
+
+func main() {
+	var apiRPCPort int
+	if err := util.LoadConfig("../../../resource", "config", "toml"); err != nil {
+		logrus.Fatal(err)
+	} else {
+		apiRPCPort = viper.GetInt("apiRPCPort")
+		if apiRPCPort == 0 {
+			apiRPCPort = 8080
+		}
+	}
+
+	conn, err := grpc.Dial(fmt.Sprintf(":%d", apiRPCPort), grpc.WithInsecure())
+	if err != nil {
+		log.Fatalf("did not connect: %s", err)
+	}
+	defer conn.Close()
+
+	c := rpc_service.NewMultisigServiceClient(conn)
+
+	response, err := c.GetPendingTransactionByAddress(context.Background(),
+		&rpc_model.GetPendingTransactionByAddressRequest{
+			SenderAddress: "E6u7lDnLgyiPuklLd6rXNQJI3_kGA1Q7e1BEXdJVB1hy",
+			Status:        rpc_model.PendingTransactionStatus_PendingTransactionPending,
+			Pagination: &rpc_model.Pagination{
+				OrderField: "block_height",
+				OrderBy:    rpc_model.OrderBy_DESC,
+				Page:       2,
+				Limit:      1,
+			},
+		},
+	)
+
+	if err != nil {
+		log.Fatalf("error calling remote.GetBlocks: %s", err)
+	}
+
+	log.Printf("response from remote.GetBlocks(): %v", response)
+
+}

api/client/GetPendingTransactionDetailByTransactionHash/client.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/spf13/viper"
+	rpc_model "github.com/zoobc/zoobc-core/common/model"
+	rpc_service "github.com/zoobc/zoobc-core/common/service"
+	"github.com/zoobc/zoobc-core/common/util"
+	"google.golang.org/grpc"
+)
+
+func main() {
+	var apiRPCPort int
+	if err := util.LoadConfig("../../../resource", "config", "toml"); err != nil {
+		logrus.Fatal(err)
+	} else {
+		apiRPCPort = viper.GetInt("apiRPCPort")
+		if apiRPCPort == 0 {
+			apiRPCPort = 8080
+		}
+	}
+
+	conn, err := grpc.Dial(fmt.Sprintf(":%d", apiRPCPort), grpc.WithInsecure())
+	if err != nil {
+		log.Fatalf("did not connect: %s", err)
+	}
+	defer conn.Close()
+
+	c := rpc_service.NewMultisigServiceClient(conn)
+
+	response, err := c.GetPendingTransactionDetailByTransactionHash(context.Background(),
+		&rpc_model.GetPendingTransactionDetailByTransactionHashRequest{
+			TransactionHashHex: "1c72a355d480ce3c10b1981a7a22e5c2d7accb0c302dbef47a25119bff1b5e17",
+		},
+	)
+
+	if err != nil {
+		log.Fatalf("error calling remote.GetPendingTransactionDetailByTransactionHash: %s", err)
+	}
+
+	log.Printf("response from remote.GetPendingTransactionDetailByTransactionHash(): %v", response)
+
+}

api/client/HealthCheck/client.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/spf13/viper"
+	rpc_model "github.com/zoobc/zoobc-core/common/model"
+	rpc_service "github.com/zoobc/zoobc-core/common/service"
+	"github.com/zoobc/zoobc-core/common/util"
+	"google.golang.org/grpc"
+)
+
+func main() {
+	var apiRPCPort int
+	if err := util.LoadConfig("../../../resource", "config", "toml"); err != nil {
+		logrus.Fatal(err)
+	} else {
+		apiRPCPort = viper.GetInt("apiRPCPort")
+		if apiRPCPort == 0 {
+			apiRPCPort = 8080
+		}
+	}
+
+	conn, err := grpc.Dial(fmt.Sprintf(":%d", apiRPCPort), grpc.WithInsecure())
+	if err != nil {
+		log.Fatalf("did not connect: %s", err)
+	}
+	defer conn.Close()
+
+	c := rpc_service.NewHealthCheckServiceClient(conn)
+
+	response, err := c.HealthCheck(context.Background(),
+		&rpc_model.Empty{},
+	)
+
+	if err != nil {
+		log.Fatalf("error calling remote.HealthCheck: %s", err)
+	}
+
+	log.Printf("response from remote.HealthCheck(): %v", response)
+
+}

api/handler/healthCheckHandler.go

@@ -0,0 +1,16 @@
+package handler
+
+import (
+	"context"
+
+	"github.com/zoobc/zoobc-core/common/model"
+)
+
+type HealthCheckHandler struct {
+}
+
+func (hc *HealthCheckHandler) HealthCheck(context.Context, *model.Empty) (*model.HealthCheckResponse, error) {
+	return &model.HealthCheckResponse{
+		Reply: "pong",
+	}, nil
+}

api/handler/multisigHandler.go

@@ -0,0 +1,40 @@
+package handler
+
+import (
+	"context"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/zoobc/zoobc-core/api/service"
+
+	"github.com/zoobc/zoobc-core/common/model"
+)
+
+type (
+	MultisigHandler struct {
+		MultisigService service.MultisigServiceInterface
+	}
+)
+
+func (msh *MultisigHandler) GetPendingTransactionByAddress(
+	ctx context.Context,
+	req *model.GetPendingTransactionByAddressRequest,
+) (*model.GetPendingTransactionByAddressResponse, error) {
+	if req.GetSenderAddress() == "" {
+		return nil, status.Error(codes.InvalidArgument, "SenderAddressNotProvided")
+	}
+	if req.GetPagination().GetPage() < 1 {
+		return nil, status.Error(codes.InvalidArgument, "PageCannotBeLessThanOne")
+	}
+	result, err := msh.MultisigService.GetPendingTransactionByAddress(req)
+	return result, err
+}
+
+func (msh *MultisigHandler) GetPendingTransactionDetailByTransactionHash(
+	ctx context.Context,
+	req *model.GetPendingTransactionDetailByTransactionHashRequest,
+) (*model.GetPendingTransactionDetailByTransactionHashResponse, error) {
+	result, err := msh.MultisigService.GetPendingTransactionDetailByTransactionHash(req)
+	return result, err
+}