beego框架编写食品溯源区块链后端

分类：区块链作者：只会_摆烂

区块链食品溯源项目

创建项目

bee new trace

安装go-sdk

go get github.com/FISCO-BCOS/go-sdk

  • 将webase的sdk证书文件复制到自己的项目

  • 修改config.toml使sdk是本项目下

修改配置文件app.conf

appname = trace
httpport = 8080
runmode = dev
autorender = false
copyrequestbody = true
EnableDocs = true
contractAddress=0xc5a3d4384897acb9ce3e9096644c35aa903d1687
distributorAddress=0x1cb30f505b9e338bb48f9cec3ceadd1d2d4da565
distributorPK=5eff4114710e69a7677a39145b71ab4b763c126aa118defd2f0316a604e9495cad29c3854604e3b7721588b4778d047e2deb9911a48ae04125e22fdce8eda292
producerAddress=0x1cb30f505b9e338bb48f9cec3ceadd1d2d4da565
producerPK=e885dc09e398461121608831780410fb2e6c782d2afc95e324057dec60e07f34d8bde9f6cdc63dd79591988165b63b9ebb96e0ddbc823fe80c6570bcee5c97fd
retailerAddress=0x746afad125d42011b289ef421e8703e0dd867b60
retailerPK=47f39c99583acea98ab31b5b38f13bd0c05726e9304cf5e803bc4cf82910c1ddb80b7941bb9bad4db450e2d761045161ea67b8cb74a66f738004d5927c3a1f70

地址私钥根据自己的webase修改

新建conf.go获取配置文件信息

package conf
​
import (
    "fmt"
​
    "github.com/astaxie/beego"
)
​
var (
    ContractAddress    string
    DistributorAddress string
    DistributorPK      string
    ProducerAddress    string
    ProducerPK         string
    RetailerAddress    string
    RetailerPK         string
)
​
func init() {
    err := beego.LoadAppConfig("ini","conf/app.conf")
    if err != nil{
        fmt.Println(err)
        return
    }
    ContractAddress,_ =beego.AppConfig.String("contractAddress")
    DistributorAddress,_ = beego.AppConfig.String("distributorAddress")
    DistributorPK,_ = beego.AppConfig.String("distributorPK")
    ProducerAddress,_ = beego.AppConfig.String("producerAddress")
    ProducerPK,_ = beego.AppConfig.String("producerPK")
    RetailerAddress,_ = beego.AppConfig.String("retailerAddress")
    RetailerPK,_ = beego.AppConfig.String("retailerPK")
}

将go-sdk下config.go和config_pem.go复制到项目目录conf目录下

编写Service层

将合约编译成go文件

abigen -abi abi/FoodInfo.abi -bin bin/FoodInfo.bin -pkg main -type FoodInfo -out FoodInfo.go
​
abigen -abi abi/Role.abi -bin bin/Role.bin -pkg main -type Role -out Role.go
​
abigen -abi abi/RoleController.abi -bin bin/RoleController.bin -pkg main -type RoleController -out RoleController.go
​
abigen -abi abi/Trace.abi -bin bin/Trace.bin -pkg main -type Trace -out Trace.go

编写TraceService

与合约进行交互

