debug deposit pass

plugin/dapp/mix/commands/mix.go

@@ -54,42 +54,48 @@ func CreateDepositCmd() *cobra.Command {
 }
 
 func addCreateDepositFlags(cmd *cobra.Command) {
-	cmd.Flags().StringP("proofs", "p", "", "'proof-pubinput' pair, multi pairs allowed with ','")
+	cmd.Flags().StringP("proofs", "f", "", "'proof-pubinput' format pair")
 	cmd.MarkFlagRequired("proofs")
 
-	cmd.Flags().Uint64P("amount", "a", 0, "deposit amount")
+	cmd.Flags().Uint64P("amount", "m", 0, "deposit amount")
 	cmd.MarkFlagRequired("amount")
 
-	cmd.Flags().StringP("secretPayment", "s", "", "secret for payment addr")
+	cmd.Flags().StringP("secretPayment", "p", "", "secret for payment addr")
 	cmd.MarkFlagRequired("secretPayment")
 
-	cmd.Flags().StringP("pubX", "x", "", "receiving pub key X")
-	cmd.MarkFlagRequired("pubX")
-
-	cmd.Flags().StringP("pubY", "y", "", "receiving pub key Y")
-	cmd.MarkFlagRequired("pubY")
-
-	cmd.Flags().StringP("secretAuth", "u", "", "secret for authorize addr")
+	cmd.Flags().StringP("secretAuth", "a", "", "secret for authorize addr")
 
 	cmd.Flags().StringP("secretReturn", "r", "", "secret for return addr")
 
 }
 
