github.com/annchain/OG@v0.0.9/rpc/controller.go

// Copyright © 2019 Annchain Authors <EMAIL ADDRESS>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package rpc

import (
	"encoding/hex"
	"fmt"
	types2 "github.com/annchain/OG/arefactor/og/types"
	"github.com/annchain/OG/arefactor/og_interface"
	"github.com/annchain/OG/common"
	"github.com/annchain/OG/consensus/annsensus"
	"github.com/annchain/OG/consensus/campaign"
	ogcrypto2 "github.com/annchain/OG/deprecated/ogcrypto"
	"github.com/annchain/OG/og/archive"
	"github.com/annchain/OG/og/txmaker"
	"github.com/annchain/OG/og/types"
	archive2 "github.com/annchain/OG/og/types/archive"
	"github.com/annchain/OG/og/verifier"
	"github.com/annchain/OG/ogcore/pool"
	"github.com/annchain/OG/types/token"
	"net/http"
	"strconv"
	"strings"

	"github.com/annchain/OG/arefactor/performance"
	"github.com/annchain/OG/og"
	"github.com/annchain/OG/og/syncer"
	"github.com/annchain/OG/p2p"
	"github.com/gin-gonic/gin"
)

type RpcController struct {
	P2pServer          *p2p.Server
	Og                 *og.Og
	TxBuffer           *pool.TxBuffer
	TxCreator          *txmaker.OGTxCreator
	SyncerManager      *syncer.SyncManager
	PerformanceMonitor *performance.PerformanceMonitor
	NewRequestChan     chan archive2.TxBaseType
	AnnSensus          *annsensus.AnnSensus
	FormatVerifier     *verifier.TxFormatVerifier
}

//TxRequester
type TxRequester interface {
	GenerateRequest(from int, to int)
}

//SequenceRequester
type SequenceRequester interface {
	GenerateRequest()
}

//NewArchiveRequest for RPC request
type NewArchiveRequest struct {
	Data []byte `json:"data"`
}

//NewAccountRequest for RPC request
type NewAccountRequest struct {
	Algorithm string `json:"algorithm"`
}

func cors(c *gin.Context) {
	c.Header("Access-Control-Allow-Origin", "*")
}

//Query query
func (r *RpcController) Query(c *gin.Context) {
	Response(c, http.StatusOK, nil, "not implemented yet")
}

//Transaction  get  transaction
func (r *RpcController) Transaction(c *gin.Context) {
	hashtr := c.Query("hash")
	hash, err := types2.HexToHash(hashtr)
	cors(c)
	if err != nil {
		Response(c, http.StatusBadRequest, fmt.Errorf("hash format error"), nil)
		return
	}
	txi := r.Og.Dag.GetTx(hash)
	if txi == nil {
		txi = r.Og.TxPool.Get(hash)
	}
	if txi == nil {
		Response(c, http.StatusBadRequest, fmt.Errorf("tx not found"), nil)
		return
	}
	switch tx := txi.(type) {
	case *archive2.Tx:
		Response(c, http.StatusOK, nil, tx)
		return
	case *types.Sequencer:
		Response(c, http.StatusOK, nil, tx)
		return
	case *archive.Archive:
		Response(c, http.StatusOK, nil, tx)
		return
	case *campaign.Campaign:
		Response(c, http.StatusOK, nil, tx)
		return
	case *campaign.TermChange:
		Response(c, http.StatusOK, nil, tx)
		return
	case *archive2.ActionTx:
		Response(c, http.StatusOK, nil, tx)
		return
	}

	Response(c, http.StatusNotFound, fmt.Errorf("status not found"), nil)
}

//Confirm checks if tx has already been confirmed.
func (r *RpcController) Confirm(c *gin.Context) {
	hashtr := c.Query("hash")
	hash, err := types2.HexToHash(hashtr)
	cors(c)
	if err != nil {
		Response(c, http.StatusBadRequest, fmt.Errorf("hash format error"), nil)
		return
	}
	txiDag := r.Og.Dag.GetTx(hash)
	txiTxpool := r.Og.TxPool.Get(hash)

	if txiDag == nil && txiTxpool == nil {
		Response(c, http.StatusNotFound, fmt.Errorf("tx not found"), nil)
		return
	}
	if txiTxpool != nil {
		Response(c, http.StatusOK, nil, false)
		return
		// c.JSON(http.StatusNotFound, gin.H{
		// 	"confirm": false,
		// })
	} else {
		Response(c, http.StatusOK, nil, true)
		return
		// c.JSON(http.StatusNotFound, gin.H{
		// 	"confirm": true,
		// })
	}

}

