Go语言+Fabric搭建区块链应用_goland引入fabric-chaincode-go版本

wget https://golang.google.cn/dl/go1.20.6.linux-amd64.tar.gz

sudo tar -C /usr/local -xzf go1.20.6.linux-amd64.tar.gz

vim ~/.bash_profile

export PATH=/usr/local/fabric/hyperledger-fabric-linux-amd64-1.4.12/bin:$PATH

configtxgen -profile TwoOrgsChannel -outputCreateChannelTx ./config/appchannel.tx -channelID appchannel

configtxgen -profile TwoOrgsChannel -outputAnchorPeersUpdate ./config/TaobaoAnchor.tx -channelID appchannel -asOrg Taobao

TaobaoPeer0Cli="CORE_PEER_ADDRESS=peer0.taobao.com:7051 CORE_PEER_LOCALMSPID=TaobaoMSP CORE_PEER_MSPCONFIGPATH=/etc/hyperledger/peer/taobao.com/users/Admin@taobao.com/msp"
 
TaobaoPeer1Cli="CORE_PEER_ADDRESS=peer1.taobao.com:7051 CORE_PEER_LOCALMSPID=TaobaoMSP CORE_PEER_MSPCONFIGPATH=/etc/hyperledger/peer/taobao.com/users/Admin@taobao.com/msp"
 
JDPeer0Cli="CORE_PEER_ADDRESS=peer0.jd.com:7051 CORE_PEER_LOCALMSPID=JDMSP CORE_PEER_MSPCONFIGPATH=/etc/hyperledger/peer/jd.com/users/Admin@jd.com/msp"
 
JDPeer1Cli="CORE_PEER_ADDRESS=peer1.jd.com:7051 CORE_PEER_LOCALMSPID=JDMSP CORE_PEER_MSPCONFIGPATH=/etc/hyperledger/peer/jd.com/users/Admin@jd.com/msp"

docker exec cli bash -c "$JDPeer0Cli peer channel join -b appchannel.block"

docker exec cli bash -c "$JDPeer1Cli peer channel join -b appchannel.block"

docker exec cli bash -c "$TaobaoPeer0Cli peer channel update -o orderer.qq.com:7050 -c appchannel -f /etc/hyperledger/config/TaobaoAnchor.tx" 

docker exec cli bash -c "$JDPeer0Cli peer channel update -o orderer.qq.com:7050 -c appchannel -f /etc/hyperledger/config/JDAnchor.tx"

package main
 
import (
"fmt"
 
"github.com/hyperledger/fabric/core/chaincode/shim"
pb "github.com/hyperledger/fabric/protos/peer"
)
 
type MyChaincode struct {
}
 
// Init 初始化时会执行该方法
func (c *MyChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
    fmt.Println("链码初始化")
    return shim.Success(nil)
}
 
// Invoke 智能合约的功能函数定义
func (c *MyChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    funcName, args := stub.GetFunctionAndParameters()
    switch funcName {
 
    default:
       return shim.Error(fmt.Sprintf("没有该功能: %s", funcName))
    }
}
 
func main() {
    err := shim.Start(new(MyChaincode))
    if err != nil {
       panic(err)
    }
}

package main
 
 
 
import (
 
    "encoding/json"
 
    "errors"
 
    "fmt"
 
    "strconv"
 
 
 
    "github.com/hyperledger/fabric/core/chaincode/shim"
 
    pb "github.com/hyperledger/fabric/protos/peer"
 
)
 
 
 
type MyChaincode struct {
 
}
 
 
 
// Init 初始化时会执行该方法
 
func (c *MyChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
 
    fmt.Println("链码初始化")
 
    // 假设A有1000元，以复合主键 userA 的形式写入账本
 
    err := WriteLedger(stub, map[string]interface{}{"name": "A", "balance": 1000}, "user", []string{"A"})
 
    if err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    // 假设B有1000元，以复合主键 userB 的形式写入账本
 
    err = WriteLedger(stub, map[string]interface{}{"name": "B", "balance": 1000}, "user", []string{"B"})
 
    if err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    return shim.Success(nil)
 
}
 
 
 
// Invoke 智能合约的功能函数定义
 
