fabric链码操作方法不定期汇总

UUID

func (t *TestChaincode) getUUID(stub shim.ChaincodeStubInterface, args []string) pb.Response {

    arl := util.GenerateUUID()
    fmt.Println(arl)

    return shim.Success([]byte(arl))
}

getLogger

func getLogger(stub shim.ChaincodeStubInterface) (c *shim.ChaincodeLogger) {
    fcn, _ := stub.GetFunctionAndParameters()
    c = shim.NewLogger(fmt.Sprintf("%s.%s.%s", stub.GetChannelID(), "你的链码名称", fcn))
    c.SetLevel(shim.LogDebug)
    return
}

rsaKey

func (t *TestChaincode) getRSAKey(stub shim.ChaincodeStubInterface, args []string) pb.Response {

    logger := getLogger(stub)

    // 生成私钥
    privateKey, err := rsa.GenerateKey(rand.Reader, 256)
    logger.Debug("generate key")
    // 生成公钥
    publicKey := &privateKey.PublicKey
    if err != nil {
        return shim.Error(err.Error())
    }
    //生成私钥字符串
    derStream := MarshalPKCS8PrivateKey(privateKey)
    block := &pem.Block{
        Type:  "PRIVATE KEY",
        Bytes: derStream,
    }
    pribuffer := bytes.NewBuffer(make([]byte, 1024*5))
    err = pem.Encode(pribuffer, block)
    if err != nil {
        return shim.Error(err.Error())
    }
    logger.Debug("privatekey is :" + pribuffer.String())
    // 生成公钥字符串
    pubbuffer := bytes.NewBuffer(make([]byte, 1024*5))
    derPkix, err := x509.MarshalPKIXPublicKey(publicKey)
    if err != nil {
        return shim.Error(err.Error())
    }
    block = &pem.Block{
        Type:  "PUBLIC KEY",
        Bytes: derPkix,
    }
    err = pem.Encode(pubbuffer, block)
    if err != nil {
        fmt.Println(err.Error())
    }
    pubStr := pubbuffer.String()
    priStr := pribuffer.String()
    logger.Debug("publickey is : " + pubStr)
    pubStr = pubStr[strings.Index(pubStr, "-----BEGIN PUBLIC KE"):]
    priStr = priStr[strings.Index(priStr, "-----BEGIN PRIVATE KE"):]

    rsaKey := &RSAKey{pubStr, priStr}
    value, err := json.Marshal(rsaKey)
    if err != nil {
        return shim.Error(err.Error())
    }

    return shim.Success(value)
}
type RSAKey struct {
    PrivateKey string `json:"privateKey"`
    PublicKey  string `json:"publicKey"`
}

获取加密对象

func getEnt(key []byte) (entities.EncrypterEntity, error) {
    factory.InitFactories(nil)
    ent, err := entities.NewAES256EncrypterEntity("ID", factory.GetDefault(), key, nil)
    if err != nil {
        return nil, err
    }
    return ent, nil
}

开始加密

ent, err := getEnt(aesKey)
if err != nil {
    return shim.Error(err.Error())
}
res, err := ent.Encrypt([]byte(data))
if err != nil {
    return shim.Error(err.Error())
}
logger.Debug(fmt.Sprintf("get encryptVal: %s", res))

开始解密

ent, err := getEnt(aesKey)
if err != nil {
    return shim.Error(err.Error())
}
res, err := ent.Decrypt(aes.Data)
if err != nil {
    return shim.Error(err.Error())
}
logger.Debug(fmt.Sprintf("get result: %s", string(res)))

解析历史结果集合

func getHisResult(result shim.HistoryQueryIteratorInterface) (bytes.Buffer, error) {
    //由于查询的结果是一个集合，所以要将结果集转成字符串，方便传输
    var buffer bytes.Buffer
    buffer.WriteString("[")

    bArrayMemberAlreadyWritten := false

    for result.HasNext() {

        response, err := result.Next()
        if err != nil {
            return buffer, err
        }

        if bArrayMemberAlreadyWritten {
            buffer.WriteString(",")
        }

        buffer.WriteString("{\"TxId\":\"")
        buffer.WriteString(response.TxId)
        buffer.WriteString("\",\"value\":")

        if response.IsDelete {
            buffer.WriteString("null")
        } else {
            buffer.WriteString(string(response.Value))
        }

        buffer.WriteString(", \"Timestamp\":\"")
        buffer.WriteString(time.Unix(response.Timestamp.Seconds, int64(response.Timestamp.Nanos)).Format("2006-01-02 15:04:05"))
        buffer.WriteString("\"")

        buffer.WriteString(", \"IsDelete\":\"")
        buffer.WriteString(strconv.FormatBool(response.IsDelete))
        buffer.WriteString("\"")

        buffer.WriteString("}")

        //item,_:= json.Marshal(response)
        //buffer.Write(item)

        bArrayMemberAlreadyWritten = true
    }

    buffer.WriteString("]")
    return buffer, nil
}

解析集合结果

func getListResult(resultsIterator shim.StateQueryIteratorInterface) ([]byte, error) {

    defer resultsIterator.Close()
    // buffer is a JSON array containing QueryRecords
    var buffer bytes.Buffer
    buffer.WriteString("[")

    bArrayMemberAlreadyWritten := false
    for resultsIterator.HasNext() {
        queryResponse, err := resultsIterator.Next()
        if err != nil {
            return nil, err
        }
        // Add a comma before array members, suppress it for the first array member
        if bArrayMemberAlreadyWritten == true {
            buffer.WriteString(",")
        }
        buffer.WriteString("{\"Key\":")
        buffer.WriteString("\"")
        buffer.WriteString(queryResponse.Key)
        buffer.WriteString("\"")

        buffer.WriteString(", \"Record\":")
        // Record is a JSON object, so we write as-is
        buffer.WriteString(string(queryResponse.Value))
        buffer.WriteString("}")
        bArrayMemberAlreadyWritten = true
    }
    buffer.WriteString("]")
    fmt.Printf("queryResult:\n%s\n", buffer.String())
    return buffer.Bytes(), nil
}

任意富查询

func (t *AccountChaincode) getResultForQueryString(stub shim.ChaincodeStubInterface, args []string) pb.Response {

    logger := getLogger(stub)
    logger.Debug("Enter [%s] account.getResultForQueryString, args: %s", stub.GetChannelID(), args)
    if len(args) < 1 {
        return shim.Error("Incorrect number of arguments. Expecting 1")
    }
    queryString := args[0]
    if queryString == "" {
        return shim.Error("queryString is nil")
    }
    queryResult, err := stub.GetQueryResult(queryString)
    if err != nil {
        return shim.Error(err.Error())
    }
    defer queryResult.Close()
    value, err := getListResult(queryResult)
    if err != nil {
        return shim.Error(err.Error())
    }
    logger.Debug("Leave [%s] account.getResultForQueryString, returned: %s", stub.GetChannelID(), string(value))
    return shim.Success(value)
}