update

blockchain/participate.go

@@ -1,127 +0,0 @@
-package blockchain
-
-import (
-	"errors"
-	"ktogame/controller"
-	"ktogame/models"
-	"ktogame/util"
-	"strconv"
-
-	"github.com/go-xorm/xorm"
-)
-
-/*
-type UserInfo struct {
-	Id               int64
-	Addr             string
-	Direct           string  //我的上级
-	DirectNumber     int     //直推总人数
-	IndirectRewards  float64 `xorm:"Decimal"`
-	Indirect         string  //上上级
-	IndirectNumber   int     //间推总人数
-	DirectRewards    float64 `xorm:"Decimal"`
-	Superiors        string  //所有上级
-	AvailableClaim   float64 `xorm:"Decimal"` //可领取收益
-	TotalClaimed     float64 `xorm:"Decimal"` //总共已领取的收益
-	AvailableReinput float64 `xorm:"Decimal"` //可用复投
-	TotalReinputed   float64 `xorm:"Decimal"` //总复投
-
-	ParticipateAmount float64 `xorm:"Decimal"` //总参与
-
-	State  int //身份   0 1正式   2  社区
-	OpTime string
-	Hash   string
-}
-
-type Performance struct {
-	Id                      int64
-	Addr                    string
-	TotalPerformance        float64 `xorm:"Decimal"`
-	ClaimedPerformanceLevel int
-	PerformanceRewards      float64 `xorm:"Decimal"`
-
-	TotalTeamCultivate    float64 `xorm:"Decimal"`
-	ClaimedCultivateLevel int
-	TeamCultivateRewards  float64 `xorm:"Decimal"`
-
-	CommunityGift float64 `xorm:"Decimal"`
-	CommunityNode float64 `xorm:"Decimal"`
-}
-*/
-
-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")
-	}
-
-	//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 (20%)
-	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
-	}
-	return nil
-}

blockchain/scan.go

@@ -2,6 +2,7 @@ package blockchain
 
 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"ktogame/contractgo/Collect"
 	"ktogame/dbUtil"
@@ -41,6 +42,7 @@ func init() {
 	TopsMap = tm
 
 	go scanBlock()
+	go modifyClaimTxs()
 }
 
 func scanBlock() {
@@ -90,27 +92,49 @@ func scanBlock() {
 			for _, l := range evm.Logs {
 				th := l.Topics[0].Hex()
 				method := TopsMap[th]
-				addr := l.Address.String()
-				if method == COLLECT_PARTICIPATE && addr == COLLECTCONTRACT {
-					var ev EventParticipate
-					abi, err := abi.JSON(strings.NewReader(Collect.CollectMetaData.ABI))
-					if err != nil {
-						ERR = err
-						break
-					}
-					err = abi.UnpackIntoInterface(&ev, method, l.Data)
-					if err != nil {
-						ERR = err
-						break
-					}
-					fmt.Printf("data=%+v\n ", ev)
-					//handle user participate
-					err = participate(dbUtil.Engine, ev.User.String(), ev.Inviter.String(), v.HashToString(), float64(ev.Amount.Uint64()))
-					if err != nil {
-						ERR = err
-						break
+				contract := l.Address.String()
+				if contract == COLLECTCONTRACT {
+					if method == COLLECT_PARTICIPATE {
+						var ev EventParticipate
+						abi, err := abi.JSON(strings.NewReader(Collect.CollectMetaData.ABI))
+						if err != nil {
+							ERR = err
+							break
+						}
+						err = abi.UnpackIntoInterface(&ev, method, l.Data)
+						if err != nil {
+							ERR = err
+							break
+						}
+						fmt.Printf("participate event data=%+v\n ", ev)
+						//handle user participate
+						err = participate(dbUtil.Engine, ev.User.String(), ev.Inviter.String(), v.HashToString(), float64(ev.Amount.Uint64()))
+						if err != nil {
+							ERR = err
+							break
+						}
+					} else if method == COLLECT_CLAIMREWARDS {
+						var evt EventClaim
+						abi, err := abi.JSON(strings.NewReader(Collect.CollectMetaData.ABI))
+						if err != nil {
+							ERR = err
+							break
+						}
+						err = abi.UnpackIntoInterface(&evt, method, l.Data)
+						if err != nil {
+							ERR = err
+							break
+						}
+						fmt.Printf("claim event data=%+v\n ", evt)
+
+						err = checkClaim(dbUtil.Engine, evt.User.String(), v.HashToString(), hex.EncodeToString(evt.Signature), float64(evt.Amount.Uint64()))
+						if err != nil {
+							ERR = err
+							break
+						}
 					}
 				}
+
 			}
 			if ERR != nil {
 				break
@@ -129,3 +153,54 @@ func scanBlock() {
 		currentBlock++
 	}
 }
+
+func modifyClaimTxs() {
+	for {
+		time.Sleep(time.Second)
+		mark := 0
+		var tx models.ClaimedTxs
+		ok, err := dbUtil.Engine.Where("state = ?", 0).Where("droped = ?", 0).Get(&tx)
+		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
+				}
+
+				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.State = 1
+			_, err = dbUtil.Engine.ID(tx.Hash).Cols("droped").Update(&tx)
+			if err != nil {
+				break
+			}
+		}
+
+	}
+
+}

blockchain/types.go

@@ -7,9 +7,10 @@ import (
 )
 
 const (
-	TopicParticipate    = "0xddd670a4142d06229b922c5d433d29131580e1a2952c86700b0a36ea9e8b87ee"
-	COLLECT_PARTICIPATE = "participate"
-	COLLECTCONTRACT     = "0xaaaaaaaaaaaaaaaaa"
+	TopicParticipate     = "0xddd670a4142d06229b922c5d433d29131580e1a2952c86700b0a36ea9e8b87ee"
+	COLLECT_PARTICIPATE  = "participate"
+	COLLECT_CLAIMREWARDS = "claimRewards"
+	COLLECTCONTRACT      = "0xaaaaaaaaaaaaaaaaa"
 )
 
 type EventParticipate struct {
@@ -17,3 +18,8 @@ type EventParticipate struct {
 	Inviter common.Address
 	Amount  *big.Int
 }
+type EventClaim struct {
+	User      common.Address
+	Amount    *big.Int
+	Signature []byte
+}

controller/calculate.go

@@ -22,10 +22,13 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 			return err
 		}
 		if !ok {
-			return errors.New("UpdateSuperiorsPerformance get super failed")
+			continue
 		}
 		supers = append(supers, tmpUser)
 	}
+	if len(supers) == 0 {
+		return nil
+	}
 
 	var rp models.RewardsPool
 	_, err := engine.Id(1).Get(&rp)
@@ -33,17 +36,39 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 		return err
 	}
 