func (c *MyChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
 
    funcName, args := stub.GetFunctionAndParameters()
 
    switch funcName {
 
    case "query":
 
       return query(stub, args)
 
    case "transfer":
 
       return transfer(stub, args)
 
    default:
 
       return shim.Error(fmt.Sprintf("没有该功能: %s", funcName))
 
    }
 
}
 
 
 
func query(stub shim.ChaincodeStubInterface, args []string) pb.Response {
 
    // 如果 args 为空，则表示查询所有 user
 
    results, err := ReadLedger(stub, "user", args)
 
    if err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    var users []map[string]interface{}
 
    for _, result := range results {
 
       var user map[string]interface{}
 
       if err = json.Unmarshal(result, &user); err != nil {
 
          return shim.Error(err.Error())
 
       }
 
       users = append(users, user)
 
    }
 
    usersByte, err := json.Marshal(&users)
 
    if err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    return shim.Success(usersByte)
 
}
 
 
 
func transfer(stub shim.ChaincodeStubInterface, args []string) pb.Response {
 
    // 验证参数
 
    if len(args) != 3 {
 
       return shim.Error("参数个数不满足")
 
    }
 
    from := args[0]
 
    to := args[1]
 
    money, err := strconv.ParseFloat(args[2], 64)
 
    if err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    // 从账本查询 from 用户
 
    fromResults, err := ReadLedger(stub, "user", []string{from})
 
    if err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    if len(fromResults) != 1 {
 
       return shim.Error("没有该用户 " + from)
 
    }
 
    var fromUser map[string]interface{}
 
    if err = json.Unmarshal(fromResults[0], &fromUser); err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    // 从账本查询 to 用户
 
    toResults, err := ReadLedger(stub, "user", []string{to})
 
    if err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    if len(toResults) != 1 {
 
       return shim.Error("没有该用户 " + to)
 
    }
 
    var toUser map[string]interface{}
 
    if err = json.Unmarshal(toResults[0], &toUser); err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    // from 用户扣除余额
 
    if money > fromUser["balance"].(float64) {
 
       return shim.Error("余额不足")
 
    }
 
    fromUser["balance"] = fromUser["balance"].(float64) - money
 
    // to 用户增加余额
 
    toUser["balance"] = toUser["balance"].(float64) + money
 
    // 写回账本
 
    err = WriteLedger(stub, fromUser, "user", []string{from})
 
    if err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    err = WriteLedger(stub, toUser, "user", []string{to})
 
    if err != nil {
 
       return shim.Error(err.Error())
 
    }
 
    return shim.Success([]byte("ok"))
 
}
 
 
 
func main() {
 
    err := shim.Start(new(MyChaincode))
 
    if err != nil {
 
       panic(err)
 
    }
 
}
 
 
 
// WriteLedger 写入账本
 
// obj 为要写入的数据
 
// objectType和keys 共同组成复合主键
 
func WriteLedger(stub shim.ChaincodeStubInterface, obj interface{}, objectType string, keys []string) error {
 
    //创建复合主键
 
    var key string
 
    if val, err := stub.CreateCompositeKey(objectType, keys); err != nil {
 
       return errors.New(fmt.Sprintf("%s-创建复合主键出错 %s", objectType, err.Error()))
 
    } else {
 
       key = val
 
    }
 
    bytes, err := json.Marshal(obj)
 
    if err != nil {
 
       return err
 
    }
 
    //写入区块链账本
 
    if err := stub.PutState(key, bytes); err != nil {
 
       return errors.New(fmt.Sprintf("%s-写入区块链账本出错: %s", objectType, err.Error()))
 
    }
 
    return nil
 
}
 
 
 
// ReadLedger 根据复合主键查询账本数据(适合获取全部或指定的数据)
 
// objectType和keys 共同组成复合主键
 
func ReadLedger(stub shim.ChaincodeStubInterface, objectType string, keys []string) (results [][]byte, err error) {
 
    // 通过主键从区块链查找相关的数据，相当于对主键的模糊查询
 
    resultIterator, err := stub.GetStateByPartialCompositeKey(objectType, keys)
 
    if err != nil {
 
       return nil, errors.New(fmt.Sprintf("%s-获取全部数据出错: %s", objectType, err))
 
    }
 
    defer resultIterator.Close()
 
 
 
    //检查返回的数据是否为空，不为空则遍历数据，否则返回空数组
 
    for resultIterator.HasNext() {
 
       val, err := resultIterator.Next()
 
       if err != nil {
 
          return nil, errors.New(fmt.Sprintf("%s-返回的数据出错: %s", objectType, err))
 
       }
 
 
 
       results = append(results, val.GetValue())
 
    }
 
    return results, nil
 
}

