devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

长安链使用Golang编写智能合约教程（二）

作者：我家自动化 | 2024-06-05 09:47:53

赞

踩

长安链使用Golang编写智能合约教程（二）

长安链2.3.0+的go合约虚拟机和2.3.0以下的不兼容，编译的方式也有差异，所以在ide上做了区分。

教程三会写一些，其他比较常用SDK方法的解释和使用方法

教程一：（长安链2.1.+的版本的智能合约）

教程三：（常见GO SDK的解释与使用） 

编写前的注意事项：

1、运行一条带有Doker_GoVM的链

2、建议直接用官方的在线IDE去写合约，因为写完可以直接测，缺点只是调试不方便。

3、如果自己拉环境在本地写合约，编译时注意编译环境，官方有提醒你去Linux下去编译。

4、如果你的链是2.3.+，使用编译器前，请先切换到2.3.+，以防不测

1、首先去新建一个合约工程

这里选择空白模板，其他模板好像是一些web3的规范模板

2、打开main.go文件（有一份示例合约）

  1. /*
  2. Copyright (C) BABEC. All rights reserved.
  3. Copyright (C) THL A29 Limited, a Tencent company. All rights reserved.
  5. SPDX-License-Identifier: Apache-2.0
  6. */
  7.  
  8. package main
  9.  
  10. import (
  11. 	"encoding/json"
  12. 	"fmt"
  13. 	"log"
  14. 	"strconv"
  15.  
  16. 	"chainmaker/pb/protogo"
  17. 	"chainmaker/sandbox"
  18. 	"chainmaker/sdk"
  19. )
  20.  
  21. type FactContract struct {
  22. }
  23.  
  24. // 存证对象
  25. type Fact struct {
  26. 	FileHash string 
  27. 	FileName string 
  28. 	Time     int 
  29. }
  30.  
  31. // 新建存证对象
  32. func NewFact(fileHash string, fileName string, time int) *Fact {
  33. 	fact := &Fact{
  34. 		FileHash: fileHash,
  35. 		FileName: fileName,
  36. 		Time:     time,
  37. 	}
  38. 	return fact
  39. }
  40.  
  41. func (f *FactContract) InitContract() protogo.Response {
  42. 	return sdk.Success([]byte("Init contract success"))
  43. }
  44.  
  45. func (f *FactContract) UpgradeContract() protogo.Response {
  46. 	return sdk.Success([]byte("Upgrade contract success"))
  47. }
  48.  
  49. func (f *FactContract) InvokeContract(method string) protogo.Response {
  50. 	switch method {
  51. 	case "save":
  52. 		return f.Save()
  53. 	case "findByFileHash":
  54. 		return f.FindByFileHash()
  55. 	default:
  56. 		return sdk.Error("invalid method")
  57. 	}
  58. }
  59.  
  60. func (f *FactContract) Save() protogo.Response {
  61. 	params := sdk.Instance.GetArgs()
  62.  
  63. 	// 获取参数
  64. 	fileHash := string(params["file_hash"])
  65. 	fileName := string(params["file_name"])
  66. 	timeStr := string(params["time"])
  67. 	time, err := strconv.Atoi(timeStr)
  68. 	if err != nil {
  69. 		msg := "time is [" + timeStr + "] not int"
  70. 		sdk.Instance.Errorf(msg)
  71. 		return sdk.Error(msg)
  72. 	}
  73.  
  74. 	// 构建结构体
  75. 	fact := NewFact(fileHash, fileName, time)
  76.  
  77. 	// 序列化
  78. 	factBytes, err := json.Marshal(fact)
  79. 	if err != nil {
  80. 		return sdk.Error(fmt.Sprintf("marshal fact failed, err: %s", err))
  81. 	}
  82. 	// 发送事件
  83. 	sdk.Instance.EmitEvent("topic_vx", []string{fact.FileHash, fact.FileName})
  84.  
  85. 	// 存储数据
  86. 	err = sdk.Instance.PutStateByte("fact_bytes", fact.FileHash, factBytes)
  87. 	if err != nil {
  88. 		return sdk.Error("fail to save fact bytes")
  89. 	}
  90.  
  91. 	// 记录日志
  92. 	sdk.Instance.Infof("[save] fileHash=" + fact.FileHash)
  93. 	sdk.Instance.Infof("[save] fileName=" + fact.FileName)
  94.  
  95. 	// 返回结果
  96. 	return sdk.Success([]byte(fact.FileName + fact.FileHash))
  97.  
  98. }
  99.  
  100. func (f *FactContract) FindByFileHash() protogo.Response {
  101. 	// 获取参数
  102. 	fileHash := string(sdk.Instance.GetArgs()["file_hash"])
  103.  
  104. 	// 查询结果
  105. 	result, err := sdk.Instance.GetStateByte("fact_bytes", fileHash)
  106. 	if err != nil {
  107. 		return sdk.Error("failed to call get_state")
  108. 	}
  109.  
  110. 	// 反序列化
  111. 	var fact Fact
  112. 	if err = json.Unmarshal(result, &fact); err != nil {
  113. 		return sdk.Error(fmt.Sprintf("unmarshal fact failed, err: %s", err))
  114. 	}
  115.  
  116. 	// 记录日志
  117. 	sdk.Instance.Infof("[find_by_file_hash] fileHash=" + fact.FileHash)
  118. 	sdk.Instance.Infof("[find_by_file_hash] fileName=" + fact.FileName)
  119.  
  120. 	// 返回结果
  121. 	return sdk.Success(result)
  122. }
  123.  
  124. func main() {
  125. 	err := sandbox.Start(new(FactContract))
  126. 	if err != nil {
  127. 		log.Fatal(err)
  128. 	}
  129. }
  130.