//Transactions query Transactions
func (r *RpcController) Transactions(c *gin.Context) {
	seqId := c.Query("seq_id")
	address := c.Query("address")
	cors(c)
	if address == "" {
		id, err := strconv.Atoi(seqId)
		if err != nil || id < 0 {
			Response(c, http.StatusOK, fmt.Errorf("seq_id format error"), nil)
			return
		}
		if r.Og.Dag.GetHeight() < uint64(id) {
			Response(c, http.StatusOK, fmt.Errorf("txs not found"), nil)
			return
		}
		txs := r.Og.Dag.GetTxisByNumber(uint64(id))
		var txsResponse struct {
			Total int        `json:"total"`
			Txs   types.Txis `json:"txs"`
		}
		txsResponse.Total = len(txs)
		txsResponse.Txs = txs
		Response(c, http.StatusOK, nil, txsResponse)
		return
	} else {
		addr, err := common.StringToAddress(address)
		if err != nil {
			Response(c, http.StatusOK, fmt.Errorf("address format error"), nil)
			return
		}
		txs := r.Og.Dag.GetTxsByAddress(addr)
		var txsResponse struct {
			Total int         `json:"total"`
			Txs   []types.Txi `json:"txs"`
		}
		if len(txs) != 0 {
			txsResponse.Total = len(txs)
			txsResponse.Txs = txs
			Response(c, http.StatusOK, nil, txsResponse)
			return
		}
		Response(c, http.StatusOK, fmt.Errorf("txs not found"), nil)
		return
	}

}

func (r *RpcController) Genesis(c *gin.Context) {
	cors(c)
	sq := r.Og.Dag.Genesis()
	if sq != nil {
		Response(c, http.StatusOK, nil, sq)
	} else {
		Response(c, http.StatusNotFound, fmt.Errorf("genesis not found"), nil)
	}
	return
}

func (r *RpcController) Sequencer(c *gin.Context) {
	cors(c)
	var sq *types.Sequencer
	hashtr := c.Query("hash")
	seqId := c.Query("seq_id")
	if seqId == "" {
		seqId = c.Query("id")
	}
	if seqId != "" {
		id, err := strconv.Atoi(seqId)
		if err != nil || id < 0 {
			Response(c, http.StatusBadRequest, fmt.Errorf("id format error"), nil)
			return
		}
		sq = r.Og.Dag.GetSequencerByHeight(uint64(id))
		if sq != nil {
			Response(c, http.StatusOK, nil, sq)
			return
		} else {
			Response(c, http.StatusNotFound, fmt.Errorf("sequencer not found"), nil)
			return
		}
	}
	if hashtr == "" {
		sq = r.Og.Dag.LatestSequencer()
		if sq != nil {
			Response(c, http.StatusOK, nil, sq)
			return
		} else {
			Response(c, http.StatusNotFound, fmt.Errorf("sequencer not found"), nil)
			return
		}
	} else {
		hash, err := types2.HexToHash(hashtr)
		if err != nil {
			Response(c, http.StatusBadRequest, fmt.Errorf("hash format error"), nil)
			return
		}
		txi := r.Og.Dag.GetTx(hash)
		if txi == nil {
			txi = r.Og.TxPool.Get(hash)
		}
		if txi == nil {
			Response(c, http.StatusNotFound, fmt.Errorf("tx not found"), nil)
			return
		}
		switch t := txi.(type) {
		case *types.Sequencer:
			Response(c, http.StatusOK, nil, t)
			return
		default:
			Response(c, http.StatusNotFound, fmt.Errorf("tx not sequencer"), nil)
			return
		}
	}
	Response(c, http.StatusNotFound, fmt.Errorf("not found"), nil)
	return
}

func (r *RpcController) NewAccount(c *gin.Context) {
	var (
		txReq  NewAccountRequest
		signer og_interface.ISigner
		err    error
	)
	err = c.ShouldBindJSON(&txReq)
	if err != nil {
		Response(c, http.StatusBadRequest, fmt.Errorf("request format error"), nil)
		return
	}
	algorithm := strings.ToLower(txReq.Algorithm)
	switch algorithm {
	case "ed25519":
		signer = &ogcrypto2.SignerEd25519{}
	case "secp256k1":
		signer = &ogcrypto2.SignerSecp256k1{}
	}
	pub, priv := signer.RandomKeyPair()
	if err != nil {
		Response(c, http.StatusInternalServerError, fmt.Errorf("Generate account error"), nil)
		return
	}
	Response(c, http.StatusInternalServerError, nil, gin.H{
		"pubkey":  pub.String(),
		"privkey": priv.String(),
	})
	return
}