docker exec cli bash -c "$JDPeer0Cli peer chaincode install -n fabric-realty -v 1.0.0 -l golang -p chaincode"

docker exec cli bash -c "$TaobaoPeer0Cli peer chaincode instantiate -o orderer.qq.com:7050 -C appchannel -n fabric-realty -l golang -v 1.0.0 -c '{\"Args\":[\"init\"]}' -P \"AND ('TaobaoMSP.member','JDMSP.member')\""

docker ps -a | awk '($2 ~ /dev-peer.*fabric-realty.*/) {print $2}'

docker exec cli bash -c "$TaobaoPeer0Cli peer chaincode invoke -C appchannel -n fabric-realty -c '{\"Args\":[\"query\"]}'"

docker exec cli bash -c "$JDPeer0Cli peer chaincode invoke -C appchannel -n fabric-realty -c '{\"Args\":[\"query\"]}'"

version: 1.0.0
 
 
 
# GO SDK 客户端配置
 
client:
 
  # 客户端所属的组织，必须是organizations定义的组织
 
  organization: JD
 
  # 日志级别
 
  logging:
 
    level: info
 
  # MSP证书的根路径
 
  cryptoconfig:
 
    path: /network/crypto-config
 
 
 
# 通道定义
 
channels:
 
  appchannel:
 
    orderers:
 
      - orderer.qq.com
 
    peers:
 
      peer0.jd.com:
 
        endorsingPeer: true
 
        chaincodeQuery: true
 
        ledgerQuery: true
 
        eventSource: true
 
      peer1.jd.com:
 
        endorsingPeer: true
 
        chaincodeQuery: true
 
        ledgerQuery: true
 
        eventSource: true
 
 
 
# 组织配置
 
organizations:
 
  JD:
 
    mspid: "JDMSP"
 
    cryptoPath: peerOrganizations/jd.com/users/{username}@jd.com/msp
 
    peers:
 
      - peer0.jd.com
 
      - peer1.jd.com
 
 
 
# orderer节点列表
 
orderers:
 
  orderer.qq.com:
 
    url: orderer.qq.com:7050
 
    # 传递给gRPC客户端构造函数
 
    grpcOptions:
 
      ssl-target-name-override: orderer.qq.com
 
      keep-alive-time: 0s
 
      keep-alive-timeout: 20s
 
      keep-alive-permit: false
 
      fail-fast: false
 
      allow-insecure: true
 
 
 
# peers节点列表
 
peers:
 
  # peer节点定义，可以定义多个
 
  peer0.jd.com:
 
    # URL用于发送背书和查询请求
 
    url: peer0.jd.com:7051
 
    # 传递给gRPC客户端构造函数
 
    grpcOptions:
 
      ssl-target-name-override: peer0.jd.com
 
      keep-alive-time: 0s
 
      keep-alive-timeout: 20s
 
      keep-alive-permit: false
 
      fail-fast: false
 
      allow-insecure: true
 
  peer1.jd.com:
 
    url: peer1.jd.com:7051
 
    grpcOptions:
 
      ssl-target-name-override: peer1.jd.com
 
      keep-alive-time: 0s
 
      keep-alive-timeout: 20s
 
      keep-alive-permit: false
 
      fail-fast: false
 
      allow-insecure: true
 
  peer0.taobao.com:
 
    url: peer0.taobao.com:7051
 
    grpcOptions:
 
      ssl-target-name-override: peer0.taobao.com
 
      keep-alive-time: 0s
 
      keep-alive-timeout: 20s
 
      keep-alive-permit: false
 
      fail-fast: false
 
      allow-insecure: true
 
  peer1.taobao.com:
 
    url: peer1.taobao.com:7051
 
    grpcOptions:
 
      ssl-target-name-override: peer1.taobao.com
 
      keep-alive-time: 0s
 
      keep-alive-timeout: 20s
 
      keep-alive-permit: false
 
      fail-fast: false
 
      allow-insecure: true

package main
 
 
 