-	for _, user := range supers {
+	for _, super := range supers {
 		var per models.Performance
-		ok, err := engine.Id(user.Addr).Get(&per)
+		ok, err := engine.Id(super.Addr).Get(&per)
 		if err != nil {
-			return err
+			fmt.Println(err)
+			continue
 		}
 		if !ok {
-			return errors.New("UpdateSuperiorsPerformance get performance failed")
+			continue
 		}
 
 		per.TotalPerformance += amount
+		if per.TotalPerformance >= CommunityMarkit*Decimals {
+			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 {
+					continue
+				}
+				super.MarketNum += 1
+				_, err = engine.ID(super.Addr).Cols("markit_num").Update(&super)
+				if err != nil {
+					fmt.Println(err)
+					continue
+				}
+				per.Recorded = 1
+			}
+		}
+
 		var level int = 0
 		for i := 1; i < len(PerformanceLevel); i++ {
 			if PerformanceLevel[i-1] <= per.TotalPerformance && per.TotalPerformance < PerformanceLevel[i] {
@@ -60,12 +85,11 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 					per.PerformanceRewards += rewards //user add rewards to PerformanceRewards
 					per.PerformanceLevel = level
 					//update available
-					err := UpdateAvailableRewards(engine, rewards, user.Addr, false, false)
+					err := UpdateAvailableRewards(engine, rewards, super.Addr, false, false)
 					if err != nil {
 						return err
 					}
-
-					_, err = engine.ID(user.Addr).Cols("total_performance,performance_rewards,performance_level").Update(&per)
+					_, err = engine.ID(super.Addr).Cols("total_performance,performance_rewards,performance_level").Update(&per)
 					if err != nil {
 						return err
 					}
@@ -84,8 +108,8 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 
 func UpdateRewardsPool(engine *xorm.Engine, amount float64) error {
 	var rp models.RewardsPool
-	rp.TeamPerformance = amount * 0.2
-	rp.TeamCultivate = amount * 0.05
+	rp.TeamPerformance = amount * 0.15
+	rp.TeamCultivate = amount * 0.10
 	rp.TotalPool += amount
 	_, err := engine.ID(1).Update(&rp)
 	if err != nil {
@@ -103,7 +127,7 @@ func UpdateAvailableRewards(engine *xorm.Engine, rewards float64, uaddr string,
 		return err
 	}
 	if !ok {
-		return errors.New("engine get failed")
+		return nil
 	}
 	user.AvailableClaim = a_rewards
 	user.AvailableReinput = a_reinput
@@ -140,7 +164,7 @@ func UpdateCommunityGift(engine *xorm.Engine, amount float64, uaddr string) erro
 		return err
 	}
 	if !ok {
-		return errors.New("engine get info failed")
+		return nil
 	}
 
 	ok, err = engine.Desc("id").Get(&tmpUser)
@@ -175,7 +199,7 @@ func UpdateCommunityGift(engine *xorm.Engine, amount float64, uaddr string) erro
 		return err
 	}
 	if !ok {
-		return errors.New("engine get per failed")
+		return nil
 	}
 	per.CommunityGift += rewards
 	_, err = engine.ID(uaddr).Cols("community_gift").Update(&per)
@@ -205,3 +229,54 @@ func UpdateCommunityNodes(engine *xorm.Engine, amount float64) error {
 	}
 	return nil
 }
+
+func UpdateMarket(engine *xorm.Engine, amount float64) error {
+	var pers []models.Performance
+	err := engine.Where("market_num >= ?", 2).Find(&pers)
+	if err != nil {
+		return err
+	}
+	var rp models.RewardsPool
+	ok, err := engine.Id(1).Get(&rp)
+	if err != nil {
+		return err
+	}
+	if !ok {
+		return nil
+	}
+
+	for _, per := range pers {
+		var level int = 0
+		for i := 1; i < len(MarketLevel); i++ {
+			if MarketLevel[i-1] <= per.MarketNum && per.MarketNum < MarketLevel[i] {
+				level = i
+				break
+			}
+		}
+		if level > 0 {
+			if level > per.MarketLevel {
+				ratio := MarketRatio[level] - MarketRatio[per.MarketLevel]
+				rewards := amount * ratio
+				if rp.TeamCultivate >= rewards {
+					rp.TeamCultivate -= rewards  //pool sub rewards
+					per.MarketRewards += rewards //user add rewards to PerformanceRewards
+					per.MarketLevel = level
+					//update available
+					err := UpdateAvailableRewards(engine, rewards, per.Addr, false, false)
+					if err != nil {
+						return err
+					}
+					_, err = engine.ID(per.Addr).Cols("market_level,market_rewards").Update(&per)
+					if err != nil {
+						return err
+					}
+				}
+			}
+		}
+	}
+	_, err = engine.ID(1).Cols("team_performance").Update(&rp)
+	if err != nil {
+		return err
+	}
+	return nil
+}

controller/controller.go

@@ -100,7 +100,7 @@ func (uc *UserController) GetClaimSignature() {
 	code := util.EnPriCode(sign, addr[len(addr)-16:])
 	TxObjectResponse(uc.Controller, code)
 }
-func (uc *UserController) setClaimHash() {
+func (uc *UserController) SetClaimHash() {
 	addr := uc.GetString("addr")
 	sign := uc.GetString("sign")
 	hash := util.GetPri(sign, addr[len(addr)-16:])
@@ -110,14 +110,36 @@ func (uc *UserController) setClaimHash() {
 	}
 
 	var ua models.UserInfo
-	uc.engine.Id(addr).Get(&ua)
+	ok, err := uc.engine.Id(addr).Get(&ua)
+	if err != nil {
+		TxObjectResponse(uc.Controller, "-1")
+		return
+	}
+	if !ok {
+		TxObjectResponse(uc.Controller, "-1")
+		return
+	}
 	if ua.AvailableClaim == 0 {
 		ErrResponse(uc.Controller, "暂无收益领取")
 		return
 	}
+	amount := ua.AvailableClaim
+	ua.TotalClaimed += ua.AvailableClaim
+	ua.AvailableClaim = 0
+	_, err = uc.engine.ID(addr).Cols("total_claimed,available_claim").Update(&ua)
+	if err != nil {
+		ErrResponse(uc.Controller, "-1")
+		return
+	}
 
-	//claimTx := models.ClaimedTxs{}
-
+	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!")
+		return
+	}
+	TxObjectResponse(uc.Controller, "ok")
 }
 func (uc *UserController) GetUserInfo() {}
 func (uc *UserController) GetTeamList() {}

controller/types.go

@@ -9,6 +9,7 @@ const (
 	ParticipateValue = 1030
 	ModBase          = 100
 	CommunityLimit   = 1000
+	CommunityMarkit  = 1000000
 
 	CommonUser     = 0
 	OfficialUser   = 1
@@ -16,5 +17,7 @@ const (
 )
 
 var PerformanceLevel = [9]float64{10000 * Decimals, 30000 * Decimals, 100000 * Decimals, 300000 * Decimals,
-	1000000 * Decimals, 200 * Decimals, 5000000 * Decimals, 10000000 * Decimals, 50000000 * Decimals}
-var PerformanceRatio = [9]float64{0, 0.3, 0.6, 0.9, 0.12, 0.15, 0.17, 0.19, 0.2}
+	1000000 * Decimals, 900000000 * Decimals}
+var PerformanceRatio = [9]float64{0, 0.3, 0.6, 0.9, 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}

models/tables.go

@@ -30,10 +30,11 @@ type Performance struct {
 	TotalPerformance   float64 `xorm:"Decimal"`
 	PerformanceLevel   int
 	PerformanceRewards float64 `xorm:"Decimal"`
+	Recorded           int
 
-	TotalTeamCultivate   float64 `xorm:"Decimal"`
-	CultivateLevel       int
-	TeamCultivateRewards float64 `xorm:"Decimal"`
+	MarketNum     int
+	MarketLevel   int
+	MarketRewards float64 `xorm:"Decimal"`
 
 	CommunityGift float64 `xorm:"Decimal"`
 	CommunityNode float64 `xorm:"Decimal"`
@@ -56,8 +57,9 @@ type ClaimedTxs struct {
 	Addr        string
 	Amount      float64 `xorm:"Decimal"`
 	BlockHeight int64
-	Hash        string
-	Signature   string //主键
+	Hash        string //主键
+	Signature   string
 	CreateTime  string
 	State       int
+	Droped      int
 }