区块链链码编写

👴的srtp项目终于💧过去了（虽然👴以及💧过去快一个🈷了，但👴是懒🐕，所以👴记起来后，👴就顺便写写），👴使用三天速成区块链，成功写了写区块链2.0的链码，👴也懒得写咋写的了，懂得都懂，不懂得看一眼也懂🌶，所以👴就只贴一波代码🌶

以下就是怎么用go写链码🌶，最简单得那种，毕竟👴就混个项目，能跑就彳亍，

package main

import (
	"fmt"
	"log"
	"strconv"
	"time"
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"github.com/hyperledger/fabric-contract-api-go/contractapi"
)

// DonateContract Chaincode implementation
type DonateContract struct {
	contractapi.Contract
}

type Donator struct {
	ID				string `json:"ID"`
	User      		string `json:"User"`
	Password		string `json:"Password"`
	Account			int    `json:"Account"`
}


type QueryHistoryResult struct {
	TxId string `json:"tx_id"`
	Value string `json:"value"`
	IsDel string `json:"is_del"`
	OnChainTime string `json:"on_chain_time"`
}

//init
func (s *DonateContract) InitLedger(ctx contractapi.TransactionContextInterface) error {
	donators := []Donator{
		{ID: "8c8b6928", User: "mfwc",Password: "password1", Account: 0},
		{ID: "bdb26a7e", User: "zhjy",Password: "password2", Account: 0},
		{ID: "c1859b89", User: "jbzz",Password: "password3", Account: 0},
	}

	for _, donator := range donators {
		donatorJSON, err := json.Marshal(donator)
		if err != nil {
			return err
		}

		err = ctx.GetStub().PutState(donator.ID, donatorJSON)
		if err != nil {
			return fmt.Errorf("failed to put to world state. %v", err)
		}
	}

	return nil
}
//new
func (s *DonateContract) CreateDonator(ctx contractapi.TransactionContextInterface, id string, user string, password string, account int) error {
	exists, err := s.DonatorExists(ctx, id)
	if err != nil {
		return err
	}
	if exists {
		return fmt.Errorf("the donator %s already exists", id)
	}

	donator := Donator{
		ID:				id,
		User:          	user,
		Password:		password,
		Account:        account,
	}
	donatorJSON, err := json.Marshal(donator)
	if err != nil {
		return err
	}

	return ctx.GetStub().PutState(id, donatorJSON)
}

