add confirm tx

blockchain/contract.go

@@ -0,0 +1,119 @@
+package blockchain
+
+import (
+	"ktogame/controller"
+	"ktogame/models"
+	"ktogame/util"
+	"strconv"
+
+	"github.com/go-xorm/xorm"
+)
+
+func participate(engine *xorm.Engine, user, inviter, hash string, amount float64) error {
+	var dui models.UserInfo
+	ok, err := engine.Id(inviter).Get(&dui)
+	if err != nil {
+		return err
+	}
+	if !ok {
+		//return errors.New("participate get user info failed")
+		dui.Id = -1
+		dui.Direct = ""
+		dui.Superiors = "-1"
+	}
+
+	//insert new user info
+	var ui models.UserInfo
+	ui.Addr = user
+	ui.Direct = inviter
+	ui.Indirect = dui.Direct
+	ui.Superiors = dui.Superiors + "," + strconv.FormatInt(dui.Id, 10)
+	ui.ParticipateAmount = float64(controller.ParticipateValue * controller.Decimals)
+	ui.State = 1
+	ui.CreateTime = util.NowTimeString()
+	ui.Hash = hash
+
+	_, err = engine.Insert(&ui)
+	if err != nil {
+		return err
+	}
+
+	//insert new user Performance
+	var uper models.Performance
+	uper.Addr = user
+	_, err = engine.Insert(&uper)
+	if err != nil {
+		return err
+	}
+
+	//update rewards pool
+	err = controller.UpdateRewardsPool(engine, amount)
+	if err != nil {
+		return err
+	}
+
+	///update Recommendation Rewards
+	///update direct recommend rewards(10%)
+	rewards := amount * 10 / 100
+	if ui.Direct != "" {
+		err := controller.UpdateAvailableRewards(engine, rewards, ui.Direct, true, true)
+		if err != nil {
+			return err
+		}
+	}
+	///update indirect recommend rewards(10%)
+	if ui.Indirect != "" {
+		err := controller.UpdateAvailableRewards(engine, rewards, ui.Indirect, true, false)
+		if err != nil {
+			return err
+		}
+	}
+
+	//update all supers performance (15%)
+	err = controller.UpdateSuperiorsPerformance(engine, ui.Superiors, amount)
+	if err != nil {
+		return err
+	}
+
+	//update Community Gift(50%)
+	err = controller.UpdateCommunityGift(engine, amount, inviter)
+	if err != nil {
+		return err
+	}
+
+	//Update Community Nodes(5%)
+	err = controller.UpdateCommunityNodes(engine, amount)
+	if err != nil {
+		return err
+	}
+
+	//update Market(10%)
+	err = controller.UpdateMarket(engine, amount)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func checkClaim(engine *xorm.Engine, addr, hash, sign string, amount float64) error {
+	var tx models.ClaimedTxs
+	ok, err := engine.Id(hash).Get(&tx)
+	if err != nil {
+		return err
+	}
+	if !ok {
+		//set record
+		claimTx := models.ClaimedTxs{Addr: addr, Amount: amount, Hash: hash,
+			Signature: sign, State: 1, Droped: 0, CreateTime: util.NowTimeString()}
+		_, err := engine.Insert(&claimTx)
+		if err != nil {
+			return err
+		}
+	}
+	tx.State = 1
+	_, err = engine.ID(hash).Cols("hash").Update(&tx)
+	if err != nil {
+		return err
+	}
+	return nil
+}

blockchain/scan.go

@@ -42,7 +42,7 @@ func init() {
 	TopsMap = tm
 
 	go scanBlock()
-	go modifyClaimTxs()
+	go confirmClaimedTxs()
 }
 
 func scanBlock() {
@@ -154,51 +154,72 @@ func scanBlock() {
 	}
 }
 
-func modifyClaimTxs() {
+func confirmClaimedTxs() {
+	var mark int64 = 0
 	for {
-		time.Sleep(time.Second)
-		mark := 0
-		var tx models.ClaimedTxs
-		ok, err := dbUtil.Engine.Where("state = ?", 0).Where("droped = ?", 0).Get(&tx)
+		time.Sleep(time.Second * 5)
+		var txs []models.ClaimedTxs
+		ok, err := dbUtil.Engine.Where("state = ?", 0).Where("droped = ?", 0).Where("id > ?", mark).Get(&txs)
 		if err != nil {
 			continue
 		}
 		if !ok {
 			continue
 		}
-		for {
-			time.Sleep(time.Second * 5)
-			if mark > 200 {
-				var ui models.UserInfo
-				_, err := dbUtil.Engine.Id(tx.Hash).Get(&ui)
-				if err != nil {
-					break
-				}
-				ui.AvailableClaim += tx.Amount
-				ui.TotalClaimed -= tx.Amount
-				_, err = dbUtil.Engine.ID(tx.Addr).Cols("total_claimed,available_claim").Update(&ui)
-				if err != nil {
-					break
-				}
+		if len(txs) > 0 {
+			mark = txs[len(txs)-1].Id
+		}
+		for _, t := range txs {
+			go func(tx models.ClaimedTxs) {
+				for {
+					time.Sleep(time.Second * 5)
+					if mark > (CONFIRMINTERVAL / 5) {
+						var ui models.UserInfo
+						_, err := dbUtil.Engine.Id(tx.Hash).Get(&ui)
+						if err != nil {
+							break
+						}
+						ui.AvailableClaim += tx.Amount
+						ui.TotalClaimed -= tx.Amount
+						_, err = dbUtil.Engine.ID(tx.Addr).Cols("total_claimed,available_claim").Update(&ui)
+						if err != nil {
+							break
+						}
 
-				tx.Droped = 1
-				_, err = dbUtil.Engine.ID(tx.Hash).Cols("droped").Update(&tx)
-				if err != nil {
-					break
-				}
-				break
-			}
-			_, err = ktoClient.GetTxByHash(context.Background(), &pb.ReqTxByHash{Hash: tx.Hash})
-			if err != nil {
-				mark++
-				continue
-			}
+						tx.Droped = 1
+						_, err = dbUtil.Engine.ID(tx.Hash).Cols("droped").Update(&tx)
+						if err != nil {
+							break
+						}
+						break
+					}
+					ptx, err := ktoClient.GetTxByHash(context.Background(), &pb.ReqTxByHash{Hash: tx.Hash})
+					if err != nil {
+						mark++
+						continue
+					}
+					if ptx.Code != 0 {
+						mark++
+						continue
+					}
+					ftx, err := transaction.DeserializeFinishedTransaction(ptx.Data)
+					if err != nil {
+						mark++
+						continue
+					}
+					//pending tx
+					if ftx.BlockNum == 0 {
+						mark++
+						continue
+					}
 
-			tx.State = 1
-			_, err = dbUtil.Engine.ID(tx.Hash).Cols("droped").Update(&tx)
-			if err != nil {
-				break
-			}
+					tx.State = 1
+					_, err = dbUtil.Engine.ID(tx.Hash).Cols("droped").Update(&tx)
+					if err != nil {
+						break
+					}
+				}
+			}(t)
 		}
 
 	}

blockchain/types.go

@@ -11,6 +11,7 @@ const (
 	COLLECT_PARTICIPATE  = "participate"
 	COLLECT_CLAIMREWARDS = "claimRewards"
 	COLLECTCONTRACT      = "0xaaaaaaaaaaaaaaaaa"
+	CONFIRMINTERVAL      = 450
 )
 
 type EventParticipate struct {

dbUtil/dbCoon.go

@@ -18,8 +18,7 @@ func init() {
 	url := beego.AppConfig.String("mysqlurls")
 	dbname := beego.AppConfig.String("mysqldb")
 	port := beego.AppConfig.String("mysqlport")
-	/*orm.RegisterDataBase("vote", "mysql", u+":"+p+"@tcp("+url+":+"+port+")/"+dbname+"?charset=utf8")
-	orm.RegisterModel(new(model.VVoteInfo))*/
+
 	var err error
 	Engine, err = xorm.NewEngine("mysql", u+":"+p+"@tcp("+url+":+"+port+")/"+dbname+"?charset=utf8")
 	if err != nil {

main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	_ "ktogame/blockchain"
+	_ "ktogame/dbUtil"
 	_ "ktogame/routers"
 
 	"github.com/astaxie/beego"