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/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)
+
 }