func (r *RpcController) QueryNonce(c *gin.Context) {
	address := c.Query("address")
	addr, err := common.StringToAddress(address)
	if err != nil {
		Response(c, http.StatusBadRequest, fmt.Errorf("address format err"), nil)
		return
	}
	noncePool, errPool := r.Og.TxPool.GetLatestNonce(addr)
	nonceDag, errDag := r.Og.Dag.GetLatestNonce(addr)
	var nonce int64
	if errPool != nil && errDag != nil {
		nonce = 0
	} else {
		nonce = int64(noncePool)
		if noncePool < nonceDag {
			nonce = int64(nonceDag)
		}
	}
	Response(c, http.StatusOK, nil, nonce)
	return
}

func (r *RpcController) QueryBalance(c *gin.Context) {
	address := c.Query("address")
	tokenIDStr := c.Query("token_id")
	all := c.Query("all")
	addr, err := common.StringToAddress(address)
	if err != nil {
		Response(c, http.StatusBadRequest, fmt.Errorf("address format err: %v", err), nil)
		return
	}
	var tokenID int32
	if tokenIDStr == "" {
		tokenID = token.OGTokenID
	} else {
		t, err := strconv.Atoi(tokenIDStr)
		if err != nil {
			Response(c, http.StatusBadRequest, fmt.Errorf("tokenID format err: %v", err), nil)
			return
		}
		tokenID = int32(t)
	}
	if all == "true" {
		b := r.Og.Dag.GetAllTokenBalance(addr)
		Response(c, http.StatusOK, nil, gin.H{
			"address": address,
			"balance": b,
		})
		return
	}

	b := r.Og.Dag.GetBalance(addr, tokenID)
	Response(c, http.StatusOK, nil, gin.H{
		"address": address,
		"balance": b,
	})
	return
}

func (r *RpcController) QueryShare(c *gin.Context) {
	Response(c, http.StatusOK, nil, "not implemented yet")
	return
}

func (r *RpcController) ContractPayload(c *gin.Context) {
	Response(c, http.StatusOK, nil, "not implemented yet")
	return
}

func (r *RpcController) ConStatus(c *gin.Context) {
	cors(c)
	if r.AnnSensus != nil {
		Response(c, http.StatusOK, nil, r.AnnSensus.GetInfo())
	} else {
		Response(c, http.StatusOK, nil, nil)
	}

}

func (r *RpcController) ConfirmStatus(c *gin.Context) {
	cors(c)
	Response(c, http.StatusOK, nil, r.Og.TxPool.GetConfirmStatus())
}

type ReceiptResponse struct {
	TxHash          string      `json:"tx_hash"`
	Status          int         `json:"status"`
	Result          interface{} `json:"result"`
	ContractAddress string      `json:"contract_address"`
}

func (r *RpcController) QueryReceipt(c *gin.Context) {
	hashHex := c.Query("hash")

	hashBytes := common.FromHex(hashHex)
	if hashBytes == nil {
		Response(c, http.StatusBadRequest, fmt.Errorf("hash not hex"), nil)
		return
	}
	hash := types2.BytesToHash(hashBytes)
	receipt := r.Og.Dag.GetReceipt(hash)
	if receipt == nil {
		Response(c, http.StatusNotFound, fmt.Errorf("can't find receipt"), nil)
		return
	}

	rr := ReceiptResponse{}
	rr.TxHash = receipt.TxHash.Hex()
	rr.Status = int(receipt.Status)
	rr.Result = receipt.ProcessResult
	rr.ContractAddress = receipt.ContractAddress.Hex()

	Response(c, http.StatusOK, nil, rr)
	return
}

type NewQueryContractReq struct {
	Address string `json:"address"`
	Data    string `json:"data"`
}

func (r *RpcController) QueryContract(c *gin.Context) {
	var (
		reqdata NewQueryContractReq
	)

	err := c.ShouldBindJSON(&reqdata)
	if err != nil {
		Response(c, http.StatusBadRequest, fmt.Errorf("request format error: %v", err), nil)
		return
	}

	addr, err := common.StringToAddress(reqdata.Address)
	if err != nil {
		Response(c, http.StatusBadRequest, err, nil)
		return
	}
	query, err := hex.DecodeString(reqdata.Data)
	if err != nil {
		Response(c, http.StatusBadRequest, fmt.Errorf("can't decode data to bytes"), nil)
		return
	}

	ret, err := r.Og.Dag.CallContract(addr, query)
	if err != nil {
		Response(c, http.StatusNotFound, fmt.Errorf("query contract error: %v", err), nil)
		return
	}

	Response(c, http.StatusOK, nil, hex.EncodeToString(ret))
	return
}

func checkError(err error, c *gin.Context, status int, message string) bool {
	if err != nil {
		c.JSON(status, gin.H{
			"error": fmt.Sprintf("%s:%s", err.Error(), message),
		})
		return false
	}
	return true
}

func Response(c *gin.Context, status int, err error, data interface{}) {
	var msg string
	if err != nil {
		msg = err.Error()
	}
	c.JSON(status, gin.H{
		"message": msg,
		"data":    data,
	})
}