import (
 
    "github.com/hyperledger/fabric-sdk-go/pkg/client/channel"
 
    "github.com/hyperledger/fabric-sdk-go/pkg/core/config"
 
    "github.com/hyperledger/fabric-sdk-go/pkg/fabsdk"
 
)
 
 
 
// 配置信息
 
var (
 
    sdk           *fabsdk.FabricSDK                              // Fabric SDK
 
    channelName   = "appchannel"                                 // 通道名称
 
    username      = "Admin"                                      // 用户
 
    chainCodeName = "fabric-realty"                              // 链码名称
 
    endpoints     = []string{"peer0.jd.com", "peer0.taobao.com"} // 要发送交易的节点
 
)
 
 
 
// init 初始化
 
func init() {
 
    var err error
 
    // 通过配置文件初始化SDK
 
    sdk, err = fabsdk.New(config.FromFile("config.yaml"))
 
    if err != nil {
 
       panic(err)
 
    }
 
}
 
 
 
// ChannelExecute 区块链交互
 
func ChannelExecute(fcn string, args [][]byte) (channel.Response, error) {
 
    // 创建客户端，表明在通道的身份
 
    ctx := sdk.ChannelContext(channelName, fabsdk.WithUser(username))
 
    cli, err := channel.New(ctx)
 
    if err != nil {
 
       return channel.Response{}, err
 
    }
 
    // 对区块链账本的写操作（调用了链码的invoke）
 
    resp, err := cli.Execute(channel.Request{
 
       ChaincodeID: chainCodeName,
 
       Fcn:         fcn,
 
       Args:        args,
 
    }, channel.WithTargetEndpoints(endpoints...))
 
    if err != nil {
 
       return channel.Response{}, err
 
    }
 
    //返回链码执行后的结果
 
    return resp, nil
 
}
 
 
 
// ChannelQuery 区块链查询
 
func ChannelQuery(fcn string, args [][]byte) (channel.Response, error) {
 
    // 创建客户端，表明在通道的身份
 
    ctx := sdk.ChannelContext(channelName, fabsdk.WithUser(username))
 
    cli, err := channel.New(ctx)
 
    if err != nil {
 
       return channel.Response{}, err
 
    }
 
    // 对区块链账本查询的操作（调用了链码的invoke），只返回结果
 
    resp, err := cli.Query(channel.Request{
 
       ChaincodeID: chainCodeName,
 
       Fcn:         fcn,
 
       Args:        args,
 
    }, channel.WithTargetEndpoints(endpoints...))
 
    if err != nil {
 
       return channel.Response{}, err
 
    }
 
    //返回链码执行后的结果
 
    return resp, nil
 
}

package main
 
 
 
import (
 
    "bytes"
 
    "encoding/json"
 
 
 
    "github.com/gin-gonic/gin"
 
)
 
 
 
func main() {
 
    g := gin.Default()
 
    g.GET("/query", func(c *gin.Context) {
 
       args := make([][]byte, 0)
 
       user := c.Query("user")
 
       if user != "" {
 
          args = append(args, []byte(user))
 
       }
 
       // 调用链码的query函数
 
       resp, err := ChannelQuery("query", args)
 
       if err != nil {
 
          c.AbortWithStatusJSON(500, gin.H{"err": err.Error()})
 
          return
 
       }
 
       var data []map[string]interface{}
 
       if err = json.Unmarshal(bytes.NewBuffer(resp.Payload).Bytes(), &data); err != nil {
 
          c.AbortWithStatusJSON(500, gin.H{"err": err.Error()})
 
          return
 
       }
 
       c.JSON(200, data)
 
    })
 
    g.POST("/transfer", func(c *gin.Context) {
 
       from := c.Query("from")
 
       to := c.Query("to")
 
       money := c.Query("money")
 
       if from == "" || to == "" || money == "" {
 
          c.AbortWithStatusJSON(400, gin.H{"err": "参数不能为空"})
 
          return
 
       }
 
       args := make([][]byte, 0)
 
       args = append(args, []byte(from), []byte(to), []byte(money))
 
       // 调用链码的transfer函数
 
       resp, err := ChannelExecute("transfer", args)
 
       if err != nil {
 
          c.AbortWithStatusJSON(500, gin.H{"err": err.Error()})
 
          return
 
       }
 
       c.JSON(200, gin.H{"msg": string(resp.Payload)})
 
    })
 
    g.Run("0.0.0.0:8000")
 
}