context.go

package context

import (
	"context"
	"encoding/hex"
	"fmt"
	"github.com/ci123chain/ci123chain/pkg/abci/codec"
	codectypes "github.com/ci123chain/ci123chain/pkg/abci/codec/types"
	sdk "github.com/ci123chain/ci123chain/pkg/abci/types"
	"github.com/ci123chain/ci123chain/pkg/account/exported"
	"github.com/ci123chain/ci123chain/pkg/account/keeper"
	"github.com/ci123chain/ci123chain/pkg/account/types"
	"github.com/ci123chain/ci123chain/pkg/app/types/service"
	"github.com/ci123chain/ci123chain/pkg/util"
	"github.com/pkg/errors"
	"github.com/tendermint/tendermint/crypto/merkle"
	rpclient "github.com/tendermint/tendermint/rpc/client"
	"strings"
)

type Context struct {
	HomeDir 	string
	NodeURI 	string
	ChainID 	string
	FromAddr 	sdk.AccAddress
	Blocked     bool
	Client 		rpclient.Client
	Verbose 	bool
	Height 		int64
	Cdc 		*codec.Codec
	InterfaceRegistry codectypes.InterfaceRegistry
	Code 		int64
	Simulate    bool
	Broadcast bool
	PrivateKey string
	Nonce uint64
	Gas uint64
}

func (ctx *Context) Context() context.Context {
	return context.Background()
}

func (ctx *Context) GetNode() (rpclient.Client, error) {
	if ctx.Client == nil {
		return nil, errors.New("must define node URL")
	}
	return ctx.Client, nil
}

func (ctx Context) WithCode (code int64) Context {
	ctx.Code = code
	return ctx
}

// WithInterfaceRegistry returns the context with an updated InterfaceRegistry
func (ctx Context) WithInterfaceRegistry(interfaceRegistry codectypes.InterfaceRegistry) Context {
	ctx.InterfaceRegistry = interfaceRegistry
	return ctx
}

func (ctx Context) WithCodec(cdc *codec.Codec) Context {
	ctx.Cdc = cdc
	return ctx
}

func (ctx Context) WithChainID(chainID string) Context {
	ctx.ChainID = chainID
	return ctx
}

func (ctx Context) WithHeight(height int64) Context {
	ctx.Height = height
	return ctx
}

func (ctx Context) WithClient(client rpclient.Client) Context {
	ctx.Client = client
	return ctx
}

func (ctx Context) WithFrom(from sdk.AccAddress) Context {
	ctx.FromAddr = from
	return ctx
}

func (ctx Context) WithBlocked(blocked bool) Context {
	ctx.Blocked = blocked
	return ctx
}

// WithSimulation returns a copy of the context with updated Simulate value
func (ctx Context) WithSimulation(simulate bool) Context {
	ctx.Simulate = simulate
	return ctx
}

func (ctx Context) WithBroadcast(broadcast bool) Context {
	ctx.Broadcast = broadcast
	return ctx
}

func (ctx Context) WithNonce(nonce uint64) Context {
	ctx.Nonce = nonce
	return ctx
}

func (ctx Context) WithGas(gas uint64) Context {
	ctx.Gas = gas
	return ctx
}

func (ctx Context) WithPrivateKey(privateKey string) Context {
	ctx.PrivateKey = privateKey
	return ctx
}

func (ctx *Context) GetFromAddresses() (sdk.AccAddress) {
	return ctx.FromAddr
}

func (ctx *Context) GetBlocked() (bool) {
	return ctx.Blocked
}

func (ctx *Context) GetBalanceByAddress(addr sdk.AccAddress, isProve bool, height string) (sdk.Coins, *merkle.Proof, error) {
	var h int64
	if height == "" {
		h = -1
	}else {
		var err error
		h, err = util.CheckInt64(height)
		if err != nil {
			return sdk.NewCoins(), nil, err
		}
		if h <=0 {
			return sdk.NewCoins(), nil, errors.New(fmt.Sprintf("unexpected height: %v", height))
		}
	}
	qparams := keeper.NewQueryAccountParams(addr, h)
	bz, err := ctx.Cdc.MarshalJSON(qparams)
	if err != nil {
		return sdk.NewCoins(), nil , err
	}
	res, _, proof, err := ctx.Query("/custom/" + types.ModuleName + "/" + types.QueryAccount, bz, isProve)
	if res == nil{
		//return sdk.NewCoins(), nil, errors.New("The account does not exist")
		return sdk.NewCoins(sdk.NewEmptyCoin()), nil, nil
	}
	if err != nil {
		return sdk.NewCoins(), nil, err
	}
	var acc exported.Account
	err2 := ctx.Cdc.UnmarshalBinaryLengthPrefixed(res, &acc)
	if err2 != nil {
		return sdk.NewCoins(), nil, err2
	}
	balance := acc.GetCoins()

	//var balance sdk.Coins
	//err2 := ctx.Cdc.UnmarshalBinaryLengthPrefixed(res, &balance)
	//if err2 != nil {
	//	return sdk.NewCoins(), nil, err2
	//}
	return balance, proof, nil
}