package service
​
import (
    "log"
​
    "github.com/FISCO-BCOS/go-sdk/abi/bind"
    "github.com/FISCO-BCOS/go-sdk/client"
    conf2 "github.com/FISCO-BCOS/go-sdk/conf"
    "github.com/ethereum/go-ethereum/common"
​
    //"github.com/FISCO-BCOS/go-sdk/client"
    "trace/conf"
)
​
var Tracecli TraceSession
​
func init() {
    configs,err := conf.ParseConfigFile("config.toml")
    if err != nil {
        log.Fatal(err)
    }
    client,err := client.Dial((*conf2.Config)(&configs[0]))
    if(err != nil) {
        log.Fatal(err)
    }
    address := conf.ContractAddress
    ContractAddress := common.HexToAddress(address)
    instance,err := NewTrace(ContractAddress,client)
    if err != nil{
        log.Fatal(err)
    }
    Tracecli = TraceSession{Contract: instance,CallOpts: *client.GetCallOpts(),TransactOpts: *client.GetTransactOpts()}
}
​
func LoadUser(user string) {
    fromAddress := ""
    privateKey := ""
    switch user {
    case "producer":
        fromAddress = conf.ProducerAddress
        privateKey = conf.ProducerPK
    case "distributor":
        fromAddress = conf.DistributorAddress
        privateKey = conf.DistributorPK
    case "retailer":
        fromAddress = conf.RetailerAddress
        privateKey = conf.RetailerPK
    default:
        return
    }
    ket,_ := crpto.HexToECDSA(privateKey)
    auth := bind.NewKeyedTransactor(key)
    auth.From = common.HexToAddress(fromAddress)
    files,_ := conf.ParseConfigFile("config.toml")
    client,_ := client.Dial((*conf2.Config)(&files[0]))
    instance,_ := TraceSession{Contract: instance,TransactOpts: *auth}
}

编写foodInfoService

package service
​
import (
    "fmt"
    "strconv"
)
​
type FoodInfoService struct{}
​
func (fs *FoodInfoService) Trace(traceNumber string) interface{} {
    trace := get_trace(traceNumber)
    return trace
}
func (fs *FoodInfoService) Get_food(traceNumber string) map[string]interface{} {
    response := make(map[string]interface{})
    name,current,quality,_,err := Tracecli.GetTraceinfoByTraceNumber(traceNumber)
    byTraceNumber,i,i2,err := Tracecli.GetTraceDetailByTraceNumber(traceNumber)
    if err != nil {
        fmt.Println(err)
    }
    response["timestamp"] = byTraceNumber[len(byTraceNumber)-1]
    response["produce"] = i[0]
    response["name"] = name
    response["current"] = current
    response["address"] = i2[0]
    response["quality"] = quality
    return response
}
func (fs *FoodInfoService) GetFoodList() []int {
    food,_ := Tracecli.GetAllFood()
    intSlice := make([]int,len(food))
    for i,v := range food {
        intSlice[i] = int(v.Int64())
    }
    return intSlice
}
​
func get_trace(traceNumber string) []interface{} {
    _,s,err := Tracecli.GetTraceinfoByTraceNumber(traceNumber)
    var responses []interface{}
    byTraceNumber,i3,err := Tracecli.GetTraceDetailByTraceNumber(traceNumber)
    if err != nil {
        fmt.Println(err)
    }
    for index := 0; index < len(byTraceNumber); index++ {
        if index == 0 {
            response := make(map[string]interface{})
            response["traceNumber"] = traceNumber
            response["name"] = s
            response["produce_time"] = byTraceNumber[0]
            response["timestamp"] = byTraceNumber[index]
            response["from"] = i[index]
            response["quality"] = i3[index]
            response["from_address"] = i2[index]
            i4 := append(responses,response)
            responses = i4
        } else {
            response := make(map[string]interface{})
            response["traceNumber"] = traceNumber
            response["name"] = s
            response["produce_time"] = byTraceNumber[0]
            response["timestamp"] = byTraceNumber[index]
            response["from"] = i[index-1]
            response["to"] = i[index]
            response["quality"] = i3[index]
            response["from_address"] = i2[index-1]
            i4 := append(responses,response)
            responses = i4
        }
    }
    return responses
}
​
func (fs *FoodInfoService) GetTrace(traceNumber string) []interface{} {
    _,response)
            responses = i4
        } else {
            response := make(map[string]interface{})
            response["traceNumber"] = traceNumber
            response["name"] = s
            response["produce_time"] = byTraceNumber[0]
            response["timestamp"] = byTraceNumber[index]
            response["from"] = i[index-1]
            response["quality"] = i3[index]
            response["from_address"] = i2[index-1]
            i4 := append(responses,response)
            responses = i4
        }
    }
    return responses
}
func (f FoodInfoService) Producing() []interface{} {
    var resList []interface{}
    numList := f.GetFoodList()
    for index := 0; index < len(numList); index++ {
        trace := f.GetTrace(strconv.Itoa(numList[index]))
        if len(trace) == 1 {
            i := append(resList,trace[0])
            resList = i
        }
    }
    fmt.Println("Producing: ",resList)
    return resList
}
func (f FoodInfoService) Distributing() []interface{} {
    numList := f.GetFoodList()
    var resList []interface{}
    for index := 0; index < len(numList); index++ {
        trace := f.GetTrace(strconv.Itoa(numList[index]))
        if len(trace) == 2 {
            i := append(resList,trace[1])
            resList = i
        }
    }
    return resList
}
func (f FoodInfoService) Retailing() []interface{} {
    numList := f.GetFoodList()
    var resList []interface{}
    for index := 0; index < len(numList); index++ {
        trace := f.GetTrace(strconv.Itoa(numList[index]))
        if len(trace) == 3 {
            i := append(resList,trace[2])
            resList = i
        }
    }
    return resList
}
​

