tendermint发行代币

发行自己的代币

代币发行概述

状态机模型是一种图灵完备的计算模型,理论上你可以用它来实现任何应用, 代币也不例外。例如,我们可以借鉴以太坊的账户模型,设计出自己的账户 状态机:

sm-account

出于简化问题考虑,我们假设系统只发行一种代币,因此在账户模型中只需要 记录每个账户的余额即可。所有账户及其余额是整个系统的状态,只有当交易 发生时,这一状态才会发生变化。

例如,假设账户tommy有1000个代币,那么当发生一笔从mary到tommy 的500个币的转账交易后,tommy的余额将增加500个代币,同时mary的余额将 减少500个代币,这意味着整个系统在这笔交易后进入了一个新的状态。

基于我们之前的学习,很容易将账户采用哈希地址来表示,同时通过非对称 加密技术进行身份验证,从而实现一个去中心化的代币账户状态机。

状态机实现

账户状态机的主要成员,包括记录系统状态的成员变量Accounts,以及表征交易的 成员函数issue()和transfer():

token-s

TokenApp的结构声明如下:

1
2
3
4
type  TokenApp struct {
types.BaseApplication
Accounts map[string]int
}

我们使用一个映射来表示系统的整个状态,其中键为哈希地址,值为账户余额。 由于crypto.Address类型其实是一个字节切片,因此我们采用其16进制表示 作为账户映射表的键。

发行交易将向指定的地址发行一定数量的代币,显然,只允许系统设定的发行人 SYSTEM_ISSUER执行该交易:

1
2
3
4
5
func (app *TokenApp) issue(issuer,to crypto.Address,value int) error {
if !bytes.Equal(issuer,SYSTEM_ISSUER) return { errors.New("invalid issuer") }
app.accounts[to] += value
return nil
}

转账交易从转出账户减去一定数量的代币,再向转入账户增加一定数量的代币, 因此我们需要先保证转出账户有足量的余额:

1
2
3
4
5
6
func (app *TokenApp) transfer(from,to crypto.Address,value int) error {
if app.accounts[from] < value {return errors.New("no enough balance")}
app.accounts[from] -= value
app.accounts[to] += value
return nil
}

简单钱包实现

为了避免琐碎的密钥/地址管理,我们使用一个简单的钱包结构来管理一组私钥:

wallet

为了避免输入冗长难记的地址,我们使用字符串标识钱包中的不同私钥,因此得到 如下的结构定义:

1
2
3
type Wallet struct {
Keys map[string]crypto.PrivKey
}

钱包应该可以随时创建新的私钥,因此我们实现GenPrivKey()方法:

1
2
3
4
5
func (wallet *Wallet) GenPrivKey(label string) crypto.PrivKey {
priv := kf.GenPrivKey()
wallet.Keys[label] = priv
return priv
}

GenPrivKey()方法需要传入一个字符串作为私钥的标识,以便我们可以在 以后使用该标识获取该私钥,或者该私钥对应的公钥或地址:

1
2
3
func (wallet *Wallet) GetPrivKey(label string) crypto.PrivKey {
return wallet.Keys[label]
}

当然,还需要提供一个方法将钱包保存到硬盘上:

1
2
3
4
5
func (wallet *Wallet) Save(wfn string){
bz,err := codec.MarshalJSON(wallet)
if err != nil { panic(err) }
ioutil.WriteFile(wfn,bz,0644)
}

或者载入硬盘的钱包文件获得一个钱包实例:

1
2
3
4
5
6
7
8
func LoadWallet(wfn string) *Wallet{
var wallet Wallet
bz,err := ioutil.ReadFile(wfn)
if err != nil { panic(err) }
err = codec.UnmarshalJSON(bz,&wallet)
if err != nil { panic(err) }
return &wallet
}

交易结构设计与实现

由于我们使用非对称密钥进行身份标识,因此在交易中需要包含身份校验所需要的 信息,例如签名、公钥和消息序列号:

tx-struct

我们使用一个统一的Tx结构来表示所有的交易,其中交易载荷指向一个Payload接口的 实现,该接口的三个方法可用于接收方的签名验证与交易路由:

GetSigner():获取交易发起方地址
GetSignBytes():获取交易载荷中用于签名的数据
GetType():获取交易类别,状态机根据该调用返回值执行相应的动作
在账户状态机应用中,我们需要两种类型的交易:发行交易、转账交易,分别用于 向指定账户发行代币,以及在指定账户之间转移代币。不同的交易对应不同的Payload 接口实现,例如对于转账交易,其对应的TransferPayload结构的接口实现如下:

1
2
3
func (p *TransferPayload) GetSigner() crypto.Address{   return p.From  }
func (p *TranferPayload) GetSignBytes() []byte { return json.Marshal(p) }
func (p *TransferPayload) GetType() string{ return "transfer" }

交易核验

在接收端,首先应当检查交易结构中公钥的有效性,这通过校验公钥与交易发起方地址 是否一致来实现,然后则通过重算交易签名来确认签名的有效性,只有有效的交易,我们 才进行后续处理。例如,下面的代码展示了交易的验证逻辑:

