add unfrozen status

plugin/dapp/mix/mix.md

+# mix 执行器 零知识证明隐私
+
+## 场景
+ 1. 存款，公转私，支持一次存入多个目标账户，目标账户隐藏，转账金额公开(需要验证金额足够)
+ 1. 转账，私对私，花费某个支票，转账给目标账户，多出部分找零给自己，目标账户和金额全隐藏
+ 1. 提款，私对公，花费某些支票，统一转出给签名地址，转账金额公开(验证)，签名地址和支票账户不一定对应，也就是任何知道支票密码的人都可以提款
+

plugin/dapp/mix/proto/mix.proto

@@ -397,22 +397,19 @@ message PaymentKeysReq{
 
 enum NoteStatus{
 	UNDEF   = 0;
-	VALID   = 1;   //已授权可使用
-	FROZEN  = 2; //未授权
-	USED    = 3;   //已使用
+	VALID   = 1;   //已授权可使用 相对消费者
+	USED    = 2;    //已使用
+	FROZEN  = 3;   //未授权
+	UNFROZEN  = 4;  //已授权 相对授权者
 }
 
-enum Role{
-    SPENDER     = 0;
-    RETURNER    = 1;
-    AUTHORIZER  = 2;
-}
 
-message WalletIndexInfo {
+
+message WalletNoteInfo {
     string             noteHash             = 1;
     string             nullifier            = 2;
     string             authorizeSpendHash   = 3;
-    Role               role                 = 4;
+    string             authorizeHash        = 4;
     string             account              = 5; //账户地址
     NoteStatus         status               = 6;
     SecretData         secret               = 7;
@@ -420,7 +417,7 @@ message WalletIndexInfo {
 }
 
 message WalletDbMixInfo {
-    WalletIndexInfo      info   = 1;
+    WalletNoteInfo       info   = 1;
     string               txIndex = 2;
 }
 
@@ -429,19 +426,17 @@ message WalletMixIndexReq {
     string             noteHash       = 1;
     string             nullifier       = 2;
     string             authorizeSpendHash   = 3;
+    string             authorizeHash        = 4;
     string             account       = 5;
     int32              status     = 6;
     int32              count      = 7;
     int32              direction  = 8;
 }
 
-message WalletIndexResp {
-    repeated WalletIndexInfo notes = 1;
+message WalletNoteResp {
+    repeated WalletNoteInfo notes = 1;
 }
 
-message WalletReqAddrs{
-    repeated string addrs = 1;
-}
 
 message WalletEnablePrivacyRst{
     string  addr = 1;

plugin/dapp/mix/rpc/rpc.go

@@ -65,13 +65,13 @@ func (c *Jrpc) ShowAccountPrivacyInfo(in *types.ReqString, result *json.RawMessa
 /////////////////privacy///////////////
 
 // ShowPrivacyAccountSpend display spend privacy account for json rpc
-func (c *Jrpc) ShowAccountNoteInfo(in *types.ReqAddrs, result *json.RawMessage) error {
-	if 0 == len(in.Addrs) {
+func (c *Jrpc) ShowAccountNoteInfo(in *mixTy.WalletMixIndexReq, result *json.RawMessage) error {
+	if in == nil {
 		return types.ErrInvalidParam
 	}
 	reply, err := c.cli.ExecWalletFunc(mixTy.MixX, "ShowAccountNoteInfo", in)
 	if err != nil {
-		log.Info("ShowPrivacyAccountSpend", "return err info", err)
+		log.Error("ShowAccountNoteInfo", "return err info", err)
 		return err
 	}
 	*result, err = types.PBToJSON(reply)
@@ -134,43 +134,6 @@ func (c *Jrpc) DecryptSecretData(in *mixTy.DecryptSecretData, result *json.RawMe
 	return err
 }
 
-//
-//func (c *Jrpc) DepositProof(in *mixTy.DepositTxReq, result *json.RawMessage) error {
-//	reply, err := c.cli.ExecWalletFunc(mixTy.MixX, "DepositProof", in)
-//	if err != nil {
-//		return err
-//	}
-//	*result, err = types.PBToJSON(reply)
-//	return err
-//}
-//
-//func (c *Jrpc) AuthProof(in *mixTy.AuthTxReq, result *json.RawMessage) error {
-//	reply, err := c.cli.ExecWalletFunc(mixTy.MixX, "AuthProof", in)
-//	if err != nil {
-//		return err
-//	}
-//	*result, err = types.PBToJSON(reply)
-//	return err
-//}
-//
-//func (c *Jrpc) TransferProof(in *mixTy.TransferTxReq, result *json.RawMessage) error {
-//	reply, err := c.cli.ExecWalletFunc(mixTy.MixX, "TransferProof", in)
-//	if err != nil {
-//		return err
-//	}
-//	*result, err = types.PBToJSON(reply)
-//	return err
-//}
-//
-//func (c *Jrpc) WithdrawProof(in *mixTy.WithdrawTxReq, result *json.RawMessage) error {
-//	reply, err := c.cli.ExecWalletFunc(mixTy.MixX, "WithdrawProof", in)
-//	if err != nil {
-//		return err
-//	}
-//	*result, err = types.PBToJSON(reply)
-//	return err
-//}
-
 func (c *Jrpc) CreateRawTransaction(in *mixTy.CreateRawTxReq, result *interface{}) error {
 	reply, err := c.cli.ExecWalletFunc(mixTy.MixX, "CreateRawTransaction", in)
 	if err != nil {

plugin/dapp/mix/wallet/exec.go

@@ -11,7 +11,7 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (policy *mixPolicy) On_ShowAccountPrivacyInfo(req *mixTy.PaymentKeysReq) (types.Message, error) {
+func (p *mixPolicy) On_ShowAccountPrivacyInfo(req *mixTy.PaymentKeysReq) (types.Message, error) {
 	if len(req.Addr) == 0 && len(req.PrivKey) == 0 {
 		return nil, errors.Wrapf(types.ErrInvalidParam, "addr or privkey need be set")
 	}
@@ -32,7 +32,7 @@ func (policy *mixPolicy) On_ShowAccountPrivacyInfo(req *mixTy.PaymentKeysReq) (t
 	}
 
 	//通过account 从钱包获取
-	keys, err := policy.getAccountPrivacyKey(req.Addr)
+	keys, err := p.getAccountPrivacyKey(req.Addr)
 	if err != nil {
 		return nil, errors.Wrapf(err, "get account =%s privacy key", req.Addr)
 	}
@@ -43,56 +43,40 @@ func (policy *mixPolicy) On_ShowAccountPrivacyInfo(req *mixTy.PaymentKeysReq) (t
 	return keys, nil
 }
 
-func (policy *mixPolicy) On_ShowAccountNoteInfo(req *types.ReqAddrs) (types.Message, error) {
-	return policy.showAccountNoteInfo(req.Addrs)
+func (p *mixPolicy) On_ShowAccountNoteInfo(req *mixTy.WalletMixIndexReq) (types.Message, error) {
+	return p.showAccountNoteInfo(req)
 }
 
-func (policy *mixPolicy) On_GetRescanStatus(in *types.ReqNil) (types.Message, error) {
-	return &types.ReqString{Data: policy.getRescanStatus()}, nil
+func (p *mixPolicy) On_GetRescanStatus(in *types.ReqNil) (types.Message, error) {
+	return &types.ReqString{Data: p.getRescanStatus()}, nil
 
 }
 
 //重新扫描所有notes
-func (policy *mixPolicy) On_RescanNotes(in *types.ReqNil) (types.Message, error) {
-	err := policy.tryRescanNotes()
+func (p *mixPolicy) On_RescanNotes(in *types.ReqNil) (types.Message, error) {
+	err := p.tryRescanNotes()
 	if err != nil {
 		bizlog.Error("rescanUTXOs", "err", err.Error())
 	}
 	return &types.ReqString{Data: "ok"}, err
 }
 
-func (policy *mixPolicy) On_EnablePrivacy(req *types.ReqAddrs) (types.Message, error) {
-	return policy.enablePrivacy(req.Addrs)
+func (p *mixPolicy) On_EnablePrivacy(req *types.ReqAddrs) (types.Message, error) {
+	return p.enablePrivacy(req.Addrs)
 }
 
-//func (policy *mixPolicy) On_EncodeSecretData(req *mixTy.SecretData) (types.Message, error) {
+//func (p *mixPolicy) On_EncodeSecretData(req *mixTy.SecretData) (types.Message, error) {
 //	return encodeSecretData(req)
 //}
 
-func (policy *mixPolicy) On_EncryptSecretData(req *mixTy.EncryptSecretData) (types.Message, error) {
+func (p *mixPolicy) On_EncryptSecretData(req *mixTy.EncryptSecretData) (types.Message, error) {
 	return encryptSecretData(req)
 }
 
-func (policy *mixPolicy) On_DecryptSecretData(req *mixTy.DecryptSecretData) (types.Message, error) {
+func (p *mixPolicy) On_DecryptSecretData(req *mixTy.DecryptSecretData) (types.Message, error) {
 	return decryptSecretData(req)
 }
 
-//func (policy *mixPolicy) On_DepositProof(req *mixTy.CreateRawTxReq) (types.Message, error) {
-//	return policy.createDepositTx(req)
-//}
-//
-//func (policy *mixPolicy) On_WithdrawProof(req *mixTy.CreateRawTxReq) (types.Message, error) {
-//	return policy.createWithdrawTx(req)
-//}
-//
-//func (policy *mixPolicy) On_AuthProof(req *mixTy.CreateRawTxReq) (types.Message, error) {
-//	return policy.createAuthTx(req)
-//}
-//
-//func (policy *mixPolicy) On_TransferProof(req *mixTy.CreateRawTxReq) (types.Message, error) {
-//	return policy.createTransferTx(req)
-//}
-
-func (policy *mixPolicy) On_CreateRawTransaction(req *mixTy.CreateRawTxReq) (types.Message, error) {
-	return policy.createRawTx(req)
+func (p *mixPolicy) On_CreateRawTransaction(req *mixTy.CreateRawTxReq) (types.Message, error) {
+	return p.createRawTx(req)
 }

plugin/dapp/mix/wallet/mix.go

@@ -147,9 +147,9 @@ func mimcHashCalc(sum []byte) []byte {
 	return mimcbn256.Sum("seed", sum)
 }
 
-func (policy *mixPolicy) getPrivKeyByAddr(addr string) (crypto.PrivKey, error) {
+func (p *mixPolicy) getPrivKeyByAddr(addr string) (crypto.PrivKey, error) {
 	//获取指定地址在钱包里的账户信息
-	Accountstor, err := policy.store.GetAccountByAddr(addr)
+	Accountstor, err := p.store.GetAccountByAddr(addr)
 	if err != nil {
 		bizlog.Error("ProcSendToAddress", "GetAccountByAddr err:", err)
 		return nil, err
@@ -161,7 +161,7 @@ func (policy *mixPolicy) getPrivKeyByAddr(addr string) (crypto.PrivKey, error) {
 		bizlog.Error("ProcSendToAddress", "FromHex err", err)
 		return nil, err
 	}
-	operater := policy.getWalletOperate()
+	operater := p.getWalletOperate()
 	password := []byte(operater.GetPassword())
 	privkey := wcom.CBCDecrypterPrivkey(password, prikeybyte)
 	//通过privkey生成一个pubkey然后换算成对应的addr
@@ -178,30 +178,30 @@ func (policy *mixPolicy) getPrivKeyByAddr(addr string) (crypto.PrivKey, error) {
 	return priv, nil
 }
 
-func (policy *mixPolicy) getAccountPrivacyKey(addr string) (*mixTy.WalletAddrPrivacy, error) {
-	if data, _ := policy.store.getAccountPrivacy(addr); data != nil {
+func (p *mixPolicy) getAccountPrivacyKey(addr string) (*mixTy.WalletAddrPrivacy, error) {
+	if data, _ := p.store.getAccountPrivacy(addr); data != nil {
 		privacyInfo := &mixTy.AccountPrivacyKey{}
-		password := []byte(policy.getWalletOperate().GetPassword())
+		password := []byte(p.getWalletOperate().GetPassword())
 		decrypted, err := decryptDataWithPading(password, data)
 		if err != nil {
-			return policy.savePrivacyPair(addr)
+			return p.savePrivacyPair(addr)
 		}
 
 		//有可能修改了秘钥，如果解密失败，需要重新设置
 		err = types.Decode(decrypted, privacyInfo)
 		if err != nil {
-			return policy.savePrivacyPair(addr)
+			return p.savePrivacyPair(addr)
 		}
 
 		return &mixTy.WalletAddrPrivacy{Privacy: privacyInfo, Addr: addr}, nil
 	}
 
-	return policy.savePrivacyPair(addr)
+	return p.savePrivacyPair(addr)
 
 }
 
-func (policy *mixPolicy) savePrivacyPair(addr string) (*mixTy.WalletAddrPrivacy, error) {
-	priv, err := policy.getPrivKeyByAddr(addr)
+func (p *mixPolicy) savePrivacyPair(addr string) (*mixTy.WalletAddrPrivacy, error) {
+	priv, err := p.getPrivKeyByAddr(addr)
 	if err != nil {
 		return nil, errors.Wrapf(err, "savePrivacyPair addr=%s", addr)
 	}
@@ -209,17 +209,17 @@ func (policy *mixPolicy) savePrivacyPair(addr string) (*mixTy.WalletAddrPrivacy,
 	bizlog.Info("savePrivacyPair", "pri", common.ToHex(priv.Bytes()), "addr", addr)
 	newPrivacy := newPrivacyKey(priv.Bytes())
 
-	password := []byte(policy.getWalletOperate().GetPassword())
+	password := []byte(p.getWalletOperate().GetPassword())
 	encryptered := encryptDataWithPadding(password, types.Encode(newPrivacy))
 	//save the privacy created to wallet db
-	policy.store.setAccountPrivacy(addr, encryptered)
+	p.store.setAccountPrivacy(addr, encryptered)
 	return &mixTy.WalletAddrPrivacy{Privacy: newPrivacy, Addr: addr}, nil
 }
 
 //查询钱包里面所有的地址对应的PrivacyKeys
-func (policy *mixPolicy) getWalletPrivacyKeys() ([]*mixTy.WalletAddrPrivacy, error) {
+func (p *mixPolicy) getWalletPrivacyKeys() ([]*mixTy.WalletAddrPrivacy, error) {
 	//通过Account前缀查找获取钱包中的所有账户信息
-	WalletAccStores, err := policy.store.GetAccountByPrefix("Account")
+	WalletAccStores, err := p.store.GetAccountByPrefix("Account")
 	if err != nil || len(WalletAccStores) == 0 {
 		bizlog.Info("getPrivacyKeyPairs", "store getAccountByPrefix error", err)
 		return nil, err
@@ -228,7 +228,7 @@ func (policy *mixPolicy) getWalletPrivacyKeys() ([]*mixTy.WalletAddrPrivacy, err
 	var infoPriRes []*mixTy.WalletAddrPrivacy
 	for _, AccStore := range WalletAccStores {
 		if len(AccStore.Addr) != 0 {
-			if privacyInfo, err := policy.getAccountPrivacyKey(AccStore.Addr); err == nil {
+			if privacyInfo, err := p.getAccountPrivacyKey(AccStore.Addr); err == nil {
 				infoPriRes = append(infoPriRes, privacyInfo)
 			}
 		}
@@ -243,38 +243,38 @@ func (policy *mixPolicy) getWalletPrivacyKeys() ([]*mixTy.WalletAddrPrivacy, err
 
 }
 
-func (policy *mixPolicy) getRescanStatus() string {
-	status := policy.store.getRescanNoteStatus()
+func (p *mixPolicy) getRescanStatus() string {
+	status := p.store.getRescanNoteStatus()
 	return mixTy.MixWalletRescanStatus(status).String()
 }
 
-func (policy *mixPolicy) tryRescanNotes() error {
+func (p *mixPolicy) tryRescanNotes() error {
 	//未使能，直接使能
-	if !policy.store.getPrivacyEnable() {
-		//policy.store.enablePrivacy()
+	if !p.store.getPrivacyEnable() {
+		//p.store.enablePrivacy()
 		return errors.Wrap(types.ErrNotAllow, "privacy need enable firstly")
 	}
-	operater := policy.getWalletOperate()
+	operater := p.getWalletOperate()
 	if operater.IsWalletLocked() {
 		return types.ErrWalletIsLocked
 	}
-	status := policy.store.getRescanNoteStatus()
+	status := p.store.getRescanNoteStatus()
 	if status == int32(mixTy.MixWalletRescanStatus_SCANNING) {
 		return errors.Wrap(types.ErrNotAllow, "mix wallet is scanning")
 	}
 
-	policy.store.setRescanNoteStatus(int32(mixTy.MixWalletRescanStatus_SCANNING))
+	p.store.setRescanNoteStatus(int32(mixTy.MixWalletRescanStatus_SCANNING))
 
-	go policy.rescanNotes()
+	go p.rescanNotes()
 
 	return nil
 }
 
 //从localdb中把Mix合约的交易按升序都获取出来依次处理
-func (policy *mixPolicy) rescanNotes() {
+func (p *mixPolicy) rescanNotes() {
 	var txInfo mixTy.LocalMixTx
 	i := 0
-	operater := policy.getWalletOperate()
+	operater := p.getWalletOperate()
 	for {
 		select {
 		case <-operater.GetWalletDone():
@@ -324,19 +324,19 @@ func (policy *mixPolicy) rescanNotes() {
 			txInfo.Index = mixTxInfos.Txs[txcount-1].GetIndex()
 		}
 
-		policy.processPrivcyTxs(&ReqHashes)
+		p.processPrivcyTxs(&ReqHashes)
 		if txcount < int(MaxTxHashsPerTime) {
 			break
 		}
 	}
 
-	policy.store.setRescanNoteStatus(int32(mixTy.MixWalletRescanStatus_FINISHED))
+	p.store.setRescanNoteStatus(int32(mixTy.MixWalletRescanStatus_FINISHED))
 	return
 }
 
-func (policy *mixPolicy) processPrivcyTxs(ReqHashes *types.ReqHashes) {
+func (p *mixPolicy) processPrivcyTxs(ReqHashes *types.ReqHashes) {
 	//通过txhashs获取对应的txdetail
-	txDetails, err := policy.getWalletOperate().GetAPI().GetTransactionByHash(ReqHashes)
+	txDetails, err := p.getWalletOperate().GetAPI().GetTransactionByHash(ReqHashes)
 	if err != nil {
 		bizlog.Error("processPrivcyTx", "GetTransactionByHash error", err)
 		return
@@ -347,18 +347,18 @@ func (policy *mixPolicy) processPrivcyTxs(ReqHashes *types.ReqHashes) {
 			bizlog.Error("processPrivcyTx wrong tx", "receipt ty", tx.Receipt.Ty, "hash", common.ToHex(tx.Tx.Hash()))
 			continue
 		}
-		set, err := policy.processMixTx(tx.Tx, tx.Height, tx.Index)
+		set, err := p.processMixTx(tx.Tx, tx.Height, tx.Index)
 		if err != nil {
 			bizlog.Error("processPrivcyTx", "processMixTx error", err)
 			continue
 		}
-		policy.store.setKvs(set)
+		p.store.setKvs(set)
 	}
 }
 
-func (policy *mixPolicy) enablePrivacy(addrs []string) (*mixTy.ReqEnablePrivacyRst, error) {
+func (p *mixPolicy) enablePrivacy(addrs []string) (*mixTy.ReqEnablePrivacyRst, error) {
 	if 0 == len(addrs) {
-		WalletAccStores, err := policy.store.GetAccountByPrefix("Account")
+		WalletAccStores, err := p.store.GetAccountByPrefix("Account")
 		if err != nil || len(WalletAccStores) == 0 {
 			bizlog.Info("enablePrivacy", "GetAccountByPrefix:err", err)
 			return nil, types.ErrNotFound
@@ -376,7 +376,7 @@ func (policy *mixPolicy) enablePrivacy(addrs []string) (*mixTy.ReqEnablePrivacyR
 	for _, addr := range addrs {
 		str := ""
 		isOK := true
-		_, err := policy.getAccountPrivacyKey(addr)
+		_, err := p.getAccountPrivacyKey(addr)
 		if err != nil {
 			isOK = false
 			str = err.Error()
@@ -390,34 +390,25 @@ func (policy *mixPolicy) enablePrivacy(addrs []string) (*mixTy.ReqEnablePrivacyR
 
 		rep.Results = append(rep.Results, priAddrResult)
 	}
-	policy.store.enablePrivacy()
+	p.store.enablePrivacy()
 	return &rep, nil
 }
 
-func (policy *mixPolicy) showAccountNoteInfo(addrs []string) (*mixTy.WalletIndexResp, error) {
-	var resps mixTy.WalletIndexResp
-	for _, addr := range addrs {
-		var req mixTy.WalletMixIndexReq
-		req.Account = addr
-		resp, err := policy.listMixInfos(&req)
-		if err != nil {
-			return nil, err
-		}
-		resps.Notes = append(resps.Notes, resp.(*mixTy.WalletIndexResp).Notes...)
-	}
-	return &resps, nil
+func (p *mixPolicy) showAccountNoteInfo(req *mixTy.WalletMixIndexReq) (*mixTy.WalletNoteResp, error) {
+	resp, err := p.listMixInfos(req)
+	return resp.(*mixTy.WalletNoteResp), err
 }
 
-func (policy *mixPolicy) createRawTx(req *mixTy.CreateRawTxReq) (*types.Transaction, error) {
+func (p *mixPolicy) createRawTx(req *mixTy.CreateRawTxReq) (*types.Transaction, error) {
 	switch req.ActionTy {
 	case mixTy.MixActionDeposit:
-		return policy.createDepositTx(req)
+		return p.createDepositTx(req)
 	case mixTy.MixActionWithdraw:
-		return policy.createWithdrawTx(req)
+		return p.createWithdrawTx(req)
 	case mixTy.MixActionAuth:
-		return policy.createAuthTx(req)
+		return p.createAuthTx(req)
 	case mixTy.MixActionTransfer:
-		return policy.createTransferTx(req)
+		return p.createTransferTx(req)
 	default:
 		return nil, errors.Wrapf(types.ErrInvalidParam, "action=%d", req.ActionTy)
 	}

plugin/dapp/mix/wallet/mixbizdb.go

@@ -144,6 +144,8 @@ func (p *mixPolicy) processAuth(auth *mixTy.MixAuthorizeAction, table *table.Tab
 	}
 	input := out.(*mixTy.AuthorizePublicInput)
 	updateAuthSpend(table, input.AuthorizeSpendHash)
+	updateAuthHash(table, input.AuthorizeHash)
+
 }
 
 func (p *mixPolicy) processNullifiers(nulls []string, table *table.Table) {
@@ -189,11 +191,27 @@ func updateAuthSpend(ldb *table.Table, authSpend string) error {
 	return ldb.Update([]byte(u.TxIndex), u)
 }
 
-func (e *mixPolicy) listMixInfos(req *mixTy.WalletMixIndexReq) (types.Message, error) {
+func updateAuthHash(ldb *table.Table, authHash string) error {
+	xs, err := ldb.ListIndex("authHash", []byte(authHash), nil, 1, 0)
+	if err != nil || len(xs) != 1 {
+		bizlog.Error("updateAuthHash update query List failed", "key", authHash, "err", err, "len", len(xs))
+		return nil
+	}
+	u, ok := xs[0].Data.(*mixTy.WalletDbMixInfo)
+	if !ok {
+		bizlog.Error("updateAuthSpend update decode failed", "data", xs[0].Data)
+		return nil
+
+	}
+	u.Info.Status = mixTy.NoteStatus_UNFROZEN
+	return ldb.Update([]byte(u.TxIndex), u)
+}
+
+func (p *mixPolicy) listMixInfos(req *mixTy.WalletMixIndexReq) (types.Message, error) {
 	if req == nil {
 		return nil, types.ErrInvalidParam
 	}
-	localDb := e.getWalletOperate().GetDBStore()
+	localDb := p.getWalletOperate().GetDBStore()
 	query := NewMixTable(localDb).GetQuery(commondb.NewKVDB(localDb))
 	var primary []byte
 
@@ -211,7 +229,7 @@ func (e *mixPolicy) listMixInfos(req *mixTy.WalletMixIndexReq) (types.Message, e
 	}
 
 	cur := &MixRow{
-		WalletDbMixInfo: &mixTy.WalletDbMixInfo{Info: &mixTy.WalletIndexInfo{
+		WalletDbMixInfo: &mixTy.WalletDbMixInfo{Info: &mixTy.WalletNoteInfo{
 			NoteHash:           req.NoteHash,
 			Nullifier:          req.Nullifier,
 			AuthorizeSpendHash: req.AuthorizeSpendHash,
@@ -233,7 +251,7 @@ func (e *mixPolicy) listMixInfos(req *mixTy.WalletMixIndexReq) (types.Message, e
 	if len(rows) == 0 {
 		return nil, types.ErrNotFound
 	}
-	var resp mixTy.WalletIndexResp
+	var resp mixTy.WalletNoteResp
 	for _, row := range rows {
 		r, ok := row.Data.(*mixTy.WalletDbMixInfo)
 		if !ok {
@@ -245,8 +263,8 @@ func (e *mixPolicy) listMixInfos(req *mixTy.WalletMixIndexReq) (types.Message, e
 	return &resp, nil
 }
 
-func (e *mixPolicy) execAutoDelLocal(tx *types.Transaction) (*types.LocalDBSet, error) {
-	kvs, err := e.store.DelRollbackKV(tx, tx.Execer)
+func (p *mixPolicy) execAutoDelLocal(tx *types.Transaction) (*types.LocalDBSet, error) {
+	kvs, err := p.store.DelRollbackKV(tx, tx.Execer)
 	if err != nil {
 		return nil, err
 	}
@@ -255,7 +273,7 @@ func (e *mixPolicy) execAutoDelLocal(tx *types.Transaction) (*types.LocalDBSet,
 	return dbSet, nil
 }
 
-func (p *mixPolicy) addTable(info *mixTy.WalletIndexInfo, heightIndex string, table *table.Table) {
+func (p *mixPolicy) addTable(info *mixTy.WalletNoteInfo, heightIndex string, table *table.Table) {
 	r := &mixTy.WalletDbMixInfo{
 		Info:    info,
 		TxIndex: heightIndex + info.NoteHash,
@@ -310,7 +328,7 @@ func (p *mixPolicy) processSecretGroup(noteHash string, secretGroup *mixTy.DHSec
 	}
 }
 
-func (p *mixPolicy) decodeSecret(noteHash string, secretData string, privacyKeys []*mixTy.WalletAddrPrivacy) (*mixTy.WalletIndexInfo, error) {
+func (p *mixPolicy) decodeSecret(noteHash string, secretData string, privacyKeys []*mixTy.WalletAddrPrivacy) (*mixTy.WalletNoteInfo, error) {
 	var dhSecret mixTy.DHSecret
 	data, err := hex.DecodeString(secretData)
 	if err != nil {
@@ -339,13 +357,14 @@ func (p *mixPolicy) decodeSecret(noteHash string, secretData string, privacyKeys
 			continue
 		}
 		bizlog.Info("processSecret.decode rawData OK", "notehash", noteHash, "addr", key.Addr)
+		//wallet产生deposit tx时候 确保了三个key不同，除非自己构造相同key的交易
 		if rawData.ReceiverKey == key.Privacy.PaymentKey.ReceiveKey ||
 			rawData.ReturnKey == key.Privacy.PaymentKey.ReceiveKey ||
 			rawData.AuthorizeKey == key.Privacy.PaymentKey.ReceiveKey {
 			//decrypted, save database
-			var info mixTy.WalletIndexInfo
+			var info mixTy.WalletNoteInfo
 			info.NoteHash = noteHash
-			info.Nullifier = mixTy.Byte2Str(mimcHashString([]string{rawData.NoteRandom}))
+			info.Nullifier = hex.EncodeToString(mimcHashString([]string{rawData.NoteRandom}))
 			//如果自己是spender,则记录有关spenderAuthHash,如果是returner，则记录returnerAuthHash
 			//如果授权为spenderAuthHash，则根据授权hash索引到本地数据库，spender更新本地为VALID，returner侧不变仍为FROZEN，花费后，两端都变为USED
 			//如果授权为returnerAuthHash，则returner更新本地为VALID，spender侧仍为FROZEN，
@@ -353,13 +372,10 @@ func (p *mixPolicy) decodeSecret(noteHash string, secretData string, privacyKeys
 			if len(rawData.AuthorizeKey) > LENNULLKEY {
 				switch key.Privacy.PaymentKey.ReceiveKey {
 				case rawData.ReceiverKey:
-					info.Role = mixTy.Role_SPENDER
-					info.AuthorizeSpendHash = mixTy.Byte2Str(mimcHashString([]string{rawData.ReceiverKey, rawData.Amount, rawData.NoteRandom}))
 				case rawData.ReturnKey:
-					info.Role = mixTy.Role_RETURNER
-					info.AuthorizeSpendHash = mixTy.Byte2Str(mimcHashString([]string{rawData.ReturnKey, rawData.Amount, rawData.NoteRandom}))
+					info.AuthorizeSpendHash = hex.EncodeToString(mimcHashString([]string{key.Privacy.PaymentKey.ReceiveKey, rawData.Amount, rawData.NoteRandom}))
 				case rawData.AuthorizeKey:
-					info.Role = mixTy.Role_AUTHORIZER
+					info.AuthorizeHash = hex.EncodeToString(mimcHashString([]string{rawData.AuthorizeKey, rawData.NoteRandom}))
 				}
 			}
 

plugin/dapp/mix/wallet/mixbiztable.go

@@ -22,6 +22,7 @@ var boardOpt = &table.Option{
 	Index: []string{
 		"noteHash",
 		"nullifier",
+		"authHash",
 		"authSpendHash",
 		"account",
 		"status"},
@@ -70,6 +71,8 @@ func (r *MixRow) Get(key string) ([]byte, error) {
 		return []byte(r.Info.NoteHash), nil
 	case "nullifier":
 		return []byte(r.Info.Nullifier), nil
+	case "authHash":
+		return []byte(r.Info.AuthorizeHash), nil
 	case "authSpendHash":
 		return []byte(r.Info.AuthorizeSpendHash), nil
 	case "account":

plugin/dapp/mix/wallet/mixstore.go

@@ -22,31 +22,6 @@ type mixStore struct {
 	*wcom.Store
 }
 
-//
-//func (store *mixStore) getAccountByPrefix(addr string) ([]*types.WalletAccountStore, error) {
-//	if len(addr) == 0 {
-//		bizlog.Error("getAccountByPrefix addr is nil")
-//		return nil, types.ErrInvalidParam
-//	}
-//	list := store.NewListHelper()
-//	accbytes := list.PrefixScan([]byte(addr))
-//	if len(accbytes) == 0 {
-//		bizlog.Error("getAccountByPrefix addr not exist")
-//		return nil, types.ErrAccountNotExist
-//	}
-//	WalletAccountStores := make([]*types.WalletAccountStore, len(accbytes))
-//	for index, accbyte := range accbytes {
-//		var walletaccount types.WalletAccountStore
-//		err := proto.Unmarshal(accbyte, &walletaccount)
-//		if err != nil {
-//			bizlog.Error("GetAccountByAddr", "proto.Unmarshal err:", err)
-//			return nil, types.ErrUnmarshal
-//		}
-//		WalletAccountStores[index] = &walletaccount
-//	}
-//	return WalletAccountStores, nil
-//}
-
 func (store *mixStore) getAccountPrivacy(addr string) ([]byte, error) {
 	if len(addr) == 0 {
 		return nil, types.ErrInvalidParam
@@ -56,29 +31,6 @@ func (store *mixStore) getAccountPrivacy(addr string) ([]byte, error) {
 
 }
 
-//
-//func (store *mixStore) getAccountByAddr(addr string) (*types.WalletAccountStore, error) {
-//	var account types.WalletAccountStore
-//	if len(addr) == 0 {
-//		bizlog.Error("GetAccountByAddr addr is nil")
-//		return nil, types.ErrInvalidParam
-//	}
-//	data, err := store.Get(calcMixAddrKey(addr))
-//	if data == nil || err != nil {
-//		if err != db.ErrNotFoundInDb {
-//			bizlog.Debug("GetAccountByAddr addr", "err", err)
-//		}
-//		return nil, types.ErrAddrNotExist
-//	}
-//
-//	err = types.Decode(data, &account)
-//	if err != nil {
-//		bizlog.Error("GetAccountByAddr", "proto.Unmarshal err:", err)
-//		return nil, types.ErrUnmarshal
-//	}
-//	return &account, nil
-//}
-
 func (store *mixStore) setAccountPrivacy(addr string, data []byte) error {
 	if len(addr) == 0 {
 		bizlog.Error("SetWalletAccountPrivacy addr is nil")
@@ -90,9 +42,6 @@ func (store *mixStore) setAccountPrivacy(addr string, data []byte) error {
 	}
 
 	store.GetDB().Set(calcMixAddrKey(addr), data)
-	//newbatch := store.NewBatch(true)
-	//newbatch.Set(calcMixAddrKey(addr), data)
-	//newbatch.Write()
 
 	return nil
 }

plugin/dapp/mix/wallet/txauth.go

@@ -67,18 +67,20 @@ type AuthorizeInput struct {
 	Valid9 string `tag:"secret"`
 }
 
-func (policy *mixPolicy) getAuthParms(req *mixTy.AuthTxReq) (*AuthorizeInput, error) {
-	note, err := policy.getNoteInfo(req.NoteHash, mixTy.NoteStatus_FROZEN)
+func (p *mixPolicy) getAuthParms(req *mixTy.AuthTxReq) (*AuthorizeInput, error) {
+	note, err := p.getNoteInfo(req.NoteHash)
 	if err != nil {
 		return nil, err
 	}
-
+	if note.Status != mixTy.NoteStatus_FROZEN {
+		return nil, errors.Wrapf(types.ErrNotAllow, "wrong note status=%s", note.Status.String())
+	}
 	if note.Secret.ReceiverKey != req.AuthorizeToAddr && note.Secret.ReturnKey != req.AuthorizeToAddr {
 		return nil, errors.Wrapf(types.ErrInvalidParam, "note no match addr to AuthorizeToAddr=%s", req.AuthorizeToAddr)
 	}
 
 	//get spend privacy key
-	privacyKey, err := policy.getAccountPrivacyKey(note.Account)
+	privacyKey, err := p.getAccountPrivacyKey(note.Account)
 	if err != nil {
 		return nil, errors.Wrapf(err, "getAccountPrivacyKey addr=%s", note.Account)
 	}
@@ -110,7 +112,7 @@ func (policy *mixPolicy) getAuthParms(req *mixTy.AuthTxReq) (*AuthorizeInput, er
 	}
 
 	//get tree path
-	treeProof, err := policy.getTreeProof(note.NoteHash)
+	treeProof, err := p.getTreeProof(note.NoteHash)
 	if err != nil {
 		return nil, errors.Wrapf(err, "getTreeProof for hash=%s", note.NoteHash)
 	}
@@ -121,13 +123,13 @@ func (policy *mixPolicy) getAuthParms(req *mixTy.AuthTxReq) (*AuthorizeInput, er
 
 }
 
-func (policy *mixPolicy) createAuthTx(req *mixTy.CreateRawTxReq) (*types.Transaction, error) {
+func (p *mixPolicy) createAuthTx(req *mixTy.CreateRawTxReq) (*types.Transaction, error) {
 	var auth mixTy.AuthTxReq
 	err := types.Decode(req.Data, &auth)
 	if err != nil {
 		return nil, errors.Wrap(err, "decode req fail")
 	}
-	input, err := policy.getAuthParms(&auth)
+	input, err := p.getAuthParms(&auth)
 	if err != nil {
 		return nil, err
 	}
@@ -137,18 +139,18 @@ func (policy *mixPolicy) createAuthTx(req *mixTy.CreateRawTxReq) (*types.Transac
 		return nil, errors.Wrapf(err, "getZkProofKeys note=%s", auth.NoteHash)
 	}
 	//verify
-	if err := policy.verifyProofOnChain(mixTy.VerifyType_AUTHORIZE, proofInfo, auth.ZkPath+mixTy.AuthVk); err != nil {
+	if err := p.verifyProofOnChain(mixTy.VerifyType_AUTHORIZE, proofInfo, auth.ZkPath+mixTy.AuthVk); err != nil {
 		return nil, errors.Wrapf(err, "verifyProof fail for note=%s", auth.NoteHash)
 	}
 
-	return policy.getAuthTx(strings.TrimSpace(req.Title+mixTy.MixX), proofInfo)
+	return p.getAuthTx(strings.TrimSpace(req.Title+mixTy.MixX), proofInfo)
 }
 
-func (policy *mixPolicy) getAuthTx(execName string, proof *mixTy.ZkProofInfo) (*types.Transaction, error) {
+func (p *mixPolicy) getAuthTx(execName string, proof *mixTy.ZkProofInfo) (*types.Transaction, error) {
 	payload := &mixTy.MixAuthorizeAction{}
 	payload.Proof = proof
 
-	cfg := policy.getWalletOperate().GetAPI().GetConfig()
+	cfg := p.getWalletOperate().GetAPI().GetConfig()
 	action := &mixTy.MixAction{
 		Ty:    mixTy.MixActionAuth,
 		Value: &mixTy.MixAction_Authorize{Authorize: payload},

plugin/dapp/mix/wallet/txdeposit.go

@@ -32,7 +32,12 @@ type DepositInput struct {
 	NoteRandom      string `tag:"secret"`
 }
 
-func (policy *mixPolicy) depositParams(receiver, returner, auth, amount string) (*mixTy.DepositProofResp, error) {
+func (p *mixPolicy) depositParams(receiver, returner, auth, amount string) (*mixTy.DepositProofResp, error) {
+	if receiver == returner || receiver == auth || returner == auth {
+		return nil, errors.Wrapf(types.ErrInvalidParam, "addrs should not be same to receiver=%s,return=%s,auth=%s",
+			receiver, returner, auth)
+	}
+
 	if len(receiver) <= 0 {
 		return nil, errors.Wrap(types.ErrInvalidParam, "receiver is nil")
 	}
@@ -53,7 +58,7 @@ func (policy *mixPolicy) depositParams(receiver, returner, auth, amount string)
 	//TODO 线上检查是否随机值在nullifer里面
 
 	// 获取receiving addr对应的paymentKey
-	payKeys, e := policy.getPaymentKey(receiver)
+	payKeys, e := p.getPaymentKey(receiver)
 	if e != nil {
 		return nil, errors.Wrapf(e, "get payment key for addr = %s", receiver)
 	}
@@ -65,7 +70,7 @@ func (policy *mixPolicy) depositParams(receiver, returner, auth, amount string)
 	//如果Input不填，缺省空为“0”字符串
 	secret.ReturnKey = "0"
 	if len(returner) > 0 {
-		returnKey, err = policy.getPaymentKey(returner)
+		returnKey, err = p.getPaymentKey(returner)
 		if err != nil {
 			return nil, errors.Wrapf(err, "get payment key for return addr = %s", returner)
 		}
@@ -76,7 +81,7 @@ func (policy *mixPolicy) depositParams(receiver, returner, auth, amount string)
 	var authKey *mixTy.PaymentKey
 	secret.AuthorizeKey = "0"
 	if len(auth) > 0 {
-		authKey, err = policy.getPaymentKey(auth)
+		authKey, err = p.getPaymentKey(auth)
 		if err != nil {
 			return nil, errors.Wrapf(err, "get payment key for authorize addr = %s", auth)
 		}
@@ -123,9 +128,9 @@ func (policy *mixPolicy) depositParams(receiver, returner, auth, amount string)
 
 }
 
-func (policy *mixPolicy) getDepositProof(receiver, returner, auth, amount, zkPath string) (*mixTy.ZkProofInfo, error) {
+func (p *mixPolicy) getDepositProof(receiver, returner, auth, amount, zkPath string) (*mixTy.ZkProofInfo, error) {
 
-	resp, err := policy.depositParams(receiver, returner, auth, amount)
+	resp, err := p.depositParams(receiver, returner, auth, amount)
 	if err != nil {
 		return nil, err
 	}
@@ -144,14 +149,14 @@ func (policy *mixPolicy) getDepositProof(receiver, returner, auth, amount, zkPat
 	}
 
 	//线上验证proof,失败的原因有可能circuit,Pk和线上vk不匹配，或不是一起产生的版本
-	if err := policy.verifyProofOnChain(mixTy.VerifyType_DEPOSIT, proofInfo, zkPath+mixTy.DepositVk); err != nil {
+	if err := p.verifyProofOnChain(mixTy.VerifyType_DEPOSIT, proofInfo, zkPath+mixTy.DepositVk); err != nil {
 		return nil, errors.Wrap(err, "verifyProof fail")
 	}
 	proofInfo.Secrets = resp.Secrets
 	return proofInfo, nil
 }
 
-func (policy *mixPolicy) createDepositTx(req *mixTy.CreateRawTxReq) (*types.Transaction, error) {
+func (p *mixPolicy) createDepositTx(req *mixTy.CreateRawTxReq) (*types.Transaction, error) {
 	var deposit mixTy.DepositTxReq
 	err := types.Decode(req.Data, &deposit)
 	if err != nil {
@@ -175,22 +180,22 @@ func (policy *mixPolicy) createDepositTx(req *mixTy.CreateRawTxReq) (*types.Tran
 
 	var proofs []*mixTy.ZkProofInfo
 	for i, rcv := range receivers {
-		p, err := policy.getDepositProof(rcv, deposit.Deposit.ReturnAddr, deposit.Deposit.AuthorizeAddr, amounts[i], deposit.ZkPath)
+		p, err := p.getDepositProof(rcv, deposit.Deposit.ReturnAddr, deposit.Deposit.AuthorizeAddr, amounts[i], deposit.ZkPath)
 		if err != nil {
 			return nil, errors.Wrapf(err, "get Deposit proof for=%s", rcv)
 		}
 		proofs = append(proofs, p)
 	}
 
-	return policy.getDepositTx(strings.TrimSpace(req.Title+mixTy.MixX), proofs)
+	return p.getDepositTx(strings.TrimSpace(req.Title+mixTy.MixX), proofs)
 
 }
 
-func (policy *mixPolicy) getDepositTx(execName string, proofs []*mixTy.ZkProofInfo) (*types.Transaction, error) {
+func (p *mixPolicy) getDepositTx(execName string, proofs []*mixTy.ZkProofInfo) (*types.Transaction, error) {
 	payload := &mixTy.MixDepositAction{}
 	payload.Proofs = proofs
 
-	cfg := policy.getWalletOperate().GetAPI().GetConfig()
+	cfg := p.getWalletOperate().GetAPI().GetConfig()
 	action := &mixTy.MixAction{
 		Ty:    mixTy.MixActionDeposit,
 		Value: &mixTy.MixAction_Deposit{Deposit: payload},

plugin/dapp/mix/wallet/txtransfer.go

@@ -92,10 +92,10 @@ type TransferOutput struct {
 	AmountRandom    string `tag:"secret"`
 }
 
-func (policy *mixPolicy) getTransferInputPart(note *mixTy.WalletIndexInfo) (*TransferInput, error) {
+func (p *mixPolicy) getTransferInputPart(note *mixTy.WalletNoteInfo) (*TransferInput, error) {
 
 	//get spend privacy key
-	privacyKey, err := policy.getAccountPrivacyKey(note.Account)
+	privacyKey, err := p.getAccountPrivacyKey(note.Account)
 	if err != nil {
 		return nil, errors.Wrapf(err, "getAccountPrivacyKey addr=%s", note.Account)
 	}
@@ -133,7 +133,7 @@ func (policy *mixPolicy) getTransferInputPart(note *mixTy.WalletIndexInfo) (*Tra
 		input.AuthorizeFlag = "1"
 	}
 
-	treeProof, err := policy.getTreeProof(note.NoteHash)
+	treeProof, err := p.getTreeProof(note.NoteHash)
 	if err != nil {
 		return nil, errors.Wrapf(err, "getTreeProof for hash=%s", note.NoteHash)
 	}
@@ -143,13 +143,13 @@ func (policy *mixPolicy) getTransferInputPart(note *mixTy.WalletIndexInfo) (*Tra
 	return &input, nil
 }
 
-func (policy *mixPolicy) getTransferOutput(req *mixTy.DepositInfo) (*TransferOutput, *mixTy.DHSecretGroup, error) {
+func (p *mixPolicy) getTransferOutput(req *mixTy.DepositInfo) (*TransferOutput, *mixTy.DHSecretGroup, error) {
 	//目前只支持一个ReceiverAddr
 	if strings.Contains(req.ReceiverAddrs, ",") || strings.Contains(req.Amounts, ",") {
 		return nil, nil, errors.Wrapf(types.ErrInvalidParam, "only support one addr or amount,addrs=%s,amount=%s",
 			req.ReceiverAddrs, req.Amounts)
 	}
-	resp, err := policy.depositParams(req.ReceiverAddrs, req.ReturnAddr, req.AuthorizeAddr, req.Amounts)
+	resp, err := p.depositParams(req.ReceiverAddrs, req.ReturnAddr, req.AuthorizeAddr, req.Amounts)
 	if err != nil {
 		return nil, nil, errors.Wrapf(err, "deposit toAddr=%s", req.ReceiverAddrs)
 	}
@@ -269,7 +269,7 @@ func getShieldValue(inputAmounts []uint64, outAmount, change, minTxFee uint64) (
 	return rst, nil
 }
 
-func (policy *mixPolicy) createTransferTx(req *mixTy.CreateRawTxReq) (*types.Transaction, error) {
+func (p *mixPolicy) createTransferTx(req *mixTy.CreateRawTxReq) (*types.Transaction, error) {
 	var transfer mixTy.TransferTxReq
 	err := types.Decode(req.Data, &transfer)
 	if err != nil {
@@ -277,19 +277,22 @@ func (policy *mixPolicy) createTransferTx(req *mixTy.CreateRawTxReq) (*types.Tra
 	}
 
 	noteHashs := strings.Split(transfer.GetInput().NoteHashs, ",")
-	var notes []*mixTy.WalletIndexInfo
+	var notes []*mixTy.WalletNoteInfo
 	for _, h := range noteHashs {
-		note, err := policy.getNoteInfo(h, mixTy.NoteStatus_VALID)
+		note, err := p.getNoteInfo(h)
 		if err != nil {
 			return nil, errors.Wrapf(err, "get note info for=%s", h)
 		}
+		if note.Status != mixTy.NoteStatus_VALID && note.Status != mixTy.NoteStatus_UNFROZEN {
+			return nil, errors.Wrapf(types.ErrNotAllow, "wrong note status=%s", note.Status.String())
+		}
 		notes = append(notes, note)
 	}
 
 	//1.获取Input
 	var inputParts []*TransferInput
 	for _, n := range notes {
-		input, err := policy.getTransferInputPart(n)
+		input, err := p.getTransferInputPart(n)
 		if err != nil {
 			return nil, errors.Wrapf(err, "getTransferInputPart note=%s", n.NoteHash)
 		}
@@ -319,7 +322,7 @@ func (policy *mixPolicy) createTransferTx(req *mixTy.CreateRawTxReq) (*types.Tra
 	if sumInput < outAmount+uint64(mixTy.Privacy2PrivacyTxFee) {
 		return nil, errors.Wrapf(types.ErrInvalidParam, "out amount=%d big than input=%d - fee=%d", outAmount, sumInput, uint64(mixTy.Privacy2PrivacyTxFee))
 	}
-	outPart, outDHSecret, err := policy.getTransferOutput(transfer.Output.Deposit)
+	outPart, outDHSecret, err := p.getTransferOutput(transfer.Output.Deposit)
 	if err != nil {
 		return nil, errors.Wrap(err, "getTransferOutput for deposit")
 	}
@@ -333,7 +336,7 @@ func (policy *mixPolicy) createTransferTx(req *mixTy.CreateRawTxReq) (*types.Tra
 		ReceiverAddrs: notes[0].Account,
 		Amounts:       strconv.FormatUint(changeAmount, 10),
 	}
-	changePart, changeDHSecret, err := policy.getTransferOutput(change)
+	changePart, changeDHSecret, err := p.getTransferOutput(change)
 	if err != nil {
 		return nil, errors.Wrap(err, "getTransferOutput change part ")
 	}
@@ -368,7 +371,7 @@ func (policy *mixPolicy) createTransferTx(req *mixTy.CreateRawTxReq) (*types.Tra
 		if err != nil {
 			return nil, errors.Wrapf(err, "verify.input getZkProofKeys,the i=%d", i)
 		}
-		if err := policy.verifyProofOnChain(mixTy.VerifyType_TRANSFERINPUT, inputProof, transfer.Input.ZkPath+mixTy.TransInputVk); err != nil {
+		if err := p.verifyProofOnChain(mixTy.VerifyType_TRANSFERINPUT, inputProof, transfer.Input.ZkPath+mixTy.TransInputVk); err != nil {
 			return nil, errors.Wrapf(err, "input verifyProof fail,the i=%d", i)
 		}
 		inputProofs = append(inputProofs, inputProof)
@@ -379,7 +382,7 @@ func (policy *mixPolicy) createTransferTx(req *mixTy.CreateRawTxReq) (*types.Tra
 	if err != nil {
 		return nil, errors.Wrapf(err, "output getZkProofKeys")
 	}
-	if err := policy.verifyProofOnChain(mixTy.VerifyType_TRANSFEROUTPUT, outputProof, transfer.Output.ZkPath+mixTy.TransOutputVk); err != nil {
+	if err := p.verifyProofOnChain(mixTy.VerifyType_TRANSFEROUTPUT, outputProof, transfer.Output.ZkPath+mixTy.TransOutputVk); err != nil {
 		return nil, errors.Wrapf(err, "output verifyProof fail")
 	}
 	outputProof.Secrets = outDHSecret
@@ -389,21 +392,21 @@ func (policy *mixPolicy) createTransferTx(req *mixTy.CreateRawTxReq) (*types.Tra
 	if err != nil {
 		return nil, errors.Wrapf(err, "change getZkProofKeys")
 	}
-	if err := policy.verifyProofOnChain(mixTy.VerifyType_TRANSFEROUTPUT, changeProof, transfer.Output.ZkPath+mixTy.TransOutputVk); err != nil {
+	if err := p.verifyProofOnChain(mixTy.VerifyType_TRANSFEROUTPUT, changeProof, transfer.Output.ZkPath+mixTy.TransOutputVk); err != nil {
 		return nil, errors.Wrapf(err, "change verifyProof fail")
 	}
 	changeProof.Secrets = changeDHSecret
 
-	return policy.getTransferTx(strings.TrimSpace(req.Title+mixTy.MixX), inputProofs, outputProof, changeProof)
+	return p.getTransferTx(strings.TrimSpace(req.Title+mixTy.MixX), inputProofs, outputProof, changeProof)
 }
 
-func (policy *mixPolicy) getTransferTx(execName string, inputProofs []*mixTy.ZkProofInfo, proofs ...*mixTy.ZkProofInfo) (*types.Transaction, error) {
+func (p *mixPolicy) getTransferTx(execName string, inputProofs []*mixTy.ZkProofInfo, proofs ...*mixTy.ZkProofInfo) (*types.Transaction, error) {
 	payload := &mixTy.MixTransferAction{}
 	payload.Inputs = inputProofs
 	payload.Output = proofs[1]
 	payload.Change = proofs[2]
 
-	cfg := policy.getWalletOperate().GetAPI().GetConfig()
+	cfg := p.getWalletOperate().GetAPI().GetConfig()
 	action := &mixTy.MixAction{
 		Ty:    mixTy.MixActionTransfer,
 		Value: &mixTy.MixAction_Transfer{Transfer: payload},

plugin/dapp/mix/wallet/txwithdraw.go

@@ -67,11 +67,14 @@ type WithdrawInput struct {
 	Valid9 string `tag:"secret"`
 }
 
-func (policy *mixPolicy) getWithdrawParams(noteHash string) (*WithdrawInput, error) {
-	note, err := policy.getNoteInfo(noteHash, mixTy.NoteStatus_VALID)
+func (p *mixPolicy) getWithdrawParams(noteHash string) (*WithdrawInput, error) {
+	note, err := p.getNoteInfo(noteHash)
 	if err != nil {
 		return nil, err
 	}
+	if note.Status != mixTy.NoteStatus_VALID && note.Status != mixTy.NoteStatus_UNFROZEN {
+		return nil, errors.Wrapf(types.ErrNotAllow, "wrong note status=%s", note.Status.String())
+	}
 
 	var input WithdrawInput
 	initTreePath(&input)
@@ -85,24 +88,24 @@ func (policy *mixPolicy) getWithdrawParams(noteHash string) (*WithdrawInput, err
 	input.AuthorizePubKey = note.Secret.AuthorizeKey
 	input.NoteRandom = note.Secret.NoteRandom
 
-	input.SpendFlag = "1"
-	if note.Role == mixTy.Role_RETURNER {
-		input.SpendFlag = "0"
-	}
 	input.AuthorizeFlag = "0"
 	if len(input.AuthorizeSpendHash) > LENNULLKEY {
 		input.AuthorizeFlag = "1"
 	}
 
 	//get spend privacy key
-	privacyKey, err := policy.getAccountPrivacyKey(note.Account)
+	privacyKey, err := p.getAccountPrivacyKey(note.Account)
 	if err != nil {
 		return nil, errors.Wrapf(err, "getAccountPrivacyKey addr=%s", note.Account)
 	}
 	input.SpendPriKey = privacyKey.Privacy.PaymentKey.SpendKey
+	input.SpendFlag = "1"
+	if privacyKey.Privacy.PaymentKey.ReceiveKey == input.ReturnPubKey {
+		input.SpendFlag = "0"
+	}
 
 	//get tree path
-	treeProof, err := policy.getTreeProof(note.NoteHash)
+	treeProof, err := p.getTreeProof(note.NoteHash)
 	if err != nil {
 		return nil, errors.Wrapf(err, "getTreeProof for hash=%s", note.NoteHash)
 	}
@@ -113,7 +116,7 @@ func (policy *mixPolicy) getWithdrawParams(noteHash string) (*WithdrawInput, err
 
 }
 
-func (policy *mixPolicy) createWithdrawTx(req *mixTy.CreateRawTxReq) (*types.Transaction, error) {
+func (p *mixPolicy) createWithdrawTx(req *mixTy.CreateRawTxReq) (*types.Transaction, error) {
 	var withdraw mixTy.WithdrawTxReq
 	err := types.Decode(req.Data, &withdraw)
 	if err != nil {
@@ -131,7 +134,7 @@ func (policy *mixPolicy) createWithdrawTx(req *mixTy.CreateRawTxReq) (*types.Tra
 
 	var sum uint64
 	for _, note := range notes {
-		input, err := policy.getWithdrawParams(note)
+		input, err := p.getWithdrawParams(note)
 		if err != nil {
 			return nil, errors.Wrapf(err, "getWithdrawParams note=%s", note)
 		}
@@ -141,7 +144,7 @@ func (policy *mixPolicy) createWithdrawTx(req *mixTy.CreateRawTxReq) (*types.Tra
 			return nil, errors.Wrapf(err, "getZkProofKeys note=%s", note)
 		}
 		//verify
-		if err := policy.verifyProofOnChain(mixTy.VerifyType_WITHDRAW, proofInfo, withdraw.ZkPath+mixTy.WithdrawVk); err != nil {
+		if err := p.verifyProofOnChain(mixTy.VerifyType_WITHDRAW, proofInfo, withdraw.ZkPath+mixTy.WithdrawVk); err != nil {
 			return nil, errors.Wrapf(err, "verifyProof fail for note=%s", note)
 		}
 
@@ -158,16 +161,16 @@ func (policy *mixPolicy) createWithdrawTx(req *mixTy.CreateRawTxReq) (*types.Tra
 		return nil, errors.Wrapf(types.ErrInvalidParam, "amount not match req=%d,note.sum=%d", withdraw.TotalAmount, sum)
 	}
 
-	return policy.getWithdrawTx(strings.TrimSpace(req.Title+mixTy.MixX), withdraw.TotalAmount, proofs)
+	return p.getWithdrawTx(strings.TrimSpace(req.Title+mixTy.MixX), withdraw.TotalAmount, proofs)
 
 }
 
-func (policy *mixPolicy) getWithdrawTx(execName string, amount uint64, proofs []*mixTy.ZkProofInfo) (*types.Transaction, error) {
+func (p *mixPolicy) getWithdrawTx(execName string, amount uint64, proofs []*mixTy.ZkProofInfo) (*types.Transaction, error) {
 	payload := &mixTy.MixWithdrawAction{}
 	payload.Amount = amount
 	payload.Proofs = proofs
 
-	cfg := policy.getWalletOperate().GetAPI().GetConfig()
+	cfg := p.getWalletOperate().GetAPI().GetConfig()
 	action := &mixTy.MixAction{
 		Ty:    mixTy.MixActionWithdraw,
 		Value: &mixTy.MixAction_Withdraw{Withdraw: payload},

plugin/dapp/mix/wallet/util.go

@@ -87,7 +87,7 @@ func decryptSecretData(req *mixTy.DecryptSecretData) (*mixTy.SecretData, error)
 	return &raw, nil
 }
 
-func (policy *mixPolicy) verifyProofOnChain(ty mixTy.VerifyType, proof *mixTy.ZkProofInfo, vkPath string) error {
+func (p *mixPolicy) verifyProofOnChain(ty mixTy.VerifyType, proof *mixTy.ZkProofInfo, vkPath string) error {
 	//vkpath verify
 	if len(vkPath) > 0 {
 		vk, err := getVerifyKey(vkPath)
@@ -111,7 +111,7 @@ func (policy *mixPolicy) verifyProofOnChain(ty mixTy.VerifyType, proof *mixTy.Zk
 		Proof: proof,
 	}
 	//onchain verify
-	_, err := policy.walletOperate.GetAPI().QueryChain(&types.ChainExecutor{
+	_, err := p.walletOperate.GetAPI().QueryChain(&types.ChainExecutor{
 		Driver:   "mix",
 		FuncName: "VerifyProof",
 		Param:    types.Encode(verify),
@@ -119,8 +119,8 @@ func (policy *mixPolicy) verifyProofOnChain(ty mixTy.VerifyType, proof *mixTy.Zk
 	return err
 }
 
-func (policy *mixPolicy) getPaymentKey(addr string) (*mixTy.PaymentKey, error) {
-	msg, err := policy.walletOperate.GetAPI().QueryChain(&types.ChainExecutor{
+func (p *mixPolicy) getPaymentKey(addr string) (*mixTy.PaymentKey, error) {
+	msg, err := p.walletOperate.GetAPI().QueryChain(&types.ChainExecutor{
 		Driver:   "mix",
 		FuncName: "PaymentPubKey",
 		Param:    types.Encode(&types.ReqString{Data: addr}),
@@ -131,8 +131,8 @@ func (policy *mixPolicy) getPaymentKey(addr string) (*mixTy.PaymentKey, error) {
 	return msg.(*mixTy.PaymentKey), err
 }
 
-func (policy *mixPolicy) getPathProof(leaf string) (*mixTy.CommitTreeProve, error) {
-	msg, err := policy.walletOperate.GetAPI().QueryChain(&types.ChainExecutor{
+func (p *mixPolicy) getPathProof(leaf string) (*mixTy.CommitTreeProve, error) {
+	msg, err := p.walletOperate.GetAPI().QueryChain(&types.ChainExecutor{
 		Driver:   "mix",
 		FuncName: "GetTreePath",
 		Param:    types.Encode(&mixTy.TreeInfoReq{LeafHash: leaf}),
@@ -143,32 +143,30 @@ func (policy *mixPolicy) getPathProof(leaf string) (*mixTy.CommitTreeProve, erro
 	return msg.(*mixTy.CommitTreeProve), nil
 }
 
-func (policy *mixPolicy) getNoteInfo(noteHash string, noteStatus mixTy.NoteStatus) (*mixTy.WalletIndexInfo, error) {
-	if policy.walletOperate.IsWalletLocked() {
+func (p *mixPolicy) getNoteInfo(noteHash string) (*mixTy.WalletNoteInfo, error) {
+	if p.walletOperate.IsWalletLocked() {
 		return nil, types.ErrWalletIsLocked
 	}
 
 	var index mixTy.WalletMixIndexReq
 	index.NoteHash = noteHash
-	msg, err := policy.listMixInfos(&index)
+	msg, err := p.listMixInfos(&index)
 	if err != nil {
 		return nil, errors.Wrapf(err, "list  noteHash=%s", noteHash)
 	}
-	resp := msg.(*mixTy.WalletIndexResp)
+	resp := msg.(*mixTy.WalletNoteResp)
 	if len(resp.Notes) < 1 {
 		return nil, errors.Wrapf(err, "list not found noteHash=%s", noteHash)
 	}
 
-	note := msg.(*mixTy.WalletIndexResp).Notes[0]
-	if note.Status != noteStatus {
-		return nil, errors.Wrapf(types.ErrNotAllow, "wrong note status=%s", note.Status.String())
-	}
+	note := msg.(*mixTy.WalletNoteResp).Notes[0]
+
 	return note, nil
 }
 
-func (policy *mixPolicy) getTreeProof(leaf string) (*mixTy.TreePathProof, error) {
+func (p *mixPolicy) getTreeProof(leaf string) (*mixTy.TreePathProof, error) {
 	//get tree path
-	path, err := policy.getPathProof(leaf)
+	path, err := p.getPathProof(leaf)
 	if err != nil {
 		return nil, errors.Wrapf(err, "get tree proof for noteHash=%s", leaf)
 	}