3、示例模板解析

21行：这里的FactContract是合约名称，对应的要和125行main函数err := sandbox.Start(new(FactContract))一致

type FactContract struct {
}

25行：Fact结构体就是要存在区块链中的结构体，根据你自己的需要去变更结构体的字段

type Fact struct {
    FileHash string 
    FileName string 
    Time     int 
}

32行:新建存证对象，根据前面25行Fact 结构体的变化而变化

func NewFact(fileHash string, fileName string, time int) *Fact {
    fact := &Fact{
        FileHash: fileHash,
        FileName: fileName,
        Time:     time,
    }
    return fact
}

41-47行：InitContract、UpgradeContract两个方法，不用动，这是实现合约必须要的两个方法，用于合约初始化和合约升级

func (f *FactContract) InitContract() protogo.Response {
    return sdk.Success([]byte("Init contract success"))
}

func (f *FactContract) UpgradeContract() protogo.Response {
    return sdk.Success([]byte("Upgrade contract success"))
}

49行：InvokeContract是调用合约的方法，根据你的合约种有多少方法，依葫芦画瓢在case ....return 继续补充就行

func (f *FactContract) InvokeContract(method string) protogo.Response {
    switch method {
    case "save":
        return f.Save()
    case "findByFileHash":
        return f.FindByFileHash()
    default:
        return sdk.Error("invalid method")
    }
}

 60行： Save（存证方法）

以下大部分依葫芦画瓢就好了，重点关注以下内容：

66-72行：做了time字段的字符校验，确保是数字

84行：发送事件函数EmitEvent，第一个参数是合约事件主题，第二个参数是合约事件参数、（注意合约事件的数据，参数数量不可大于16） 写了事件、订阅之后可以监听到事件状态

87行：存储数据函数sdk.Instance.PutStateByte，三个参数 key、field 、value   ，（原本我以为弄个key-value的存储参数就行了，为什么官方要弄个field，我也不理解，但是官方有解释，不过用长安链就遵从他的规则吧）  这里就是说key是一个命名空间，相当于一个域，真正的key是一个拼接串，value是存证的内容。

93、94行：记录日志，可记可不记，写了的话，节点的日志记录会存下来

