unfreeze exec/del local

executor/action.go

@@ -61,7 +61,7 @@ func (a *action) UnfreezeCreate(create *uf.UnfreezeCreate) (*types.Receipt, erro
 	k := []byte(unfreezeID)
 	v := types.Encode(unfreeze)
 	kv = append(kv, &types.KeyValue{k, v})
-	receiptLog := a.getCreateLog(unfreeze)
+	receiptLog := a.getUnfreezeLog(unfreeze)
 	logs = append(logs, receiptLog)
 	return &types.Receipt{types.ExecOk, kv, logs}, nil
 }
@@ -103,7 +103,7 @@ func (a *action) UnfreezeWithdraw(withdraw *uf.UnfreezeWithdraw) (*types.Receipt
 	unfreeze.WithdrawTimes += int32(reaTimes)
 	unfreeze.Remaining -= available
 	a.saveStateDB(&unfreeze)
-	receiptLog := a.getWithdrawLog(&unfreeze)
+	receiptLog := a.getUnfreezeLog(&unfreeze)
 	logs = append(logs, receiptLog)
 	k := []byte(withdraw.UnfreezeID)
 	v := types.Encode(&unfreeze)
@@ -147,7 +147,7 @@ func (a *action) UnfreezeTerminate(terminate *uf.UnfreezeTerminate) (*types.Rece
 	kv = append(kv, receipt.KV...)
 	unfreeze.Remaining = 0
 	a.saveStateDB(&unfreeze)
-	receiptLog := a.getTerminateLog(&unfreeze)
+	receiptLog := a.getUnfreezeLog(&unfreeze)
 	logs = append(logs, receiptLog)
 	k := []byte(terminate.UnfreezeID)
 	v := types.Encode(&unfreeze)
@@ -165,37 +165,20 @@ func key(id string) (keys []byte) {
 	return keys
 }
 
-func (a *action) getCreateLog(unfreeze *uf.Unfreeze) *types.ReceiptLog {
+func (a *action) getUnfreezeLog(unfreeze *uf.Unfreeze) *types.ReceiptLog {
 	log := &types.ReceiptLog{}
 	log.Ty = uf.TyLogCreateUnfreeze
-	r := &uf.ReceiptCreate{}
+	r := &uf.ReceiptUnfreeze{}
 	r.UnfreezeID = unfreeze.UnfreezeID
 	r.Initiator = unfreeze.Initiator
-	log.Log = types.Encode(r)
-	return log
-}
-
-func (a *action) getWithdrawLog(unfreeze *uf.Unfreeze) *types.ReceiptLog {
-	log := &types.ReceiptLog{}
-	log.Ty = uf.TyLogCreateUnfreeze
-	r := &uf.ReceiptWithdraw{}
-	r.WithdrawTimes = unfreeze.WithdrawTimes
 	r.Beneficiary = unfreeze.Beneficiary
-	log.Log = types.Encode(r)
-	return log
-}
-
-func (a *action) getTerminateLog(unfreeze *uf.Unfreeze) *types.ReceiptLog {
-	log := &types.ReceiptLog{}
-	log.Ty = uf.TyLogCreateUnfreeze
-	r := &uf.ReceiptTerminate{}
-	r.UnfreezeID = unfreeze.UnfreezeID
+	r.TokenName = unfreeze.TokenName
 	log.Log = types.Encode(r)
 	return log
 }
 
 //查询可提币状态
-func QueryWithdraw(stateDB dbm.KV, param *uf.QueryUnfreezeWithdraw) (types.Message, error) {
+func QueryUnfreezeWithdraw(stateDB dbm.KV, param *uf.QueryUnfreezeWithdraw) (types.Message, error) {
 	//查询提币次数
 	//计算当前可否提币
 	unfreezeID := param.UnfreezeID

executor/exec_del_local.go

@@ -6,9 +6,24 @@ import (
 )
 
 func (u *Unfreeze) execDelLocal(receiptData *types.ReceiptData) (*types.LocalDBSet, error) {
-	
-	
 	dbSet := &types.LocalDBSet{}
+	if receiptData.GetTy() != types.ExecOk {
+		return dbSet, nil
+	}
+	for _, log := range receiptData.Logs {
+		switch log.Ty {
+		case uf.TyLogCreateUnfreeze, uf.TyLogWithdrawUnfreeze, uf.TyLogTerminateUnfreeze:
+			var receipt uf.ReceiptUnfreeze
+			err := types.Decode(log.Log, &receipt)
+			if err != nil {
+				return nil, err
+			}
+			kv := u.rollbackUnfreezeCreate(&receipt)
+			dbSet.KV = append(dbSet.KV, kv...)
+		default:
+			return nil, types.ErrNotSupport
+		}
+	}
 	return dbSet, nil
 }
 

executor/exec_local.go

@@ -6,9 +6,24 @@ import (
 )
 
 func (u *Unfreeze) execLocal(receiptData *types.ReceiptData) (*types.LocalDBSet, error) {
-	
-	
 	dbSet := &types.LocalDBSet{}
+	if receiptData.GetTy() != types.ExecOk {
+		return dbSet, nil
+	}
+	for _, log := range receiptData.Logs {
+		switch log.Ty {
+		case uf.TyLogCreateUnfreeze, uf.TyLogWithdrawUnfreeze, uf.TyLogTerminateUnfreeze:
+			var receipt uf.ReceiptUnfreeze
+			err := types.Decode(log.Log, &receipt)
+			if err != nil {
+				return nil, err
+			}
+			kv := u.saveUnfreezeCreate(&receipt)
+			dbSet.KV = append(dbSet.KV, kv...)
+		default:
+			return nil, types.ErrNotSupport
+		}
+	}
 	return dbSet, nil
 }
 

executor/query.go

@@ -5,6 +5,6 @@ import (
 	"gitlab.33.cn/chain33/chain33/types"
 )
 
-func (u *Unfreeze) Query_QueryWithdraw(in *uf.QueryUnfreezeWithdraw) (types.Message, error) {
-	return QueryWithdraw(u.GetStateDB(), in)
+func (u *Unfreeze) Query_QueryUnfreezeWithdraw(in *uf.QueryUnfreezeWithdraw) (types.Message, error) {
+	return QueryUnfreezeWithdraw(u.GetStateDB(), in)
 }

executor/unfreeze.go

 package executor
 
 import (
+	"fmt"
+
 	log "github.com/inconshreveable/log15"
 	uf "gitlab.33.cn/chain33/chain33/plugin/dapp/unfreeze/types"
 	drivers "gitlab.33.cn/chain33/chain33/system/dapp"
@@ -38,3 +40,19 @@ func GetName() string {
 func (u *Unfreeze) GetDriverName() string {
 	return driverName
 }
+
+func (u *Unfreeze) saveUnfreezeCreate(res *uf.ReceiptUnfreeze) (kvs []*types.KeyValue) {
+	kv := &types.KeyValue{}
+	kv.Key = []byte(fmt.Sprintf("mavl-unfreeze-"+"%s-"+"%s-"+"%s", res.Initiator, res.Beneficiary, res.TokenName))
+	kv.Value = []byte(res.UnfreezeID)
+	kvs = append(kvs, kv)
+	return kvs
+}
+
+func (u *Unfreeze) rollbackUnfreezeCreate(res *uf.ReceiptUnfreeze) (kvs []*types.KeyValue) {
+	kv := &types.KeyValue{}
+	kv.Key = []byte(fmt.Sprintf("mavl-unfreeze-"+"%s-"+"%s-"+"%s", res.Initiator, res.Beneficiary, res.TokenName))
+	kv.Value = []byte(res.UnfreezeID)
+	kvs = append(kvs, kv)
+	return kvs
+}

proto/unfreeze.proto

@@ -57,18 +57,11 @@ message UnfreezeTerminate {
 }
 
 // receipt
-message ReceiptCreate {
+message ReceiptUnfreeze {
     string unfreezeID = 1;
     string initiator = 2;
-}
-
-message ReceiptWithdraw {
-    int32 withdrawTimes = 1;
-    string beneficiary = 3;
-}
-
-message ReceiptTerminate {
-    string unfreezeID = 1;
+	string beneficiary = 3;
+	string tokenName = 4;
 }
 
 // query

types/const.go

@@ -22,12 +22,12 @@ var (
 	ExecerUnfreeze = []byte(UnfreezeX)
 )
 
-//const (
-//	Action_CreateUnfreeze    = "createUnfreeze"
-//	Action_WithdrawUnfreeze  = "withdrawUnfreeze"
-//	Action_TerminateUnfreeze = "terminateUnfreeze"
-//)
+const (
+	Action_CreateUnfreeze    = "createUnfreeze"
+	Action_WithdrawUnfreeze  = "withdrawUnfreeze"
+	Action_TerminateUnfreeze = "terminateUnfreeze"
+)
 
-//const (
-//	FuncName_QueryXXX = "QueryXXX"
-//)
+const (
+	FuncName_QueryUnfreezeWithdraw = "QueryUnfreezeWithdraw"
+)

types/types.go

 package types
 
 import (
+	"encoding/json"
+	"math/rand"
 	"reflect"
+	"time"
 
 	log "github.com/inconshreveable/log15"
+	"gitlab.33.cn/chain33/chain33/common/address"
 	"gitlab.33.cn/chain33/chain33/types"
 )
 
@@ -35,9 +39,9 @@ type UnfreezeType struct {
 
 func (u *UnfreezeType) GetLogMap() map[int64]*types.LogInfo {
 	return map[int64]*types.LogInfo{
-		TyLogCreateUnfreeze:    {reflect.TypeOf(ReceiptCreate{}), "LogCreateUnfreeze"},
-		TyLogWithdrawUnfreeze:  {reflect.TypeOf(ReceiptWithdraw{}), "LogWithdrawUnfreeze"},
-		TyLogTerminateUnfreeze: {reflect.TypeOf(ReceiptTerminate{}), "LogTerminateUnfreeze"},
+		TyLogCreateUnfreeze:    {reflect.TypeOf(ReceiptUnfreeze{}), "LogCreateUnfreeze"},
+		TyLogWithdrawUnfreeze:  {reflect.TypeOf(ReceiptUnfreeze{}), "LogWithdrawUnfreeze"},
+		TyLogTerminateUnfreeze: {reflect.TypeOf(ReceiptUnfreeze{}), "LogTerminateUnfreeze"},
 	}
 }
 
@@ -53,35 +57,107 @@ func (u *UnfreezeType) GetTypeMap() map[string]int32 {
 	}
 }
 
-////创建解冻相关交易
-//func (u UnfreezeType) CreateTx(action string, message json.RawMessage) (*types.Transaction, error) {
-//	tlog.Debug("UnfreezeType.CreateTx", "action", action)
-//	if action == Action_CreateUnfreeze {
-//		var param UnfreezeCreate
-//		err := json.Unmarshal(message, &param)
-//		if err != nil {
-//			tlog.Error("CreateTx", "Error", err)
-//			return nil, types.ErrInputPara
-//		}
-//		return CreateRawGamePreCreateTx(&param)
-//	} else if action == Action_WithdrawUnfreeze {
-//		var param UnfreezeWithdraw
-//		err := json.Unmarshal(message, &param)
-//		if err != nil {
-//			tlog.Error("CreateTx", "Error", err)
-//			return nil, types.ErrInputPara
-//		}
-//		return CreateRawGamePreMatchTx(&param)
-//	} else if action == Action_TerminateUnfreeze {
-//		var param UnfreezeTerminate
-//		err := json.Unmarshal(message, &param)
-//		if err != nil {
-//			tlog.Error("CreateTx", "Error", err)
-//			return nil, types.ErrInputPara
-//		}
-//		return CreateRawGamePreCancelTx(&param)
-//	} else {
-//		return nil, types.ErrNotSupport
-//	}
-//	return nil, nil
-//}
+// TODO createTx接口暂时没法用，作为一个预留接口
+func (u UnfreezeType) CreateTx(action string, message json.RawMessage) (*types.Transaction, error) {
+	tlog.Debug("UnfreezeType.CreateTx", "action", action)
+	if action == Action_CreateUnfreeze {
+		var param UnfreezeCreate
+		err := json.Unmarshal(message, &param)
+		if err != nil {
+			tlog.Error("CreateTx", "Error", err)
+			return nil, types.ErrInputPara
+		}
+		return CreateUnfreezeCreateTx(&param)
+	} else if action == Action_WithdrawUnfreeze {
+		var param UnfreezeWithdraw
+		err := json.Unmarshal(message, &param)
+		if err != nil {
+			tlog.Error("CreateTx", "Error", err)
+			return nil, types.ErrInputPara
+		}
+		return CreateUnfreezeWithdrawTx(&param)
+	} else if action == Action_TerminateUnfreeze {
+		var param UnfreezeTerminate
+		err := json.Unmarshal(message, &param)
+		if err != nil {
+			tlog.Error("CreateTx", "Error", err)
+			return nil, types.ErrInputPara
+		}
+		return CreateUnfreezeTerminateTx(&param)
+	} else {
+		return nil, types.ErrNotSupport
+	}
+	return nil, nil
+}
+
+func CreateUnfreezeCreateTx(parm *UnfreezeCreate) (*types.Transaction, error) {
+	if parm == nil {
+		tlog.Error("CreateUnfreezeCreateTx", "parm", parm)
+		return nil, types.ErrInvalidParam
+	}
+	v := &UnfreezeCreate{
+		StartTime:   parm.StartTime,
+		TokenName:   parm.TokenName,
+		TotalCount:  parm.TotalCount,
+		Beneficiary: parm.Beneficiary,
+		Period:      parm.Period,
+		Means:       parm.Means,
+		Amount:      parm.Amount,
+	}
+	create := &UnfreezeAction{
+		Ty:    UnfreezeActionCreate,
+		Value: &UnfreezeAction_Create{v},
+	}
+	tx := &types.Transaction{
+		Execer:  []byte(getRealExecName(types.GetParaName())),
+		Payload: types.Encode(create),
+		Nonce:   rand.New(rand.NewSource(time.Now().UnixNano())).Int63(),
+		To:      address.ExecAddress(getRealExecName(types.GetParaName())),
+	}
+	tx.SetRealFee(types.MinFee)
+	return tx, nil
+}
+
+func CreateUnfreezeWithdrawTx(parm *UnfreezeWithdraw) (*types.Transaction, error) {
+	if parm == nil {
+		tlog.Error("CreateUnfreezeWithdrawTx", "parm", parm)
+		return nil, types.ErrInvalidParam
+	}
+	v := &UnfreezeWithdraw{
+		UnfreezeID: parm.UnfreezeID,
+	}
+	withdraw := &UnfreezeAction{
+		Ty:    UnfreezeActionWithdraw,
+		Value: &UnfreezeAction_Withdraw{v},
+	}
+	tx := &types.Transaction{
+		Execer:  []byte(getRealExecName(types.GetParaName())),
+		Payload: types.Encode(withdraw),
+		Nonce:   rand.New(rand.NewSource(time.Now().UnixNano())).Int63(),
+		To:      address.ExecAddress(getRealExecName(types.GetParaName())),
+	}
+	tx.SetRealFee(types.MinFee)
+	return tx, nil
+}
+
+func CreateUnfreezeTerminateTx(parm *UnfreezeTerminate) (*types.Transaction, error) {
+	if parm == nil {
+		tlog.Error("CreateUnfreezeTerminateTx", "parm", parm)
+		return nil, types.ErrInvalidParam
+	}
+	v := &UnfreezeTerminate{
+		UnfreezeID: parm.UnfreezeID,
+	}
+	terminate := &UnfreezeAction{
+		Ty:    UnfreezeActionTerminate,
+		Value: &UnfreezeAction_Terminate{v},
+	}
+	tx := &types.Transaction{
+		Execer:  []byte(getRealExecName(types.GetParaName())),
+		Payload: types.Encode(terminate),
+		Nonce:   rand.New(rand.NewSource(time.Now().UnixNano())).Int63(),
+		To:      address.ExecAddress(getRealExecName(types.GetParaName())),
+	}
+	tx.SetRealFee(types.MinFee)
+	return tx, nil
+}