func (ctx *Context) GetNonceByAddress(addr sdk.AccAddress, isProve bool) (uint64, *merkle.Proof, error) {
	qparams := keeper.NewQueryAccountParams(addr, 0)
	bz, err := ctx.Cdc.MarshalJSON(qparams)
	if err != nil {
		return 0, nil , err
	}
	res, _, proof, err := ctx.Query("/custom/" + types.ModuleName + "/" + types.QueryAccount, bz, isProve)
	if res == nil{
		return 0, nil, nil
	}
	if err != nil {
		return 0, nil, err
	}
	//var nonce uint64
	//err2 := ctx.Cdc.UnmarshalBinaryLengthPrefixed(res, &nonce)
	//if err2 != nil {
	//	return 0, nil, err2
	//}
	var acc exported.Account
	err2 := ctx.Cdc.UnmarshalBinaryLengthPrefixed(res, &acc)
	if err2 != nil {
		return 0, nil, err2
	}
	nonce := acc.GetSequence()
	return nonce, proof, nil
}

// PrintOutput prints output while respecting output and indent flags
// NOTE: pass in marshalled structs that have been unmarshaled
// because this function will panic on marshaling errors
func (ctx Context) PrintOutput(toPrint fmt.Stringer) (err error) {
	//var out []byte

	//switch ctx.OutputFormat {
	//case "text":
	//	out, err = yaml.Marshal(&toPrint)
	//
	//case "json":
	//	if ctx.Indent {
	//		out, err = ctx.Codec.MarshalJSONIndent(toPrint, "", "  ")
	//	} else {
	//		out, err = ctx.Cdc.MarshalJSON(toPrint)
	//	}
	//}
	//if err != nil {
	//	return
	//}

	fmt.Println(toPrint)
	return
}

// broadcastTx
func (ctx *Context) BroadcastSignedTx(data []byte) (sdk.TxResponse, error) {
	if ctx.Simulate {
		return ctx.CalculateGas(data)
	}
	async := ctx.Blocked
	if async {
		return ctx.BroadcastSignedDataAsync(data)
	} else {
		return ctx.BroadcastSignedData(data)
	}
}

func (ctx *Context) CalculateGas(txByte []byte) (sdk.TxResponse, error){
	simReq := &service.SimulateRequest{Tx: txByte}
	by, err := simReq.Marshal()
	if err != nil {
		return sdk.TxResponse{}, err
	}
	bz, height, _, err := ctx.Query("/weelink.app.Service/Simulate", by, false)
	if err != nil {
		return sdk.TxResponse{}, err
	}

	var simRes service.SimulateResponse
	if err := simRes.Unmarshal(bz); err != nil {
		return sdk.TxResponse{}, err
	}

	return sdk.TxResponse{
		Height:     height,
		Code:       simRes.Result.GetCode(),
		Data:       strings.ToUpper(hex.EncodeToString(simRes.Result.GetData())),
		RawLog:     simRes.Result.GetLog(),
		GasWanted:  int64(simRes.Result.GetGasWanted()),
		GasUsed:    int64(simRes.Result.GetGasUsed()),
		Events:     sdk.StringifyEvents(simRes.Result.GetEvents()),
		Codespace:  simRes.Result.GetCodespace(),
	}, nil
}

// 消息确认 同步
func (ctx *Context) BroadcastSignedData(data []byte) (sdk.TxResponse, error) {
	res, err := ctx.broadcastTx(data)
	if err != nil {
		return sdk.TxResponse{}, err
	}
	if ctx.Verbose {
		fmt.Printf("txHash=%v BlockHeight=%v\n", res.TxHash, res.Height)
	}
	return res, nil
}


// 内部调用 BroadcastTxSync，同步等待checktx 消息，消息确认还是异步的
func (ctx *Context) BroadcastSignedDataAsync(data []byte) (sdk.TxResponse, error) {
	return ctx.broadcastTxSync(data)
}

// Broadcast the transfer bytes to Tendermint
func (ctx *Context) broadcastTx(tx []byte) (sdk.TxResponse, error) {
	node, err := ctx.GetNode()
	if err != nil {
		return sdk.TxResponse{}, err
	}
	res, err := node.BroadcastTxCommit(ctx.Context(), tx)
	if err != nil {
		return sdk.NewResponseFormatBroadcastTxCommit(res), err
	}
	if res.CheckTx.Code != uint32(0) {
		return sdk.NewResponseFormatBroadcastTxCommit(res), err
	}
	if res.DeliverTx.Code != uint32(0) {
		return sdk.NewResponseFormatBroadcastTxCommit(res), err
	}

	return sdk.NewResponseFormatBroadcastTxCommit(res), nil
}

func (ctx *Context) broadcastTxSync(tx []byte) (sdk.TxResponse, error) {
	node, err := ctx.GetNode()
	if err != nil {
		return sdk.TxResponse{}, err
	}
	res, err := node.BroadcastTxSync(ctx.Context(), tx)
	if err != nil {
		return sdk.NewResponseFormatBroadcastTx(res), err
	}

	return sdk.NewResponseFormatBroadcastTx(res), nil
}