97行：返回要遵从官方规范

func (f *FactContract) Save() protogo.Response {
    params := sdk.Instance.GetArgs()

    // 获取参数
    fileHash := string(params["file_hash"])
    fileName := string(params["file_name"])
    timeStr := string(params["time"])
    time, err := strconv.Atoi(timeStr)
    if err != nil {
        msg := "time is [" + timeStr + "] not int"
        sdk.Instance.Errorf(msg)
        return sdk.Error(msg)
    }

    // 构建结构体
    fact := NewFact(fileHash, fileName, time)

    // 序列化
    factBytes, err := json.Marshal(fact)
    if err != nil {
        return sdk.Error(fmt.Sprintf("marshal fact failed, err: %s", err))
    }
    // 发送事件
    sdk.Instance.EmitEvent("topic_vx", []string{fact.FileHash, fact.FileName})

    // 存储数据
    err = sdk.Instance.PutStateByte("fact_bytes", fact.FileHash, factBytes)
    if err != nil {
        return sdk.Error("fail to save fact bytes")
    }

    // 记录日志
    sdk.Instance.Infof("[save] fileHash=" + fact.FileHash)
    sdk.Instance.Infof("[save] fileName=" + fact.FileName)

    // 返回结果
    return sdk.Success([]byte(fact.FileName + fact.FileHash))

}

 取证方法：

以下大部分依葫芦画瓢就好了，重点关注以下内容：

  • 134行：取证的方法：sdk.Instance.GetStateByte ，这里的“fact_bytes”就是这个合约的域，所以这里填写的要和你在存证中填写的域一致才行。
  • 其他按照规范以葫芦画瓢

func (f *FactContract) FindByFileHash() protogo.Response {
    // 获取参数
    fileHash := string(sdk.Instance.GetArgs()["file_hash"])

    // 查询结果
    result, err := sdk.Instance.GetStateByte("fact_bytes", fileHash)
    if err != nil {
        return sdk.Error("failed to call get_state")
    }

    // 反序列化
    var fact Fact
    if err = json.Unmarshal(result, &fact); err != nil {
        return sdk.Error(fmt.Sprintf("unmarshal fact failed, err: %s", err))
    }

    // 记录日志
    sdk.Instance.Infof("[find_by_file_hash] fileHash=" + fact.FileHash)
    sdk.Instance.Infof("[find_by_file_hash] fileName=" + fact.FileName)

    // 返回结果
    return sdk.Success(result)
}

125行：main函数，这个new合约对象的时候保证名称和最开始21行的结构体名称一样就行了，其他的不用变。

func main() {
    err := sandbox.Start(new(FactContract))
    if err != nil {
        log.Fatal(err)
    }
}

4、新增一个查询历史数据的方法

以上就是main.go模板内容的解析，但是一般情况下，我们还有查询历史数据的需求，模板没有提供，所以这里根据模板继续补充一个查询历史记录的方法：

  1. func (f *FactContract) GetHistoryByFileHash() protogo.Response {
  2. 	// 获取参数
  3. 	fileHash := string(sdk.Instance.GetArgs()["file_hash"])
  4.  
  5. 	// 查询结果
  6. 	iter, err := sdk.Instance.NewHistoryKvIterForKey("fact_bytes", fileHash)
  7. 	if err != nil {
  8. 		return sdk.Error("failed to delere get_state")
  9. 	}
  10. 	defer iter.Close()
  11. 	var keyModifications []*sdk.KeyModification
  12. 	// 遍历结果
  13. 	for {
  14. 		if !iter.HasNext() {
  15. 			break
  16. 		}
  17. 		keyModification, err := iter.Next()
  18. 		if err != nil {
  19. 			sdk.Instance.Infof("Error iterating: %v", err)
  20. 		}
  21. 		if keyModification == nil {
  22. 			break
  23. 		}
  24.  
  25. 		keyModifications = append(keyModifications, keyModification)
  26.  
  27. 	}
  28.  
  29. 	jsonBytes, err := json.Marshal(keyModifications)
  30. 	if err != nil {
  31. 		return sdk.Error(fmt.Sprintf("Error marshaling keyModifications: %v", err))
  32. 	}
  33.  
  34. 	// 返回结果
  35. 	return sdk.Success(jsonBytes)
  36. }

