bitcoin, btc 비트 코 인 이체, jsonrpc 기능, 언어 golang 개발

package ltc

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"service/app/core/db"
	"service/app/core/model"
	"service/config"
	"strconv"
	"time"
)

const (
	//RPCURL url
	RPCURL = "http://x.x.x.x:9332"
	//JSONRpcVersion   
	JSONRpcVersion = "2.0"
	//COMPONY       
	COMPONY = "xxxxxxxxxxxxxxxxxxxxxxxxx"
)

var (
	//ID   id
	ID int
)

//GetNewAddress     
func GetNewAddress(name string) (string, error) {
	var (
		params = []interface{}{
			name, //       ，  ，   ：""
		}

		jsonData map[string]interface{}
		result   []byte
		err      error
	)

	result = JSONRPCPost("getnewaddress", params)
	err = json.Unmarshal(result, &jsonData)
	if err != nil {
		return "", err
	}
	if e, ok := jsonData["error"]; ok {
		if e != nil {
			return "", errors.New(e.(string))
		}
	}
	return jsonData["result"].(string), nil
}

//GetReceivedByAddress                          ，          。
func GetReceivedByAddress(address string) float64 {
	var (
		params = []interface{}{
			address, //          
			6,       //         ，  ：6
		}
		jsonData  map[string]interface{}
		result    []byte
		newAmount float64
		err       error
	)
	result = JSONRPCPost("getreceivedbyaddress", params)
	err = json.Unmarshal(result, &jsonData)
	if err != nil {
		log.Print(err.Error())
		return 0
	}
	if e, ok := jsonData["error"]; ok {
		if e != nil {
			log.Print(err.Error())

			return 0
		}
	}
	// log.Print(jsonData)
	//        ，       TODO:
	newAmount, err = strconv.ParseFloat(fmt.Sprintf("%.2f", jsonData["result"]), 64)
	if err != nil {
		return 0
	}
	return newAmount
}

//GetBalanceByAddress       ,            ，     
func GetBalanceByAddress(address []string) float64 {
	var (
		params = []interface{}{
			6,        //       ，   ：1
			99999999, //       ，   ：9999999
			address,  //              
		}
		jsonData map[string]interface{}
		result   []byte
		err      error
		amount   float64
	)
	result = JSONRPCPost("listunspent", params)
	err = json.Unmarshal(result, &jsonData)
	log.Print(jsonData)
	if err != nil {
		return 0
	}
	if e, ok := jsonData["error"]; ok {
		if e != nil {
			return 0
		}
	}
	log.Print(jsonData["result"])
	for _, v := range jsonData["result"].([]interface{}) {
		newV := v.(map[string]interface{})
		num := newV["amount"].(float64)
		if num > 0 && num >= minNum {
			amount += num
		}
	}
	return amount

}

//GetBalance            （     ） ltc  
func GetBalance(label string) float64 {
	var (
		params = []interface{}{
			label, //          ，  ，    *，      
			6,     //      UTXO         ，  ，   ：6
			true,  //              ，  ，   ：true
		}
		jsonData map[string]interface{}
		result   []byte
		err      error
	)
	result = JSONRPCPost("getbalance", params)
	err = json.Unmarshal(result, &jsonData)
	if err != nil {
		return 0
	}
	if e, ok := jsonData["error"]; ok {
		if e != nil {
			return 0
		}
	}
	return jsonData["result"].(float64)
}

//GetUTXORecordByAddress       ,            
func GetUTXORecordByAddress(address []string) []interface{} {
	var (
		params = []interface{}{
			6,        //       ，   ：1
			99999999, //       ，   ：9999999
			address,  //              
		}
		jsonData map[string]interface{}
		result   []byte
		err      error
	)
	result = JSONRPCPost("listunspent", params)
	err = json.Unmarshal(result, &jsonData)
	if err != nil {
		log.Print(err.Error())
		return nil
	}
	if e, ok := jsonData["error"]; ok {
		if e != nil {
			log.Print(e.(map[string]interface{})["message"])
			return nil
		}
	}
	return jsonData["result"].([]interface{})
}

//      
//@param     input          UTXO    txid，vout   output                ：    
func createRawtransaction(input, output []map[string]interface{}) (interface{}, error) {
	var (
		params   []interface{}
		result   []byte
		err      error
		jsonData map[string]interface{}
	)
	params = append(params, input)
	params = append(params, output)
	result = JSONRPCPost("createrawtransaction", params)
	err = json.Unmarshal(result, &jsonData)
	if err != nil {
		return nil, err
	}
	if e, ok := jsonData["error"]; ok {
		if e != nil {
			return nil, errors.New(e.(map[string]interface{})["message"].(string))
		}
	}
	return jsonData["result"], nil
}