编写食物数据模型Food

food.go

package models
​
import "math/big"
​
// Food 表示食物的数据模型
type Food struct {
    Name        string   `json:"name"`        // 食物名称
    TraceNumber *big.Int `json:"TraceNumber"` // 追溯编号，使用 *big.Int 类型以支持大整数
    TraceName   string   `json:"TraceName"`   // 追溯名称
    Quality     uint8    `json:"Quality"`     // 食物质量，使用 uint8 表示无符号 8 位整数
}
​

在utils下统一请求数据格式

response.go
package utils
​
import (
    "encoding/json"
    "fmt"
)
​
// returnDataStruct 定义了用于返回 JSON 数据的结构体
type returnDataStruct struct {
    Ret  int         `json:"ret"`  // 返回状态码
    Msg  string      `json:"msg"`  // 返回消息
    Data interface{} `json:"data"` // 返回数据，使用空接口表示可以包含任何类型的数据
}
​
// Send_json 用于构建并返回标准的 JSON 响应
func Send_json(ret int,msg string,data interface{}) []byte {
    // 构建 returnDataStruct 结构体实例
    retu,err := json.Marshal(returnDataStruct{
        Ret:  ret,Msg:  msg,Data: data,})
    if err != nil {
        fmt.Println("error:",err)
    }
    return retu
}
​
// Send_custom_json 用于构建并返回标准的 json响应
func Send_custom_json(ret int,data_key string,data interface{}) []byte {
    response := make(map[string]interface{})
    response["ret"] = ret
    response[data_key] = data
    retu,err := json.Marshal(response)
    if err != nil {
        fmt.Println(err)
    }
    return retu
}
​

编写给用户返回的数据格式

User.go
package controllers
​
import (
    "trace/conf"
    "trace/utils"
​
    "github.com/beego/beego/v2/server/web"
)
​
type User struct {
    web.Controller
}
​
func (u User) Userinfof() {
    userName := u.GetString("userName")
    var jsons []byte
    switch userName {
    case "produce":
        jsons = utils.Send_custom_json(200,"address",conf.ProducerAddress)
    case "distributor":
        jsons = utils.Send_custom_json(200,conf.DistributorAddress)
    case "retailer":
        jsons = utils.Send_custom_json(200,conf.RetailerAddress)
    default:
        jsons = utils.Send_custom_json(200,"error","user not found")
    }
    u.Ctx.ResponseWriter.Write(jsons)
}
​
注册路由
web.Router("/userinfo",&controllers.User{},"*:Userinfof")

编写处理与食物追溯相关请求

Trace.go

