一 环境准备

1 下载智能合约IDE
https://github.com/gxchain/gxchain-alpha/releases/latest

2 注册测试账户
https://testnet.wallet.gxchain.org/#/

3 认领测试网代币
https://testnet.gxchain.org/gxc/get_token?init0
init0为你的账户名

二 智能合约基本结构

#include <graphenelib/contract.hpp>
#include <graphenelib/dispatcher.hpp>
#include <graphenelib/print.hpp>
#include <graphenelib/types.h>
using namespace graphene;

class helloworld : public contract   // 继承合约类
{
  public:
    helloworld(uint64_t id)               // 定义带参构造函数，参数为部署合约的用户id
        : contract(id)
    { }

    /// @abi action                            // 给action加入注释，方便导出abi
    void hi(std::string user)
    {
        for (int i = 0; i < 2; ++i) {
            print("hi, ", user, "\n");
        }
    }
};

GRAPHENE_ABI(helloworld, (hi))   // 实现apply函数接口

三 多索引表结构

仅1个一级索引
最多支持16个二级索引
仅支持uint64_t类型

    //@abi table offer i64                                           // 给table加入注释，方便导出abi
    struct offer {
        uint64_t id;
        uint64_t idx1;
        uint64_t idx2;
        uint64_t stringidx;

        uint64_t primary_key() const { return id; }         //定义一级索引函数，这段代码的函数名和类型都是固定的，不能改动，用于指定唯一主键，这里把id作为主键
        uint64_t by_index1() const { return idx1; }         //定义二级索引函数
        uint64_t by_index2() const { return idx2; }        //定义二级索引函数
        uint64_t by_stringidx() const {return stringidx; }//定义二级索引函数


        GRAPHENE_SERIALIZE(offer, (id)(idx1)(idx2)(stringidx))   //序列化table成员变量
    };

    typedef multi_index<N(offer), offer,
                        indexed_by<N(idx1), const_mem_fun<offer, uint64_t, &offer::by_index1>>,
                        indexed_by<N(idx2), const_mem_fun<offer, uint64_t, &offer::by_index2>>,
                        indexed_by<N(stringidx), const_mem_fun<offer, uint64_t, &offer::by_stringidx>>>
        offer_index;    //定义多索引容器类型
    offer_index offers; //定义成员多索引容器对象，需要在构造函数中用offers(_self, _self)初始化

四 多索引表的增删改查

增

emplace-增加

uint64_t pk = offers.available_primary_key();
print("pk=", pk);
offers.emplace(0, [&](auto &o) {
    o.id = pk;
    o.idx1 = i1;
    o.idx2 = i2;
    o.stringidx = graphenelib::string_to_name(name.c_str());

删

erase-删除

auto it = offers.find(5);
graphene_assert(it != offers.end(), “not find item”);
offers.erase(it)

改

modify-修改

auto it = offers.find(5);
offers.modify(it, 0, [&](auto &o) {
  //这里是对象的修改代码
  o.idx1 = 1000;
});

查

查询

//一级索引查询
auto it = offers.find(5);

//二级索引查询
auto idx = offers.template get_index<N(stringidx)>();
auto matched_offer_itr = idx.lower_bound(N(key));
if (matched_offer_itr != idx.end()) {
    dump_item(*matched_offer_itr);
}

五 常用迭代器

begin 返回最小主键值开始的迭代器
end 返回尾部的迭代器

available_primary_key-返回下个可用主键
lower_bound-查找小于等于给定主键值的对象
upper_bound-查找大于给定主键值的对象

六 前端和智能合约交互

gscatter
gscatter-js

七 后续学习资源

https://docs.gxchain.org/zh/contract/ 官方文档
https://mp.weixin.qq.com/s/HZ-_pJ5gvjGjPpQtBEI98A 官方视频教程《简介与运行原理》
https://mp.weixin.qq.com/s/xtmxOPI9YAUrJkgsBcPR5A 官方视频教程 《内置数据类型与持久化存储》

八 完整代码示例

后端

#include <graphenelib/system.h>
#include <graphenelib/contract.hpp>
#include <graphenelib/dispatcher.hpp>
#include <graphenelib/multi_index.hpp>
#include <graphenelib/print.hpp>
#include <graphenelib/types.h>
#include <graphenelib/global.h>

using namespace graphene;

class todolist : public contract
{
  public:
    todolist(uint64_t id)
        : contract(id),
        todos(_self, _self)
    {
    }

    /// @abi action
    void create(const uint32_t id, const std::string& description){
        uint64_t sender = get_trx_sender();
        todos.emplace(sender, [&](auto& todo){
            todo.id = id;
            todo.description = description;
            todo.completed = 0;
        });
    }
    /// @abi action
    void destory(const uint32_t id){
        auto it = todos.find(id);
        graphene_assert(it != todos.end(), "todo does not exist!");
        todos.erase(it);
        
        print("todo#", id, " destory");
    }
    /// @abi action
    void complete(const uint32_t id){
        auto it = todos.find(id);
        graphene_assert(it != todos.end(), "todo does not exist!");
        
        uint64_t sender = get_trx_sender();
        todos.modify(it,sender, [&](auto& todo){
            todo.completed = 1;
        });
        
        print("todo#", id, " complete");
    }
    
  private:
      //@abi table todo i64 
      struct todo{
          uint64_t id;
          std::string description;
          uint64_t completed;
          
          uint64_t primary_key() const {return id;}
          GRAPHENE_SERIALIZE(todo, (id)(description)(completed))
      };
      
      typedef multi_index<N(todo), todo> todo_index;
      todo_index todos;
};

GRAPHENE_ABI(todolist, (create)(complete)(destory))

前端 待补充