fabric 智能合约go语言模板

基于fabric分布式账本 的存证智能合约模板

eg:

package main

import (
	"encoding/json"
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/hyperledger/fabric/core/chaincode/shim"
	"github.com/hyperledger/fabric/core/chaincode/shim/ext/cid"
	pb "github.com/hyperledger/fabric/protos/peer"
)

type chaincode struct {
}

type DataAsset struct {
	CtNo                string  `json:"ctNo"`                
	ParentCtNo          string  `json:"parentCtNo"`          
	RootCtNo            string  `json:"rootNo"`              
	OpenName            string  `json:"openName"`            
	OpenUscc            string  `json:"openUscc"`            
	ReceiveName         string  `json:"receiveName"`         
	ReceiveUscc         string  `json:"receiveUscc"`         
	AcceptName          string  `json:"acceptName"`          
	AcceptUscc          string  `json:"acceptUscc"`          
	SignTime            int64   `json:"signTime"`            
	LoginUserId         string  `json:"loginUserId"`         
	CreateDatetimeAsset int64   `json:"createDatetimeAsset"` 
	DataType            int     `json:"dateType"`            
	Operator            string  `json:"operator"`            
	AssetTxId           string  `json:"assetTxId"`           
}

type Contract struct {
	AgreementNo       string `json:"agreementNo"`       
	RelCtNo           string `json:"relCtNo"`           
	AgreementHash     string `json:"agreementHash"`     
	DataType          int    `json:"dateType"`          
	CreateDatetimeCon int64  `json:"createDatetimeCon"` 
	Operator          string `json:"operator"`          
	LoginUserId       string `json:"loginUserId"`       
	BillTxId          string `json:"billTxId"`          
}

func (t *chaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
	fmt.Println("SX Chaincode init......")
	return shim.Success(nil)
}

func (t *chaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
	function, args := stub.GetFunctionAndParameters()

	fmt.Println("SX Chaincode invoke is running " + function)
	fmt.Println("SX Chaincode ======>>> args: ")
	fmt.Println(args)
	fmt.Println("SX Chaincode =========")

	txId := stub.GetTxID()
	fmt.Println("SX Chaincode ======>>> txId: " + txId)

	// 开具签收
	if function == "putAssetAndContract" {
		return t.putAssetAndContract(stub, args, txId)
	}

	if function == "getCurrentDatas" {
		return t.getCurrentDatas(stub, args)
	}

	return shim.Error(fmt.Sprintf("unknown function %s", function))
}

func (t *chaincode) putAssetAndContract(stub shim.ChaincodeStubInterface, args []string, txId string) pb.Response {
	if len(args) != 21 {
		res := fmt.Sprintf("invalid number of args %d", len(args))
		fmt.Println(res)
		return shim.Error(res)
	}
	var params [21]string
	for i := 0; i < len(args); i++ {
		params[i] = strings.Replace(args[i], " ", "", -1)
	}
	fmt.Println("========== params ==========")
	fmt.Println(params)

	// 判断资产是否存在
	keyAssets := params[1]
	assets, err := stub.GetState(keyAssets)
	if err != nil {
		return shim.Error("Failed to get asset: " + err.Error())
	} else if assets != nil {
		fmt.Println("This asset already exists")
		return shim.Error("This asset already exists")
	}

	// 判断合同是否存在
	keyBills := params[18] + "_" + params[19]
	// bills, err := stub.GetState(keyBills)
	// if err != nil {
	// 	return shim.Error("Failed to get contract: " + err.Error())
	// } else if bills != nil {
	// 	fmt.Println("This contract already exists")
	// 	return shim.Error("This contract already exists")
	// }

	// 资产数据上链
	dt, _ := stub.GetTxTimestamp()
	amounts, _ := strconv.ParseFloat(params[10], 64)
	datetime := time.Unix(dt.Seconds, int64(dt.Nanos)).UnixNano() / 1e6
	val, ok, err := cid.GetAttributeValue(stub, "hf.EnrollmentID")
	if err != nil {
		return shim.Error(err.Error())
	}
	if !ok {
		return shim.Error("The client identity does not possess the attribute")
	}
	jkyamounts, _ := strconv.ParseFloat(params[11], 64)
	promiseTime, _ := strconv.ParseInt(params[12], 10, 64)
	signTime, _ := strconv.ParseInt(params[16], 10, 64)
	dataAsset := &DataAsset{params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8], params[9],
		amounts, jkyamounts, promiseTime, params[13], params[14], params[15], signTime, params[17], datetime, 1, val, txId}
	dataAssetJSONBytes, err := json.Marshal(dataAsset)
	if err != nil {
		return shim.Error(err.Error())
	}
	err = stub.PutState(keyAssets, dataAssetJSONBytes)
	if err != nil {
		return shim.Error(err.Error())
	}

	// 合同数据上链
	contract := &Contract{params[18], params[19], params[20], 2, datetime, val, params[17], txId}
	dataBillJSONBytes, err := json.Marshal(contract)
	if err != nil {
		return shim.Error(err.Error())
	}
	err = stub.PutState(keyBills, dataBillJSONBytes)
	if err != nil {
		return shim.Error(err.Error())
	}
	return shim.Success(nil)
}

func (t *chaincode) getCurrentDatas(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	var params [2]string
	for i := 0; i < len(args); i++ {
		params[i] = strings.Replace(args[i], " ", "", -1)
	}
	dataBytes, err := stub.GetState(params[1])
	if err != nil {
		return shim.Error("Failed to delete")
	}
	return shim.Success(dataBytes)
}

func main() {
	err := shim.Start(new(chaincode))
	if err != nil {
		fmt.Printf("Error starting New key per invoke: %s", err)
	}
}