package controllers
​
import "github.com/beego/beego/v2/server/web"
​
type Trace struct {
    web.Controller
}
​
​
newfood处理创建新食物的请求
func (t Trace) newFood() {
    t.newFood()
}
​
处理创建新食物的具体逻辑
func (t *Trace) newfood() {
    // 初始化 Food 结构体
    var food models.Food
    // 获取请求体数据
    data := t.Ctx.Input.RequestBody
    // 调用 paramjson 函数解析 JSON 数据
    success,parsedFood := paramjson(data,&food)
    if !success {
        // 如果解析失败，返回错误响应
        t.Ctx.ResponseWriter.Write(utils.Send_json(0,"传入参数不正确",parsedFood))
        return
    }
    // 调用 LoadUser 函数加载用户
    service.LoadUser("producer")
    // 调用 Tracecli.NewFood 函数创建新食物
    _,receipt,err := service.Tracecli.NewFood(parsedFood.Name,parsedFood.TraceNumber,parsedFood.TraceName,strconv.Itoa(int(parsedFood.Quality)))
    if err != nil {
        // 如果创建失败，返回错误响应
        t.Ctx.ResponseWriter.Write(utils.Send_json(0,"trace already exist",err))
        return
    }
    // 返回成功响应
    t.Ctx.ResponseWriter.Write(utils.Send_json(1,"ok",receipt))
}
编写解析json数据具体逻辑
func paramjson(data []byte,food *models.Food) (bool,models.Food) {
    // 如果输入数据为 nil，则返回解析失败的结果
    if data == nil {
        return false,models.Food{}
    }
    // 尝试解析 JSON 数据并填充到 models.Food 结构体中
    if err := json.Unmarshal(data,&food); err != nil {
        // 解析失败，则返回解析失败的结果
        return false,models.Food{}
    } else {
        // 解析成功，则返回解析后的 models.Food 结构体
        return true,*food
    }
}
​
配置路由
web.Router("/produce",&controllers.Trace{},"POST:NewFood")

Adddistribution 处理食物分销的请求

func (t Trace) Adddistribution() {
    t.adddistribution()
}
adddistribution 处理食物分销的具体逻辑
func (t Trace) adddistribution() {
    var food models.Food
    data := t.Ctx.Input.RequestBody
    paramjson(data,&food)
    b,i := paramjson(data,&food)
    if !b {
        t.Ctx.ResponseWriter.Write(utils.Send_json(0,i))
    }
    service.LoadUser("distributor")
    _,err := service.Tracecli.AddTraceInfoByDistributor(food.TraceNumber,food.TraceName,new(big.Int).SetUint64(uint64(food.Quality)))
    if err != nil {
        t.Ctx.ResponseWriter.Write(utils.Send_json(0,err))
    }
    t.Ctx.ResponseWriter.Write(utils.Send_json(1,receipt))
}
配置路由
web.Router("/distributor","POST:Adddistribution")

Addretail 处理食物零售的请求

func (t Trace) Addretail() {
    t.Addretail()
}
addretail 处理食物零售的具体逻辑
func (t Trace) addretail() {
    var food models.Food
    data := t.Ctx.Input.RequestBody
    paramjson(data,i))
    }
    service.LoadUser("retailer")
    _,err := service.Tracecli.AddTraceInfoByRetailer(food.TraceNumber,err))
​
    }
    t.Ctx.ResponseWriter.Write(utils.Send_json(1,receipt))
}
配置路由
web.Router("/addretail","POST:Addretail")

编写GetfoodInfo 控制器

处理食品信息的请求

type GetfoodInfo struct {
    web.Controller
}
​

Trace 获取某个食品的溯源信息

func (g GetfoodInfo) Trace() {
    // 检索追溯号和 FoodInfoService 实例
    tn,fs := g.getTraceNumberAndService()
​
    // 在 FoodInfoService 上调用 Get_food 方法，并以 JSON 格式响应结果
    g.Ctx.Output.JSON(fs.Get_food(tn),false,false)
}