方法解析：

这里我只解释重点步骤

1、调用查询历史数据接口

iter, err := sdk.Instance.NewHistoryKvIterForKey("fact_bytes", fileHash)

返回值类型：

后面就是根据返回值的结构进行遍历，

var keyModifications []*sdk.KeyModification

把结果放在 keyModifications  然后进行序列化，返回

 5、新增一个删除方法

注意，这里虽然是一个删除方法，但是不是真的删除，只有有一个isDelete的字段，如果调用了这个方法，某个域对应的hash会被标记为删除。代码不在解释

  1. func (f *FactContract) DeleteByFileHash() protogo.Response {
  2. 	// 获取参数
  3. 	fileHash := string(sdk.Instance.GetArgs()["file_hash"])
  4.  
  5. 	// 查询结果
  6. 	err := sdk.Instance.DelState("fact_bytes", fileHash)
  7. 	if err != nil {
  8. 		return sdk.Error("failed to delere get_state")
  9. 	}
  10.  
  11. 	// 返回结果
  12. 	return sdk.Success(nil)
  13. }

6、完整合约

  1. /*
  2. Copyright (C) BABEC. All rights reserved.
  3. Copyright (C) THL A29 Limited, a Tencent company. All rights reserved.
  5. SPDX-License-Identifier: Apache-2.0
  6. */
  7.  
  8. package main
  9.  
  10. import (
  11. 	"chainmaker/pb/protogo"
  12. 	"chainmaker/sandbox"
  13. 	"chainmaker/sdk"
  14. 	"encoding/json"
  15. 	"fmt"
  16. 	"log"
  17. 	"strconv"
  18. )
  19.  
  20. type FactContract struct {
  21. }
  22.  
  23. // 存证对象
  24. type Fact struct {
  25. 	FileHash string
  26. 	FileName string
  27. 	Time     int
  28. }
  29.  
  30. // 新建存证对象
  31. func NewFact(fileHash string, fileName string, time int) *Fact {
  32. 	fact := &Fact{
  33. 		FileHash: fileHash,
  34. 		FileName: fileName,
  35. 		Time:     time,
  36. 	}
  37. 	return fact
  38. }
  39.  
  40. func (f *FactContract) InitContract() protogo.Response {
  41. 	return sdk.Success([]byte("Init contract success"))
  42. }
  43.  
  44. func (f *FactContract) UpgradeContract() protogo.Response {
  45. 	return sdk.Success([]byte("Upgrade contract success"))
  46. }
  47.  
  48. func (f *FactContract) InvokeContract(method string) protogo.Response {
  49. 	switch method {
  50. 	case "save":
  51. 		return f.Save()
  52. 	case "findByFileHash":
  53. 		return f.FindByFileHash()
  54. 	case "deltedByFileHash":
  55. 		return f.DeleteByFileHash()
  56. 	case "getHistoryByFileHash":
  57. 		return f.GetHistoryByFileHash()
  58. 	default:
  59. 		return sdk.Error("invalid method")
  60. 	}
  61. }
  62.  
  63. func (f *FactContract) Save() protogo.Response {
  64. 	params := sdk.Instance.GetArgs()
  65.  
  66. 	// 获取参数
  67. 	fileHash := string(params["file_hash"])
  68. 	fileName := string(params["file_name"])
  69. 	timeStr := string(params["time"])
  70. 	time, err := strconv.Atoi(timeStr)
  71. 	if err != nil {
  72. 		msg := "time is [" + timeStr + "] not int"
  73. 		sdk.Instance.Errorf(msg)
  74. 		return sdk.Error(msg)
  75. 	}
  76.  
  77. 	// 构建结构体
  78. 	fact := NewFact(fileHash, fileName, time)
  79.  
  80. 	// 序列化
  81. 	factBytes, err := json.Marshal(fact)
  82. 	if err != nil {
  83. 		return sdk.Error(fmt.Sprintf("传过来的参数序列化失败, err: %s", err))
  84. 	}
  85. 	// 发送事件
  86. 	sdk.Instance.EmitEvent("topic_vx", []string{fact.FileHash, fact.FileName})
  87.  
  88. 	// 存储数据
  89. 	err = sdk.Instance.PutStateByte("fact_bytes", fact.FileHash, factBytes)
  90. 	if err != nil {
  91. 		return sdk.Error("fail to save fact bytes")
  92. 	}
  93.  
  94. 	// 记录日志
  95. 	// sdk.Instance.Infof("[save] fileHash=" + fact.FileHash)
  96. 	// sdk.Instance.Infof("[save] fileName=" + fact.FileName)
  97. 	createUser, _ := sdk.Instance.GetSenderRole()
  98. 	sdk.Instance.Infof("[saveUser] create=" + createUser)
  99.  
  100. 	// 返回结果
  101. 	return sdk.Success([]byte(fact.FileName + fact.FileHash))
  102.  
  103. }
  104.  
  105. func (f *FactContract) FindByFileHash() protogo.Response {
  106. 	// 获取参数
  107. 	fileHash := string(sdk.Instance.GetArgs()["file_hash"])
  108.  
  109. 	// 查询结果
  110. 	result, err := sdk.Instance.GetStateByte("fact_bytes", fileHash)
  111. 	if err != nil {
  112. 		return sdk.Error("failed to call get_state")
  113. 	}
  114.  
  115. 	// 反序列化
  116. 	var fact Fact
  117. 	if err = json.Unmarshal(result, &fact); err != nil {
  118. 		return sdk.Error(fmt.Sprintf("unmarshal fact failed, err: %s", err))
  119. 	}
  120.  
  121. 	// 记录日志
  122. 	sdk.Instance.Infof("[find_by_file_hash] fileHash=" + fact.FileHash)
  123. 	sdk.Instance.Infof("[find_by_file_hash] fileName=" + fact.FileName)
  124.  
  125. 	// 返回结果
  126. 	return sdk.Success(result)
  127. }
  128.  
  129. func (f *FactContract) DeleteByFileHash() protogo.Response {
  130. 	// 获取参数
  131. 	fileHash := string(sdk.Instance.GetArgs()["file_hash"])
  132.  
  133. 	// 查询结果
  134. 	err := sdk.Instance.DelState("fact_bytes", fileHash)
  135. 	if err != nil {
  136. 		return sdk.Error("failed to delere get_state")
  137. 	}
  138.  
  139. 	// 返回结果
  140. 	return sdk.Success(nil)
  141. }
  142.  
  143. func (f *FactContract) GetHistoryByFileHash() protogo.Response {
  144. 	// 获取参数
  145. 	fileHash := string(sdk.Instance.GetArgs()["file_hash"])
  146.  
  147. 	// 查询结果
  148. 	iter, err := sdk.Instance.NewHistoryKvIterForKey("fact_bytes", fileHash)
  149. 	if err != nil {
  150. 		return sdk.Error("failed to delere get_state")
  151. 	}
  152. 	defer iter.Close()
  153. 	var keyModifications []*sdk.KeyModification
  154. 	// 遍历结果
  155. 	for {
  156. 		if !iter.HasNext() {
  157. 			break
  158. 		}
  159. 		keyModification, err := iter.Next()
  160. 		if err != nil {
  161. 			sdk.Instance.Infof("Error iterating: %v", err)
  162. 		}
  163. 		if keyModification == nil {
  164. 			break
  165. 		}
  166.  
  167. 		keyModifications = append(keyModifications, keyModification)
  168.  
  169. 		sdk.Instance.Infof("Key: %s, Field: %s, Value: %s, TxId: %s, BlockHeight: %d, IsDelete: %t, Timestamp: %s, \n",
  170. 			keyModification.Key, keyModification.Field, keyModification.Value, keyModification.TxId, keyModification.BlockHeight, keyModification.IsDelete, keyModification.Timestamp)
  171. 	}
  172.  
  173. 	jsonBytes, err := json.Marshal(keyModifications)
  174. 	if err != nil {
  175. 		return sdk.Error(fmt.Sprintf("Error marshaling keyModifications: %v", err))
  176. 	}
  177.  
  178. 	// 返回结果
  179. 	return sdk.Success(jsonBytes)
  180. }
  181.  
  182. func main() {
  183. 	err := sandbox.Start(new(FactContract))
  184. 	if err != nil {
  185. 		log.Fatal(err)
  186. 	}
  187. }

