online code

blockchain/contract.go

@@ -1,7 +1,9 @@
 package blockchain
 
 import (
+	"errors"
 	"ktogame/controller"
+	"ktogame/dbUtil"
 	"ktogame/models"
 	"ktogame/util"
 	"strconv"
@@ -11,12 +13,23 @@ import (
 	"github.com/go-xorm/xorm"
 )
 
-func participate(engine *xorm.Engine, user, inviter, hash string, amount float64) error {
+func participate(user, inviter, hash string, amount float64) error {
+	logs.Info("into participate=====")
+	sesion := dbUtil.Engine.NewSession()
+	var Error error
+	defer func() {
+		if Error != nil {
+			sesion.Rollback()
+		} else {
+			sesion.Commit()
+			logs.Info("participate end=====")
+		}
+	}()
 	var ui, dui models.UserInfo
-	ok, err := engine.Id(inviter).Get(&dui)
-	if err != nil {
-		logs.Info(err)
-		return err
+	ok, Error := sesion.ID(inviter).Get(&dui)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 	if !ok {
 		dui.Id = -1
@@ -36,82 +49,82 @@ func participate(engine *xorm.Engine, user, inviter, hash string, amount float64
 	ui.CreateTime = util.NowTimeString()
 	ui.Hash = hash
 	logs.Info("user info:", ui.Direct, ui.Indirect, ui.Superiors)
-	okk, err := engine.Id(ui.Addr).Get(&dui)
-	if err != nil {
-		logs.Info(err)
-		return err
+	okk, Error := sesion.ID(ui.Addr).Get(&dui)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 	if okk {
+		Error = errors.New("user already participated")
 		logs.Info("%v already participated!", ui.Addr)
 		return nil
 	}
-	_, err = engine.Insert(&ui)
-	if err != nil {
-		logs.Info(err)
-		return err
+	_, Error = sesion.Insert(&ui)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 
 	//insert new user Performance
 	var uper models.Performance
 	uper.Addr = user
-	_, err = engine.Insert(&uper)
-	if err != nil {
-		return err
+	_, Error = sesion.Insert(&uper)
+	if Error != nil {
+		return Error
 	}
 
 	//update rewards pool
-	err = controller.UpdateRewardsPool(engine, amount)
-	if err != nil {
-		logs.Info(err)
-		return err
+	Error = controller.UpdateRewardsPool(sesion, amount)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 
 	///update Recommendation Rewards
 	///update direct recommend rewards(10%)
 	rewards := amount * 10 / 100
 	if ui.Direct != "" {
-		err := controller.UpdateAvailableRewards(rewards, ui.Direct, true, true)
-		if err != nil {
-			logs.Info(err)
-			return err
+		Error = controller.UpdateAvailableRewards(sesion, rewards, ui.Direct, true, true)
+		if Error != nil {
+			logs.Info(Error)
+			return Error
 		}
 	}
 	///update indirect recommend rewards(10%)
 	if ui.Indirect != "" {
-		err := controller.UpdateAvailableRewards(rewards, ui.Indirect, true, false)
-		if err != nil {
-			logs.Info(err)
-			return err
+		Error = controller.UpdateAvailableRewards(sesion, rewards, ui.Indirect, true, false)
+		if Error != nil {
+			logs.Info(Error)
+			return Error
 		}
 	}
 
 	//update all supers performance (15%)
-	err = controller.UpdateSuperiorsPerformance(engine, ui.Superiors, amount)
-	if err != nil {
-		logs.Info(err)
-		return err
+	Error = controller.UpdateSuperiorsPerformance(sesion, ui.Superiors, amount)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 	//update Community Gift(50%)
-	err = controller.UpdateCommunityGift(engine, amount, inviter)
-	if err != nil {
-		logs.Info(err)
-		return err
+	Error = controller.UpdateCommunityGift(sesion, amount, inviter)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 
 	//Update Community Nodes(5%)
-	err = controller.UpdateCommunityNodes(engine, amount)
-	if err != nil {
-		logs.Info(err)
-		return err
+	Error = controller.UpdateCommunityNodes(sesion, amount)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 
 	//update Market(10%)
-	err = controller.UpdateMarket(engine, amount)
-	if err != nil {
-		logs.Info(err)
-		return err
+	Error = controller.UpdateMarket(sesion, amount)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
-	logs.Info("participate end")
 	return nil
 }
 

blockchain/scan.go

@@ -61,6 +61,7 @@ func scanBlock() {
 		return
 	}
 	currentBlock = uint64(bi.BlockNumber) + 1
+	logs.Info("currentBlock===", currentBlock)
 	for {
 		time.Sleep(time.Second * 3)
 
@@ -123,7 +124,7 @@ func scanBlock() {
 						}
 						logs.Info("participate data:", ev.Participant.String(), ev.Inviter.String(), v.HashToString(), float64(ev.Amount.Uint64()/controller.Decimals))
 						//handle user participate
-						err = participate(dbUtil.Engine, ev.Participant.String(), ev.Inviter.String(), v.HashToString(), float64(ev.Amount.Uint64()/controller.Decimals))
+						err = participate(ev.Participant.String(), ev.Inviter.String(), v.HashToString(), float64(ev.Amount.Uint64()/controller.Decimals))
 						if err != nil {
 							logs.Error(err)
 							ERR = err

blockchain/types.go

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

controller/calculate.go

@@ -2,7 +2,6 @@ package controller
 
 import (
 	"fmt"
-	"ktogame/dbUtil"
 	"ktogame/models"
 	"strings"
 
@@ -11,7 +10,7 @@ import (
 	"github.com/go-xorm/xorm"
 )
 
-func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount float64) error {
+func UpdateSuperiorsPerformance(engine *xorm.Session, superiorsStr string, amount float64) error {
 	logs.Info("into UpdateSuperiorsPerformance:", superiorsStr, amount)
 	ids := strings.Split(superiorsStr, ",")
 	if len(ids) <= 0 {
@@ -36,14 +35,14 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 	}
 
 	var rp models.RewardsPool
-	_, err := engine.Id(1).Get(&rp)
+	_, err := engine.ID(1).Get(&rp)
 	if err != nil {
 		return err
 	}
 
 	for _, super := range supers {
 		var per models.Performance
-		ok, err := engine.Id(super.Addr).Get(&per)
+		ok, err := engine.ID(super.Addr).Get(&per)
 		if err != nil {
 			fmt.Println(err)
 			continue
@@ -56,7 +55,7 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 		per.TotalPerformance += amount
 		if per.TotalPerformance >= float64(CommunityMarket) {
 			var super models.Performance
-			ok, err := engine.Id(per.Addr).Get(&super)
+			ok, err := engine.ID(per.Addr).Get(&super)
 			if err != nil {
 				fmt.Println(err)
 				continue
@@ -94,7 +93,7 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 					//update available
 					logs.Debug("Performance check=====2,", per.Addr, level, amount, ratio, rewards)
 
-					err := UpdateAvailableRewards(rewards, super.Addr, false, false)
+					err := UpdateAvailableRewards(engine, rewards, super.Addr, false, false)
 					if err != nil {
 						return err
 					}
@@ -113,14 +112,14 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 	if err != nil {
 		return err
 	}
-	logs.Info("into UpdateSuperiorsPerformance end:", rp)
+	logs.Info("UpdateSuperiorsPerformance end:", rp)
 	return nil
 }
 
-func UpdateRewardsPool(engine *xorm.Engine, amount float64) error {
+func UpdateRewardsPool(engine *xorm.Session, amount float64) error {
 	logs.Info("into UpdateRewardsPool:", amount)
 	var rp models.RewardsPool
-	_, err := dbUtil.Engine.Id(1).Get(&rp)
+	_, err := engine.ID(1).Get(&rp)
 	if err != nil {
 		return err
 	}
@@ -136,12 +135,12 @@ func UpdateRewardsPool(engine *xorm.Engine, amount float64) error {
 	return nil
 }
 
-func UpdateAvailableRewards(rewards float64, uaddr string, join, isdirect bool) error {
+func UpdateAvailableRewards(engine *xorm.Session, rewards float64, uaddr string, join, isdirect bool) error {
 	logs.Info("into UpdateAvailableRewards:", rewards, uaddr, join, isdirect)
 	a_rewards := rewards * 60 / 100
 	a_reinput := rewards * 40 / 100
 	var user models.UserInfo
-	ok, err := dbUtil.Engine.Id(uaddr).Get(&user)
+	ok, err := engine.ID(uaddr).Get(&user)
 	if err != nil {
 		return err
 	}
@@ -156,7 +155,7 @@ func UpdateAvailableRewards(rewards float64, uaddr string, join, isdirect bool)
 			user.DirectNumber += 1
 			user.DirectRewards += rewards
 			logs.Info("check direct info=====:", rewards, a_rewards, a_reinput, user.AvailableClaim, user.AvailableReinput, user.DirectNumber, user.DirectRewards)
-			_, err := dbUtil.Engine.ID(user.Addr).Cols("available_claim,available_reinput,direct_number,direct_rewards").Update(&user)
+			_, err := engine.ID(user.Addr).Cols("available_claim,available_reinput,direct_number,direct_rewards").Update(&user)
 			if err != nil {
 				return err
 			}
@@ -164,26 +163,26 @@ func UpdateAvailableRewards(rewards float64, uaddr string, join, isdirect bool)
 			user.IndirectNumber += 1
 			user.IndirectRewards += rewards
 			logs.Info("check indirect info=====:", rewards, a_rewards, a_reinput, user.AvailableClaim, user.AvailableReinput, user.DirectNumber, user.DirectRewards)
-			_, err := dbUtil.Engine.ID(user.Addr).Cols("available_claim,available_reinput,indirect_number,indirect_rewards").Update(&user)
+			_, err := engine.ID(user.Addr).Cols("available_claim,available_reinput,indirect_number,indirect_rewards").Update(&user)
 			if err != nil {
 				return err
 			}
 		}
 	} else {
 		logs.Info("check else info=====:", user.AvailableClaim, user.AvailableReinput)
-		_, err := dbUtil.Engine.ID(user.Addr).Cols("available_claim,available_reinput").Update(&user)
+		_, err := engine.ID(user.Addr).Cols("available_claim,available_reinput").Update(&user)
 		if err != nil {
 			return err
 		}
 	}
-	logs.Info("into UpdateAvailableRewards end:", user)
+	logs.Info("UpdateAvailableRewards end:", user)
 	return nil
 }
 
-func UpdateCommunityGift(engine *xorm.Engine, amount float64, uaddr string) error {
+func UpdateCommunityGift(engine *xorm.Session, amount float64, uaddr string) error {
 	logs.Info("into UpdateCommunityGift:", amount, uaddr)
 	var user, tmpUser models.UserInfo
-	ok, err := engine.Id(uaddr).Get(&user)
+	ok, err := engine.ID(uaddr).Get(&user)
 	if err != nil {
 		return err
 	}
@@ -213,13 +212,13 @@ func UpdateCommunityGift(engine *xorm.Engine, amount float64, uaddr string) erro
 	}
 
 	rewards := amount * (float64(leftNum+rightNum) / 100)
-	err = UpdateAvailableRewards(rewards, user.Addr, false, false)
+	err = UpdateAvailableRewards(engine, rewards, user.Addr, false, false)
 	if err != nil {
 		return err
 	}
 
 	var per models.Performance
-	ok, err = engine.Id(uaddr).Get(&per)
+	ok, err = engine.ID(uaddr).Get(&per)
 	if err != nil {
 		return err
 	}
@@ -231,11 +230,11 @@ func UpdateCommunityGift(engine *xorm.Engine, amount float64, uaddr string) erro
 	if err != nil {
 		return err
 	}
-	logs.Info("into UpdateCommunityGift end:", amount, uaddr)
+	logs.Info("UpdateCommunityGift end:", amount, uaddr)
 	return nil
 }
 
-func UpdateCommunityNodes(engine *xorm.Engine, amount float64) error {
+func UpdateCommunityNodes(engine *xorm.Session, amount float64) error {
 	logs.Info("into UpdateCommunityNodes:", amount)
 	var nodes []models.UserInfo
 	err := engine.Where("state = ?", CommunityUsers).Find(&nodes)
@@ -247,14 +246,14 @@ func UpdateCommunityNodes(engine *xorm.Engine, amount float64) error {
 	}
 	rewards := (amount * 5 / 100) / float64(len(nodes))
 	for _, node := range nodes {
-		err = UpdateAvailableRewards(rewards, node.Addr, false, false)
+		err = UpdateAvailableRewards(engine, rewards, node.Addr, false, false)
 		if err != nil {
 			fmt.Println(err)
 			continue
 		}
 
 		var per models.Performance
-		_, err = engine.Id(node.Addr).Get(&per)
+		_, err = engine.ID(node.Addr).Get(&per)
 		if err != nil {
 			fmt.Println(err)
 			continue
@@ -267,11 +266,11 @@ func UpdateCommunityNodes(engine *xorm.Engine, amount float64) error {
 			continue
 		}
 	}
-	logs.Info("into UpdateCommunityNodes end:", amount)
+	logs.Info("UpdateCommunityNodes end:", amount)
 	return nil
 }
 
-func UpdateMarket(engine *xorm.Engine, amount float64) error {
+func UpdateMarket(engine *xorm.Session, amount float64) error {
 	logs.Info("into UpdateMarket:", amount)
 	var pers []models.Performance
 	err := engine.Where("market_num >= ?", 2).Find(&pers)
@@ -279,7 +278,7 @@ func UpdateMarket(engine *xorm.Engine, amount float64) error {
 		return err
 	}
 	var rp models.RewardsPool
-	ok, err := engine.Id(1).Get(&rp)
+	ok, err := engine.ID(1).Get(&rp)
 	if err != nil {
 		return err
 	}
@@ -308,7 +307,7 @@ func UpdateMarket(engine *xorm.Engine, amount float64) error {
 					//update available
 					logs.Debug(" UpdateMarket=====2,", per.Addr, rewards)
 
-					err := UpdateAvailableRewards(rewards, per.Addr, false, false)
+					err := UpdateAvailableRewards(engine, rewards, per.Addr, false, false)
 					if err != nil {
 						return err
 					}
@@ -326,6 +325,6 @@ func UpdateMarket(engine *xorm.Engine, amount float64) error {
 	if err != nil {
 		return err
 	}
-	logs.Info("into UpdateMarket end:", amount)
+	logs.Info("UpdateMarket end:", amount)
 	return nil
 }

controller/controller.go

@@ -1,6 +1,7 @@
 package controller
 
 import (
+	"errors"
 	"fmt"
 	"ktogame/models"
 	"ktogame/util"
@@ -13,59 +14,63 @@ import (
 )
 
 func (uc *UserController) Reinput() {
+	sesion := uc.engine.NewSession()
+	var Error error
+	defer func() {
+		if Error != nil {
+			sesion.Rollback()
+			ErrResponse(uc.Controller, Error)
+		} else {
+			sesion.Commit()
+		}
+	}()
 	user := uc.GetString("addr")
 	var ui models.UserInfo
-	ok, err := uc.engine.Id(user).Get(&ui)
-	if err != nil {
-		ErrResponse(uc.Controller, err)
+	ok, Error := uc.engine.Id(user).Get(&ui)
+	if Error != nil {
 		return
 	}
 	if !ok {
-		ErrResponse(uc.Controller, "user not exist!")
+		Error = errors.New("user not exist")
 		return
 	}
 
 	///update availableReinput by left in db
 	///update totalReinput
 	if ui.AvailableReinput < ModBase {
-		ErrResponse(uc.Controller, "no available reinput balance")
+		Error = errors.New("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)
+
+	//test
+	//reinputValue := ui.AvailableReinput
+	//test end
+	logs.Info("check Reinput user:%v,num:%v available:%v,reinputValue=======%v", user, ui.AvailableReinput, reinputValue)
 
 	///update Recommendation Rewards
 	///update direct recommend rewards
 	rewards := reinputValue * 10 / 100
 	if ui.Direct != "" {
-		err := UpdateAvailableRewards(rewards, ui.Direct, false, false)
-		if err != nil {
-			logs.Error("check err=======", err)
-			ErrResponse(uc.Controller, err)
+		Error = UpdateAvailableRewards(sesion, rewards, ui.Direct, false, false)
+		if Error != nil {
 			return
 		}
 	}
 	///update indirect recommend rewards
 	if ui.Indirect != "" {
-		err := UpdateAvailableRewards(rewards, ui.Indirect, false, false)
-		if err != nil {
-			logs.Error("check err=======", err)
-			ErrResponse(uc.Controller, err)
+		Error = UpdateAvailableRewards(sesion, rewards, ui.Indirect, false, false)
+		if Error != nil {
 			return
 		}
 	}
-	err = UpdateRewardsPool(uc.engine, reinputValue)
-	if err != nil {
-		logs.Error("check err=======", err)
-		ErrResponse(uc.Controller, err)
+	Error = UpdateRewardsPool(sesion, reinputValue)
+	if Error != nil {
 		return
 	}
-	err = UpdateSuperiorsPerformance(uc.engine, ui.Superiors, reinputValue)
-	if err != nil {
-		logs.Error("check err=======", err)
-		ErrResponse(uc.Controller, err)
+	Error = UpdateSuperiorsPerformance(sesion, ui.Superiors, reinputValue)
+	if Error != nil {
 		return
 	}
 
@@ -75,10 +80,8 @@ func (uc *UserController) Reinput() {
 	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)
+	_, Error = uc.engine.ID(user).Cols("available_reinput,total_reinputed,state").Update(&ui)
+	if Error != nil {
 		return
 	}
 	TxObjectResponse(uc.Controller, "ok")
@@ -99,8 +102,6 @@ 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)
 	i_time := time.Now().Unix() + 3600*2
 
 	pow := decimal.NewFromFloat(float64(10)).Pow(decimal.NewFromFloat(float64(18)))
@@ -117,36 +118,46 @@ func (uc *UserController) SetClaimHash() {
 	hash := uc.GetString("hash")
 	sign := uc.GetString("sign")
 
+	sesion := uc.engine.NewSession()
+	var Error error
+	defer func() {
+		if Error != nil {
+			sesion.Rollback()
+			ErrResponse(uc.Controller, Error)
+			return
+		}
+		sesion.Commit()
+	}()
+
 	var ua models.UserInfo
-	ok, err := uc.engine.Id(addr).Get(&ua)
-	if err != nil {
-		ErrResponse(uc.Controller, err)
+	ok, Error := uc.engine.Id(addr).Get(&ua)
+	if Error != nil {
 		return
 	}
 	if !ok {
-		ErrResponse(uc.Controller, "user not exist!")
+		Error = errors.New("user not exist")
 		return
 	}
 	if ua.AvailableClaim == 0 {
-		ErrResponse(uc.Controller, "暂无收益领取")
+		Error = errors.New("user no available rewards to claim")
 		return
 	}
+
 	amount := ua.AvailableClaim
 	ua.TotalClaimed += amount
 	ua.AvailableClaim = 0
-	_, err = uc.engine.ID(addr).Cols("available_claim,total_claimed").Update(&ua)
-	if err != nil {
-		ErrResponse(uc.Controller, err)
+	_, Error = sesion.ID(addr).Cols("available_claim,total_claimed").Update(&ua)
+	if Error != nil {
 		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, err)
+	_, Error = sesion.Insert(&claimTx)
+	if Error != nil {
 		return
 	}
+
 	TxObjectResponse(uc.Controller, "ok")
 	return
 }
@@ -210,7 +221,7 @@ func (uc *UserController) TotalUsers() {
 		ErrResponse(uc.Controller, err)
 		return
 	}
-	us.Id = c
+	us.Id = c - 1
 	TxObjectResponse(uc.Controller, us)
 	return
 }

controller/types.go

@@ -16,7 +16,7 @@ const (
 	CommunityUsers = 2
 )
 
-//var PerformanceLevel = [6]float64{1, 3, 5, 7, 9, 11}	//test
+//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}

dbUtil/dbCoon.go

@@ -19,12 +19,11 @@ func init() {
 	dbname := beego.AppConfig.String("mysqldb")
 	port := beego.AppConfig.String("mysqlport")
 
-	fmt.Println(u, p, url, dbname, port)
+	fmt.Println(u, url, dbname, port)
 	e, err := xorm.NewEngine("mysql", u+":"+p+"@tcp("+url+":+"+port+")/"+dbname+"?charset=utf8")
 	if err != nil {
 		log.Fatal("错误=", err)
 	}
 	Engine = e
 	fmt.Println("dbUtil init")
-	//Engine.ShowSQL(true)
 }

enums/CommonErrorResult.go

@@ -1,77 +0,0 @@
-package enums
-
-type CommonErrorResult int
-
-const (
-	SUCCESSFUL                 = 0
-	REQUEST_ERROR              = 100
-	SYS_ERROR                  = 400
-	REGISTER_FAIL              = 1001
-	USER_LOGIN_FAIL            = 1006
-	CHECK_SMS_FAIL             = 1002
-	REGISTER_PHONE_AGAIN       = 1004
-	REGISTER_ORGCODE_NOTEXISTS = 1005
-	ETH_ACCESS_CREATE_ERROR    = 1007
-	GET_USER_INFO_ERROR        = 1008
-	ERROR_MSG_INFO             = 1010
-	ORM_INSER_ERROR            = 2001
-	ETH_DIAL_ERROR             = 3001
-	GENERE_FALID               = 4202
-
-	MAX_FHL_BLOCK  = "max_fhl_block:"  //最大块号
-	USE_FHL_BLOCK  = "use_fhl_block:"  //当前处理块号
-	USE_SWAP_NFT   = "use_swap_nft:"   //当前处理块号
-	USE_WITHDRAWAL = "use_withdrawal:" //用户提取
-
-	USDRIDO    = "Transfer"    //转账
-	GDLIDO     = "Approval"    //授权
-	WITHDRAWAL = "newWithdraw" //提取
-	NEWDEPOSIT = "newDeposit"  //下注
-	//WITHDRAWCONTRACT = "0x868c9fFfcA5483931219B624e4F6A3033Dfe7a3b"  //取款合约
-	WITHDRAWCONTRACT = "0x5620CA8Ed0636d967c511bBB47a48460a9327f84" //测试取款合约
-	USDTMINTCONTRACT = "0x5620CA8Ed0636d967c511bBB47a48460a9327f84" //usdt正式申购
-	//USDTMINTCONTRACT = "0x3Aa22DA9B16D9BBCf60A45aC598508fB3F05e92c" //测试申购合约事件
-	//
-	AMOUNTCONTRACT = "0xb544f5Cef94fE0B2C3BB3a4886ea8918Bbe444f5" //获取价格
-	VERIFYCONTRACT = "0x8e437A9a89E16ED807Ab1841C029e5e9C4A82c74"
-	USDT           = "0xa6ea066bae96432414ac62818e62e2ecaa570de3" //usdt合约
-	//GDLCONTRACT = "0x9830c7dbcff54eb564ef952e2e5634787fc1c5d8" //代币合约地址
-	KTOCONTRACT = "0x3850D46C0442A86AaDd41D99f635e316c8788269" //kto合约地址
-	//DIGIT       = "0xc14771a70de44653a1fea2f9ab9eb3d69dbcbee7352bf3aee607c541955eb9ee" //签名验证的盐test
-	DIGIT = "0xce832387833fd72921b64fcb454dcc394940a5cdb53125e579ed10d529799e3c"
-)
-
-func (c CommonErrorResult) String() string {
-	switch c {
-	case SUCCESSFUL:
-		return "操作成功"
-	case SYS_ERROR:
-		return "系统异常"
-	case REQUEST_ERROR:
-		return "请重新登录"
-	case REGISTER_FAIL:
-		return "注册失败"
-	case USER_LOGIN_FAIL:
-		return "用户名或密码错误"
-	case CHECK_SMS_FAIL:
-		return "验证码错误或失效"
-	case REGISTER_PHONE_AGAIN:
-		return "该账户已被使用"
-	case REGISTER_ORGCODE_NOTEXISTS:
-		return "邀请码不存在"
-	case ERROR_MSG_INFO:
-		return "自定义错误返回"
-	case ETH_ACCESS_CREATE_ERROR:
-		return "钱包创建失败，稍后再试"
-	case ORM_INSER_ERROR:
-		return "数据创建出现错误"
-	case GET_USER_INFO_ERROR:
-		return "获取用户信息失败"
-	case ETH_DIAL_ERROR:
-		return "eth Dial not connect"
-	case GENERE_FALID:
-		return "GenerateKey is faild"
-	default:
-		return "UNKNOWN"
-	}
-}

main.go

@@ -4,6 +4,7 @@ import (
 	_ "ktogame/blockchain"
 	_ "ktogame/dbUtil"
 	_ "ktogame/routers"
+	_ "ktogame/util"
 
 	"github.com/astaxie/beego"
 	"github.com/astaxie/beego/logs"
@@ -14,7 +15,7 @@ import (
 func main() {
 	log := logs.NewLogger()
 	log.SetLogger(logs.AdapterConsole, `{"level":1,"color":false}`)
-	logs.SetLogger(logs.AdapterFile, `{"filename":"listener.log","maxsize":512000,"maxlines":10000,"daily":true}`)
+	logs.SetLogger(logs.AdapterFile, `{"filename":"listener.log","maxsize":2000000000,"maxlines":100000,"daily":true}`)
 	logs.EnableFuncCallDepth(true)
 	logs.SetLogFuncCallDepth(3)
 	logs.Async()

util/utils.go

@@ -3,14 +3,21 @@ package util
 import (
 	"crypto/md5"
 	"encoding/hex"
-	"ktogame/enums"
 	"time"
 
+	"github.com/astaxie/beego"
 	"github.com/astaxie/beego/logs"
 
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
+var DIGIT string
+
+func init() {
+	DIGIT = beego.AppConfig.String("digit")
+	logs.Info("init digit==", DIGIT[len(DIGIT)-4:])
+}
+
 func NowTimeString() string {
 	return time.Now().Format("2006-01-02 15:04:05")
 }
@@ -27,7 +34,7 @@ func Md5(str string) string {
 
 func Sign(amountStr, addr, timeStr string) string {
 	logs.Info("Sign==========", amountStr, addr, timeStr)
-	keccakA := crypto.Keccak256([]byte(amountStr), []byte(enums.DIGIT))
+	keccakA := crypto.Keccak256([]byte(amountStr), []byte(DIGIT))
 	keccakS := crypto.Keccak256(keccakA, []byte(timeStr), []byte(addr))
 	return "0x" + hex.EncodeToString(keccakS)
 }