getTraceNumberAndService 是一个辅助方法，用于检索追溯号和 FoodInfoService

编写getTraceNumberAndService方法
func (g GetfoodInfo) getTraceNumberAndService() (string,*service.FoodInfoService) {
    // 从请求参数中检索追溯号
    tn := g.GetString("traceNumber")
​
    // 将追溯号转换为整数
    atoi,_ := strconv.Atoi(tn)
​
    // 检查追溯号是否小于 0 或为空；如果是，则以错误响应
    if atoi < 0 || tn == "" {
        g.Ctx.ResponseWriter.Write(utils.Send_custom_json(0,"invalid parameter"))
    }
​
    // 创建 FoodInfoService 的新实例
    fs := &service.FoodInfoService{}
​
    // 返回追溯号和 FoodInfoService 实例
    return tn,fs
}
配置路由
web.Router("/trace",&controllers.GetfoodInfo{},"*:Trace")

获取某个食品当前信息

func (g GetfoodInfo) GetFood() {
    tn,fs := g.getTraceNumberAndService()
    g.Ctx.Output.JSON(fs.Get_food(tn),false)
}
​
配置路由
web.Router("/food","*:GetFood")

获取某个生产商的食物信息

func (g GetfoodInfo) Producing() {
    fs := g.getFoodInfoService()
    g.Ctx.Output.JSON(fs.Producing(),false)
}

getFoodInfoService 是用于获取 FoodInfoService 实例的方法

func (g GetfoodInfo) getFoodInfoService() *service.FoodInfoService {
    // 创建并返回 FoodInfoService 的新实例
    fs := &service.FoodInfoService{}
    return fs
}

配置路由
web.Router("/producing","GET:Producing")

获取位于中间商的食物信息

func (g GetfoodInfo) Distributing() {
    fs := g.getFoodInfoService()
    g.Ctx.Output.JSON(fs.Distributing(),false)
}
配置路由
web.Router("/distributing","GET:Distributing")

获取超市的食物信息

func (g GetfoodInfo) Retailing() {
    fs := g.getFoodInfoService()
    g.Ctx.Output.JSON(fs.Retailing(),false)
}
​
配置路由
web.Router("/retailing","GET:Retailing")

INITROLE 函数用于初始化角色设置

INITROLE

// INITROLE 函数用于初始化角色设置
func INITROLE() {
    // 从配置中获取分发者的地址和私钥
    fromAddress := conf.DistributorAddress
    privateKey := conf.DistributorPK
​
    // 将私钥解析为 ECDSA 密钥
    key,err := crypto.HexToECDSA(privateKey)
    if err != nil {
        fmt.Println("error private:",err)
        return
    }
​
    // 创建一个新的 KeyedTransactor，将密钥和地址设置为授权信息
    auth := bind.NewKeyedTransactor(key)
    auth.From = common.HexToAddress(fromAddress)
​
    // 从配置文件中解析 FISCO-BCOS 客户端的配置
    files,_ := client.Dial((*conf2.Config)(&files[0]))
​
    // 部署 Service 合约并获取合约实例
    _,instance,_ := service.DeployService(client.GetTransactOpts(),client)
    session := service.ServiceSession{Contract: instance,TransactOpts: *client.GetTransactOpts()}
​
    // 将分发者地址转换为 common.Address 类型
    address := common.HexToAddress(conf.DistributorAddress)
​
    // 设置 Distributor 角色
    _,err = session.SetDRRole(address.String())
    if err != nil {
        fmt.Println(err)
    }
​
    // 将生产者地址转换为 common.Address 类型
    address1 := common.HexToAddress(conf.ProducerAddress)
​
    // 设置 Producer 角色
    _,err = session.ResetPRRole(address1.String())
    if err != nil {
        fmt.Println(err)
    }
​
    // 将零售商地址转换为 common.Address 类型
    address2 := common.HexToAddress(conf.RetailerAddress)
​
    // 设置 Retailer 角色
    _,err = session.ResetRRRole(address2.String())
    if err != nil {
        fmt.Println(err)
    }
​
    // 部署 Role 合约并获取合约实例
    _,instance1,err := Role.DeployService(client.GetTransactOpts(),client)
    if err != nil {
        fmt.Println(err)
    }
​
    session1 := Role.ServiceSession{Contract: instance1,TransactOpts: *client.GetTransactOpts()}
​
    // 判断所有角色是否设置成功
    err1 := session1.OnlyDRRole(address)
    err2 := session1.OnlyPRRole(address1)
    err3 := session1.OnlyPRRole(address2)
​
    if err1 != nil || err2 != nil || err3 != nil {
        fmt.Println(err1)
        fmt.Println(err2)
        fmt.Println(err3)
    }
}
​