7、结果展示

1、部署demo2合约

2、发起上链，上链了3条数据，其中file_hash我都是输入的1

3、查询某一个结果

4、删除一个结果

这也是一个上链操作

5、查询历史结果

这里没有格式化，现在拿去专门json格式化一下

  1. [
  2.     {
  3.         "Key": "fact_bytes",
  4.         "Field": "1",
  5.         "Value": "eyJGaWxlSGFzaCI6IjEiLCJGaWxlTmFtZSI6IjIiLCJUaW1lIjozfQ==",
  6.         "TxId": "254071cabbca415186ae64956644d2230be111ebb94144d79f168a2252995a88",
  7.         "BlockHeight": 14,
  8.         "IsDelete": false,
  9.         "Timestamp": "1716864398"
  10.     },
  11.     {
  12.         "Key": "fact_bytes",
  13.         "Field": "1",
  14.         "Value": "eyJGaWxlSGFzaCI6IjEiLCJGaWxlTmFtZSI6IjIiLCJUaW1lIjozfQ==",
  15.         "TxId": "ce705bbbaedb4315858b4e68b6331f4a947c3eb5a262433dbe2823ad3c87ee06",
  16.         "BlockHeight": 15,
  17.         "IsDelete": false,
  18.         "Timestamp": "1716864410"
  19.     },
  20.     {
  21.         "Key": "fact_bytes",
  22.         "Field": "1",
  23.         "Value": "eyJGaWxlSGFzaCI6IjEiLCJGaWxlTmFtZSI6IjIiLCJUaW1lIjozfQ==",
  24.         "TxId": "6e099f7ce81543bf8fd0bf565f741478de53b4bc72834112a8bc0bc5f06f9a47",
  25.         "BlockHeight": 16,
  26.         "IsDelete": false,
  27.         "Timestamp": "1716864421"
  28.     },
  29.     {
  30.         "Key": "fact_bytes",
  31.         "Field": "1",
  32.         "Value": "",
  33.         "TxId": "5f76c217063e41ad8c0f2b4ab3fae2418d784c9f0ade416b94715e95214acfc5",
  34.         "BlockHeight": 17,
  35.         "IsDelete": true,
  36.         "Timestamp": "1716864504"
  37.     }
  38. ]

value就是存证的字符串，但是这里是base64编码，转码结果如下

（注意：这里你会发现所有的value都是一样的，因为是我存证的数据都是输入的一样的）

转码结果如下：

8、个人理解

  • 官方文档有错：官方文档把key叫做命名空间取了一个固定值，field作为存证hash，这里应该是他们写反了，field 才有域、空间的意思。上面的解析，我还是按照官方错误的来说的。因为他最后存在level_db中的key是拼接的，所以写反写没事，都一样。你可以改成对的。
  • 之所以引入一个命名空间的概念，我猜测应该是为了在数据库中方便查看，因为同一份id可能会被存多次，加了一个空间会方便区分。不过官方也提供了没有命名空间的存储方法PutStateFromKey(key string, value string) error  就是教程一用的方法
  • 删除函数，并不是真的删除，会新上链一条数据，标明某个域、某个key被删除了，但是已经上链的数据不会变动。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/675979
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号