//read_message
func (s *DonateContract) ReadDonator(ctx contractapi.TransactionContextInterface, id string) (*Donator, error) {
	donatorJSON, err := ctx.GetStub().GetState(id)
	if err != nil {
		return nil, fmt.Errorf("failed to read from world state: %v", err)
	}
	if donatorJSON == nil {
		return nil, fmt.Errorf("the donator %s does not exist", id)
	}

	var donator Donator
	err = json.Unmarshal(donatorJSON, &donator)
	if err != nil {
		return nil, err
	}

	return &donator, nil
}
//update
func (s *DonateContract) UpdateDonator(ctx contractapi.TransactionContextInterface, id string, user string, password string, account int) error {
	exists, err := s.DonatorExists(ctx, id)
	if err != nil {
		return err
	}
	if !exists {
		return fmt.Errorf("the donator %s does not exist", id)
	}

	// overwriting original donator with new donator
	donator := Donator{
		ID:				id,
		User:          	user,
		Password:		password,
		Account:        account,
	}
	donatorJSON, err := json.Marshal(donator)
	if err != nil {
		return err
	}

	return ctx.GetStub().PutState(id, donatorJSON)
}
//delete
func (s *DonateContract) DeleteDonator(ctx contractapi.TransactionContextInterface, id string) error {
	exists, err := s.DonatorExists(ctx, id)
	if err != nil {
		return err
	}
	if !exists {
		return fmt.Errorf("the donator %s does not exist", id)
	}

	return ctx.GetStub().DelState(id)
}
//getall
func (s *DonateContract) GetAllDonators(ctx contractapi.TransactionContextInterface) ([]*Donator, error) {
	// range query with empty string for startKey and endKey does an
	// open-ended query of all donators in the chaincode namespace.
	resultsIterator, err := ctx.GetStub().GetStateByRange("", "")
	if err != nil {
		return nil, err
	}
	defer resultsIterator.Close()

	var donators []*Donator
	for resultsIterator.HasNext() {
		queryResponse, err := resultsIterator.Next()
		if err != nil {
			return nil, err
		}

		var donator Donator
		err = json.Unmarshal(queryResponse.Value, &donator)
		if err != nil {
			return nil, err
		}
		donators = append(donators, &donator)
	}

	return donators, nil
}
//search
func (s *DonateContract) DonatorExists(ctx contractapi.TransactionContextInterface, id string) (bool, error) {
	donatorJSON, err := ctx.GetStub().GetState(id)
	if err != nil {
		return false, fmt.Errorf("failed to read from world state: %v", err)
	}

	return donatorJSON != nil, nil
}
//donate
func (s *DonateContract) Donate(ctx contractapi.TransactionContextInterface, donoid string, doneid string, money int) error {
	donor, err := s.ReadDonator(ctx, donoid)
	if err != nil {
		return err
	}
	donee, err := s.ReadDonator(ctx, doneid)
	if err != nil {
		return err
	}
	s.UpdateDonator(ctx,donor.ID,donor.User,donor.Password,donor.Account-money)
	s.UpdateDonator(ctx,donee.ID,donee.User,donee.Password,donee.Account+money)
	return nil
}
//signin
func (s *DonateContract) signin(ctx contractapi.TransactionContextInterface, id string, user string, password string) error {
	//id,user,password
	s.CreateDonator(ctx,id,user,MD5(password),0)
	return nil
}

//md5
func MD5(text string) string {
	ctx := md5.New()
	ctx.Write([]byte(text))
	return hex.EncodeToString(ctx.Sum(nil))
}

//check pass
func (s *DonateContract) Check(ctx contractapi.TransactionContextInterface, id string, password string) (bool, error) {
	user, err := s.ReadDonator(ctx, id)
	if err != nil {
		return false,err
	}
	if MD5(password)==user.Password {
		return true,nil
	} else{
		return false,nil
	}
}

//charge
func (s *DonateContract) Charge(ctx contractapi.TransactionContextInterface, donoid string, money int) error {
	donor, err := s.ReadDonator(ctx, donoid)
	if err != nil {
		return err
	}
	s.UpdateDonator(ctx,donor.ID,donor.User,donor.Password,donor.Account+money)
	return nil
}

//history

func (s *DonateContract) GetHistory(ctx contractapi.TransactionContextInterface, id string) ([]QueryHistoryResult, error) {
	resultsIterator, err := ctx.GetStub().GetHistoryForKey(id)
	if err != nil {
			return nil, err
	}
	defer resultsIterator.Close()
	//results := []QueryResult{}
	//results := make([]QueryResult, 0)
	results := make([]QueryHistoryResult, 0)
	for resultsIterator.HasNext() {
			if queryResponse, err := resultsIterator.Next();err==nil{
					res := QueryHistoryResult{}
					res.TxId=queryResponse.TxId
					res.Value=string(queryResponse.Value)
					res.IsDel=strconv.FormatBool(queryResponse.IsDelete)
					res.OnChainTime=time.Unix(queryResponse.Timestamp.Seconds,0).Format("2006-01-02 15:04:05")
					results= append(results, res)
			}
			if err!=nil {
					return nil,err
			}
	}
	return results, nil
}


//main
func main() {
	donateChaincode, err := contractapi.NewChaincode(&DonateContract{})
	if err != nil {
		log.Panicf("Error creating donate chaincode: %v", err)
	}
	if err := donateChaincode.Start(); err != nil {
		log.Panicf("Error starting donate chaincode: %v", err)
	}
}