.gitignore

@@ -0,0 +1 @@
+conf

blockchain/contract.go

@@ -115,29 +115,37 @@ func participate(engine *xorm.Engine, user, inviter, hash string, amount float64
 	return nil
 }
 
-func checkClaim(engine *xorm.Engine, addr, hash, sign string, amount float64, height int64) error {
-	logs.Info("checkClaim :", addr, hash, sign, amount)
+func checkClaim(engine *xorm.Engine, addr, hash string, height int64, amount float64, sign string) error {
 	var tx models.ClaimedTxs
 	ok, err := engine.Id(hash).Get(&tx)
 	if err != nil {
+		logs.Error(err)
 		return err
 	}
 	if !ok {
-		//set record
-		logs.Info("set record========")
-		claimTx := models.ClaimedTxs{Addr: addr, Amount: amount, BlockHeight: height, Hash: hash,
-			Signature: sign, State: 1, Droped: 0, CreateTime: util.NowTimeString()}
-		_, err := engine.Insert(&claimTx)
-		if err != nil {
-			return err
+		logs.Info("set new claim record,addr:%v,hash:%v", addr, hash)
+		itx := models.ClaimedTxs{
+			Addr:        addr,
+			BlockHeight: height,
+			Hash:        hash,
+			Signature:   sign,
+			Amount:      amount,
+			State:       1,
+			Droped:      0,
+			CreateTime:  util.NowTimeString(),
 		}
-	} else {
-		logs.Info("update record========")
-		tx.State = 1
-		_, err = engine.ID(hash).Cols("hash").Update(&tx)
+		_, err := engine.Insert(&itx)
 		if err != nil {
 			return err
 		}
+		return nil
+	}
+	logs.Info("update record========:", addr, hash)
+	tx.State = 1
+	tx.BlockHeight = height
+	_, err = engine.ID(hash).Cols("block_height,state").Update(&tx)
+	if err != nil {
+		return err
 	}
 	return nil
 }

blockchain/scan.go

@@ -61,7 +61,6 @@ func scanBlock() {
 		return
 	}
 	currentBlock = uint64(bi.BlockNumber) + 1
-	//currentBlock =62203394
 	for {
 		time.Sleep(time.Second * 3)
 
@@ -71,7 +70,10 @@ func scanBlock() {
 			continue
 		}
 		logs.Info("currentBlock:", currentBlock, "chainblock:", res.MaxHeight)
-		if res.MaxHeight < currentBlock {
+		if res.MaxHeight+1 == currentBlock {
+			continue
+		}
+		if res.MaxHeight+1 < currentBlock {
 			currentBlock = res.MaxHeight
 		}
 
@@ -148,7 +150,8 @@ func scanBlock() {
 							bts = append(bts, b)
 						}
 
-						err = checkClaim(dbUtil.Engine, evt.User.String(), v.HashToString(), hex.EncodeToString(bts), float64(evt.Amount.Uint64()/controller.Decimals), int64(v.BlockNum))
+						err = checkClaim(dbUtil.Engine, evt.User.String(), "0x"+v.HashToString(), int64(v.BlockNum),
+							float64(evt.Amount.Uint64())/controller.Decimals, hex.EncodeToString(bts))
 						if err != nil {
 							logs.Error(err)
 							ERR = err
@@ -178,75 +181,44 @@ func scanBlock() {
 }
 
 func confirmClaimedTxs() {
-	var mark int64 = 0
 	for {
 		time.Sleep(time.Second * 5)
-		logs.Info("confirmClaimedTxs mark= %v\n", mark)
 		var txs []models.ClaimedTxs
-		err := dbUtil.Engine.Where("state = ?", 0).Where("droped = ?", 0).Where("id > ?", mark).Find(&txs)
+		err := dbUtil.Engine.Where("state = ?", 0).Where("droped = ?", 0).Find(&txs)
 		if err != nil {
 			logs.Error(err)
 			continue
 		}
-		if len(txs) > 0 {
-			mark = txs[len(txs)-1].Id
-		}
-		for _, t := range txs {
-			go func(tx models.ClaimedTxs) {
-				interval := 0
-				for {
-					time.Sleep(time.Second * 5)
-					if interval > (CONFIRMINTERVAL / 5) {
-						var ui models.UserInfo
-						_, err := dbUtil.Engine.Id(tx.Hash).Get(&ui)
-						if err != nil {
-							mark = tx.Id - 1
-							return
-						}
-						ui.AvailableClaim += tx.Amount
-						ui.TotalClaimed -= tx.Amount
-						_, err = dbUtil.Engine.ID(tx.Addr).Cols("total_claimed,available_claim").Update(&ui)
-						if err != nil {
-							mark = tx.Id - 1
-							return
-						}
-
-						tx.Droped = 1
-						_, err = dbUtil.Engine.ID(tx.Hash).Cols("droped").Update(&tx)
-						if err != nil {
-							mark = tx.Id - 1
-							return
-						}
-						return
-					}
-					ptx, err := ktoClient.GetTxByHash(context.Background(), &pb.ReqTxByHash{Hash: tx.Hash})
-					if err != nil {
-						interval++
-						continue
-					}
-					if ptx.Code != 0 {
-						interval++
-						continue
-					}
-					ftx, err := transaction.DeserializeFinishedTransaction(ptx.Data)
-					if err != nil {
-						interval++
-						continue
-					}
-					//pending tx
-					if ftx.BlockNum == 0 {
-						interval++
-						continue
-					}
+		logs.Info("confirmClaimedTxs get unconfirmed tx num: %v", len(txs))
+		for _, tx := range txs {
+			loc, _ := time.LoadLocation("Local")
+			formatTime, err := time.ParseInLocation(TimeLayout, tx.CreateTime, loc)
+			if err != nil {
+				logs.Error("confirmClaimedTxs:", err)
+			}
+			if formatTime.Unix()+CONFIRMINTERVAL < time.Now().Unix() {
+				var ui models.UserInfo
+				_, err := dbUtil.Engine.Id(tx.Hash).Get(&ui)
+				if err != nil {
+					logs.Error("confirmClaimedTxs:", err)
+					continue
+				}
+				logs.Info("confirmClaimedTxs mark claimed tx droped,addr:%v,hash:%v,amount:%v", tx.Addr, tx.Hash, tx.Amount)
+				ui.AvailableClaim += tx.Amount
+				ui.TotalClaimed -= tx.Amount
+				_, err = dbUtil.Engine.ID(tx.Addr).Cols("available_claim,total_claimed").Update(&ui)
+				if err != nil {
+					logs.Error("confirmClaimedTxs:", err)
+					continue
+				}
 
-					tx.State = 1
-					_, err = dbUtil.Engine.ID(tx.Hash).Cols("state").Update(&tx)
-					if err != nil {
-						mark = tx.Id - 1
-					}
-					return
+				tx.Droped = 1
+				_, err = dbUtil.Engine.ID(tx.Hash).Cols("droped").Update(&tx)
+				if err != nil {
+					logs.Error("confirmClaimedTxs:", err)
+					continue
 				}
-			}(t)
+			}
 		}
 	}
 }

blockchain/types.go

@@ -7,12 +7,13 @@ import (
 )
 
 const (
-	TOPIC_PARTICIPATE    = "0x8ed860f76da405897619eab937f09dcb4d0d9b56cf68a3d489130a2489cf151f"
-	TOPIC_CLAIM          = "0x4804104ccbc53649f5b8b29ecf858272a4a6ed6b9949f0d30237c7a147e84671"
-	COLLECT_PARTICIPATE  = "Participate"
-	COLLECT_CLAIMREWARDS = "Claim"
-	COLLECTCONTRACT      = "0xC6Ff5462e5409d11AF6B080ADC3dc0a17E94b0A6"
-	CONFIRMINTERVAL      = 450
+	TOPIC_PARTICIPATE           = "0x8ed860f76da405897619eab937f09dcb4d0d9b56cf68a3d489130a2489cf151f"
+	TOPIC_CLAIM                 = "0x4804104ccbc53649f5b8b29ecf858272a4a6ed6b9949f0d30237c7a147e84671"
+	COLLECT_PARTICIPATE         = "Participate"
+	COLLECT_CLAIMREWARDS        = "Claim"
+	COLLECTCONTRACT             = "0xC6Ff5462e5409d11AF6B080ADC3dc0a17E94b0A6" //test
+	CONFIRMINTERVAL             = 600
+	TimeLayout           string = "2006-01-02 15:04:05"
 )
 
 type EventParticipate struct {

conf/app.conf

@@ -1,12 +0,0 @@
-
-httpport = 8080
-runmode = dev
-
-mysqluser = root
-mysqlpass = CFT^7ujm
-mysqlurls = 45.249.245.49
-mysqlport = 3306
-mysqldb   = ktogame
-
-miner_node = 36.255.222.160:13869
-kto_rpc = https://www.kortho-chain.com

conf/locale_en-US.ini

@@ -1,8 +0,0 @@
-addrError = verification code error
-profitNot = There is no income to be collected
-opeaAgain = Request Submission in progress
-success = ok
-addrNowError = Address error
-againBind = Invalid multiple bindings
-idoError = Invalid address, no mint qualification
-againNft = Multiple NFTs, unable to mint

conf/locale_zh-CN.ini

@@ -1,8 +0,0 @@
-success = ok
-addrError = 地址無效
-addrNowError = 當前地址無效
-againBind = 多次綁定無效
-idoError = 地址無效，沒有鑄造資格
-againNft = 多張NFT，無法鑄造
-profitNot = 没有可领取的收益
-opeaAgain = 请勿重复领取

controller/calculate.go

@@ -17,6 +17,7 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 	if len(ids) <= 0 {
 		return nil
 	}
+	logs.Info("UpdateSuperiorsPerformance ids::::::", ids)
 	var supers []models.UserInfo
 	for _, sid := range ids {
 		var tmpUser models.UserInfo
@@ -29,6 +30,7 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 		}
 		supers = append(supers, tmpUser)
 	}
+	logs.Info("UpdateSuperiorsPerformance supers::::::%v", len(supers))
 	if len(supers) == 0 {
 		return nil
 	}
@@ -52,25 +54,24 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 		}
 
 		per.TotalPerformance += amount
-		if per.TotalPerformance >= CommunityMarket {
-			if per.Recorded == 0 {
-				var super models.Performance
-				ok, err := engine.Id(per.Addr).Get(&super)
-				if err != nil {
-					fmt.Println(err)
-					continue
-				}
-				if !ok {
-					logs.Info("%v not exist!", per.Addr)
-					continue
-				}
-				super.MarketNum += 1
-				_, err = engine.ID(super.Addr).Cols("markit_num").Update(&super)
-				if err != nil {
-					fmt.Println(err)
-					continue
-				}
-				per.Recorded = 1
+		if per.TotalPerformance >= float64(CommunityMarket) {
+			var super models.Performance
+			ok, err := engine.Id(per.Addr).Get(&super)
+			if err != nil {
+				fmt.Println(err)
+				continue
+			}
+			if !ok {
+				logs.Info("%v not exist!", per.Addr)
+				continue
+			}
+
+			super.MarketNum = int(per.TotalPerformance / float64(CommunityMarket))
+			logs.Debug("matket check=====,", per.Addr, per.TotalPerformance, CommunityMarket, super.MarketNum)
+			_, err = engine.ID(super.Addr).Cols("market_num").Update(&super)
+			if err != nil {
+				fmt.Println(err)
+				continue
 			}
 		}
 
@@ -81,6 +82,7 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 				break
 			}
 		}
+		logs.Debug("Performance check=====1,", per.Addr, rp.TeamPerformance, per.TotalPerformance, per.PerformanceRewards, level, per.PerformanceLevel)
 		if level > 0 {
 			if level > per.PerformanceLevel {
 				ratio := PerformanceRatio[level] - PerformanceRatio[per.PerformanceLevel]
@@ -90,17 +92,21 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 					per.PerformanceRewards += rewards //user add rewards to PerformanceRewards
 					per.PerformanceLevel = level
 					//update available
+					logs.Debug("Performance check=====2,", per.Addr, level, amount, ratio, rewards)
+
 					err := UpdateAvailableRewards(rewards, super.Addr, false, false)
 					if err != nil {
 						return err
 					}
-					_, err = engine.ID(super.Addr).Cols("total_performance,performance_rewards,performance_level").Update(&per)
-					if err != nil {
-						return err
-					}
 				}
 			}
 		}
+		_, err = engine.ID(super.Addr).Cols("total_performance,performance_level,performance_rewards").Update(&per)
+		if err != nil {
+			return err
+		}
+		logs.Debug("Performance check=====3,", per.Addr, rp.TeamPerformance, per.TotalPerformance, per.PerformanceRewards, per.PerformanceLevel)
+
 	}
 
 	_, err = engine.ID(1).Cols("team_performance").Update(&rp)
@@ -114,10 +120,15 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 func UpdateRewardsPool(engine *xorm.Engine, amount float64) error {
 	logs.Info("into UpdateRewardsPool:", amount)
 	var rp models.RewardsPool
-	rp.TeamPerformance = amount * 0.15
-	rp.TeamCultivate = amount * 0.10
+	_, err := dbUtil.Engine.Id(1).Get(&rp)
+	if err != nil {
+		return err
+	}
+
+	rp.TeamPerformance += amount * 0.15
+	rp.TeamCultivate += amount * 0.10
 	rp.TotalPool += amount
-	_, err := engine.ID(1).Update(&rp)
+	_, err = engine.ID(1).Update(&rp)
 	if err != nil {
 		return err
 	}
@@ -138,8 +149,8 @@ func UpdateAvailableRewards(rewards float64, uaddr string, join, isdirect bool)
 		logs.Info("%v not exist!", uaddr)
 		return nil
 	}
-	user.AvailableClaim = a_rewards
-	user.AvailableReinput = a_reinput
+	user.AvailableClaim += a_rewards
+	user.AvailableReinput += a_reinput
 	if join {
 		if isdirect {
 			user.DirectNumber += 1
@@ -241,6 +252,20 @@ func UpdateCommunityNodes(engine *xorm.Engine, amount float64) error {
 			fmt.Println(err)
 			continue
 		}
+
+		var per models.Performance
+		_, err = engine.Id(node.Addr).Get(&per)
+		if err != nil {
+			fmt.Println(err)
+			continue
+		}
+
+		per.CommunityNode += rewards
+		_, err = engine.ID(node.Addr).Cols("community_node").Update(&per)
+		if err != nil {
+			fmt.Println(err)
+			continue
+		}
 	}
 	logs.Info("into UpdateCommunityNodes end:", amount)
 	return nil
@@ -270,6 +295,8 @@ func UpdateMarket(engine *xorm.Engine, amount float64) error {
 				break
 			}
 		}
+		logs.Debug(" UpdateMarket=====1,", per.Addr, rp.TeamCultivate, per.MarketRewards, level, per.MarketLevel)
+
 		if level > 0 {
 			if level > per.MarketLevel {
 				ratio := MarketRatio[level] - MarketRatio[per.MarketLevel]
@@ -279,6 +306,8 @@ func UpdateMarket(engine *xorm.Engine, amount float64) error {
 					per.MarketRewards += rewards //user add rewards to PerformanceRewards
 					per.MarketLevel = level
 					//update available
+					logs.Debug(" UpdateMarket=====2,", per.Addr, rewards)
+
 					err := UpdateAvailableRewards(rewards, per.Addr, false, false)
 					if err != nil {
 						return err
@@ -290,6 +319,8 @@ func UpdateMarket(engine *xorm.Engine, amount float64) error {
 				}
 			}
 		}
+		logs.Debug(" UpdateMarket=====3,", per.Addr, rp.TeamCultivate, per.MarketRewards, level, per.MarketLevel)
+
 	}
 	_, err = engine.ID(1).Cols("team_performance").Update(&rp)
 	if err != nil {

controller/controller.go

@@ -7,6 +7,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/astaxie/beego/logs"
+
 	"github.com/shopspring/decimal"
 )
 
@@ -19,33 +21,20 @@ func (uc *UserController) Reinput() {
 		return
 	}
 	if !ok {
-		ErrResponse(uc.Controller, "db get failed!")
-		return
-	}
-	if ui.AvailableReinput < ModBase {
-		ErrResponse(uc.Controller, "no available reinput balance")
+		ErrResponse(uc.Controller, "user not exist!")
 		return
 	}
 
 	///update availableReinput by left in db
 	///update totalReinput
-	left := uint64(ui.AvailableReinput) % ModBase
-	reinputValue := ui.AvailableReinput - float64(left)
-	ui.AvailableReinput = float64(left)
-	ui.TotalReinputed += reinputValue
-	if ui.TotalReinputed >= CommunityLimit {
-		ui.State = CommunityUsers
-	}
-	_, err = uc.engine.ID(user).Cols("available_reinput").Update(&ui)
-	if err != nil {
-		ErrResponse(uc.Controller, err)
-		return
-	}
-	_, err = uc.engine.ID(user).Cols("total_reinput").Update(&ui)
-	if err != nil {
-		ErrResponse(uc.Controller, err)
+	if ui.AvailableReinput < ModBase {
+		ErrResponse(uc.Controller, "no available reinput balance")
 		return
 	}
+	num := uint64(ui.AvailableReinput) / uint64(ModBase)
+
+	reinputValue := float64(num * ModBase)
+	logs.Info("check Reinput user:%v,num:%v available:%v,reinputValue=======%v", user, num, ui.AvailableReinput, reinputValue)
 
 	///update Recommendation Rewards
 	///update direct recommend rewards
@@ -53,6 +42,7 @@ func (uc *UserController) Reinput() {
 	if ui.Direct != "" {
 		err := UpdateAvailableRewards(rewards, ui.Direct, false, false)
 		if err != nil {
+			logs.Error("check err=======", err)
 			ErrResponse(uc.Controller, err)
 			return
 		}
@@ -61,21 +51,38 @@ func (uc *UserController) Reinput() {
 	if ui.Indirect != "" {
 		err := UpdateAvailableRewards(rewards, ui.Indirect, false, false)
 		if err != nil {
+			logs.Error("check err=======", err)
 			ErrResponse(uc.Controller, err)
 			return
 		}
 	}
 	err = UpdateRewardsPool(uc.engine, reinputValue)
 	if err != nil {
+		logs.Error("check err=======", err)
 		ErrResponse(uc.Controller, err)
 		return
 	}
 	err = UpdateSuperiorsPerformance(uc.engine, ui.Superiors, reinputValue)
 	if err != nil {
+		logs.Error("check err=======", err)
+		ErrResponse(uc.Controller, err)
+		return
+	}
+
+	ui.AvailableReinput -= reinputValue
+	ui.TotalReinputed += reinputValue
+
+	if ui.TotalReinputed >= CommunityLimit {
+		ui.State = CommunityUsers
+	}
+	_, err = uc.engine.ID(user).Cols("available_reinput,total_reinputed,state").Update(&ui)
+	if err != nil {
+		logs.Error("check err=======", err)
 		ErrResponse(uc.Controller, err)
 		return
 	}
 	TxObjectResponse(uc.Controller, "ok")
+	return
 }
 func (uc *UserController) GetClaimSignature() {
 	addr := uc.GetString("addr")
@@ -92,34 +99,32 @@ func (uc *UserController) GetClaimSignature() {
 		return
 	}
 
-	format := time.Now().AddDate(0, 0, 1).Format("2006-01-02")
-	te, _ := time.ParseInLocation("2006-01-02", format, time.Local)
+	// format := time.Now().AddDate(0, 0, 1).Format("2006-01-02")
+	// te, _ := time.ParseInLocation("2006-01-02", format, time.Local)
+	i_time := time.Now().Unix() + 3600*2
 
 	pow := decimal.NewFromFloat(float64(10)).Pow(decimal.NewFromFloat(float64(18)))
 	amount := decimal.NewFromFloat(ua.AvailableClaim).Mul(pow).BigInt().String()
 
-	out1 := util.Sign(amount, strings.ToLower(user[2:]), fmt.Sprint(te.Unix()))
-	sign := out1 + "-" + amount + "-" + fmt.Sprint(te.Unix())
+	out1 := util.Sign(amount, strings.ToLower(user[2:]), fmt.Sprint(i_time))
+	sign := out1 + "-" + amount + "-" + fmt.Sprint(i_time)
 	code := util.EnPriCode(sign, addr[len(addr)-16:])
 	TxObjectResponse(uc.Controller, code)
+	return
 }
 func (uc *UserController) SetClaimHash() {
 	addr := uc.GetString("addr")
+	hash := uc.GetString("hash")
 	sign := uc.GetString("sign")
-	hash := util.GetPri(sign, addr[len(addr)-16:])
-	if len(hash) != 66 {
-		TxObjectResponse(uc.Controller, "-1")
-		return
-	}
 
 	var ua models.UserInfo
 	ok, err := uc.engine.Id(addr).Get(&ua)
 	if err != nil {
-		TxObjectResponse(uc.Controller, "-1")
+		ErrResponse(uc.Controller, err)
 		return
 	}
 	if !ok {
-		TxObjectResponse(uc.Controller, "user not exist!")
+		ErrResponse(uc.Controller, "user not exist!")
 		return
 	}
 	if ua.AvailableClaim == 0 {
@@ -127,19 +132,19 @@ func (uc *UserController) SetClaimHash() {
 		return
 	}
 	amount := ua.AvailableClaim
-	ua.TotalClaimed += ua.AvailableClaim
+	ua.TotalClaimed += amount
 	ua.AvailableClaim = 0
-	_, err = uc.engine.ID(addr).Cols("total_claimed,available_claim").Update(&ua)
+	_, err = uc.engine.ID(addr).Cols("available_claim,total_claimed").Update(&ua)
 	if err != nil {
-		ErrResponse(uc.Controller, "-1")
+		ErrResponse(uc.Controller, err)
 		return
 	}
-
+	logs.Info("check SetClaimHash---------:", addr, hash, ua.AvailableClaim, ua.TotalClaimed, amount)
 	claimTx := models.ClaimedTxs{Addr: addr, Amount: amount, Hash: hash,
 		Signature: sign, State: 0, Droped: 0, CreateTime: util.NowTimeString()}
 	_, err = uc.engine.Insert(&claimTx)
 	if err != nil {
-		ErrResponse(uc.Controller, "set claim tx info failed!")
+		ErrResponse(uc.Controller, err)
 		return
 	}
 	TxObjectResponse(uc.Controller, "ok")
@@ -148,15 +153,8 @@ func (uc *UserController) SetClaimHash() {
 func (uc *UserController) GetUserInfo() {
 	user := uc.GetString("addr")
 	var us models.UserInfo
-	ok, err := uc.engine.ID(user).Get(&us)
-	if err != nil {
-		TxObjectResponse(uc.Controller, err)
-		return
-	}
-	if !ok {
-		TxObjectResponse(uc.Controller, us)
-		return
-	}
+	uc.engine.Id(user).Get(&us)
+
 	TxObjectResponse(uc.Controller, us)
 	return
 }
@@ -175,7 +173,7 @@ func (uc *UserController) GetTeamList() {
 	var us models.UserInfo
 	var teamList []models.UserInfo
 
-	ok, err := uc.engine.ID(user).Get(&us)
+	ok, err := uc.engine.Id(user).Get(&us)
 	if err != nil {
 		TxObjectResponse(uc.Controller, err)
 		return
@@ -185,7 +183,7 @@ func (uc *UserController) GetTeamList() {
 		return
 	}
 
-	c, err := uc.engine.Where("superiors like ?", "%,"+fmt.Sprint(us.Id)).FindAndCount(&teamList)
+	c, err := uc.engine.Where("superiors like ?", "%,"+fmt.Sprint(us.Id)+"%").FindAndCount(&teamList)
 	if err != nil {
 		TxObjectResponse(uc.Controller, err)
 		return
@@ -201,30 +199,18 @@ func (uc *UserController) GetTeamList() {
 func (uc *UserController) GetPerformance() {
 	user := uc.GetString("addr")
 	var per models.Performance
-
-	ok, err := uc.engine.Id(user).Get(&per)
-	if err != nil {
-		TxObjectResponse(uc.Controller, err)
-		return
-	}
-	if !ok {
-		TxObjectResponse(uc.Controller, per)
-		return
-	}
+	uc.engine.Id(user).Get(&per)
 	TxObjectResponse(uc.Controller, per)
 	return
 }
 func (uc *UserController) TotalUsers() {
 	var us models.UserInfo
-	ok, err := uc.engine.Desc("id").Get(&us)
+	c, err := uc.engine.Count(&us)
 	if err != nil {
-		TxObjectResponse(uc.Controller, err)
-		return
-	}
-	if !ok {
-		TxObjectResponse(uc.Controller, us)
+		ErrResponse(uc.Controller, err)
 		return
 	}
+	us.Id = c
 	TxObjectResponse(uc.Controller, us)
 	return
 }

controller/types.go

@@ -16,7 +16,9 @@ const (
 	CommunityUsers = 2
 )
 
-var PerformanceLevel = [9]float64{10000, 30000, 100000, 300000, 1000000, 900000000}
-var PerformanceRatio = [9]float64{0, 0.3, 0.6, 0.9, 0.12, 0.15}
+//var PerformanceLevel = [6]float64{1, 3, 5, 7, 9, 11}	//test
+
+var PerformanceLevel = [6]float64{10000, 30000, 100000, 300000, 1000000, 900000000}
+var PerformanceRatio = [6]float64{0, 0.03, 0.06, 0.09, 0.12, 0.15}
 var MarketLevel = [5]int{2, 3, 4, 5, 6}
 var MarketRatio = [5]float64{0, 0.04, 0.06, 0.08, 0.10}

dbUtil/dbCoon.go

@@ -26,4 +26,5 @@ func init() {
 	}
 	Engine = e
 	fmt.Println("dbUtil init")
+	//Engine.ShowSQL(true)
 }

enums/CommonErrorResult.go

@@ -36,8 +36,9 @@ const (
 	VERIFYCONTRACT = "0x8e437A9a89E16ED807Ab1841C029e5e9C4A82c74"
 	USDT           = "0xa6ea066bae96432414ac62818e62e2ecaa570de3" //usdt合约
 	//GDLCONTRACT = "0x9830c7dbcff54eb564ef952e2e5634787fc1c5d8" //代币合约地址
-	KTOCONTRACT = "0x3850D46C0442A86AaDd41D99f635e316c8788269"                         //kto合约地址
-	DIGIT       = "0xc14771a70de44653a1fea2f9ab9eb3d69dbcbee7352bf3aee607c541955eb9ee" //签名验证的盐
+	KTOCONTRACT = "0x3850D46C0442A86AaDd41D99f635e316c8788269" //kto合约地址
+	//DIGIT       = "0xc14771a70de44653a1fea2f9ab9eb3d69dbcbee7352bf3aee607c541955eb9ee" //签名验证的盐test
+	DIGIT = "0xce832387833fd72921b64fcb454dcc394940a5cdb53125e579ed10d529799e3c"
 )
 
 func (c CommonErrorResult) String() string {

main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	_ "ktogame/blockchain"
 	_ "ktogame/dbUtil"
 	_ "ktogame/routers"
@@ -31,6 +30,5 @@ func main() {
 	i18n.SetMessage("zh-CN", "conf/locale_zh-CN.ini")
 	i18n.SetMessage("en-US", "conf/locale_en-US.ini")
 	beego.BConfig.RecoverPanic = true
-	fmt.Println("main============")
 	beego.Run()
 }

models/tables.go

@@ -5,10 +5,10 @@ type UserInfo struct {
 	Addr              string  `xorm:"pk"` //主键
 	Direct            string  //我的上级
 	DirectNumber      int     //直推总人数
-	IndirectRewards   float64 `xorm:"Decimal"`
+	IndirectRewards   float64 `xorm:"Decimal"` //间推奖励
 	Indirect          string  //上上级
 	IndirectNumber    int     //间推总人数
-	DirectRewards     float64 `xorm:"Decimal"`
+	DirectRewards     float64 `xorm:"Decimal"` //直推奖励
 	Superiors         string  //所有上级
 	AvailableClaim    float64 `xorm:"Decimal"` //可领取收益
 	TotalClaimed      float64 `xorm:"Decimal"` //总共已领取的收益
@@ -16,28 +16,23 @@ type UserInfo struct {
 	TotalReinputed    float64 `xorm:"Decimal"` //总复投
 	ParticipateAmount float64 `xorm:"Decimal"` //总参与
 
-	State      int //身份   0 1正式   2  社区
+	State      int //身份   0 普通 	 1 正式   2 社区
 	CreateTime string
 	Hash       string
 }
 
-// TeamCultivate float64 `xorm:"Decimal"`
-// 	CommunityGift float64 `xorm:"Decimal"`
-// 	CommunityNode float64 `xorm:"Decimal"`
-
 type Performance struct {
-	Addr               string  `xorm:"pk"` //主键
-	TotalPerformance   float64 `xorm:"Decimal"`
+	Addr               string  `xorm:"pk"`      //主键
+	TotalPerformance   float64 `xorm:"Decimal"` //团队总业绩
 	PerformanceLevel   int
-	PerformanceRewards float64 `xorm:"Decimal"`
-	Recorded           int
+	PerformanceRewards float64 `xorm:"Decimal"` //团队收益
 
 	MarketNum     int
 	MarketLevel   int
-	MarketRewards float64 `xorm:"Decimal"`
+	MarketRewards float64 `xorm:"Decimal"` //市场收益
 
-	CommunityGift float64 `xorm:"Decimal"`
-	CommunityNode float64 `xorm:"Decimal"`
+	CommunityGift float64 `xorm:"Decimal"` //团队赠送收益
+	CommunityNode float64 `xorm:"Decimal"` //社区节点收益
 }
 
 type BlockInfo struct {
@@ -58,7 +53,7 @@ type ClaimedTxs struct {
 	Addr        string
 	Amount      float64 `xorm:"Decimal"`
 	BlockHeight int64
-	Hash        string //主键
+	Hash        string `xorm:"pk"` //主键
 	Signature   string
 	CreateTime  string
 	State       int