-func parseProofPara(input string) ([]*mixTy.ZkProofInfo, error) {
-	var proofInputs []*mixTy.ZkProofInfo
-	inputParas := strings.Split(input, ",")
-	for _, i := range inputParas {
-		inputs := strings.Split(i, "-")
-		if len(inputs) != 2 {
-			fmt.Println("proofs parameters not correct:", i)
-			return nil, types.ErrInvalidParam
-		}
-		var proofInfo mixTy.ZkProofInfo
-		proofInfo.Proof = inputs[0]
-		proofInfo.PublicInput = inputs[1]
-		proofInputs = append(proofInputs, &proofInfo)
+//func parseProofPara(input string) ([]*mixTy.ZkProofInfo, error) {
+//	var proofInputs []*mixTy.ZkProofInfo
+//	inputParas := strings.Split(input, ",")
+//	for _, i := range inputParas {
+//		inputs := strings.Split(i, "-")
+//		if len(inputs) != 2 {
+//			fmt.Println("proofs parameters not correct:", i)
+//			return nil, types.ErrInvalidParam
+//		}
+//		var proofInfo mixTy.ZkProofInfo
+//		proofInfo.Proof = inputs[0]
+//		proofInfo.PublicInput = inputs[1]
+//		proofInputs = append(proofInputs, &proofInfo)
+//	}
+//	return proofInputs, nil
+//}
+
+func parseProofPara(input string) (*mixTy.ZkProofInfo, error) {
+	inputs := strings.Split(input, "-")
+	if len(inputs) != 2 {
+		fmt.Println("proofs parameters not correct:", input)
+		return nil, types.ErrInvalidParam
 	}
-	return proofInputs, nil
+	var proofInfo mixTy.ZkProofInfo
+	proofInfo.Proof = inputs[0]
+	proofInfo.PublicInput = inputs[1]
+	return &proofInfo, nil
 }
 
 func createDeposit(cmd *cobra.Command, args []string) {
@@ -97,28 +103,23 @@ func createDeposit(cmd *cobra.Command, args []string) {
 	amount, _ := cmd.Flags().GetUint64("amount")
 	proofsPara, _ := cmd.Flags().GetString("proofs")
 	secretPayment, _ := cmd.Flags().GetString("secretPayment")
-	pubX, _ := cmd.Flags().GetString("pubX")
-	pubY, _ := cmd.Flags().GetString("pubY")
+	secretAuth, _ := cmd.Flags().GetString("secretAuth")
+	secretReturn, _ := cmd.Flags().GetString("secretReturn")
 
 	proofInputs, err := parseProofPara(proofsPara)
 	if err != nil {
 		return
 	}
 
-	var pubkey mixTy.PubKey
-	pubkey.X = pubX
-	pubkey.Y = pubY
-	var paySecret mixTy.DHSecret
-	paySecret.Secret = secretPayment
-	paySecret.Epk = &pubkey
-
-	var group mixTy.DHSecretGroup
-	group.Payment = &paySecret
+	proofInputs.Secrets = &mixTy.DHSecretGroup{
+		Payment:   secretPayment,
+		Authorize: secretAuth,
+		Returner:  secretReturn,
+	}
 
 	payload := &mixTy.MixDepositAction{}
 	payload.Amount = amount
-	payload.NewCommits = append(payload.NewCommits, proofInputs...)
-	payload.NewCommits[0].Group = &group
+	payload.Proof = proofInputs
 
 	params := &rpctypes.CreateTxIn{
 		Execer:     getRealExecName(paraName, mixTy.MixX),
@@ -163,7 +164,7 @@ func createWithdraw(cmd *cobra.Command, args []string) {
 
 	payload := &mixTy.MixWithdrawAction{}
 	payload.Amount = amount
-	payload.SpendCommits = append(payload.SpendCommits, proofInputs...)
+	payload.SpendCommits = append(payload.SpendCommits, proofInputs)
 	params := &rpctypes.CreateTxIn{
 		Execer:     getRealExecName(paraName, mixTy.MixX),
 		ActionName: "Withdraw",
@@ -190,15 +191,39 @@ func addCreateTransferFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("input", "i", "", "input 'proof-pubinput' pair, multi pairs allowed with ','")
 	cmd.MarkFlagRequired("input")
 
-	cmd.Flags().StringP("output", "o", "", "output 'proof-pubinput' pair, multi pairs allowed with ','")
+	cmd.Flags().StringP("output", "o", "", "output 'proof-pubinput' pair")
 	cmd.MarkFlagRequired("output")
 
+	cmd.Flags().StringP("secretPayment", "p", "", "secret for payment addr")
+	cmd.MarkFlagRequired("secretPayment")
+
+	cmd.Flags().StringP("secretAuth", "a", "", "secret for authorize addr")
+
+	cmd.Flags().StringP("secretReturn", "r", "", "secret for return addr")
+
+	cmd.Flags().StringP("change", "c", "", "output change 'proof-pubinput' pair")
+	cmd.MarkFlagRequired("change")
+
+	cmd.Flags().StringP("changePayment", "t", "", "secret for change payment addr")
+	cmd.MarkFlagRequired("changePayment")
+
+	cmd.Flags().StringP("changeAuth", "u", "", "secret for change authorize addr")
+
+	cmd.Flags().StringP("changeReturn", "e", "", "secret for change return addr")
+
 }
 
 func createTransfer(cmd *cobra.Command, args []string) {
 	paraName, _ := cmd.Flags().GetString("paraName")
 	proofsInput, _ := cmd.Flags().GetString("input")
 	proofsOutput, _ := cmd.Flags().GetString("output")
+	proofsChange, _ := cmd.Flags().GetString("change")
+	secretPayment, _ := cmd.Flags().GetString("secretPayment")
+	secretAuth, _ := cmd.Flags().GetString("secretAuth")
+	secretReturn, _ := cmd.Flags().GetString("secretReturn")
+	changePayment, _ := cmd.Flags().GetString("changePayment")
+	changeAuth, _ := cmd.Flags().GetString("changeAuth")
+	changeReturn, _ := cmd.Flags().GetString("changeReturn")
 
 	proofInputs, err := parseProofPara(proofsInput)
 	if err != nil {
@@ -210,10 +235,27 @@ func createTransfer(cmd *cobra.Command, args []string) {
 		fmt.Println("proofsOutput error")
 		return
 	}
+	proofOutputs.Secrets = &mixTy.DHSecretGroup{
+		Payment:   secretPayment,
+		Returner:  secretAuth,
+		Authorize: secretReturn,
+	}
+
+	proofChanges, err := parseProofPara(proofsChange)
+	if err != nil {
+		fmt.Println("proofsOutput error")
+		return
+	}
+	proofChanges.Secrets = &mixTy.DHSecretGroup{
+		Payment:   changePayment,
+		Returner:  changeAuth,
+		Authorize: changeReturn,
+	}
 
 	payload := &mixTy.MixTransferAction{}
-	payload.Input = append(payload.Input, proofInputs...)
-	payload.Output = append(payload.Output, proofOutputs...)
+	payload.Input = proofInputs
+	payload.Output = proofOutputs
+	payload.Change = proofChanges
 	params := &rpctypes.CreateTxIn{
 		Execer:     getRealExecName(paraName, mixTy.MixX),
 		ActionName: "Transfer",
@@ -246,13 +288,13 @@ func createAuthorize(cmd *cobra.Command, args []string) {
 	paraName, _ := cmd.Flags().GetString("paraName")
 	proofsPara, _ := cmd.Flags().GetString("proofs")
 
-	proofInputs, err := parseProofPara(proofsPara)
+	proofInput, err := parseProofPara(proofsPara)
 	if err != nil {
 		return
 	}
 
 	payload := &mixTy.MixAuthorizeAction{}
-	payload.AuthCommits = append(payload.AuthCommits, proofInputs...)
+	payload.AuthCommits = append(payload.AuthCommits, proofInput)
 	params := &rpctypes.CreateTxIn{
 		Execer:     getRealExecName(paraName, mixTy.MixX),
 		ActionName: "Authorize",
@@ -668,7 +710,7 @@ func ShowAccountNoteInfo() *cobra.Command {
 }
 
 func accountNoteCmdFlags(cmd *cobra.Command) {
-	cmd.Flags().StringP("accounts", "a", "", "accounts")
+	cmd.Flags().StringP("accounts", "a", "", "accounts,note status:1:valid,2:frozen,3:used")
 	cmd.MarkFlagRequired("accounts")
 
 }
@@ -998,11 +1040,9 @@ func transferSecretCmdFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("toAddr", "t", "", "transfer to addr")
 	cmd.MarkFlagRequired("toAddr")
 
-	cmd.Flags().StringP("auth", "a", "", "transfer to auth addr")
-	cmd.MarkFlagRequired("auth")
+	cmd.Flags().StringP("auth", "a", "", "transfer to auth addr,optional")
 
-	cmd.Flags().StringP("returner", "r", "", "transfer to returner addr")
-	cmd.MarkFlagRequired("returner")
+	cmd.Flags().StringP("returner", "r", "", "transfer to returner addr,optional")
 
 	cmd.Flags().Uint64P("amount", "m", 0, "transfer amount")
 	cmd.MarkFlagRequired("amount")

plugin/dapp/mix/executor/config.go

@@ -26,19 +26,25 @@ func isSuperManager(cfg *types.Chain33Config, addr string) bool {
 // need super manager
 func (a *action) Config(config *mixTy.MixConfigAction) (*types.Receipt, error) {
 	cfg := a.api.GetConfig()
-	if !isSuperManager(cfg, a.fromaddr) {
-		return nil, errors.Wrapf(types.ErrNotAllow, "not super manager,%s", a.fromaddr)
-	}
 	switch config.Ty {
 	case mixTy.MixConfigType_VerifyKey:
+		//必须是超级管理员才能配置
+		if !isSuperManager(cfg, a.fromaddr) {
+			return nil, errors.Wrapf(types.ErrNotAllow, "not super manager,%s", a.fromaddr)
+		}
 		return a.ConfigAddVerifyKey(config.GetVerifyKey())
 	case mixTy.MixConfigType_AuthPubKey:
+		//必须是超级管理员才能配置
+		if !isSuperManager(cfg, a.fromaddr) {
+			return nil, errors.Wrapf(types.ErrNotAllow, "not super manager,%s", a.fromaddr)
+		}
 		if config.Action == mixTy.MixConfigAct_Add {
 			return a.ConfigAddAuthPubKey(config.GetAuthPk())
 		} else {
 			return a.ConfigDeleteAuthPubKey(config.GetAuthPk())
 		}
 	case mixTy.MixConfigType_PaymentPubKey:
+		//个人配置，个人负责，可重配
 		return a.ConfigPaymentPubKey(config.GetPaymentKey())
 	}
 	return nil, errors.Wrapf(types.ErrNotFound, "ty=%d", config.Ty)

plugin/dapp/mix/executor/deposit.go

@@ -81,19 +81,13 @@ func (a *action) depositVerify(proof *mixTy.ZkProofInfo) (string, uint64, error)
 */
 func (a *action) Deposit(deposit *mixTy.MixDepositAction) (*types.Receipt, error) {
 	//1. zk-proof校验
-	var sum uint64
-	var commitHashs []string
-	for _, v := range deposit.NewCommits {
-		hash, val, err := a.depositVerify(v)
-		if err != nil {
-			return nil, err
-		}
-		sum += val
-		commitHashs = append(commitHashs, hash)
+	noteHash, val, err := a.depositVerify(deposit.Proof)
+	if err != nil {
+		return nil, err
 	}
-	//校验总存款额
-	if sum != deposit.Amount {
-		return nil, mixTy.ErrInputParaNotMatch
+	//校验存款额,目前只支持一次只存一张支票
+	if val != deposit.Amount {
+		return nil, errors.Wrapf(mixTy.ErrInputParaNotMatch, "deposit amount=%d not equal proof amount=%d", deposit.Amount, val)
 	}
 
 	//存款
@@ -110,9 +104,7 @@ func (a *action) Deposit(deposit *mixTy.MixDepositAction) (*types.Receipt, error
 	}
 	//push new commit to merkle tree
 	var leaves [][]byte
-	for _, h := range commitHashs {
-		leaves = append(leaves, transferFr2Bytes(h))
-	}
+	leaves = append(leaves, transferFr2Bytes(noteHash))
 	rpt, err := pushTree(a.db, leaves)
 	if err != nil {
 		return nil, err

plugin/dapp/mix/executor/transfer.go

@@ -111,21 +111,22 @@ func MixTransferInfoVerify(db dbm.KV, transfer *mixTy.MixTransferAction, minFee
 	var inputs []*mixTy.TransferInputPublicInput
 	var outputs []*mixTy.TransferOutputPublicInput
 
-	for _, k := range transfer.Input {
-		in, err := transferInputVerify(db, k)
-		if err != nil {
-			return nil, nil, err
-		}
-		inputs = append(inputs, in)
+	in, err := transferInputVerify(db, transfer.Input)
+	if err != nil {
+		return nil, nil, err
 	}
+	inputs = append(inputs, in)
 
-	for _, k := range transfer.Output {
-		out, err := transferOutputVerify(db, k)
-		if err != nil {
-			return nil, nil, err
-		}
-		outputs = append(outputs, out)
+	out, err := transferOutputVerify(db, transfer.Output)
+	if err != nil {
+		return nil, nil, err
+	}
+	outputs = append(outputs, out)
+	change, err := transferOutputVerify(db, transfer.Change)
+	if err != nil {
+		return nil, nil, err
 	}
+	outputs = append(outputs, change)
 
 	if !VerifyCommitValues(inputs, outputs, minFee) {
 		return nil, nil, errors.Wrap(mixTy.ErrSpendInOutValueNotMatch, "verifyValue")

plugin/dapp/mix/proto/mix.proto

@@ -72,26 +72,27 @@ message DHSecret{
 
 //Diff-Helman 加密group, for spender, returner, authorizer to decrypt
 message DHSecretGroup{
-    DHSecret payment = 1;
-    DHSecret returner = 2;
-    DHSecret authorize = 3;
+    string payment = 1;
+    string returner = 2;
+    string authorize = 3;
 }
 
 message ZkProofInfo {
     string proof        = 1;
     string publicInput  = 2;
-    DHSecretGroup group = 3;
+    DHSecretGroup secrets = 3;
 }
 
 message MixDepositAction {
     uint64 amount = 1;
-    repeated ZkProofInfo newCommits = 2;
+    ZkProofInfo proof = 2;
 
 }
 
 message MixTransferAction {
-    repeated ZkProofInfo input = 1;
-    repeated ZkProofInfo output = 2;
+    ZkProofInfo input = 1;
+    ZkProofInfo output = 2;
+    ZkProofInfo change = 3;
 
 }
 
@@ -368,9 +369,9 @@ message CommitValueRst{
 
 enum NoteStatus{
 	UNDEF   = 0;
-	FROZEN  = 1; //未授权
-	VALID   = 2;   //已授权可使用
-	INVALID = 3;   //已使用
+	VALID   = 1;   //已授权可使用
+	FROZEN  = 2; //未授权
+	USED    = 3;   //已使用
 }
 
 message WalletIndexInfo {
@@ -401,11 +402,11 @@ message WalletMixIndexReq {
 }
 
 message WalletIndexResp {
-    repeated WalletIndexInfo datas = 1;
+    repeated WalletIndexInfo notes = 1;
 }
 
 message WalletReqAddrs{
-    repeated string data = 1;
+    repeated string addrs = 1;
 }
 
 message WalletEnablePrivacyRst{
@@ -415,7 +416,7 @@ message WalletEnablePrivacyRst{
 }
 
 message WalletEnablePrivacyResp{
-    repeated WalletEnablePrivacyRst data = 1;
+    repeated WalletEnablePrivacyRst resps = 1;
 }
 
 

plugin/dapp/mix/types/mix.pb.go

@@ -6,12 +6,13 @@ package types
 import (
 	context "context"
 	fmt "fmt"
+	math "math"
+
 	types "github.com/33cn/chain33/types"
 	proto "github.com/golang/protobuf/proto"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
-	math "math"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -119,24 +120,24 @@ func (MixConfigAct) EnumDescriptor() ([]byte, []int) {
 type NoteStatus int32
 
 const (
-	NoteStatus_UNDEF   NoteStatus = 0
-	NoteStatus_FROZEN  NoteStatus = 1
-	NoteStatus_VALID   NoteStatus = 2
-	NoteStatus_INVALID NoteStatus = 3
+	NoteStatus_UNDEF  NoteStatus = 0
+	NoteStatus_VALID  NoteStatus = 1
+	NoteStatus_FROZEN NoteStatus = 2
+	NoteStatus_USED   NoteStatus = 3
 )
 
 var NoteStatus_name = map[int32]string{
 	0: "UNDEF",
-	1: "FROZEN",
-	2: "VALID",
-	3: "INVALID",
+	1: "VALID",
+	2: "FROZEN",
+	3: "USED",
 }
 
 var NoteStatus_value = map[string]int32{
-	"UNDEF":   0,
-	"FROZEN":  1,
-	"VALID":   2,
-	"INVALID": 3,
+	"UNDEF":  0,
+	"VALID":  1,
+	"FROZEN": 2,
+	"USED":   3,
 }
 
 func (x NoteStatus) String() string {
@@ -518,12 +519,12 @@ func (m *DHSecret) GetSecret() string {
 
 //Diff-Helman 加密group, for spender, returner, authorizer to decrypt
 type DHSecretGroup struct {
-	Payment              *DHSecret `protobuf:"bytes,1,opt,name=payment,proto3" json:"payment,omitempty"`
-	Returner             *DHSecret `protobuf:"bytes,2,opt,name=returner,proto3" json:"returner,omitempty"`
-	Authorize            *DHSecret `protobuf:"bytes,3,opt,name=authorize,proto3" json:"authorize,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	Payment              string   `protobuf:"bytes,1,opt,name=payment,proto3" json:"payment,omitempty"`
+	Returner             string   `protobuf:"bytes,2,opt,name=returner,proto3" json:"returner,omitempty"`
+	Authorize            string   `protobuf:"bytes,3,opt,name=authorize,proto3" json:"authorize,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *DHSecretGroup) Reset()         { *m = DHSecretGroup{} }
@@ -551,31 +552,31 @@ func (m *DHSecretGroup) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_DHSecretGroup proto.InternalMessageInfo
 
-func (m *DHSecretGroup) GetPayment() *DHSecret {
+func (m *DHSecretGroup) GetPayment() string {
 	if m != nil {
 		return m.Payment
 	}
-	return nil
+	return ""
 }
 
-func (m *DHSecretGroup) GetReturner() *DHSecret {
+func (m *DHSecretGroup) GetReturner() string {
 	if m != nil {
 		return m.Returner
 	}
-	return nil
+	return ""
 }
 
-func (m *DHSecretGroup) GetAuthorize() *DHSecret {
+func (m *DHSecretGroup) GetAuthorize() string {
 	if m != nil {
 		return m.Authorize
 	}
-	return nil
+	return ""
 }
 
 type ZkProofInfo struct {
 	Proof                string         `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"`
 	PublicInput          string         `protobuf:"bytes,2,opt,name=publicInput,proto3" json:"publicInput,omitempty"`
-	Group                *DHSecretGroup `protobuf:"bytes,3,opt,name=group,proto3" json:"group,omitempty"`
+	Secrets              *DHSecretGroup `protobuf:"bytes,3,opt,name=secrets,proto3" json:"secrets,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
 	XXX_unrecognized     []byte         `json:"-"`
 	XXX_sizecache        int32          `json:"-"`
@@ -620,19 +621,19 @@ func (m *ZkProofInfo) GetPublicInput() string {
 	return ""
 }
 
-func (m *ZkProofInfo) GetGroup() *DHSecretGroup {
+func (m *ZkProofInfo) GetSecrets() *DHSecretGroup {
 	if m != nil {
-		return m.Group
+		return m.Secrets
 	}
 	return nil
 }
 
 type MixDepositAction struct {
-	Amount               uint64         `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
-	NewCommits           []*ZkProofInfo `protobuf:"bytes,2,rep,name=newCommits,proto3" json:"newCommits,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+	Amount               uint64       `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
+	Proof                *ZkProofInfo `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
 }
 
 func (m *MixDepositAction) Reset()         { *m = MixDepositAction{} }
@@ -667,19 +668,20 @@ func (m *MixDepositAction) GetAmount() uint64 {
 	return 0
 }
 
-func (m *MixDepositAction) GetNewCommits() []*ZkProofInfo {
+func (m *MixDepositAction) GetProof() *ZkProofInfo {
 	if m != nil {
-		return m.NewCommits
+		return m.Proof
 	}
 	return nil
 }
 
 type MixTransferAction struct {
-	Input                []*ZkProofInfo `protobuf:"bytes,1,rep,name=input,proto3" json:"input,omitempty"`
-	Output               []*ZkProofInfo `protobuf:"bytes,2,rep,name=output,proto3" json:"output,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+	Input                *ZkProofInfo `protobuf:"bytes,1,opt,name=input,proto3" json:"input,omitempty"`
+	Output               *ZkProofInfo `protobuf:"bytes,2,opt,name=output,proto3" json:"output,omitempty"`
+	Change               *ZkProofInfo `protobuf:"bytes,3,opt,name=change,proto3" json:"change,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
 }
 
 func (m *MixTransferAction) Reset()         { *m = MixTransferAction{} }
@@ -707,20 +709,27 @@ func (m *MixTransferAction) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MixTransferAction proto.InternalMessageInfo
 
-func (m *MixTransferAction) GetInput() []*ZkProofInfo {
+func (m *MixTransferAction) GetInput() *ZkProofInfo {
 	if m != nil {
 		return m.Input
 	}
 	return nil
 }
 
-func (m *MixTransferAction) GetOutput() []*ZkProofInfo {
+func (m *MixTransferAction) GetOutput() *ZkProofInfo {
 	if m != nil {
 		return m.Output
 	}
 	return nil
 }
 
+func (m *MixTransferAction) GetChange() *ZkProofInfo {
+	if m != nil {
+		return m.Change
+	}
+	return nil
+}
+
 type MixWithdrawAction struct {
 	Amount               uint64         `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
 	SpendCommits         []*ZkProofInfo `protobuf:"bytes,2,rep,name=spendCommits,proto3" json:"spendCommits,omitempty"`
@@ -3139,7 +3148,7 @@ func (m *WalletMixIndexReq) GetDirection() int32 {
 }
 
 type WalletIndexResp struct {
-	Datas                []*WalletIndexInfo `protobuf:"bytes,1,rep,name=datas,proto3" json:"datas,omitempty"`
+	Notes                []*WalletIndexInfo `protobuf:"bytes,1,rep,name=notes,proto3" json:"notes,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
 	XXX_unrecognized     []byte             `json:"-"`
 	XXX_sizecache        int32              `json:"-"`
@@ -3170,15 +3179,15 @@ func (m *WalletIndexResp) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_WalletIndexResp proto.InternalMessageInfo
 
-func (m *WalletIndexResp) GetDatas() []*WalletIndexInfo {
+func (m *WalletIndexResp) GetNotes() []*WalletIndexInfo {
 	if m != nil {
-		return m.Datas
+		return m.Notes
 	}
 	return nil
 }
 
 type WalletReqAddrs struct {
-	Data                 []string `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
+	Addrs                []string `protobuf:"bytes,1,rep,name=addrs,proto3" json:"addrs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -3209,9 +3218,9 @@ func (m *WalletReqAddrs) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_WalletReqAddrs proto.InternalMessageInfo
 
-func (m *WalletReqAddrs) GetData() []string {
+func (m *WalletReqAddrs) GetAddrs() []string {
 	if m != nil {
-		return m.Data
+		return m.Addrs
 	}
 	return nil
 }
@@ -3272,7 +3281,7 @@ func (m *WalletEnablePrivacyRst) GetMsg() string {
 }
 
 type WalletEnablePrivacyResp struct {
-	Data                 []*WalletEnablePrivacyRst `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
+	Resps                []*WalletEnablePrivacyRst `protobuf:"bytes,1,rep,name=resps,proto3" json:"resps,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
 	XXX_unrecognized     []byte                    `json:"-"`
 	XXX_sizecache        int32                     `json:"-"`
@@ -3303,9 +3312,9 @@ func (m *WalletEnablePrivacyResp) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_WalletEnablePrivacyResp proto.InternalMessageInfo
 
-func (m *WalletEnablePrivacyResp) GetData() []*WalletEnablePrivacyRst {
+func (m *WalletEnablePrivacyResp) GetResps() []*WalletEnablePrivacyRst {
 	if m != nil {
-		return m.Data
+		return m.Resps
 	}
 	return nil
 }
@@ -3649,164 +3658,164 @@ func init() {
 }
 
 var fileDescriptor_5c21d519a9be369a = []byte{
-	// 2503 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0x4b, 0x73, 0x1b, 0x4b,
-	0x15, 0xf6, 0xe8, 0x69, 0x1d, 0x3d, 0x2c, 0x75, 0x72, 0x7d, 0x15, 0x17, 0x37, 0x98, 0xbe, 0xb9,
-	0xc1, 0x71, 0xc0, 0xdc, 0xab, 0x84, 0x14, 0x14, 0xc5, 0xbd, 0x25, 0x22, 0x39, 0xd2, 0x4d, 0x2c,
-	0xab, 0xda, 0xca, 0x93, 0x47, 0xd5, 0x58, 0x6a, 0x5b, 0x53, 0x91, 0x34, 0xe3, 0x99, 0x91, 0x23,
-	0xb1, 0x82, 0x0d, 0xac, 0x28, 0x8a, 0x0d, 0x4b, 0x28, 0x56, 0x54, 0xb1, 0xa6, 0x28, 0x8a, 0x5f,
-	0xc0, 0x0f, 0x60, 0xc3, 0x96, 0x5f, 0xc0, 0x4f, 0xa0, 0xfa, 0x35, 0xd3, 0x33, 0x92, 0xfc, 0x08,
-	0x2c, 0xd9, 0xcd, 0x39, 0xfd, 0x75, 0xf7, 0xe9, 0xef, 0x9c, 0x3e, 0x7d, 0xba, 0x07, 0x72, 0x63,
-	0x6b, 0xb6, 0xe7, 0xb8, 0xb6, 0x6f, 0xa3, 0xb4, 0x3f, 0x77, 0xa8, 0xb7, 0x55, 0xe8, 0xdb, 0xe3,
-	0xb1, 0x3d, 0x11, 0xca, 0xad, 0x8a, 0xef, 0x9a, 0x13, 0xcf, 0xec, 0xfb, 0x96, 0x52, 0xe1, 0x2f,
-	0x21, 0xff, 0xe6, 0xed, 0x0b, 0xea, 0x5a, 0x27, 0xf3, 0xa7, 0x74, 0x8e, 0x3e, 0x81, 0x14, 0xeb,
-	0x58, 0x35, 0xb6, 0x8d, 0x9d, 0x52, 0xad, 0xb2, 0xc7, 0x47, 0xd9, 0x13, 0xed, 0xbd, 0xb9, 0x43,
-	0x09, 0x6f, 0x46, 0x37, 0x21, 0x7d, 0x6e, 0x8e, 0xa6, 0xb4, 0x9a, 0xd8, 0x36, 0x76, 0x72, 0x44,
-	0x08, 0xf8, 0x11, 0x14, 0xb4, 0xb1, 0x3c, 0x74, 0x17, 0x52, 0x03, 0xd3, 0x37, 0xab, 0xc6, 0x76,
-	0x72, 0x27, 0x5f, 0x43, 0x72, 0x30, 0x0d, 0x42, 0x78, 0x3b, 0xfe, 0x1a, 0xe4, 0xeb, 0x53, 0x7f,
-	0xd8, 0x9d, 0x1e, 0xf3, 0x6e, 0x48, 0xeb, 0x96, 0x93, 0x90, 0x33, 0x80, 0xae, 0x39, 0x1f, 0xd3,
-	0x89, 0xcf, 0xac, 0x44, 0x90, 0x32, 0x07, 0x03, 0x97, 0x5b, 0x99, 0x23, 0xfc, 0x1b, 0x7d, 0x05,
-	0x72, 0x8e, 0x39, 0xb7, 0x26, 0xa7, 0x4f, 0xe9, 0x5c, 0x9a, 0x15, 0x2a, 0xd0, 0x67, 0x50, 0x70,
-	0x69, 0x9f, 0x5a, 0xe7, 0x12, 0x90, 0xdc, 0x36, 0x76, 0xf2, 0xb5, 0xa2, 0x34, 0x49, 0xcc, 0x4c,
-	0x22, 0x10, 0xfc, 0x6f, 0x03, 0x36, 0x0e, 0xac, 0xd9, 0x63, 0x7b, 0x72, 0x62, 0x9d, 0xd6, 0x39,
-	0x67, 0xe8, 0x0e, 0x24, 0x7a, 0x73, 0x49, 0xce, 0x4d, 0xd9, 0x39, 0xc0, 0x70, 0x7e, 0x12, 0xbd,
-	0x39, 0xba, 0x0f, 0x19, 0x81, 0xe7, 0x76, 0x94, 0x6a, 0x37, 0xe2, 0xc8, 0x7a, 0xdf, 0x27, 0x12,
-	0x82, 0x6a, 0x90, 0x3b, 0x57, 0x7c, 0x48, 0xb3, 0x96, 0x30, 0xd5, 0x5a, 0x23, 0x21, 0x0c, 0x55,
-	0x21, 0x63, 0x32, 0xc2, 0xde, 0x56, 0x53, 0x6c, 0xa1, 0xad, 0x35, 0x22, 0x65, 0xf4, 0x00, 0xc0,
-	0x09, 0x78, 0xaa, 0xa6, 0xf9, 0x70, 0xca, 0x8b, 0x21, 0x81, 0xad, 0x35, 0xa2, 0xc1, 0x7e, 0x90,
-	0x95, 0xde, 0xc4, 0x8f, 0x61, 0xbd, 0xd1, 0x3a, 0xa2, 0x7d, 0x97, 0xfa, 0xe8, 0xab, 0x90, 0xa4,
-	0xce, 0x5b, 0xbe, 0xd6, 0x05, 0xa2, 0x58, 0x0b, 0xda, 0x84, 0x8c, 0xc7, 0xa1, 0xdc, 0xea, 0x1c,
-	0x91, 0x12, 0xfe, 0xad, 0x01, 0x45, 0x35, 0xca, 0x13, 0xd7, 0x9e, 0x3a, 0xe8, 0x1e, 0x64, 0xe5,
-	0x6c, 0x72, 0xb8, 0x0d, 0x39, 0x9c, 0x82, 0x11, 0xd5, 0x8e, 0xee, 0xc3, 0xba, 0x4b, 0xfd, 0xa9,
-	0x3b, 0xa1, 0x2e, 0x27, 0x6f, 0x09, 0x36, 0x00, 0xa0, 0x6f, 0x42, 0x8e, 0x2d, 0xdb, 0x76, 0xad,
-	0x9f, 0x52, 0x49, 0xdd, 0x02, 0x3a, 0x44, 0xe0, 0x33, 0x16, 0xea, 0x5d, 0xd7, 0xb6, 0x4f, 0xda,
-	0x93, 0x13, 0x9b, 0xc5, 0xb0, 0xc3, 0x04, 0x19, 0x45, 0x42, 0x40, 0xdb, 0x90, 0x77, 0xa6, 0xc7,
-	0x23, 0xab, 0xdf, 0x9e, 0x38, 0x53, 0x5f, 0x06, 0x92, 0xae, 0x42, 0xbb, 0x90, 0x3e, 0x65, 0xcb,
-	0x92, 0x33, 0xde, 0x8c, 0xcd, 0xc8, 0x97, 0x4c, 0x04, 0x04, 0xff, 0x04, 0xca, 0x07, 0xd6, 0xac,
-	0x41, 0x1d, 0xdb, 0xb3, 0x7c, 0xe9, 0xf0, 0x4d, 0xc8, 0x98, 0x63, 0x7b, 0x2a, 0xc9, 0x48, 0x11,
-	0x29, 0xa1, 0x1a, 0xc0, 0x84, 0xbe, 0x7b, 0x6c, 0x8f, 0xc7, 0x96, 0xef, 0x55, 0x13, 0xb1, 0x3d,
-	0x13, 0xd8, 0x4d, 0x34, 0x14, 0xb6, 0xa0, 0x72, 0x60, 0xcd, 0x7a, 0x6c, 0x57, 0x9f, 0x50, 0x57,
-	0x4e, 0xb0, 0x03, 0x69, 0x8b, 0x1b, 0x6f, 0xac, 0x1c, 0x43, 0x00, 0xd0, 0x2e, 0x64, 0xec, 0xa9,
-	0x2f, 0xd6, 0xb9, 0x0a, 0x2a, 0x11, 0xb8, 0xcf, 0xa7, 0x7a, 0x69, 0xf9, 0xc3, 0x81, 0x6b, 0xbe,
-	0xbb, 0x64, 0x2d, 0x8f, 0xa0, 0xe0, 0x39, 0x74, 0x32, 0xb8, 0x7c, 0x35, 0x11, 0x1c, 0xfe, 0x12,
-	0xd0, 0x81, 0x35, 0xab, 0x2b, 0x97, 0xc9, 0x59, 0x1e, 0x42, 0x9e, 0x79, 0x51, 0x0d, 0xb6, 0x7a,
-	0x59, 0x3a, 0x0c, 0xff, 0x25, 0x01, 0x39, 0x36, 0x98, 0x18, 0xa3, 0x04, 0x09, 0x5f, 0xec, 0xdc,
-	0x34, 0x49, 0xf8, 0x73, 0xf4, 0x29, 0x64, 0xfa, 0x7c, 0x2f, 0xca, 0x30, 0xdb, 0x5c, 0xb2, 0x47,
-	0x2d, 0x7b, 0xc2, 0xb6, 0x96, 0xc0, 0xa1, 0x07, 0x90, 0x1d, 0x08, 0x47, 0x4a, 0xcf, 0x7f, 0x18,
-	0x76, 0x89, 0x78, 0xb8, 0xb5, 0x46, 0x14, 0x12, 0x3d, 0x82, 0xf5, 0x77, 0x92, 0x32, 0xbe, 0x57,
-	0xf3, 0xb5, 0x6a, 0xd8, 0x2b, 0x4a, 0x66, 0x6b, 0x8d, 0x04, 0x58, 0xd6, 0xcf, 0x97, 0x5e, 0x95,
-	0xbb, 0x58, 0xeb, 0x17, 0xf5, 0x37, 0xeb, 0xa7, 0xb0, 0xe8, 0xbb, 0xfa, 0x96, 0xc8, 0xf0, 0x8e,
-	0xb7, 0xc2, 0x8e, 0x31, 0x62, 0x59, 0x52, 0x09, 0xd0, 0x61, 0x16, 0x68, 0x01, 0x92, 0xeb, 0xe9,
-	0x6a, 0x61, 0xbf, 0x05, 0xeb, 0x13, 0xdb, 0xa7, 0x2d, 0xd3, 0x1b, 0xca, 0x1d, 0x13, 0xc8, 0x5a,
-	0x18, 0x88, 0xfd, 0x22, 0x25, 0xfc, 0x47, 0x03, 0x6e, 0xa8, 0x45, 0xea, 0x63, 0x61, 0x28, 0xf8,
-	0x2e, 0xa5, 0xc4, 0xb6, 0x7d, 0x6d, 0xbc, 0x88, 0x0e, 0xdd, 0x81, 0xe2, 0x64, 0x3a, 0x1a, 0x59,
-	0x27, 0x16, 0x75, 0x39, 0x48, 0x0c, 0x1d, 0x55, 0xa2, 0x3d, 0x40, 0xc1, 0x0a, 0x8e, 0x58, 0x24,
-	0x71, 0xa8, 0x48, 0x48, 0x4b, 0x5a, 0x34, 0x4b, 0x53, 0x11, 0x4b, 0xff, 0x6e, 0x40, 0x55, 0xd1,
-	0xca, 0x6d, 0xbc, 0xae, 0xb9, 0x55, 0xc8, 0x8a, 0xa1, 0x5e, 0x49, 0x43, 0x95, 0x18, 0xb6, 0xbc,
-	0x96, 0x76, 0x29, 0x71, 0x85, 0xf1, 0xa9, 0x95, 0xc6, 0x2f, 0x50, 0x92, 0x5e, 0x42, 0x09, 0xfe,
-	0xbd, 0x01, 0xb7, 0xd4, 0x52, 0x0e, 0xf9, 0xde, 0xbd, 0xaa, 0x1b, 0xdf, 0x67, 0x0d, 0x35, 0xc8,
-	0x0d, 0x86, 0x22, 0xf3, 0x79, 0x32, 0xc2, 0x97, 0x67, 0xc4, 0x10, 0x86, 0xff, 0x66, 0xc0, 0xcd,
-	0x20, 0x14, 0xaf, 0x4b, 0xf4, 0x0e, 0x6c, 0x98, 0x5a, 0xdf, 0xf0, 0xb4, 0x8f, 0xab, 0x19, 0x5d,
-	0x81, 0x4a, 0x0b, 0x8b, 0xa8, 0xf2, 0xba, 0x4e, 0xc0, 0xdb, 0x00, 0xcd, 0x99, 0xe5, 0xf9, 0x2f,
-	0xd8, 0x5e, 0xd1, 0x6a, 0x15, 0x63, 0x67, 0x5d, 0xd6, 0x2a, 0x77, 0xa1, 0x2c, 0x72, 0x50, 0xcf,
-	0xa5, 0xf4, 0x19, 0x35, 0xcf, 0x69, 0xb4, 0xa6, 0x29, 0x48, 0xdc, 0x27, 0xb0, 0x11, 0xe2, 0xd8,
-	0xfa, 0x96, 0xc3, 0xfe, 0x60, 0xe8, 0xb8, 0xae, 0x6b, 0x9f, 0x53, 0xe6, 0x45, 0x37, 0x4a, 0x52,
-	0x20, 0xb3, 0x36, 0x7e, 0x94, 0x1d, 0x51, 0x91, 0xd6, 0x73, 0x24, 0x90, 0xd1, 0x6d, 0x00, 0x47,
-	0x64, 0xcb, 0x01, 0x9d, 0x71, 0x3e, 0x8a, 0x44, 0xd3, 0xb0, 0x22, 0x6a, 0x32, 0x1d, 0x0b, 0x9b,
-	0x39, 0x07, 0x45, 0x12, 0x2a, 0x58, 0x14, 0x0c, 0xe9, 0xc8, 0xa1, 0xae, 0x57, 0x4d, 0x6f, 0x27,
-	0x77, 0x8a, 0x44, 0x89, 0xb8, 0x09, 0x79, 0x66, 0x1c, 0x4f, 0xc2, 0xf4, 0xec, 0x32, 0xf3, 0x46,
-	0xd4, 0x3c, 0xd1, 0xb6, 0x74, 0x20, 0xe3, 0x3b, 0x50, 0xe0, 0x9c, 0x59, 0x9e, 0x4f, 0xa8, 0xe7,
-	0xb0, 0x23, 0x9a, 0x51, 0xe0, 0xc9, 0x52, 0x50, 0x08, 0xb8, 0x01, 0xa5, 0xb0, 0x94, 0xe9, 0x9a,
-	0x96, 0xcb, 0x76, 0xb5, 0x63, 0xf2, 0x02, 0x4a, 0xcc, 0x26, 0x25, 0x36, 0x17, 0x3f, 0x5e, 0xc2,
-	0x20, 0x09, 0x64, 0x7c, 0x07, 0x32, 0x32, 0x4e, 0x0a, 0x60, 0xbc, 0x92, 0x1d, 0x8d, 0x57, 0x4c,
-	0x7a, 0x2d, 0xc1, 0xc6, 0x6b, 0xfc, 0x11, 0x64, 0xbb, 0xae, 0x75, 0x2e, 0x8b, 0xce, 0xc0, 0xd5,
-	0xaa, 0x2c, 0xb5, 0x01, 0x1d, 0x0d, 0x4d, 0x97, 0x8a, 0xc8, 0x56, 0xe6, 0xec, 0x40, 0xd6, 0x11,
-	0x9d, 0x64, 0xbd, 0x53, 0x52, 0xe5, 0x93, 0xd0, 0x12, 0xd5, 0x8c, 0xbe, 0x05, 0xf9, 0xa0, 0xe6,
-	0xec, 0xbe, 0x95, 0x47, 0x51, 0xac, 0xd8, 0xd2, 0x11, 0xf8, 0x57, 0x06, 0x54, 0xea, 0xfd, 0x3e,
-	0xdb, 0x7b, 0x6c, 0x30, 0xb3, 0xcf, 0xd7, 0xf9, 0xed, 0x48, 0xd5, 0x27, 0xe6, 0xfc, 0x60, 0xa1,
-	0xea, 0x63, 0xb6, 0xe9, 0x75, 0x1f, 0xaa, 0x43, 0xc9, 0x8b, 0x58, 0x2f, 0x0d, 0x50, 0x27, 0xc6,
-	0xe2, 0xd2, 0x48, 0xac, 0x03, 0xfe, 0x21, 0x54, 0x5e, 0x9a, 0xa3, 0x11, 0xf5, 0xeb, 0x83, 0x81,
-	0x2b, 0x2d, 0x42, 0x35, 0xb1, 0x7e, 0xb3, 0xaf, 0x6c, 0x51, 0x67, 0xd7, 0x82, 0xe5, 0x44, 0x01,
-	0x83, 0x92, 0x3e, 0x11, 0x96, 0xf4, 0xf8, 0xaf, 0x06, 0x80, 0x98, 0xaa, 0x61, 0xfa, 0x26, 0xdb,
-	0xcf, 0xd2, 0x78, 0xb9, 0xef, 0x85, 0x27, 0xa2, 0x4a, 0x96, 0x43, 0x44, 0x81, 0x18, 0x49, 0x0e,
-	0x11, 0xdd, 0xb2, 0x1c, 0x92, 0x5c, 0x9e, 0x43, 0x56, 0x9c, 0x17, 0x6c, 0x23, 0xb1, 0xb4, 0x49,
-	0xcc, 0xc9, 0xc0, 0x1e, 0xcb, 0x3c, 0xac, 0x69, 0xf0, 0x1b, 0xa8, 0x34, 0x27, 0x7d, 0x7b, 0x40,
-	0x07, 0xda, 0x02, 0xaa, 0x90, 0xa5, 0x42, 0x29, 0x4d, 0x57, 0x22, 0xba, 0x0f, 0x59, 0xd7, 0x7c,
-	0xc7, 0x40, 0xd2, 0x05, 0xaa, 0x66, 0x0f, 0x7b, 0x13, 0x85, 0xc0, 0x3f, 0xe2, 0x63, 0xbb, 0x73,
-	0xc7, 0xd7, 0xc6, 0x0e, 0xab, 0x71, 0x43, 0xaf, 0xc6, 0xaf, 0x1f, 0x61, 0xbf, 0x30, 0xa0, 0xd2,
-	0xa0, 0x57, 0x1d, 0xfe, 0x3b, 0xb0, 0x11, 0x76, 0x76, 0xad, 0x30, 0x86, 0xe2, 0x21, 0x1f, 0x87,
-	0xa9, 0xfb, 0x45, 0x72, 0xd5, 0xfd, 0x02, 0xff, 0xc6, 0x80, 0x0d, 0x55, 0x87, 0xb0, 0x0c, 0xc5,
-	0x12, 0x0b, 0xab, 0xce, 0x85, 0xb7, 0xeb, 0xe1, 0xfd, 0x4f, 0x57, 0x31, 0xc7, 0x08, 0x57, 0xd7,
-	0xc3, 0x68, 0xd2, 0x34, 0x91, 0x43, 0x81, 0x43, 0xe2, 0x87, 0x02, 0x47, 0x45, 0xdd, 0x1e, 0xd4,
-	0xb5, 0xf8, 0x97, 0x06, 0x94, 0xa3, 0x36, 0x79, 0xce, 0x85, 0x47, 0xea, 0xd7, 0xd5, 0x25, 0x63,
-	0xa5, 0x5b, 0xe5, 0xbd, 0x63, 0x0f, 0xb2, 0x9e, 0x3c, 0x45, 0x2f, 0xba, 0x57, 0x28, 0x10, 0xb3,
-	0xa4, 0xc8, 0xcf, 0x03, 0xd3, 0x1f, 0x72, 0x53, 0xae, 0x74, 0x78, 0x6e, 0xb1, 0xb2, 0x52, 0x74,
-	0x52, 0x67, 0x83, 0x92, 0xf5, 0xec, 0x9e, 0x8c, 0x64, 0x77, 0x76, 0x2a, 0x9c, 0x9b, 0x23, 0x6b,
-	0xc0, 0xbb, 0xa5, 0x78, 0x5b, 0xa8, 0xc0, 0x7b, 0x50, 0x0e, 0x6a, 0x3c, 0xe5, 0xa7, 0x0b, 0x28,
-	0x61, 0x75, 0x79, 0x25, 0xd6, 0xc1, 0x73, 0x42, 0xa2, 0x8c, 0x4b, 0x88, 0xba, 0x5a, 0x5d, 0x28,
-	0xdd, 0x1c, 0x2f, 0x09, 0xa3, 0xca, 0x88, 0x99, 0xa9, 0x98, 0xe7, 0xb0, 0xbc, 0xc2, 0xc8, 0x00,
-	0x96, 0x7b, 0x3c, 0xa2, 0x63, 0xc4, 0x70, 0x79, 0x7f, 0x64, 0x9e, 0xf2, 0x6a, 0xbb, 0x48, 0x42,
-	0x05, 0x1b, 0x9d, 0x4d, 0xc7, 0x1b, 0xb3, 0xbc, 0x31, 0x90, 0x59, 0xd9, 0xe4, 0x8b, 0xd3, 0xdc,
-	0x3e, 0xa9, 0xae, 0x47, 0x1c, 0x1e, 0xf1, 0x2a, 0x09, 0x61, 0x78, 0x1f, 0x0a, 0xfc, 0x99, 0xe4,
-	0x0a, 0x24, 0x73, 0x47, 0xdb, 0x84, 0x87, 0x3d, 0x27, 0xa8, 0x48, 0x02, 0x19, 0xff, 0x29, 0x01,
-	0x45, 0x6d, 0xa0, 0xeb, 0x90, 0x7f, 0x1b, 0xc0, 0x0c, 0x5e, 0x6a, 0xd4, 0xee, 0x0a, 0x35, 0x6c,
-	0x7f, 0x72, 0x49, 0x72, 0x26, 0x48, 0xd7, 0x55, 0x8a, 0x14, 0x9d, 0x72, 0x25, 0x2f, 0x3a, 0x2d,
-	0x7d, 0x99, 0xd3, 0x32, 0xb1, 0x65, 0x47, 0x1c, 0x92, 0x8d, 0x3b, 0xe4, 0x7d, 0x48, 0xff, 0x9d,
-	0x01, 0x65, 0x55, 0x4d, 0x5f, 0x89, 0xf9, 0x4d, 0xc8, 0xf8, 0xb6, 0x96, 0x7c, 0xa4, 0xc4, 0xa8,
-	0xf3, 0x6d, 0x46, 0xbb, 0x96, 0x75, 0x34, 0x4d, 0x2c, 0x71, 0xa5, 0x16, 0x12, 0x57, 0x98, 0x92,
-	0xd2, 0x91, 0x94, 0x74, 0x0f, 0xf2, 0x7d, 0x5e, 0x1d, 0x8a, 0x82, 0xf4, 0xa2, 0x62, 0xe6, 0xd7,
-	0x49, 0x40, 0xd1, 0x4b, 0x0e, 0x77, 0xea, 0xff, 0xb7, 0xde, 0x65, 0x51, 0x80, 0x1e, 0x46, 0x48,
-	0xae, 0xe6, 0x22, 0xcf, 0x74, 0x5a, 0x0b, 0x89, 0xf8, 0x62, 0x1b, 0xf2, 0xdc, 0x24, 0x59, 0x25,
-	0x80, 0xd8, 0x0d, 0x9a, 0x0a, 0xff, 0xcb, 0x80, 0x1b, 0xb1, 0xbb, 0xda, 0xf5, 0x5c, 0xa2, 0xd3,
-	0x98, 0x88, 0xd1, 0x78, 0xcd, 0x23, 0x25, 0xbe, 0xc8, 0xd4, 0x7b, 0x2d, 0x32, 0xbd, 0xb8, 0xc8,
-	0x7f, 0x18, 0x50, 0x89, 0x6d, 0x21, 0xcf, 0x41, 0x5f, 0x40, 0xd1, 0xd7, 0x63, 0x51, 0x2e, 0xf5,
-	0x56, 0xe0, 0x8a, 0x78, 0x9c, 0x92, 0x28, 0x1e, 0x7d, 0x0e, 0x05, 0xdf, 0x74, 0x4f, 0xa9, 0x7f,
-	0xa8, 0x9e, 0xb0, 0x58, 0xff, 0xad, 0x58, 0x7f, 0x8d, 0x55, 0x12, 0xc1, 0xb3, 0xfe, 0xfd, 0xa1,
-	0x39, 0x39, 0xa5, 0xb2, 0x7f, 0xf2, 0xf2, 0xfe, 0x3a, 0x1e, 0xff, 0x2c, 0x01, 0xa5, 0xc7, 0x1a,
-	0x2b, 0x5e, 0xbc, 0x2a, 0x34, 0xe2, 0x55, 0x21, 0xba, 0x0b, 0x25, 0xb5, 0x06, 0x89, 0x11, 0x3e,
-	0x8b, 0x69, 0xd9, 0x06, 0x10, 0x53, 0x49, 0x94, 0xd8, 0x41, 0x11, 0x1d, 0xba, 0x0b, 0x29, 0x36,
-	0xf2, 0x05, 0x6e, 0xe2, 0xed, 0x68, 0x6f, 0xe1, 0x25, 0x69, 0x19, 0x36, 0x7c, 0x41, 0xda, 0x85,
-	0x8c, 0x98, 0x47, 0x3e, 0x1f, 0x2d, 0x43, 0x4b, 0x04, 0xfe, 0x79, 0x02, 0x36, 0x44, 0xf9, 0xcf,
-	0xaf, 0x8f, 0xfc, 0x59, 0xf5, 0xa2, 0xdc, 0xc8, 0xaf, 0x97, 0x32, 0x57, 0xa8, 0x37, 0xfa, 0x40,
-	0x71, 0xc5, 0xc4, 0x71, 0x1b, 0xc0, 0xf2, 0x88, 0x7a, 0x23, 0x4e, 0xf1, 0x7b, 0xb7, 0xa6, 0xe1,
-	0x4f, 0x15, 0xe2, 0x9a, 0x21, 0x63, 0x51, 0x89, 0xe8, 0x1e, 0x64, 0x3c, 0xdf, 0xf4, 0xa7, 0x1e,
-	0x5f, 0x59, 0xf8, 0x77, 0xa3, 0x63, 0xfb, 0xf4, 0x88, 0x37, 0x10, 0x09, 0xe0, 0x50, 0x51, 0xee,
-	0x66, 0x57, 0x6d, 0x40, 0xf5, 0xdc, 0xfd, 0x52, 0x51, 0xd0, 0x38, 0x3e, 0xb0, 0x04, 0x05, 0xbb,
-	0x90, 0xb2, 0x26, 0x27, 0xb6, 0x8c, 0x68, 0xf5, 0xb2, 0x18, 0x23, 0x8a, 0x70, 0x0c, 0x33, 0xd7,
-	0x9f, 0x89, 0xeb, 0xb8, 0x7c, 0x73, 0x91, 0x22, 0xfe, 0xa7, 0xa1, 0xee, 0x56, 0x7c, 0xdc, 0x01,
-	0x9d, 0x5d, 0x76, 0xf4, 0xfc, 0x2f, 0xe8, 0x5d, 0x4d, 0xdf, 0x66, 0x84, 0xbe, 0x74, 0xc0, 0xd5,
-	0x4d, 0x48, 0x0b, 0x7c, 0x96, 0xab, 0x85, 0xc0, 0x6c, 0x19, 0x58, 0x2e, 0x15, 0xbf, 0x41, 0xd6,
-	0x79, 0x4b, 0xa8, 0xc0, 0x5f, 0x44, 0xe2, 0x86, 0xe7, 0x83, 0x6f, 0xe8, 0x77, 0xfd, 0xd5, 0xac,
-	0xc9, 0x37, 0x80, 0x3b, 0x50, 0x12, 0x2d, 0x84, 0x9e, 0xb1, 0xe3, 0x71, 0xf9, 0x5f, 0x23, 0x02,
-	0x9b, 0x02, 0xd5, 0x9c, 0x98, 0xc7, 0x23, 0x2a, 0xef, 0x9d, 0x6c, 0xa7, 0x2e, 0xfb, 0x83, 0x84,
-	0x20, 0x65, 0x79, 0x87, 0x4f, 0x39, 0x73, 0xeb, 0x84, 0x7f, 0xa3, 0x32, 0x24, 0xc7, 0xde, 0xa9,
-	0xa4, 0x8a, 0x7d, 0xe2, 0x67, 0xf0, 0xe1, 0xb2, 0x31, 0xd9, 0x12, 0x3e, 0x8b, 0xfc, 0xef, 0xfa,
-	0x28, 0xb2, 0x82, 0xb8, 0x05, 0xd2, 0xc2, 0x0e, 0xc0, 0x33, 0xbb, 0x6f, 0x8e, 0x0e, 0xac, 0x59,
-	0x6f, 0xc6, 0x2c, 0x18, 0x86, 0x8e, 0xe5, 0xdf, 0x8c, 0xf6, 0x21, 0xb5, 0x4e, 0x87, 0x22, 0xc1,
-	0x25, 0x89, 0x94, 0x18, 0xed, 0x56, 0xf0, 0x8a, 0x93, 0x24, 0x42, 0x60, 0xe5, 0x4a, 0x81, 0x8f,
-	0x25, 0xde, 0x50, 0xce, 0xf4, 0xf8, 0x32, 0x22, 0xf1, 0x15, 0x4c, 0x96, 0x58, 0x3a, 0x59, 0x72,
-	0xf9, 0x64, 0x29, 0x6d, 0xb2, 0xd0, 0xf3, 0xe9, 0x95, 0x9e, 0xcf, 0xc4, 0x3d, 0xff, 0x10, 0x8a,
-	0x9a, 0x7d, 0x9e, 0x83, 0x3e, 0x86, 0xa4, 0x3f, 0x53, 0x5e, 0x57, 0xfb, 0x2c, 0xe4, 0x84, 0xb0,
-	0x56, 0x7c, 0x00, 0x15, 0x49, 0x1d, 0x73, 0x36, 0xa1, 0xde, 0x74, 0xf4, 0xdf, 0xf8, 0xb0, 0x0d,
-	0x37, 0x08, 0x3d, 0x5b, 0x08, 0x8a, 0x1a, 0x64, 0x5d, 0x3e, 0xb4, 0x32, 0xa7, 0xaa, 0x5d, 0x62,
-	0x23, 0x73, 0x13, 0x05, 0xdc, 0xfd, 0x31, 0x40, 0xf8, 0x77, 0x14, 0xe5, 0x21, 0xdb, 0x68, 0x76,
-	0x0f, 0x8f, 0xda, 0xbd, 0xf2, 0x1a, 0x2a, 0xc0, 0xfa, 0xcb, 0x76, 0xaf, 0xd5, 0x20, 0xf5, 0x97,
-	0x65, 0x03, 0x55, 0xa0, 0xd8, 0x23, 0xf5, 0xce, 0xd1, 0x7e, 0x93, 0xb4, 0x3b, 0xdd, 0xe7, 0xbd,
-	0x72, 0x02, 0x21, 0x28, 0x29, 0xd5, 0xe1, 0xf3, 0x1e, 0xd3, 0x25, 0x51, 0x11, 0x72, 0xf5, 0xe7,
-	0xbd, 0xd6, 0x21, 0x69, 0xbf, 0x69, 0x96, 0x53, 0xbb, 0x75, 0x4e, 0x57, 0xf8, 0x7f, 0x91, 0xb5,
-	0x07, 0x3f, 0x05, 0xcb, 0x6b, 0xa8, 0x04, 0x10, 0xfe, 0x3a, 0x15, 0xb3, 0x74, 0xf5, 0xe7, 0x90,
-	0x72, 0x62, 0xf7, 0x63, 0x1e, 0x11, 0xc1, 0x4f, 0x0d, 0x94, 0x85, 0x64, 0x7d, 0x30, 0x28, 0xaf,
-	0x21, 0x80, 0x4c, 0x83, 0x8e, 0xa8, 0x4f, 0xcb, 0xc6, 0xee, 0xf7, 0x00, 0xc2, 0x34, 0x88, 0x72,
-	0x90, 0x7e, 0xde, 0x69, 0x34, 0xf7, 0x05, 0x68, 0x9f, 0x1c, 0xbe, 0x69, 0x76, 0xca, 0x06, 0x53,
-	0xbf, 0xa8, 0x3f, 0x6b, 0x37, 0xca, 0x09, 0xb6, 0xd0, 0x76, 0x47, 0x08, 0xc9, 0xdd, 0xef, 0xc3,
-	0x07, 0x07, 0xd6, 0x4c, 0xed, 0x47, 0xaf, 0x6f, 0x4e, 0xe4, 0x38, 0xeb, 0x90, 0x6a, 0x37, 0x9e,
-	0x35, 0x05, 0x17, 0x47, 0x8f, 0xeb, 0x9d, 0x4e, 0xbb, 0xf3, 0xa4, 0x6c, 0x30, 0x69, 0xbf, 0xdd,
-	0x69, 0x1f, 0xb5, 0x9a, 0x8d, 0x72, 0xa2, 0xf6, 0x67, 0x03, 0x60, 0x6c, 0xcd, 0xd4, 0xeb, 0xd1,
-	0x43, 0xd8, 0x78, 0x12, 0x1b, 0x47, 0x3d, 0x0f, 0x10, 0x7a, 0xd6, 0xb1, 0x46, 0x5b, 0xe5, 0x50,
-	0x3c, 0xf2, 0x5d, 0x6b, 0x72, 0x8a, 0xd7, 0xd0, 0xa7, 0x90, 0x17, 0x5d, 0xd8, 0x32, 0xae, 0xd4,
-	0xe3, 0x73, 0x28, 0x46, 0x22, 0x00, 0x6d, 0x84, 0x20, 0x9e, 0x52, 0xb6, 0xb6, 0x42, 0x45, 0x3c,
-	0x56, 0xf0, 0xda, 0x71, 0x86, 0xff, 0x40, 0x7f, 0xf0, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8e,
-	0xab, 0x71, 0x40, 0x75, 0x1f, 0x00, 0x00,
+	// 2504 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0x4b, 0x93, 0x23, 0x47,
+	0x11, 0x56, 0xeb, 0xad, 0xd4, 0x63, 0xa4, 0xda, 0xf5, 0x58, 0x9e, 0xc0, 0x66, 0x28, 0xaf, 0x97,
+	0xf1, 0x98, 0x18, 0xcc, 0xec, 0xe2, 0x30, 0x07, 0xec, 0x10, 0x2b, 0xcd, 0x4a, 0xde, 0x1d, 0x8d,
+	0xa2, 0xa4, 0x7d, 0x02, 0x87, 0x5e, 0xa9, 0x66, 0xd4, 0xb1, 0x92, 0xba, 0xa7, 0xbb, 0x35, 0x2b,
+	0x71, 0x82, 0x0b, 0x3e, 0x11, 0x04, 0x07, 0xae, 0x10, 0x9c, 0x88, 0xe0, 0x4c, 0x10, 0x04, 0xbf,
+	0x80, 0x1f, 0xc0, 0x85, 0x2b, 0xbf, 0x80, 0x9f, 0x40, 0xd4, 0xab, 0xbb, 0xba, 0x25, 0xcd, 0x63,
+	0xe1, 0xc8, 0xad, 0x33, 0x2b, 0xab, 0x2a, 0xf3, 0xcb, 0x47, 0x65, 0x55, 0x43, 0x61, 0x6a, 0x2d,
+	0x0e, 0x1c, 0xd7, 0xf6, 0x6d, 0x94, 0xf1, 0x97, 0x0e, 0xf5, 0x76, 0x4a, 0x43, 0x7b, 0x3a, 0xb5,
+	0x67, 0x82, 0xb9, 0x53, 0xf3, 0x5d, 0x73, 0xe6, 0x99, 0x43, 0xdf, 0x52, 0x2c, 0xfc, 0x15, 0x14,
+	0x5f, 0xbe, 0x7e, 0x4a, 0x5d, 0xeb, 0x74, 0xf9, 0x88, 0x2e, 0xd1, 0x47, 0x90, 0x66, 0x13, 0xeb,
+	0xc6, 0xae, 0xb1, 0x57, 0x39, 0xac, 0x1d, 0xf0, 0x55, 0x0e, 0xc4, 0xf8, 0x60, 0xe9, 0x50, 0xc2,
+	0x87, 0xd1, 0x6d, 0xc8, 0x5c, 0x98, 0x93, 0x39, 0xad, 0x27, 0x77, 0x8d, 0xbd, 0x02, 0x11, 0x04,
+	0xfe, 0x0c, 0x4a, 0xda, 0x5a, 0x1e, 0xba, 0x0b, 0xe9, 0x91, 0xe9, 0x9b, 0x75, 0x63, 0x37, 0xb5,
+	0x57, 0x3c, 0x44, 0x72, 0x31, 0x4d, 0x84, 0xf0, 0x71, 0xfc, 0x2d, 0x28, 0x36, 0xe6, 0xfe, 0xb8,
+	0x37, 0x7f, 0xc5, 0xa7, 0x21, 0x6d, 0x5a, 0x41, 0x8a, 0x9c, 0x03, 0xf4, 0xcc, 0xe5, 0x94, 0xce,
+	0x7c, 0xa6, 0x25, 0x82, 0xb4, 0x39, 0x1a, 0xb9, 0x5c, 0xcb, 0x02, 0xe1, 0xdf, 0xe8, 0x1b, 0x50,
+	0x70, 0xcc, 0xa5, 0x35, 0x3b, 0x7b, 0x44, 0x97, 0x52, 0xad, 0x90, 0x81, 0xbe, 0x07, 0x25, 0x97,
+	0x0e, 0xa9, 0x75, 0x21, 0x05, 0x52, 0xbb, 0xc6, 0x5e, 0xf1, 0xb0, 0x2c, 0x55, 0x12, 0x3b, 0x93,
+	0x88, 0x08, 0xfe, 0xb7, 0x01, 0x5b, 0xc7, 0xd6, 0xe2, 0x81, 0x3d, 0x3b, 0xb5, 0xce, 0x1a, 0x1c,
+	0x33, 0x74, 0x07, 0x92, 0x83, 0xa5, 0x04, 0xe7, 0xb6, 0x9c, 0x1c, 0xc8, 0x70, 0x7c, 0x92, 0x83,
+	0x25, 0xfa, 0x04, 0xb2, 0x42, 0x9e, 0xeb, 0x51, 0x39, 0xbc, 0x15, 0x97, 0x6c, 0x0c, 0x7d, 0x22,
+	0x45, 0xd0, 0x21, 0x14, 0x2e, 0x14, 0x1e, 0x52, 0xad, 0x35, 0x48, 0xb5, 0x13, 0x24, 0x14, 0x43,
+	0x75, 0xc8, 0x9a, 0x0c, 0xb0, 0xd7, 0xf5, 0x34, 0x33, 0xb4, 0x9d, 0x20, 0x92, 0x46, 0xf7, 0x00,
+	0x9c, 0x00, 0xa7, 0x7a, 0x86, 0x2f, 0xa7, 0xbc, 0x18, 0x02, 0xd8, 0x4e, 0x10, 0x4d, 0xec, 0x47,
+	0x39, 0xe9, 0x4d, 0xfc, 0x00, 0xf2, 0xcd, 0x76, 0x9f, 0x0e, 0x5d, 0xea, 0xa3, 0x6f, 0x42, 0x8a,
+	0x3a, 0xaf, 0xb9, 0xad, 0x2b, 0x40, 0xb1, 0x11, 0xb4, 0x0d, 0x59, 0x8f, 0x8b, 0x72, 0xad, 0x0b,
+	0x44, 0x52, 0x78, 0x08, 0x65, 0xb5, 0xc8, 0x43, 0xd7, 0x9e, 0x3b, 0xa8, 0x0e, 0x39, 0xb9, 0x99,
+	0x74, 0x98, 0x22, 0xd1, 0x0e, 0xe4, 0x5d, 0xea, 0xcf, 0xdd, 0x19, 0x75, 0xa5, 0xcb, 0x02, 0x9a,
+	0xf9, 0x93, 0xd9, 0x64, 0xbb, 0xd6, 0xcf, 0xa8, 0xdc, 0x21, 0x64, 0xe0, 0x39, 0x0b, 0xdb, 0x9e,
+	0x6b, 0xdb, 0xa7, 0x9d, 0xd9, 0xa9, 0xcd, 0xe2, 0xd1, 0x61, 0x84, 0xdc, 0x40, 0x10, 0x68, 0x17,
+	0x8a, 0xce, 0xfc, 0xd5, 0xc4, 0x1a, 0x76, 0x66, 0xce, 0xdc, 0x97, 0x3b, 0xe8, 0x2c, 0x74, 0x00,
+	0x39, 0xa1, 0xb5, 0x27, 0xa1, 0x57, 0x4e, 0x8d, 0x58, 0x40, 0x94, 0x10, 0x1e, 0x40, 0xf5, 0xd8,
+	0x5a, 0x34, 0xa9, 0x63, 0x7b, 0x96, 0x2f, 0x1d, 0xb8, 0x0d, 0x59, 0x73, 0x6a, 0xcf, 0xa5, 0x75,
+	0x69, 0x22, 0x29, 0xb4, 0xa7, 0x74, 0x4a, 0xc6, 0x9c, 0x1a, 0xa8, 0x2d, 0xf5, 0xc4, 0xbf, 0x35,
+	0xa0, 0x76, 0x6c, 0x2d, 0x06, 0x2c, 0x39, 0x4f, 0xa9, 0x2b, 0xd7, 0xdd, 0x83, 0x8c, 0xc5, 0xf5,
+	0x36, 0x36, 0xcf, 0xe7, 0x02, 0x68, 0x1f, 0xb2, 0xf6, 0xdc, 0x57, 0x26, 0xae, 0x17, 0x95, 0x12,
+	0x4c, 0x76, 0x38, 0x36, 0x67, 0x67, 0x74, 0x25, 0xd6, 0x34, 0x59, 0x21, 0x81, 0x87, 0x5c, 0xad,
+	0x67, 0x96, 0x3f, 0x1e, 0xb9, 0xe6, 0x9b, 0x2b, 0xcc, 0xfd, 0x0c, 0x4a, 0x9e, 0x43, 0x67, 0xa3,
+	0x07, 0xf6, 0x74, 0x6a, 0xf9, 0x5e, 0x3d, 0x19, 0x4b, 0xfa, 0x70, 0xf9, 0x88, 0x1c, 0xfe, 0x0a,
+	0xd0, 0xb1, 0xb5, 0x68, 0x28, 0xcf, 0xca, 0x5d, 0xee, 0x43, 0x91, 0x39, 0x5b, 0x2d, 0x66, 0x6c,
+	0x5c, 0x4c, 0x17, 0xc3, 0x7f, 0x49, 0x42, 0x81, 0x2d, 0x26, 0xd6, 0xa8, 0x40, 0xd2, 0x17, 0xc9,
+	0x9a, 0x21, 0x49, 0x7f, 0x89, 0x3e, 0x85, 0xec, 0x90, 0xa7, 0x9f, 0x84, 0x69, 0x7b, 0x4d, 0x5a,
+	0x5a, 0xf6, 0x8c, 0x65, 0x93, 0x90, 0x43, 0xf7, 0x20, 0x37, 0x12, 0xbe, 0x96, 0x68, 0xbd, 0x1b,
+	0x4e, 0x89, 0x04, 0x41, 0x3b, 0x41, 0x94, 0x24, 0xfa, 0x0c, 0xf2, 0x6f, 0x24, 0x64, 0x3c, 0x3d,
+	0x8b, 0x87, 0xf5, 0x70, 0x56, 0x14, 0xcc, 0x76, 0x82, 0x04, 0xb2, 0x6c, 0x9e, 0x2f, 0x23, 0x40,
+	0x26, 0xae, 0x36, 0x2f, 0x1a, 0x1b, 0x6c, 0x9e, 0x92, 0x45, 0x3f, 0xd0, 0x13, 0x25, 0xcb, 0x27,
+	0xbe, 0x17, 0x4e, 0x8c, 0x01, 0xcb, 0xea, 0x48, 0x20, 0x1d, 0x26, 0x7e, 0x1b, 0x90, 0xb4, 0xa7,
+	0xa7, 0x65, 0xc7, 0x0e, 0xe4, 0x67, 0xb6, 0x4f, 0xdb, 0xa6, 0x37, 0x96, 0x89, 0x15, 0xd0, 0x5a,
+	0x18, 0x88, 0xb4, 0x92, 0x14, 0xfe, 0xa3, 0x01, 0xb7, 0x94, 0x91, 0xfa, 0x5a, 0x18, 0x4a, 0xbe,
+	0x4b, 0x29, 0xb1, 0x6d, 0x5f, 0x5b, 0x2f, 0xc2, 0x43, 0x77, 0xa0, 0x3c, 0x9b, 0x4f, 0x26, 0xd6,
+	0xa9, 0x45, 0x5d, 0x2e, 0x24, 0x96, 0x8e, 0x32, 0xd1, 0x01, 0xa0, 0xc0, 0x82, 0x3e, 0x8b, 0x24,
+	0x2e, 0x2a, 0x2a, 0xc4, 0x9a, 0x11, 0x4d, 0xd3, 0x74, 0x44, 0xd3, 0xbf, 0x1b, 0x50, 0x57, 0xb0,
+	0x72, 0x1d, 0x6f, 0xaa, 0x6e, 0x1d, 0x72, 0x62, 0xa9, 0xe7, 0x52, 0x51, 0x45, 0x86, 0x23, 0x2f,
+	0xa4, 0x5e, 0x8a, 0xdc, 0xa0, 0x7c, 0x7a, 0xa3, 0xf2, 0x2b, 0x90, 0x64, 0xd6, 0x40, 0x82, 0x7f,
+	0x6f, 0xc0, 0x7b, 0xca, 0x94, 0x13, 0x9e, 0xe7, 0xd7, 0x75, 0xe3, 0xdb, 0xd8, 0x70, 0x08, 0x85,
+	0xd1, 0xb8, 0x2f, 0xcb, 0x66, 0xfa, 0x92, 0xb2, 0x19, 0x8a, 0xe1, 0xbf, 0x19, 0x70, 0x3b, 0x08,
+	0xc5, 0x9b, 0x02, 0xbd, 0x07, 0x5b, 0xa6, 0x36, 0x37, 0x3c, 0xe0, 0xe3, 0x6c, 0x06, 0x57, 0xc0,
+	0xd2, 0xc2, 0x22, 0xca, 0xbc, 0xa9, 0x13, 0xf0, 0x2e, 0x40, 0x6b, 0x61, 0x79, 0xfe, 0x53, 0x96,
+	0x2b, 0x5a, 0x7b, 0x62, 0xec, 0xe5, 0x65, 0x7b, 0x72, 0x17, 0xaa, 0xa2, 0x06, 0x0d, 0x5c, 0x4a,
+	0x1f, 0x53, 0xf3, 0x82, 0x46, 0xdb, 0x98, 0x92, 0x94, 0xfb, 0x08, 0xb6, 0x42, 0x39, 0x66, 0xdf,
+	0x7a, 0xb1, 0x3f, 0x18, 0xba, 0x5c, 0xcf, 0xb5, 0x2f, 0x28, 0x3f, 0x2b, 0xa3, 0x20, 0x05, 0x34,
+	0x1b, 0xe3, 0x27, 0x49, 0x9f, 0xfa, 0xbc, 0xee, 0x16, 0x48, 0x40, 0xa3, 0x0f, 0x00, 0x1c, 0x51,
+	0x2d, 0x47, 0x74, 0xc1, 0xf1, 0x28, 0x13, 0x8d, 0xc3, 0xce, 0xd9, 0xd9, 0x7c, 0x2a, 0x74, 0xe6,
+	0x18, 0x94, 0x49, 0xc8, 0x60, 0x51, 0x30, 0xa6, 0x13, 0x87, 0xba, 0x5e, 0x3d, 0xb3, 0x9b, 0xda,
+	0x2b, 0x13, 0x45, 0xe2, 0x16, 0x14, 0x99, 0x72, 0xbc, 0x08, 0xd3, 0xf3, 0xab, 0xd4, 0x9b, 0x50,
+	0xf3, 0x54, 0x4b, 0xe9, 0x80, 0xc6, 0x77, 0xa0, 0xc4, 0x31, 0xb3, 0x3c, 0x9f, 0x50, 0xcf, 0x61,
+	0x27, 0x39, 0x83, 0xc0, 0x93, 0xdd, 0x9f, 0x20, 0x70, 0x13, 0x2a, 0x61, 0xf7, 0xd2, 0x33, 0x2d,
+	0x97, 0x65, 0xb5, 0x63, 0xf2, 0x9e, 0x49, 0xec, 0x26, 0x29, 0xb6, 0x17, 0x3f, 0x5e, 0xc2, 0x20,
+	0x09, 0x68, 0x7c, 0x07, 0xb2, 0x32, 0x4e, 0x4a, 0x60, 0x3c, 0x97, 0x13, 0x8d, 0xe7, 0x8c, 0x7a,
+	0x21, 0x85, 0x8d, 0x17, 0xf8, 0x7d, 0xc8, 0xf5, 0x5c, 0xeb, 0x42, 0xf6, 0x99, 0x81, 0xab, 0x55,
+	0x27, 0x6a, 0x03, 0xea, 0x8f, 0x4d, 0x97, 0x8a, 0xc8, 0x56, 0xea, 0xec, 0x41, 0xce, 0x11, 0x93,
+	0xe4, 0x71, 0x5d, 0x51, 0x1d, 0x93, 0xe0, 0x12, 0x35, 0x8c, 0xbe, 0x0b, 0xc5, 0xa0, 0xcd, 0xec,
+	0xbd, 0x96, 0x47, 0x51, 0xac, 0xbf, 0xd2, 0x25, 0xf0, 0xaf, 0x0c, 0xa8, 0x35, 0x86, 0x43, 0x96,
+	0x7b, 0x6c, 0x31, 0x73, 0xc8, 0xed, 0xfc, 0x7e, 0xa4, 0xd1, 0x13, 0x7b, 0xbe, 0xb3, 0xd2, 0xe8,
+	0x31, 0xdd, 0xf4, 0x56, 0x0f, 0x35, 0xa0, 0xe2, 0x45, 0xb4, 0x97, 0x0a, 0xa8, 0x13, 0x63, 0xd5,
+	0x34, 0x12, 0x9b, 0x80, 0x7f, 0x0c, 0xb5, 0x67, 0xe6, 0x64, 0x42, 0xfd, 0xc6, 0x68, 0xe4, 0x4a,
+	0x8d, 0xd0, 0xa1, 0xb0, 0xdf, 0x1c, 0x2a, 0x5d, 0xd4, 0xd9, 0xb5, 0xa2, 0x39, 0x51, 0x82, 0x41,
+	0x17, 0x9f, 0x0c, 0xbb, 0x78, 0xfc, 0x57, 0x03, 0x40, 0x6c, 0xd5, 0x34, 0x7d, 0x93, 0xe5, 0xb3,
+	0x54, 0x5e, 0xe6, 0xbd, 0xf0, 0x44, 0x94, 0xc9, 0x6a, 0x88, 0x68, 0x1b, 0x23, 0xc5, 0x21, 0xc2,
+	0x5b, 0x57, 0x43, 0x52, 0xeb, 0x6b, 0xc8, 0x86, 0xf3, 0x82, 0x25, 0x12, 0x2b, 0x9b, 0xc4, 0x9c,
+	0x8d, 0xec, 0xa9, 0xac, 0xc3, 0x1a, 0x07, 0xbf, 0x84, 0x5a, 0x6b, 0x36, 0xb4, 0x47, 0x74, 0xa4,
+	0x19, 0x50, 0x87, 0x1c, 0x15, 0x4c, 0xd5, 0xfb, 0x4a, 0x12, 0x7d, 0x02, 0x39, 0xd7, 0x7c, 0xc3,
+	0x84, 0xa4, 0x0b, 0x54, 0x9b, 0x1e, 0xce, 0x26, 0x4a, 0x02, 0xff, 0x84, 0xaf, 0xed, 0x2e, 0x1d,
+	0x5f, 0x5b, 0x3b, 0x6c, 0xc0, 0x0d, 0xbd, 0x01, 0xbf, 0x79, 0x84, 0xfd, 0xd2, 0x80, 0x5a, 0x93,
+	0x5e, 0x77, 0xf9, 0xcf, 0x61, 0x2b, 0x9c, 0xec, 0x5a, 0x61, 0x0c, 0xc5, 0x43, 0x3e, 0x2e, 0xa6,
+	0xae, 0x14, 0xa9, 0x4d, 0x57, 0x0a, 0xfc, 0x1b, 0x03, 0xb6, 0x54, 0x1f, 0xc2, 0x2a, 0x14, 0x2b,
+	0x2c, 0xac, 0x89, 0x17, 0xde, 0x6e, 0x84, 0x57, 0x3e, 0x9d, 0xc5, 0x1c, 0x23, 0x5c, 0xdd, 0x08,
+	0xa3, 0x49, 0xe3, 0x44, 0x0e, 0x05, 0x2e, 0x12, 0x3f, 0x14, 0xb8, 0x54, 0xd4, 0xed, 0x41, 0x5f,
+	0x8b, 0xbf, 0x36, 0xa0, 0x1a, 0xd5, 0xc9, 0x73, 0x2e, 0x3d, 0x52, 0xbf, 0x1d, 0xed, 0xfb, 0xd7,
+	0xb8, 0x55, 0x5e, 0x4f, 0x6e, 0x7a, 0xf9, 0xf8, 0xda, 0x80, 0x32, 0x3f, 0x0f, 0x4c, 0x7f, 0xcc,
+	0x55, 0xb9, 0xd6, 0xe1, 0xb9, 0xc3, 0xda, 0x4a, 0x31, 0x49, 0x9d, 0x0d, 0x8a, 0xd6, 0xab, 0x7b,
+	0x2a, 0x52, 0xdd, 0xd9, 0xa9, 0x70, 0x61, 0x4e, 0xac, 0x11, 0x9f, 0x96, 0xe6, 0x63, 0x21, 0x03,
+	0x1f, 0x40, 0x35, 0xe8, 0xf1, 0x94, 0x9f, 0x2e, 0x81, 0x84, 0xf5, 0xe5, 0xb5, 0xd8, 0x04, 0xcf,
+	0x09, 0x81, 0x32, 0xae, 0x00, 0xea, 0x7a, 0x7d, 0xa1, 0x74, 0x73, 0xbc, 0x25, 0x8c, 0x32, 0x23,
+	0x6a, 0xa6, 0x63, 0x9e, 0xc3, 0xf2, 0x0a, 0x23, 0x03, 0x58, 0xe6, 0x78, 0x84, 0xc7, 0x80, 0xe1,
+	0xf4, 0xd1, 0xc4, 0x3c, 0xe3, 0xdd, 0x76, 0x99, 0x84, 0x0c, 0xb6, 0x3a, 0xdb, 0x8e, 0x0f, 0xe6,
+	0xf8, 0x60, 0x40, 0xb3, 0xb6, 0xc9, 0x17, 0xa7, 0xb9, 0x7d, 0x5a, 0xcf, 0x47, 0x1c, 0x1e, 0xf1,
+	0x2a, 0x09, 0xc5, 0xf0, 0x11, 0x94, 0xf8, 0xcb, 0xc8, 0x35, 0x40, 0xe6, 0x8e, 0xb6, 0x09, 0x0f,
+	0x7b, 0x0e, 0x50, 0x99, 0x04, 0x34, 0xfe, 0x53, 0x12, 0xca, 0xda, 0x42, 0x37, 0x01, 0xff, 0x03,
+	0x00, 0x33, 0x78, 0x9c, 0x51, 0xd9, 0x15, 0x72, 0x58, 0x7e, 0x72, 0x4a, 0x62, 0x26, 0x40, 0xd7,
+	0x59, 0x0a, 0x14, 0x1d, 0x72, 0x45, 0xaf, 0x3a, 0x2d, 0x73, 0x95, 0xd3, 0xb2, 0x31, 0xb3, 0x23,
+	0x0e, 0xc9, 0xc5, 0x1d, 0xf2, 0x36, 0xa0, 0xff, 0xce, 0x80, 0xaa, 0xea, 0xa6, 0xaf, 0x85, 0xfc,
+	0x36, 0x64, 0x7d, 0x5b, 0x2b, 0x3e, 0x92, 0x62, 0xd0, 0xf9, 0x36, 0x83, 0x5d, 0xab, 0x3a, 0x1a,
+	0x27, 0x56, 0xb8, 0xd2, 0x2b, 0x85, 0x2b, 0x2c, 0x49, 0x99, 0x48, 0x49, 0xfa, 0x18, 0x8a, 0x43,
+	0xde, 0x1d, 0x8a, 0x86, 0xf4, 0xb2, 0x66, 0xe6, 0xd7, 0x29, 0x40, 0xd1, 0x4b, 0x0e, 0x77, 0xea,
+	0xff, 0x53, 0xef, 0xaa, 0x28, 0x40, 0xf7, 0x23, 0x20, 0xd7, 0x0b, 0x91, 0xd7, 0x12, 0x6d, 0x84,
+	0x44, 0x7c, 0xb1, 0x0b, 0x45, 0xae, 0x92, 0xec, 0x12, 0x40, 0x64, 0x83, 0xc6, 0xc2, 0xff, 0x32,
+	0xe0, 0x56, 0xec, 0xae, 0x76, 0x33, 0x97, 0xe8, 0x30, 0x26, 0x63, 0x30, 0xde, 0xf0, 0x48, 0x89,
+	0x1b, 0x99, 0x7e, 0x2b, 0x23, 0x33, 0xab, 0x46, 0xfe, 0xc3, 0x80, 0x5a, 0x2c, 0x85, 0x3c, 0x07,
+	0x7d, 0x09, 0x65, 0x5f, 0x8f, 0x45, 0x69, 0xea, 0x7b, 0x81, 0x2b, 0xe2, 0x71, 0x4a, 0xa2, 0xf2,
+	0xe8, 0x0b, 0x28, 0xf9, 0xa6, 0x7b, 0x46, 0xfd, 0x13, 0xfd, 0xb9, 0x6b, 0x27, 0x36, 0x5f, 0x43,
+	0x95, 0x44, 0xe4, 0xd9, 0x7c, 0xf1, 0xb4, 0x25, 0xe7, 0xa7, 0xae, 0x9e, 0xaf, 0xcb, 0xe3, 0x9f,
+	0x27, 0xa1, 0xf2, 0x40, 0x43, 0xc5, 0x8b, 0x77, 0x85, 0x46, 0xbc, 0x2b, 0x44, 0x77, 0xa1, 0xa2,
+	0x6c, 0x90, 0x32, 0xc2, 0x67, 0x31, 0x2e, 0x4b, 0x00, 0xb1, 0x95, 0x94, 0x12, 0x19, 0x14, 0xe1,
+	0xa1, 0xbb, 0x90, 0x66, 0x2b, 0x5f, 0xe2, 0x26, 0x3e, 0x8e, 0x0e, 0x56, 0x5e, 0x92, 0xd6, 0xc9,
+	0x86, 0x2f, 0x48, 0xe1, 0x9b, 0x60, 0x76, 0xa3, 0xb4, 0x7a, 0x13, 0xfc, 0x45, 0x12, 0xb6, 0x44,
+	0xfb, 0xcf, 0xaf, 0x8f, 0xfc, 0xf5, 0xf5, 0xb2, 0xda, 0xc8, 0xaf, 0x97, 0xb2, 0x56, 0xa8, 0x67,
+	0xf9, 0x80, 0x71, 0xcd, 0xc2, 0xf1, 0x01, 0x80, 0xe5, 0x11, 0xf5, 0x50, 0x9c, 0xe6, 0xf7, 0x6e,
+	0x8d, 0xc3, 0x9f, 0x2a, 0xc4, 0x35, 0x43, 0xc6, 0xa2, 0x22, 0xd1, 0xc7, 0x90, 0xf5, 0x7c, 0xd3,
+	0x9f, 0x7b, 0xdc, 0xb2, 0xf0, 0x87, 0x46, 0xd7, 0xf6, 0x69, 0x9f, 0x0f, 0x10, 0x29, 0xc0, 0x45,
+	0x45, 0xbb, 0x9b, 0xdb, 0x94, 0x80, 0xea, 0x85, 0xfb, 0x99, 0x82, 0xa0, 0xf9, 0xea, 0xd8, 0x12,
+	0x10, 0xec, 0x43, 0xda, 0x9a, 0x9d, 0xda, 0x32, 0xa2, 0xd5, 0xcb, 0x62, 0x0c, 0x28, 0xc2, 0x65,
+	0x98, 0xba, 0xfe, 0x42, 0x5c, 0xc7, 0xe5, 0x9b, 0x8b, 0x24, 0xf1, 0x3f, 0x0d, 0x75, 0xb7, 0xe2,
+	0xeb, 0x8e, 0xe8, 0xe2, 0xaa, 0xa3, 0xe7, 0x7f, 0x01, 0xef, 0x66, 0xf8, 0xb6, 0x23, 0xf0, 0x65,
+	0x02, 0xac, 0x6e, 0x43, 0x46, 0xc8, 0xe7, 0x38, 0x5b, 0x10, 0x4c, 0x97, 0x91, 0xe5, 0x52, 0xf1,
+	0xe7, 0x23, 0xcf, 0x47, 0x42, 0x06, 0xfe, 0x32, 0x12, 0x37, 0xbc, 0x1e, 0x7c, 0x07, 0x32, 0xcc,
+	0x10, 0xf5, 0xbc, 0xbb, 0x09, 0x35, 0x21, 0x84, 0xef, 0x42, 0x45, 0x8c, 0x10, 0x7a, 0xce, 0x8e,
+	0x47, 0xae, 0x06, 0xbb, 0x34, 0x06, 0x6f, 0x05, 0x9c, 0xc0, 0x04, 0xb6, 0x85, 0x5c, 0x6b, 0x66,
+	0xbe, 0x9a, 0x50, 0x79, 0xf3, 0x64, 0xb9, 0xba, 0xee, 0xb7, 0x11, 0x82, 0xb4, 0xe5, 0x9d, 0x3c,
+	0xe2, 0xd8, 0xe5, 0x09, 0xff, 0x46, 0x55, 0x48, 0x4d, 0xbd, 0x33, 0x09, 0x16, 0xfb, 0xc4, 0x5d,
+	0x78, 0x77, 0xdd, 0x9a, 0xcc, 0x88, 0x7b, 0x90, 0x71, 0xa9, 0xe7, 0x28, 0x23, 0xde, 0x8f, 0x18,
+	0x11, 0x57, 0x81, 0x08, 0x59, 0xdc, 0x05, 0x78, 0x6c, 0x0f, 0xcd, 0xc9, 0xb1, 0xb5, 0x18, 0x2c,
+	0x98, 0x0e, 0xe3, 0xd0, 0xb9, 0xfc, 0x9b, 0x41, 0x3f, 0xa6, 0xd6, 0xd9, 0x58, 0x14, 0xb9, 0x14,
+	0x91, 0x14, 0xb3, 0xd9, 0x0a, 0x5e, 0x72, 0x52, 0x44, 0x10, 0xac, 0x65, 0x29, 0xf1, 0xb5, 0xc4,
+	0x3b, 0xca, 0xb9, 0x1e, 0x63, 0x46, 0x24, 0xc6, 0x82, 0xcd, 0x92, 0x6b, 0x37, 0x4b, 0xad, 0xdf,
+	0x2c, 0xad, 0x6d, 0x16, 0x7a, 0x3f, 0xb3, 0xd1, 0xfb, 0xd9, 0xb8, 0xf7, 0xef, 0x43, 0x59, 0xd3,
+	0xcf, 0x73, 0xd0, 0x87, 0x90, 0xf2, 0x17, 0x0a, 0x34, 0x95, 0x6b, 0x21, 0x26, 0x84, 0x8d, 0xe2,
+	0x63, 0xa8, 0x49, 0xec, 0x98, 0xc3, 0x09, 0xf5, 0xe6, 0x93, 0xff, 0xc6, 0x8b, 0x1d, 0xb8, 0x45,
+	0xe8, 0xf9, 0x4a, 0x58, 0x1c, 0x42, 0xce, 0xe5, 0x4b, 0x2b, 0x75, 0xea, 0xda, 0x45, 0x36, 0xb2,
+	0x37, 0x51, 0x82, 0xfb, 0x3f, 0x05, 0x08, 0x7f, 0x8a, 0xa2, 0x22, 0xe4, 0x9a, 0xad, 0xde, 0x49,
+	0xbf, 0x33, 0xa8, 0x26, 0x50, 0x09, 0xf2, 0xcf, 0x3a, 0x83, 0x76, 0x93, 0x34, 0x9e, 0x55, 0x0d,
+	0x54, 0x83, 0xf2, 0x80, 0x34, 0xba, 0xfd, 0xa3, 0x16, 0xe9, 0x74, 0x7b, 0x4f, 0x06, 0xd5, 0x24,
+	0x42, 0x50, 0x51, 0xac, 0x93, 0x27, 0x03, 0xc6, 0x4b, 0xa1, 0x32, 0x14, 0x1a, 0x4f, 0x06, 0xed,
+	0x13, 0xd2, 0x79, 0xd9, 0xaa, 0xa6, 0xf7, 0x1b, 0x1c, 0xae, 0xf0, 0xb7, 0x22, 0x1b, 0x0f, 0xfe,
+	0x05, 0x56, 0x13, 0xa8, 0x02, 0x10, 0xfe, 0x31, 0x15, 0xbb, 0xf4, 0xf4, 0x27, 0x91, 0x6a, 0x72,
+	0xff, 0x43, 0x1e, 0x11, 0xc1, 0x8f, 0x0d, 0x94, 0x83, 0x54, 0x63, 0x34, 0xaa, 0x26, 0x10, 0x40,
+	0xb6, 0x49, 0x27, 0xd4, 0xa7, 0x55, 0x63, 0xff, 0x73, 0x80, 0xb0, 0x14, 0xa2, 0x02, 0x64, 0x9e,
+	0x74, 0x9b, 0xad, 0xa3, 0x6a, 0x82, 0x7d, 0x3e, 0x6d, 0x3c, 0xee, 0x34, 0xab, 0x06, 0x93, 0x3f,
+	0x22, 0x27, 0x2f, 0x5b, 0xdd, 0x6a, 0x12, 0xe5, 0x21, 0xfd, 0xa4, 0xdf, 0x6a, 0x56, 0x53, 0xfb,
+	0x3f, 0x84, 0x77, 0x8e, 0xad, 0x85, 0x4a, 0x48, 0x6f, 0x68, 0xce, 0xe4, 0x22, 0x79, 0x48, 0x77,
+	0x9a, 0x8f, 0x5b, 0x02, 0x88, 0xfe, 0x83, 0x46, 0xb7, 0xdb, 0xe9, 0x3e, 0xac, 0x1a, 0x8c, 0x3a,
+	0xea, 0x74, 0x3b, 0xfd, 0x76, 0xab, 0x59, 0x4d, 0x1e, 0xfe, 0xd9, 0x00, 0x98, 0x5a, 0x0b, 0xf5,
+	0x7c, 0x74, 0x1f, 0xb6, 0x1e, 0xc6, 0xd6, 0x51, 0xef, 0x03, 0x84, 0x9e, 0x77, 0xad, 0xc9, 0x4e,
+	0x35, 0x24, 0xfb, 0xbe, 0x6b, 0xcd, 0xce, 0x70, 0x02, 0x7d, 0x0a, 0x45, 0x31, 0x85, 0xd9, 0x70,
+	0xad, 0x19, 0x5f, 0x40, 0x39, 0xe2, 0x7e, 0xb4, 0x15, 0x0a, 0xf1, 0x9a, 0xb2, 0xb3, 0x13, 0x32,
+	0xe2, 0x81, 0x82, 0x13, 0xaf, 0xb2, 0xfc, 0xa7, 0xf9, 0xbd, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff,
+	0xa5, 0x75, 0x24, 0x52, 0x69, 0x1f, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.

plugin/dapp/mix/types/type.go

@@ -70,8 +70,9 @@ func (p *MixType) GetLogMap() map[int64]*types.LogInfo {
 	return map[int64]*types.LogInfo{
 		TyLogMixConfigVk:             {Ty: reflect.TypeOf(ZkVerifyKeys{}), Name: "LogMixConfigVk"},
 		TyLogMixConfigAuth:           {Ty: reflect.TypeOf(AuthPubKeys{}), Name: "LogMixConfigAuthPubKey"},
-		TyLogCurrentCommitTreeLeaves: {Ty: reflect.TypeOf(CommitTreeLeaves{}), Name: "TyLogCommitTreeLeaves"},
-		TyLogCurrentCommitTreeRoots:  {Ty: reflect.TypeOf(CommitTreeRoots{}), Name: "TyLogCommitTreeRoots"},
+		TyLogCurrentCommitTreeLeaves: {Ty: reflect.TypeOf(CommitTreeLeaves{}), Name: "LogCommitTreeLeaves"},
+		TyLogCurrentCommitTreeRoots:  {Ty: reflect.TypeOf(CommitTreeRoots{}), Name: "LogCommitTreeRoots"},
+		TyLogMixConfigPaymentKey:     {Ty: reflect.TypeOf(PaymentKey{}), Name: "LogConfigReceivingKey"},
 	}
 }
 

plugin/dapp/mix/wallet/mixbizdb.go

@@ -5,6 +5,8 @@
 package wallet
 
 import (
+	"encoding/hex"
+
 	"github.com/33cn/chain33/common"
 
 	commondb "github.com/33cn/chain33/common/db"
@@ -15,6 +17,9 @@ import (
 	"github.com/pkg/errors"
 )
 
+//空的公钥字符为“0”，不是空，这里多设置了长度
+const LENNULLKEY = 10
+
 func (p *mixPolicy) execAutoLocalMix(tx *types.Transaction, receiptData *types.ReceiptData, index int, height int64) (*types.LocalDBSet, error) {
 	set, err := p.execLocalMix(tx, receiptData, height, int64(index))
 	if err != nil {
@@ -86,40 +91,43 @@ func (p *mixPolicy) processMixTx(tx *types.Transaction, height, index int64) (*t
 }
 
 func (p *mixPolicy) processDeposit(deposit *mixTy.MixDepositAction, heightIndex string, table *table.Table) {
-	for _, m := range deposit.NewCommits {
-		data, err := mixTy.DecodePubInput(mixTy.VerifyType_DEPOSIT, m.PublicInput)
-		if err != nil {
-			bizlog.Error("processDeposit decode", "pubInput", m.PublicInput)
-			continue
-		}
-		input := data.(*mixTy.DepositPublicInput)
-		p.processSecretGroup(input.NoteHash, m.Group, heightIndex, table)
-
+	data, err := mixTy.DecodePubInput(mixTy.VerifyType_DEPOSIT, deposit.Proof.PublicInput)
+	if err != nil {
+		bizlog.Error("processDeposit decode", "pubInput", deposit.Proof.PublicInput)
+		return
 	}
+	input := data.(*mixTy.DepositPublicInput)
+	p.processSecretGroup(input.NoteHash, deposit.Proof.Secrets, heightIndex, table)
 }
 
 func (p *mixPolicy) processTransfer(transfer *mixTy.MixTransferAction, heightIndex string, table *table.Table) {
 	var nulls []string
-	for _, m := range transfer.Input {
-		data, err := mixTy.DecodePubInput(mixTy.VerifyType_TRANSFERINPUT, m.PublicInput)
-		if err != nil {
-			bizlog.Error("processTransfer.input decode", "pubInput", m.PublicInput)
-			continue
-		}
-		input := data.(*mixTy.TransferInputPublicInput)
-		nulls = append(nulls, input.NullifierHash)
+	data, err := mixTy.DecodePubInput(mixTy.VerifyType_TRANSFERINPUT, transfer.Input.PublicInput)
+	if err != nil {
+		bizlog.Error("processTransfer.input decode", "pubInput", transfer.Input.PublicInput)
+		return
 	}
+	input := data.(*mixTy.TransferInputPublicInput)
+	nulls = append(nulls, input.NullifierHash)
 	p.processNullifiers(nulls, table)
 
-	for _, m := range transfer.Output {
-		data, err := mixTy.DecodePubInput(mixTy.VerifyType_TRANSFEROUTPUT, m.PublicInput)
-		if err != nil {
-			bizlog.Error("processTransfer.output decode", "pubInput", m.PublicInput)
-			continue
-		}
-		input := data.(*mixTy.TransferOutputPublicInput)
-		p.processSecretGroup(input.NoteHash, input.DhSecrets, heightIndex, table)
+	//out
+	data, err = mixTy.DecodePubInput(mixTy.VerifyType_TRANSFEROUTPUT, transfer.Output.PublicInput)
+	if err != nil {
+		bizlog.Error("processTransfer.output decode", "pubInput", transfer.Output.PublicInput)
+		return
+	}
+	outInput := data.(*mixTy.TransferOutputPublicInput)
+	p.processSecretGroup(outInput.NoteHash, outInput.DhSecrets, heightIndex, table)
+
+	//change
+	data, err = mixTy.DecodePubInput(mixTy.VerifyType_TRANSFEROUTPUT, transfer.Change.PublicInput)
+	if err != nil {
+		bizlog.Error("processTransfer.output decode", "pubInput", transfer.Change.PublicInput)
+		return
 	}
+	changeInput := data.(*mixTy.TransferOutputPublicInput)
+	p.processSecretGroup(changeInput.NoteHash, changeInput.DhSecrets, heightIndex, table)
 
 }
 
@@ -158,7 +166,7 @@ func updateNullifier(ldb *table.Table, nullifier string) error {
 		return nil
 
 	}
-	u.Info.Status = mixTy.NoteStatus_INVALID
+	u.Info.Status = mixTy.NoteStatus_USED
 	return ldb.Update([]byte(u.TxIndex), u)
 }
 
@@ -222,16 +230,16 @@ func (e *mixPolicy) listMixInfos(req *mixTy.WalletMixIndexReq) (types.Message, e
 	if len(rows) == 0 {
 		return nil, types.ErrNotFound
 	}
-	var rep mixTy.WalletIndexResp
+	var resp mixTy.WalletIndexResp
 	for _, row := range rows {
 		r, ok := row.Data.(*mixTy.WalletDbMixInfo)
 		if !ok {
 			bizlog.Error("listMixInfos", "err", "bad row type")
 			return nil, types.ErrDecode
 		}
-		rep.Datas = append(rep.Datas, r.Info)
+		resp.Notes = append(resp.Notes, r.Info)
 	}
-	return &rep, nil
+	return &resp, nil
 }
 
 func (e *mixPolicy) execAutoDelLocal(tx *types.Transaction) (*types.LocalDBSet, error) {
@@ -268,34 +276,46 @@ func (p *mixPolicy) processSecretGroup(noteHash string, secretGroup *mixTy.DHSec
 	}
 
 	//可能自己账户里面既有spender,也有returner 或authorize,都要解一遍
-	info, err := p.decodeSecret(noteHash, secretGroup.Payment, privacyKeys)
-	if err != nil {
-		bizlog.Error("processSecretGroup.spender", "err", err)
-	}
-	if info != nil {
-		p.addTable(info, heightIndex, table)
+	if len(secretGroup.Payment) > 0 {
+		info, err := p.decodeSecret(noteHash, secretGroup.Payment, privacyKeys)
+		if err != nil {
+			bizlog.Error("processSecretGroup.spender", "err", err)
+		}
+		if info != nil {
+			p.addTable(info, heightIndex, table)
+		}
 	}
 
-	info, err = p.decodeSecret(noteHash, secretGroup.Returner, privacyKeys)
-	if err != nil {
-		bizlog.Error("processSecretGroup.Returner", "err", err)
-	}
-	if info != nil {
-		p.addTable(info, heightIndex, table)
+	if len(secretGroup.Returner) > 0 {
+		info, err := p.decodeSecret(noteHash, secretGroup.Returner, privacyKeys)
+		if err != nil {
+			bizlog.Error("processSecretGroup.Returner", "err", err)
+		}
+		if info != nil {
+			p.addTable(info, heightIndex, table)
+		}
 	}
 
-	info, err = p.decodeSecret(noteHash, secretGroup.Authorize, privacyKeys)
-	if err != nil {
-		bizlog.Error("processSecretGroup.Authorize", "err", err)
-	}
-	if info != nil {
-		p.addTable(info, heightIndex, table)
+	if len(secretGroup.Authorize) > 0 {
+		info, err := p.decodeSecret(noteHash, secretGroup.Authorize, privacyKeys)
+		if err != nil {
+			bizlog.Error("processSecretGroup.Authorize", "err", err)
+		}
+		if info != nil {
+			p.addTable(info, heightIndex, table)
+		}
 	}
 }
 
-func (p *mixPolicy) decodeSecret(noteHash string, dhSecret *mixTy.DHSecret, privacyKeys []*mixTy.WalletAddrPrivacy) (*mixTy.WalletIndexInfo, error) {
-	if dhSecret == nil {
-		return nil, errors.Wrapf(types.ErrEmpty, "secret nil for notehash=%s", noteHash)
+func (p *mixPolicy) decodeSecret(noteHash string, secretData string, privacyKeys []*mixTy.WalletAddrPrivacy) (*mixTy.WalletIndexInfo, error) {
+	var dhSecret mixTy.DHSecret
+	data, err := hex.DecodeString(secretData)
+	if err != nil {
+		return nil, errors.Wrapf(err, "decode secret str=%s", secretData)
+	}
+	err = types.Decode(data, &dhSecret)
+	if err != nil {
+		return nil, errors.Wrapf(err, "decode secret data=%s", secretData)
 	}
 
 	tempPubKey := &mixTy.PubKey{X: dhSecret.Epk.X, Y: dhSecret.Epk.Y}
@@ -307,8 +327,10 @@ func (p *mixPolicy) decodeSecret(noteHash string, dhSecret *mixTy.DHSecret, priv
 		}
 		decryptData, err := decryptData(key.Privacy.ShareSecretKey.PrivKey, tempPubKey, cryptData)
 		if err != nil {
-			return nil, errors.Wrapf(err, "decrypt for notehash=%s,crypt=%s", noteHash, dhSecret.Secret)
+			bizlog.Info("processSecret.decryptData", "decrypt for notehash", noteHash, "secret", secretData, "addr", key.Addr, "err", err)
+			continue
 		}
+		bizlog.Info("processSecret.decryptData OK", "decrypt for notehash", noteHash, "addr", key.Addr)
 		var rawData mixTy.SecretData
 		err = types.Decode(decryptData, &rawData)
 		if err != nil {
@@ -323,16 +345,20 @@ func (p *mixPolicy) decodeSecret(noteHash string, dhSecret *mixTy.DHSecret, priv
 			info.NoteHash = noteHash
 			info.Nullifier = getFrString(mimcHashString([]string{rawData.NoteRandom}))
 			//如果自己是spender,则记录有关spenderAuthHash,如果是returner，则记录returnerAuthHash
-			//如果授权为spenderAuthHash，则spender更新本地为OPEN，returner侧仍为FROZEN，花费后，两端都变为USED
-			//如果授权为returnerAuthHash，则returner更新本地为OPEN，spender侧仍为FROZEN，
-			if rawData.PaymentPubKey == key.Privacy.PaymentKey.PayKey {
-				info.AuthSpendHash = getFrString(mimcHashString([]string{rawData.PaymentPubKey, rawData.Amount, rawData.NoteRandom}))
-			} else if rawData.ReturnPubKey == key.Privacy.PaymentKey.PayKey {
-				info.IsReturner = true
-				info.AuthSpendHash = getFrString(mimcHashString([]string{rawData.ReturnPubKey, rawData.Amount, rawData.NoteRandom}))
+			//如果授权为spenderAuthHash，则根据授权hash索引到本地数据库，spender更新本地为VALID，returner侧不变仍为FROZEN，花费后，两端都变为USED
+			//如果授权为returnerAuthHash，则returner更新本地为VALID，spender侧仍为FROZEN，
+			if len(rawData.AuthorizePubKey) > LENNULLKEY {
+				if rawData.PaymentPubKey == key.Privacy.PaymentKey.PayKey {
+					info.AuthSpendHash = getFrString(mimcHashString([]string{rawData.PaymentPubKey, rawData.Amount, rawData.NoteRandom}))
+				} else if rawData.ReturnPubKey == key.Privacy.PaymentKey.PayKey {
+					info.IsReturner = true
+					info.AuthSpendHash = getFrString(mimcHashString([]string{rawData.ReturnPubKey, rawData.Amount, rawData.NoteRandom}))
+				}
 			}
+
 			info.Status = mixTy.NoteStatus_VALID
-			if len(rawData.AuthorizePubKey) > 0 {
+			//空的公钥为"0"字符，不是空字符
+			if len(rawData.AuthorizePubKey) > LENNULLKEY {
 				info.Status = mixTy.NoteStatus_FROZEN
 			}
 			//账户地址

plugin/dapp/mix/wallet/mixsignature.go

@@ -43,7 +43,7 @@ func (r *MixSignature) Bytes() []byte {
 
 // IsZero check is zero
 func (r *MixSignature) IsZero() bool {
-	return len(r.sign.Output) == 0 || len(r.sign.Input) == 0
+	return r.sign.Output == nil || r.sign.Input == nil
 }
 
 // String convert to string

plugin/dapp/mix/wallet/proof.go

@@ -5,6 +5,7 @@
 package wallet
 
 import (
+	"encoding/hex"
 	"math/big"
 	"strconv"
 
@@ -104,28 +105,33 @@ func (policy *mixPolicy) depositProof(req *mixTy.DepositProofReq) (*mixTy.Deposi
 	fr.SetRandom()
 	secret.NoteRandom = fr.String()
 
-	// 获取addr对应的paymentKey
-	toKey, errr := policy.getPaymentKey(req.PaymentAddr)
-	if errr != nil {
-		return nil, errors.Wrapf(errr, "get payment key for addr = %s", req.PaymentAddr)
+	// 获取receiving addr对应的paymentKey
+	toKey, e := policy.getPaymentKey(req.PaymentAddr)
+	if e != nil {
+		return nil, errors.Wrapf(e, "get payment key for addr = %s", req.PaymentAddr)
 	}
 	secret.PaymentPubKey = toKey.PayingKey
 
+	//获取return addr对应的key
 	var returnKey *mixTy.PaymentKey
 	var err error
+	//如果Input不填，缺省空为“0”字符串
+	secret.ReturnPubKey = "0"
 	if len(req.ReturnAddr) > 0 {
-		returnKey, err = policy.getPaymentKey(req.PaymentAddr)
+		returnKey, err = policy.getPaymentKey(req.ReturnAddr)
 		if err != nil {
-			return nil, errors.Wrapf(err, "get payment key for addr = %s", req.PaymentAddr)
+			return nil, errors.Wrapf(err, "get payment key for return addr = %s", req.ReturnAddr)
 		}
 		secret.ReturnPubKey = returnKey.PayingKey
 	}
 
+	//获取auth addr对应的key
 	var authKey *mixTy.PaymentKey
-	if len(req.ReturnAddr) > 0 {
-		authKey, err = policy.getPaymentKey(req.PaymentAddr)
+	secret.AuthorizePubKey = "0"
+	if len(req.AuthorizeAddr) > 0 {
+		authKey, err = policy.getPaymentKey(req.AuthorizeAddr)
 		if err != nil {
-			return nil, errors.Wrapf(err, "get payment key for addr = %s", req.PaymentAddr)
+			return nil, errors.Wrapf(err, "get payment key for authorize addr = %s", req.AuthorizeAddr)
 		}
 		secret.AuthorizePubKey = authKey.PayingKey
 	}
@@ -133,12 +139,13 @@ func (policy *mixPolicy) depositProof(req *mixTy.DepositProofReq) (*mixTy.Deposi
 	//DH加密
 	data := types.Encode(&secret)
 	var group mixTy.DHSecretGroup
-	group.Payment = encryptData(toKey.ReceivingKey, data)
+
+	group.Payment = hex.EncodeToString(types.Encode(encryptData(toKey.ReceivingKey, data)))
 	if returnKey != nil {
-		group.Returner = encryptData(returnKey.ReceivingKey, data)
+		group.Returner = hex.EncodeToString(types.Encode(encryptData(returnKey.ReceivingKey, data)))
 	}
 	if authKey != nil {
-		group.Authorize = encryptData(authKey.ReceivingKey, data)
+		group.Authorize = hex.EncodeToString(types.Encode(encryptData(authKey.ReceivingKey, data)))
 	}
 
 	var resp mixTy.DepositProofResp
@@ -180,8 +187,12 @@ func (policy *mixPolicy) getNoteInfo(noteHash string, noteStatus mixTy.NoteStatu
 	if err != nil {
 		return nil, errors.Wrapf(err, "list table fail noteHash=%s", noteHash)
 	}
+	resp := msg.(*mixTy.WalletIndexResp)
+	if len(resp.Notes) < 1 {
+		return nil, errors.Wrapf(err, "list table lens=0 for noteHash=%s", noteHash)
+	}
 
-	note := msg.(*mixTy.WalletIndexResp).Datas[0]
+	note := msg.(*mixTy.WalletIndexResp).Notes[0]
 	if note.Status != noteStatus {
 		return nil, errors.Wrapf(types.ErrNotAllow, "note status=%s", note.Status.String())
 	}
@@ -324,18 +335,19 @@ func getCommitValue(noteAmount, transferAmount, minTxFee uint64) (*mixTy.CommitV
 		return nil, errors.Wrapf(types.ErrInvalidParam, "amount sum fail for mul G point")
 	}
 
+	//三个混淆随机值可以随机获取，这里noteRandom和为了Nullifier计算的NoteRandom不同。
 	//获取随机值，截取一半给change和transfer,和值给Note,直接用完整的random值会溢出
-	var changeRandom, transRandom, v fr_bn256.Element
+	var changeRdm, transRdm, v fr_bn256.Element
 	random := v.SetRandom().String()
-	changeRandom.SetString(random[0 : len(random)/2])
-	transRandom.SetString(random[len(random)/2:])
+	changeRdm.SetString(random[0 : len(random)/2])
+	transRdm.SetString(random[len(random)/2:])
 
-	var noteRandom fr_bn256.Element
-	noteRandom.Add(&changeRandom, &transRandom)
+	var noteRdm fr_bn256.Element
+	noteRdm.Add(&changeRdm, &transRdm)
 
-	noteH := mixTy.MulCurvePointH(noteRandom.String())
-	transferH := mixTy.MulCurvePointH(transRandom.String())
-	changeH := mixTy.MulCurvePointH(changeRandom.String())
+	noteH := mixTy.MulCurvePointH(noteRdm.String())
+	transferH := mixTy.MulCurvePointH(transRdm.String())
+	changeH := mixTy.MulCurvePointH(changeRdm.String())
 	//fmt.Println("change",changeRandom.String())
 	//fmt.Println("transfer",transRandom.String())
 	//fmt.Println("note",noteRandom.String())
@@ -353,9 +365,9 @@ func getCommitValue(noteAmount, transferAmount, minTxFee uint64) (*mixTy.CommitV
 	}
 
 	rst := &mixTy.CommitValueRst{
-		NoteRandom:     noteRandom.String(),
-		TransferRandom: transRandom.String(),
-		ChangeRandom:   changeRandom.String(),
+		NoteRandom:     noteRdm.String(),
+		TransferRandom: transRdm.String(),
+		ChangeRandom:   changeRdm.String(),
 		Note:           &mixTy.CommitValue{X: noteAmountG.X.String(), Y: noteAmountG.Y.String()},
 		Transfer:       &mixTy.CommitValue{X: transAmountG.X.String(), Y: transAmountG.Y.String()},
 		Change:         &mixTy.CommitValue{X: changeAmountG.X.String(), Y: changeAmountG.Y.String()},
@@ -369,6 +381,7 @@ func (policy *mixPolicy) transferProof(req *mixTy.TransferProofReq) (*mixTy.Tran
 		return nil, err
 	}
 	inputPart, err := policy.getTransferInputPart(note)
+	bizlog.Info("transferProof get notes succ", "notehash", req.NoteHash)
 
 	noteAmount, err := strconv.ParseUint(note.Secret.Amount, 10, 64)
 	if err != nil {
@@ -388,6 +401,7 @@ func (policy *mixPolicy) transferProof(req *mixTy.TransferProofReq) (*mixTy.Tran
 	if err != nil {
 		return nil, errors.Wrapf(err, "deposit toAddr")
 	}
+	bizlog.Info("transferProof deposit to receiver succ", "notehash", req.NoteHash)
 
 	//output 找零 part,如果找零为0也需要设置，否则只有一个输入一个输出，H部分的随机数要相等，就能推测出转账值来
 	//在transfer output 部分特殊处理，如果amount是0的值则不加进tree
@@ -399,12 +413,13 @@ func (policy *mixPolicy) transferProof(req *mixTy.TransferProofReq) (*mixTy.Tran
 	if err != nil {
 		return nil, errors.Wrapf(err, "deposit toAddr")
 	}
+	bizlog.Info("transferProof deposit to change succ", "notehash", req.NoteHash)
 
 	commitValue, err := getCommitValue(noteAmount, req.Amount, minTxFee)
 	if err != nil {
 		return nil, err
 	}
-
+	bizlog.Info("transferProof get commit value succ", "notehash", req.NoteHash)
 	//noteCommitX, transferX, changeX
 	inputPart.CommitValue = commitValue.Note
 	inputPart.SpendRandom = commitValue.NoteRandom

plugin/dapp/mix/wallet/proof_test.go

 package wallet
 
 import (
+	"encoding/hex"
+	"fmt"
 	"testing"
 
+	"github.com/33cn/chain33/types"
+	mixTy "github.com/33cn/plugin/plugin/dapp/mix/types"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -35,4 +39,15 @@ func TestGetCommitValue(t *testing.T) {
 	minFee = 1
 	_, err = getCommitValue(note, transfer, minFee)
 	assert.Nil(t, err)
+
+	a := "0a9c010a4d3136323433323838333039363632323833373538343930323239313730303834393836343035373630373234353332323934333436353837323033353436363930353333373131303333323139124b3238383637383239373931373237373235343930333236303134303538313534363138303135353433383231393339363836333632313634323236303434353739313434393237383237331a82033078656663333331616261616139653039353966636536356163343364626534306364646139356534356261636163613161326166626265366637323533633132326233346264323337353932343066306237623836653363343635666131343065666332636665623861653035366234323163303665353062396532646564636236383963336536656435363636373731343235663736313931653831356665666633646432393965633535386261323731343238333131623130353364376265633864646163313733393632326238666138326438373336666531623332633835376438343330643634646637336530643265326238373932396335633762366437336534383365363130303561313361376531643730636637653834656132613235343166373235363834656266613737653235313232326466313039336230313964646165623963376134393763316538653737386462313730323636323536666666363332643437363738626633366634383361373334346666326330"
+	da, err := hex.DecodeString(a)
+	assert.Nil(t, err)
+
+	var data mixTy.DHSecret
+
+	err = types.Decode(da, &data)
+	assert.Nil(t, err)
+	fmt.Println("data", data)
+
 }