//      
//@param hex    createrawtransaction             
//@param options             
func fundRawtransaction(hex interface{}) (interface{}, error) {
	var (
		options = map[string]interface{}{
			"changeAddress":   COMPONY,
			"changePosition":  1,
			"includeWatching": false,
			"lockUnspents":    false,
			"feeRate":         0.00002,
		}
		params = []interface{}{
			hex,
			options,
		}
		result   []byte
		err      error
		jsonData map[string]interface{}
	)
	result = JSONRPCPost("fundrawtransaction", params)
	err = json.Unmarshal(result, &jsonData)
	if err != nil {
		return nil, err
	}
	if e, ok := jsonData["error"]; ok {
		if e != nil {
			return nil, errors.New(e.(map[string]interface{})["message"].(string))
		}
	}

	return jsonData["result"].(map[string]interface{})["hex"], nil
}

//    
//@param  hex  fundrawtransaction   hex   
func signRawtransactionwallet(hex interface{}) (interface{}, error) {
	var (
		params = []interface{}{
			hex,
		}
		result   []byte
		err      error
		jsonData map[string]interface{}
	)
	result = JSONRPCPost("signrawtransactionwithwallet", params)
	err = json.Unmarshal(result, &jsonData)
	if err != nil {
		return nil, err
	}
	if e, ok := jsonData["error"]; ok {
		if e != nil {
			return nil, errors.New(e.(map[string]interface{})["message"].(string))
		}
	}
	returnData := jsonData["result"].(map[string]interface{})
	if !returnData["complete"].(bool) {
		return nil, errors.New("No complete signature set")
	}
	return returnData["hex"], nil
}

//     P2P   
//@param  hex signrawtransactionwithwallet   hex   
func sendRawtransaction(hex interface{}) (interface{}, error) {
	var (
		params = []interface{}{
			hex,
		}
		result   []byte
		err      error
		jsonData map[string]interface{}
	)
	result = JSONRPCPost("sendrawtransaction", params)
	err = json.Unmarshal(result, &jsonData)
	if err != nil {
		return nil, err
	}
	if e, ok := jsonData["error"]; ok {
		if e != nil {
			return nil, errors.New(e.(map[string]interface{})["message"].(string))
		}
	}
	return jsonData["result"], nil
}

//SendTransaction   
//@param address       string
//@param amount      float64
func SendTransaction(address string, amount float64) (string, error) {
	var (
		list                                             []interface{}
		input                                            []map[string]interface{}
		output                                           []map[string]interface{}
		amountAll                                        float64
		createResult, fundResult, signResult, sendResult interface{}
		err                                              error
	)

	list = GetUTXORecordByAddress([]string{COMPONY})
	if len(list) <= 0 {
		return "", errors.New("  UTXO     ")
	}
	for _, v := range list {
		newV := v.(map[string]interface{})
		input = append(input, map[string]interface{}{
			"txid": newV["txid"],
			"vout": newV["vout"],
		})
		amountAll += newV["amount"].(float64)
	}
	if amountAll < amount {
		return "", errors.New("      ")
	}
	output = append(output, map[string]interface{}{
		address: amount,
	})
	createResult, err = createRawtransaction(input, output)
	if err != nil {
		return "", errors.New("createRawtransaction" + err.Error())
	}
	fundResult, err = fundRawtransaction(createResult)
	if err != nil {
		return "", errors.New("fundRawtransaction" + err.Error())
	}
	signResult, err = signRawtransactionwallet(fundResult)
	if err != nil {
		return "", errors.New("signRawtransactionwallet" + err.Error())
	}
	sendResult, err = sendRawtransaction(signResult)
	if err != nil {
		return "", errors.New("sendRawtransaction" + err.Error())
	}
	return sendResult.(string), nil
}

//JSONRPCPost post  
func JSONRPCPost(method string, params []interface{}) []byte {
	var (
		formData = map[string]interface{}{
			"jsonrpc": JSONRpcVersion,
			"id":      ID + 1,
			"method":  method,
			"params":  params,
		}
		httpClient    = &http.Client{}
		reqJSON, data []byte
		req           *http.Request
		resp          *http.Response

		err error
	)
	reqJSON, err = json.Marshal(formData)
	payloadBuffer := bytes.NewReader(reqJSON)
	req, err = http.NewRequest("POST", RPCURL, payloadBuffer)
	if err != nil {
		log.Print(err.Error())
		return nil
	}
	req.Header.Add("Content-Type", "application/json;charset=utf-8")
	req.Header.Add("Accept", "application/json")
	req.SetBasicAuth("test", "testpassword")
	resp, err = httpClient.Do(req)
	if err != nil {
		fmt.Println(err.Error())
		return nil
	}
	defer resp.Body.Close()
	data, err = ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println(err.Error())
		return nil
	}
	return data
}