1
2
3
4
5
6
7
func (app *AccountApp) validateTx(tx *Tx) error {
addr := tx.PubKey.Address()
if !bytes.Equals(addr,tx.Payload.GetSigner()) { return errors.New("pubkey / signer mismatch") }
valid := tx.PubKey.VerifyBytes(tx.Payload.GetSignBytes(),tx.Signature)
if !valid { errors.New("bad signature") }
return nil
}

交易路由

一旦交易验证有效,状态就可以根据交易类别进行分别处理了。例如:

1
2
3
4
5
6
7
8
switch tx.Payload.GetType(){
case "transfer":
pld := tx.Payload.(TransferPayload)
app.transfer(pld.From,pld.To,pld.Value)
case "issue":
pld := tx.Payload.(IssuePayload)
app.issue(pld.Issuer,pld.To,pld.Value)
}

交易的编解码处理

根据我们定义的交易结构,显然在RPC客户端提交交易之前,需要首先串行化为 16进制码流,在ABCI应用中同时也需要相应的解码:

tx-code

tendermint官方推荐的编解码器是其自产的go-amino,它类似于protobuf,最大的特点是支持 解码到接口类型 —— 这就是我们可以在Tx结构中使用接口类型的原因。

amino通过在编码码流中加入标识序列来区分不同的接口实现结构,因此解码接口之前,首先 需要注册接口以及对应的实现结构及标识名,例如,在下面的代码中,我们注册Payload接口, 然后注册其两个实现结构TransferPayload和IssuePayload,并分别使用tx/transfer 和tx/issue来标识这两个Payload接口的实现:

1
2
3
4
codec := amino.NewCodec()
codec.RegisterInterface((*Payload)(nil),nil)
codec.RegisterConcrete(*TransferPayload{},"tx/transfer",nil)
codec.RegisterConcrete(*IssuePayload{},"tx/issue",nil)

需要指出的是,当你使用amino时,并不是所有的自定义类型都需要在codec中注册,只有那些 需要解码到接口类型的结构,才需要进行注册。

现在,接收端可以对接收到的二进制码流bz进行解码了:

1
2
3
4
5
func (app *AccountApp) decodeTx(bz []byte) (*Tx,error){
var tx Tx
err := codec.UnmarshalBinary(bz,&tx)
return &tx,err
}

ABCI协议实现

有了基本的状态机、钱包、交易结构以及序列化手段,现在我们可以实现状态机的ABCI接口了:

token-abci

交易检查:CheckTx

在CheckTx()方法实现中检查交易的有效性,只有解码正确并且检查有效的交易才允许 进入交易内存池:

1
2
3
4
5
6
7
8
func (app *TokenApp) CheckTx(bz []byte) types.ResponseCheckTx {
var tx Tx
err := codec.UnmarshalBinary(bz,&tx)
if err !=nil { return types.ResponseCheckTx{Code:1,Info: err.Error()}}
err = app.validateTx(tx)
if err !=nil { return types.ResponseCheckTx{Code:2,Info:err.Error()}}
return types.ResponseCheckTx{}
}

交易执行:DeliverTx

在DeliverTx()方法中判断交易类型,然后执行相应的状态迁移:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func (app *TokenApp) DeliverTx(bz []byte) (rsp types.ResponseDeliverTx){
var tx Tx
codec.UnmarshalBinary(bz,&tx)
switch tx.Payload.GetType() {
case "transfer":
pld := tx.Payload.(TransferPayload)
app.transfer(pld.From,pld.To,pld.Value)
case "issue":
pld := tx.Payload.(IssuePayload)
app.issue(pld.Issuer,pld.To,pld.Value)
default: rsp.Code = 1
}
return
}

状态查询

在Query()方法中返回指定账户的余额:

1
2
3
4
5
6
func (app *TokenApp) Query(req types.RequestQuery) types.ResponseQuery{
addr := crypto.Address(req.Data)
bal, _ := codec.MarshalBinary(app.Accounts[addr.String()])
desc: = fmt.Sprintf("balance : %v => %v",addr,app.Accounts[addr.String])
return types.ResponseQuery{Key:req.Data,Value:bal,Log:desc}
}

RPC客户端开发

tendermint内置了RPC开发接口的API封装包rpc/client,极大地简化了客户端的 开发难度:

rpc-client

使用rpc/client包的NewHTTP()方法,我们可以得到一个HTTP实例:

cli := client.NewHTTP("http://localhost:26657","")
HTTP结构实现了tendermint中所有的RPC客户端接口,例如ABCI客户端接口 (ABCIClient)、历史数据访问接口(HistoryClient)等,因此我们可以直接 利用其方法向abci应用提交交易。

首先构造一个发行交易,并利用发行人私钥签名交易:

1
2
3
paylod := NewIssuePayload(issuerAddr,receiverAddr,value)
tx := NewTx(payload)
tx.Sign(issuerPrivKey)

然后将交易实例序列化:

rawtx,_ := codec.MarshalBinary(tx)
最后使用HTTP实例的BroadcastTxCommit()方法提交给节点,并 打印输出响应结果:

1
2
ret,_ := cli.BroadcastTxCommit(rawtx)
fmt.Printf("ret => %+v\n",ret)

坚持原创技术分享,您的支持将鼓励我继续创作!