main函数初始化

func main() {
    // 初始化角色
    INITROLE()
​
    // 设置 Beego 路由不区分大小写
    beego.BConfig.RouterCaseSensitive = false
​
    // 运行 Beego 应用
    beego.Run()
}

原文地址：https://blog.csdn.net/m0_58188818/article/details/135448302

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

基于BSC测试网收益聚合器Beefy协议的编译、测试、部署
文章浏览阅读903次。文章主要介绍了收益聚合器Beefy协议在币安智能链测试网网上的编译测试部署流程，以Pancake上的USDC-BUSD最新Curve版流动池的农场质押为例，详细介绍了完整的操作流程。_怎么在bsc网络上部署应用
《后端技术面试 38 讲》学习笔记 Day 13
文章浏览阅读952次。比特币的主要思路是，构建一个无中心、去信任的分布式记账系统。交易签名只能保证交易不是他人伪造的，却不能阻止交易的发起者自己进行多重交易，即交易的发起者将一个比特币同时转账给两个人，也就是所谓的双花。比特币应用的区块链场景也叫做公链，因为这个区块链对所有人都是公开的。除此之外，还有一种区块链应用场景，被称作联盟链。区块链的出现，使得低成本，去信任的跨组织合作成为可能，将重构组织间的关系，这个关系既包括企业间的关系，也包括政府和企业间的关系，还有政府部门间的关系。
元宇宙虚拟人迎来高峰期，哪个是你的最爱？
文章浏览阅读2.5k次。虚拟人从最初的不温不火，到现在步入“出生高峰期”，元宇宙可以说是功不可没。此前，量子位发布了《虚拟数字人深度产业报告》，报告显示，到2030年我国虚拟数字人整体市场规模将达到2700亿元。其中，“身份型虚拟人”市场规模预计达到1750亿元，占主导地位，而“服务型虚拟人”总规模也将超过950亿元。得益于AI、VR/AR 等技术的发展，虚拟人的应用场景正在从传统的虚拟偶像等娱乐行业迈向更多元化的领域。_最喜欢的虚拟角色
区块链媒体：Web3.015个方法解析-华媒舍
文章浏览阅读1.3k次，点赞25次，收藏13次。通过调查和分析用户需求、兴趣和行为，你可以更好地定位你的目标受众，并在市场中找到你的定位。在设计你的Web3.0项目时，注重用户界面的友好性、交互流畅性和功能的创新性，以提供独特的用户体验。通过与有影响力的人或组织进行合作，推广你的Web3.0项目。通过与他们分享你的项目并抓住他们的推荐，可以迅速获得更多的关注度。通过优化你的网站和内容，将有助于提高你的排名，并增加有机流量。通过提供奖励激励计划，如空投、奖励机制等，激励用户参与你的Web3.0项目。的人或组织合作，可以增加你的项目的曝光度。
Solidity 合约安全，常见漏洞 （上篇）
文章浏览阅读1.7k次。这个智能合约安全系列提供了一个广泛的列表，列出了在 Solidity 智能合约中容易反复出现的问题和漏洞。Solidity 中的安全问题可以归结为智能合约的行为方式不符合它们的意图。我们不可能对所有可能出错的事情做一个全面的列表。然而，正如传统的软件工程有常见的漏洞主题，如 SQL 注入、缓冲区超限和跨网站脚本，智能合约中也有反复出现的。_solidity安全漏洞
区块链系统探索之路：比特币核心的编译和探索
文章浏览阅读1.3k次。本文描述了比特币核心的编译与交互方法_编译比特币
兼容东西，贯通南北：超聚变的“四水归堂”
文章浏览阅读884次。四水归堂，是中国建筑艺术中的一种独特形式。这种形式下，由四面房屋围出一个天井，房屋内侧坡向天井内倾斜，下雨时雨水会从东西南北四方流入天井，从而起到收集水源，防涝护屋的作用，寓意水聚天心，天人合一。在科技产业当中，很多时候我们需要学习古人的智慧与意蕴，尝试打通各个生态，聚四方之力为我所用，这样才能为最终用户带来最大化价值。随着数字化、智能化的发展，算力成为生产力的根基。在这一大背景下，算力需要贯通软..._超聚变csdn
云计算与区块链：数字时代的双雄
文章浏览阅读1k次，点赞24次，收藏19次。云计算和区块链是当代科技领域两个备受关注的核心技术。本文将深入探讨云计算和区块链的发展历程，详细剖析其起初阶段的奠基、面临的问题、业务内容、当前研究方向、用到的技术、实际应用场景、未来发展趋势，并提供相关链接供读者深入了解。
探索未来世界，解密区块链奥秘！
文章浏览阅读1.5k次。融入对等网络的奥妙，了解集中式、全分布式和混合式对等网络的差异，以及区块链网络的结构与协议，让你跃入区块链的连结网络。揭开密码学的神秘面纱，探寻对称密码学、非对称密码学、哈希函数、数字签名等关键技术，让你了解信息安全的核心。解码共识算法的精髓，从理论到实践，从PoW、PoS到PBFT，让你深入了解区块链如何达成共识。探索智能合约的世界，从定义到生命周期，从执行引擎到开发与部署，带你进入无限可能的合约领域。了解令人惊叹的区块链世界，从概念到价值，从发展历程到政策法规，一篇章串联出区块链的精髓。
八月 NFT 行业解读：数据下滑，熊市持续
文章浏览阅读777次。8 月份，加密货币市场经历了明显的波动，比特币价格波动幅度较大。与此同时，NFT 市场出现大幅下跌，引发了人们对这一新兴行业未来发展趋势的担忧
Day16【元宇宙的实践构想04】—— 元宇宙的安全
文章浏览阅读8.8k次，点赞53次，收藏37次。近二十年来，我国信息科技发展日益成熟，出现的网络完全问题也是“百花齐放”。而元宇宙作为5G技术、AR/VR技术、云计算以及区块链等技术的组合体，其安全性指定会被人们所广泛关注。根据前面所讲，元宇宙融合了虚拟世界和现实世界，通过数据将现实世界的各种元素映射到数字化的虚拟世界中。所以没有数据，就等于没有元宇宙的一切；没有信息安全，元宇宙的社会生产、生活就不能正常有序地进行。所以足以可见数据安全、信息安全对元宇宙发展起到的重要作用！！_元宇宙 安全计算
Web 3.0顶级干货教学：区块链概述
文章浏览阅读1.4k次。最早使用历史 1991年采用 时间戳 追溯 数字文档，之后 2009年后创始人**中本聪** （satoshi nakamoto ）日裔美国人，在设计比特币数字货币中将此理念写入应用程序中_web3.0学习
DeFi收益来源全面概述
文章浏览阅读1.7k次。DeFi收益来源全面概述_drfi收益
BTC重上四万二
文章浏览阅读941次，点赞17次，收藏21次。号外：教链内参1.28《从BTC现货ETF的近期数据看到的》隔夜BTC经历现货ETF通过后的情绪冷静，一度破位40k后又逐渐修复至42k上方。请珍惜42k的BTC吧。也许到下个周期，我们将不再有机会见到这个高度的BTC了。下面，让我们重温，42k的BTC，在过去四年穿越牛熊的过程中，带给我们的启迪吧。需要提醒的是，历史文字，自有历史局限性，回顾，也须带着批判性的目光阅读和审视。2021年2月8日，...
区块链基础概念
文章浏览阅读1.2k次，点赞23次，收藏21次。其实一开始我也是这么想的，但根据PoW算法机制，如果你的计算量不够大，是无法控制区块链的走向的，也就是说，即使你投入了大量的成本用于完成任务，也不能保证自己成功。例如，你持有100个币，总共持有了30天，那么,此时你的币龄就为3000,这个时候，如果你发现了一个PoS区块，那么你的币龄就会被减去一定的值，每减少365个币龄，将会从区块中获得0.05个币的利息(可理解为年利率5%),那么在这个案例中，利息=3000×5%/365=0.41个币。前面说过，谁的算力强，谁最先解决问题的概率就越大。
JS 实现区块链分布式网络
文章浏览阅读1.9k次。这里主要实现的部分继续下去，对 Blockchain 这个对象有一些修改，如果使用 TS 的话可能要修改对应的 interface，但是如果是 JS 的话就无所谓了。需要安装的依赖有：express现在的 express 已经不内置 body-parser，需要作为单独的依赖下载request不下载会报错，是使用 request-promise 所需要的依赖和已经 deprecated 了，具体 reference 可以参考。_js区块链
以太坊大涨
文章浏览阅读1k次，点赞19次，收藏19次。作者：Zach Pandl Grayscale编译：象牙山首席村民 碳链价值以太坊在2023年取得了丰厚的回报。但表现不如比特币以及其他一些智能合约公链代币。我们认为，这反映了今年比特币特有的积极因素以及以太坊链上活动的缓慢复苏。尽管以太坊的涨幅低于比特币，但从绝对值和风险调整值来看，今年以太坊的表现优于传统资产类别。以太坊不断增长的L2生态系统的发展可能会吸引新用户，并在2024年支撑以太币的...
金庆培：世界需要有一个国际易货贸易协定
文章浏览阅读908次，点赞20次，收藏20次。通证是以数字形式存在，代表的是一种权利、一种固有和内在的价值。徐教授告诉我：多年的职业经历，多年的为易货贸易的思考，认识到在处理贸易和经济领域的关系时，应以提高人民生活水平、保证社会成员充分就业、保证就业成员实际收入和有效需求的大幅稳定增长、实现世界资源的充分利用以及扩大货物的生产和交换为目的，期望通过达成互惠互利安排，实行公开、公平、公正的“三公原则”，开展国家与国家、企业与企业之间的易货贸易，规避因信用问题引起的各类风险，消除国际贸易中的歧视待遇，促进全球国家的经济发展，从而为实现上述目标做出贡献。
fisco bcos webase 对应api列表
文章浏览阅读2.5k次。由于webase文档原因，查找起来比较局限，有时候想找一个api却又忘了在哪个模块的目录下，需要一步一步单独点，而利用文档自带的检索功能又因为查找文档全部信息，显得十分缓慢，所以整理了有关WeBASE的api列表但不可否认，现在只有列表，没有对应的页面跳转，文章目的也只是为了多了解webase的接口_webase私钥管理里获取
十分钟发布自己的NFT
文章浏览阅读1.4k次，点赞28次，收藏21次。基于​openzeppelin来构建我们的NFT，并用一个例子来手把手的说明如何在opensea快速发布自己的NFT智能合约（ERC721）。
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot