def query_user_invitation_code(sender): # 查询地址查看生成的邀请码
if not IsValid(sender):
raise Exception("Incorrect address format.")
key = concat(KEY_INVITATION_CODE, sender)
return Get(key)
def query_invitation_code_user(invitation_code): # 根据邀请码，查询生成邀请码的地址
key = concat(KEY_INVITATION_CODE, invitation_code)
return Get(key)
def owner():
return Get(KEY_OWNER)
def issue(): # 返回当前期数
return Get(KEY_NUMBER_DRAWS)
def description():
return Get(KEY_DESCRIPTION)
def burn_disabled():
return Get(KEY_BURN_DISABLED)
def query_issue_stakepool(rd): # 查询该期数的所有用户投注金额
key = concat(rd, KEY_USER_POOL)
return Get(key) # 返回int
def query_user_bet_num(rd, sender_address): # 查询用户对该期数的投注次数
user_bets_key = concat(concat(KEY_USER_BETS, sender_address), rd) # 用户投注次数
return Get(user_bets_key)
def stake(number, amount, invitation_code): # 用户投注
if len(number) != 3:
raise Exception("请输入正确的投注号码")
if amount < 10000 * GARD_FACTOR:
raise Exception("每次投注不能少于 10000gard")
if if_lottery():
raise Exception('当前期已经结束，处于开奖期，前往开奖')
sender_address = GetTxSender() # 当前调用地址
if BalanceOf(sender_address, [GARD_DENOM])[0] < 10000 * GARD_FACTOR:
raise Exception("账户余额不足投注")
now_time = GetTime() # 当前时间
rd = Get(KEY_NUMBER_DRAWS) # 当前期数
user_bets_key = concat(concat(KEY_USER_BETS, sender_address), rd) # 用户投注次数
user_bets = Get(user_bets_key)
if not user_bets:
Put(user_bets_key, 1)
else:
if user_bets >= 3:
raise Exception("当前用户投注次数超过三次")
else:
Put(user_bets_key, user_bets + 1)
now_user_pool = stakepool() # 当前用户池额度
if not now_user_pool:
Put(KEY_USER_POOL, amount)
else:
Put(KEY_USER_POOL, amount + now_user_pool) # 添加入总的用户池额度
now_issue_stakepool = query_issue_stakepool(rd)
issue_stakepool_key = concat(rd, KEY_USER_POOL) # 当期的用户池总额度
if now_issue_stakepool > 0:
Put(issue_stakepool_key, now_issue_stakepool + amount)
else:
Put(issue_stakepool_key, amount)
note_key = concat(rd, KEY_CALUCLATION_NOTE)
num_note = Get(note_key) # 获取投注数
now_note = num_note + 1 # 每个用户投注一次，次数增加一次
Put(note_key, now_note) # 记录每一期的总的投注数
# 投注数每次都增加，避免出现一个过大的列表
betting_record_key = concat(concat(KEY_NUMBER_BETS_PEER_ISSUE, rd), str(now_note)) # 每一期的投注记录 key
user_info = [str(now_time), sender_address, number, str(amount)] # 保存为一个数组
Assert(user_info[3] == str(amount), "erro") # 输出address
PutArray(betting_record_key, user_info) # 记录投注记录
number_key = concat(concat(rd, KEY_BETTING_NUMBER), sender_address) # 用户的投注号码
amount_key = concat(concat(concat(rd, KEY_BETTING_AMOUNT), number), sender_address) # 记录用户投注的金额
stake_all_key = concat(KEY_MY_ALL_STAKE, sender_address) # 我所有的投注记录，只记录三天以内的
stake_list = GetArray(stake_all_key)
if len(stake_list) == 0:
ls = []
ls.append(rd)
PutArray(stake_all_key, ls) # 记录我的投注记录期号
else:
periods_exceeds_list = get_periods_exceeds(sender_address, rd) # 返回去掉一天外的数组
PutArray(stake_all_key, periods_exceeds_list)
numbers = GetArray(number_key)
if len(numbers) == 0:
PutArray(number_key, [number]) # 记录用户的投注号码
Put(amount_key, amount) # 记录用户对这个号码的投注金额
else:
ls = []
existed = False
for i in range(len(numbers)):
ls.append(numbers[i])
if numbers[i] == number:
balance = query_users_number_amount(sender_address, rd, number)
balance_amount = balance + amount
Put(amount_key, balance_amount)
existed = True
if not existed:
ls.append(number)
PutArray(number_key, ls)
Put(amount_key, amount) # 记录用户对这个号码的投注金额
invited_key = concat(KEY_INVITED_RECORD, sender_address) # 被邀请记录
invited = Get(invited_key)
invitation_user = query_invitation_code_user(invitation_code) # 生成邀请码的地址
invitation_key = concat(KEY_INVITATION_RECORD, invitation_user) # 上级邀请记录
if len(invitation_code) == 4 and not invited and invitation_user and invitation_user != sender_address:
Put(invited_key, invitation_user) # 提交被邀请记录
invitation_list_value = GetArray(invitation_key)
invitation_list = []
for i in range(len(invitation_list_value)):
invitation_list.append(invitation_list_value[i])
invitation_list.append(sender_address)
PutArray(invitation_key, invitation_list) # 提交邀请人的邀请记录，由于可以邀请很多人，所有是个列表
stake_count_key = concat(KEY_MY_STAKE_COUNT, sender_address) # 我的投注统计，包括投注的总 token，和获取奖励的总 token
count_value = GetArray(stake_count_key)
if len(count_value) == 0:
PutArray(stake_count_key, [str(amount), str(0)])
if len(count_value) == 2:
betting_amount = int(count_value[0]) # 总共投注
reward_amount = int(count_value[1]) # 获得奖励
PutArray(stake_count_key, [str(betting_amount + amount), str(reward_amount)]) # 提交自己投注记录
ContractBalanceInject(sender_address, GARD_DENOM, amount)
return True
def stakepool(): # 查询用户奖池额度
return Get(KEY_USER_POOL)
def syspool(): # 查询系统奖池额度
return Get(KEY_SYSTEM_POOL)
def get_draw_calculation_note(number_draws): # 查询期数的总共投注次数
note_key = concat(number_draws, KEY_CALUCLATION_NOTE)
return Get(note_key)
def query_draws_pid(): # 查询当前期数对应的pid
number_draws = Get(KEY_NUMBER_DRAWS) # 当前期数
key = concat(number_draws, KEY_DRAWS_PID)
return Get(key)
def query_my_inviter(sender_address): # 查询该地址的上级邀请人
if not IsValid(sender_address):
raise Exception("Incorrect address format.")
key = concat(KEY_INVITED_RECORD, sender_address)
return Get(key)
def query_users_number_amount(sender_address, rd, number): # 根据该地址对应期数的用户投注号码，查询该号码的投注金额
if not IsValid(sender_address):
raise Exception("Incorrect address format.")
amount_key = concat(concat(concat(rd, KEY_BETTING_AMOUNT), number), sender_address)
return Get(amount_key)
def query_periods_time(draws): # 查询期数对应的时间戳
draws_time_key = concat(draws, KEY_PERIODS_TIME)
return Get(draws_time_key) # 当前期号对应的时间戳
def draw(): # 开奖
if not if_lottery():
raise Exception("当前期数还在进行时")
draws = Get(KEY_NUMBER_DRAWS) # 当前期数
sender = GetTxSender()
if BalanceOf(sender, [GARD_DENOM])[0] <= 0:
raise Exception("当前账户没有持有 GARD，无法开奖")
sys_pool = syspool() # 当前的系统奖池额度
now_users_pool = stakepool() # 当前用户池额度
now_time = GetTime() # 获取当前时间
prize_number = GetRand(3) # 生成中奖号码
prize_key = concat(KEY_PRIZE_NUMBER, draws)
Put(prize_key, prize_number) # 记录每一期的中奖号码
rand_amount = int(GetRand(4)) # 生成随机开奖奖励 amount
lettry_amount = rand_amount * GARD_FACTOR
draws_lettry_key = concat(KEY_LOTTERY_USER, draws)
PutArray(draws_lettry_key, [sender, str(now_time), str(lettry_amount)]) # 增加开奖人记录
now_users_pool = now_users_pool - lettry_amount
Put(KEY_USER_POOL, now_users_pool) # 先从用户奖池扣除这一部分开奖奖金
# 算出当前中奖人数有多少个
note_key = concat(draws, KEY_CALUCLATION_NOTE)
note_num = Get(note_key) # 当期有多少个投注数, 返回是个int
fist_amount = 0 # 第一名的总额度
second_amount = 0 # 二等奖中奖总token额度
thrid_amount = 0 # 三等奖中奖总token额度
for i in range(1, note_num + 1):
betting_info = query_bets_note(draws, str(i))
number = betting_info[2]
if first_prize_match(draws, number):
fist_amount = int(betting_info[3]) + fist_amount
continue
if second_prize_match(draws, number):
second_amount = int(betting_info[3]) + second_amount
continue
if thrid_prize_match(draws, number):
thrid_amount = int(betting_info[3]) + thrid_amount
continue
award_key = concat(draws, KEY_AMOUNT_EACH_AWARD) # 中奖额度信息
PutArray(award_key, [str(sys_pool), str(now_users_pool), str(fist_amount), str(second_amount),
str(thrid_amount)]) # 记录每一期的中奖额度信息
PutArray(KEY_LAST_NUMBER_DRAWS, [draws, str(now_time)]) # 最后一期期数和期数结束时间
draws = get_period_generation()
Put(KEY_NUMBER_DRAWS, draws) # 期数变更
key = concat(draws, KEY_DRAWS_PID)
now_pid = get_pid()
Put(key, now_pid) # 更改这期的pid
draws_time_key = concat(draws, KEY_PERIODS_TIME)
Put(draws_time_key, now_time) # 当前期号对应的时间戳
all_periods = query_periods_list()
list = []
for i in range(len(all_periods)):
list.append(all_periods[i])
new_list = []
if len(list) == 24:
for i in range(len(list)):
if i != len(list) - 1:
new_list.append(list[i + 1])
else:
break
new_list.append(draws)
PutArray(KEY_PERIODS_LIST, new_list)
else:
list.append(draws)
PutArray(KEY_PERIODS_LIST, list) # 记录之前的期数，最多24个
ContractBalanceSend(sender, GARD_DENOM, lettry_amount) # 给开奖人奖金
return True
def query_user_withdraw_status(rd, address): # 查询用户指定期数的兑奖状态
withdraw_status_key = concat(concat(KEY_WITZHDRAWS_STATUS, rd), address)
return Get(withdraw_status_key)
def withdraw(draws): # 根据期数兑奖
sender = GetTxSender()
now_draws = Get(KEY_NUMBER_DRAWS) # 当前期数
time = GetTime() # 当前时间
last_number = GetArray(KEY_LAST_NUMBER_DRAWS)
if query_user_withdraw_status(draws, sender):
raise Exception("当期已经兑过奖")
if len(last_number) == 0:
raise Exception("当前期还无法兑奖")
last_draws_time = int(last_number[1]) # 最后一期时间
if int(draws) >= int(now_draws):
raise Exception("当前期无法兑奖")
if len(query_users_number(sender, draws)) == 0:
raise Exception("当前期数没有投注")
if time - last_draws_time >= 60 * 60 * 24 * 1: # 计算是否超过一天
raise Exception("当前已经超过一天未兑奖，无法兑现")
amount_award_list = query_amount_award(draws) # 查询每一期的中奖额度信息
lottery_sys_pool = int(amount_award_list[0]) # 开奖时的系统池额度
lottery_users_pool = int(amount_award_list[1]) # 开奖时的用户池额度
fist_pool_amount = int(amount_award_list[2]) # 开奖时候的一等奖额度
second_pool_amount = int(amount_award_list[3]) # 开奖时候的二等奖额度
thrid_pool_amount = int(amount_award_list[4]) # 开奖时候的三等奖额度
numbers = query_users_number(sender, draws) # 用户投注的所有号码
withdraws_all_amount = 0 # 应该获取到的所有奖金额度
user_pool_amount = 0 # 应该要减去的用户奖池额度
sys_pool_amount = 0 # 应该要减去的系统奖池额度
fist_withdraws_amount = 0 # 用户兑奖的一等奖额度
second_withdraws_amount = 0 # 用户兑奖的二等奖额度
thrid_withdraws_amount = 0 # 用户兑奖的三等奖额度
for num in numbers: # 遍历所有号码
if first_prize_match(draws, num):
fist_amount = query_users_number_amount(sender, draws, num)
withdraws_fist_amount = fist_amount * lottery_users_pool / 10 * 4 / fist_pool_amount + lottery_sys_pool / 1000
user_pool_amount = user_pool_amount + fist_amount * lottery_users_pool / 10 * 4 / fist_pool_amount
sys_pool_amount = sys_pool_amount + lottery_sys_pool / 1000
withdraws_all_amount = withdraws_all_amount + withdraws_fist_amount
fist_withdraws_amount = fist_withdraws_amount + withdraws_fist_amount
continue
if second_prize_match(draws, num):
second_amount = query_users_number_amount(sender, draws, num)
withdraw_second_amount = second_amount * lottery_users_pool / 10 * 2 / second_pool_amount
withdraws_all_amount = withdraws_all_amount + withdraw_second_amount
user_pool_amount = user_pool_amount + withdraw_second_amount
second_withdraws_amount = second_withdraws_amount + withdraw_second_amount
continue
if thrid_prize_match(draws, num):
thrid_amount = query_users_number_amount(sender, draws, num)
withdraws_thrid_amount = thrid_amount * lottery_users_pool / 10 * 1 / thrid_pool_amount
withdraws_all_amount = withdraws_all_amount + withdraws_thrid_amount
user_pool_amount = user_pool_amount + withdraws_thrid_amount
thrid_withdraws_amount = thrid_withdraws_amount + withdraws_thrid_amount
continue
if withdraws_all_amount > 0: # 如果中奖则给其转账,并判断邀请逻辑
inviter_address = query_my_inviter(sender) # 上级地址
event_pool = ppool() # 查询活动奖池额度
sys_pool = syspool() # 查询系统奖池额度
user_pool = stakepool() # 查询活动奖池
if inviter_address and event_pool > 0: # 如果存在邀请者，并或活动奖池大于0
# rd = int(GetRand(1)) # 随机字符串
# pted_event_amount = event_pool / 1000 + event_pool * rd / 1000 # 分配随机 0.1% 到 1% 不等
rd = int(GetRand(4))
pted_event_amount = rd * GARD_FACTOR
sr_key = concat(KEY_SHARED_REWARD, sender) # 被邀请的被推广奖励
sender_reward_list = GetArray(sr_key)
if len(sender_reward_list) == 0:
PutArray(sr_key, [str(0), str(pted_event_amount)])
else:
promotion_amount = sender_reward_list[0] # 推广奖励
promoted_amount = int(sender_reward_list[1]) # 被推广奖励
PutArray(sr_key, [promotion_amount, str(promoted_amount + pted_event_amount)]) # 提交自己的被推广奖励
# rd = int(GetRand(1)) # 随机字符串
# pro_event_amount = event_pool / 1000 + event_pool * rd / 1000 # 分配随机 0.1% 到 1% 不等
pro_event_amount = rd * GARD_FACTOR
sr_key = concat(KEY_SHARED_REWARD, inviter_address) # 推广者的推广奖励
invited_reward_list = GetArray(sr_key) # 邀请者
if len(invited_reward_list) == 0:
PutArray(sr_key, [str(pro_event_amount), str(0)])
else:
promotion_amount = int(invited_reward_list[0]) # 推广奖励
promoted_amount = invited_reward_list[1] # 被推广奖励
PutArray(sr_key, [str(promotion_amount + pro_event_amount), promoted_amount]) # 提交推广者的推广奖励
ContractBalanceSend(sender, GARD_DENOM, pted_event_amount) # 给投注人转入被邀请奖励
ContractBalanceSend(inviter_address, GARD_DENOM, pro_event_amount) # 给邀请人转推广奖励
now_event_pool = event_pool - pted_event_amount - pro_event_amount
Put(KEY_EVENT_POOL, now_event_pool) # 更新活动奖池额度
issue_account = query_issue_account() # 查询总的中奖额度信息
withdraw_account = query_withdraw_account(draws) # 查询该兑奖期的兑奖额度信息
withdraw_account_key = concat(KEY_ISSUE_ACCOUNT, draws)
if len(issue_account) != 0:
old_fist = int(issue_account[0])
old_second = int(issue_account[1])
old_thrid = int(issue_account[2])
PutArray(KEY_ISSUE_ACCOUNT,
[str(old_fist + fist_withdraws_amount), str(old_second + second_withdraws_amount),
str(old_thrid + thrid_withdraws_amount)]) # 提交总的中奖额度信息
else:
PutArray(KEY_ISSUE_ACCOUNT, [str(fist_withdraws_amount), str(second_withdraws_amount),
str(thrid_withdraws_amount)]) # 提交总的中奖额度信息
if len(withdraw_account) != 0:
old_withdraws_fist = int(withdraw_account[0])
old_withdraws_second = int(withdraw_account[1])
old_withdraws_thrid = int(withdraw_account[2])
PutArray(withdraw_account_key, [str(old_withdraws_fist + fist_withdraws_amount),
str(old_withdraws_second + second_withdraws_amount),
str(old_withdraws_thrid + thrid_withdraws_amount)]) # 提交指定期的兑奖额度信息
else:
PutArray(withdraw_account_key, [str(fist_withdraws_amount), str(second_withdraws_amount),
str(thrid_withdraws_amount)]) # 提交指定期的兑奖额度信息
Put(KEY_USER_POOL, user_pool - user_pool_amount) # 提交用户奖池
Put(KEY_SYSTEM_POOL, sys_pool - sys_pool_amount) # 提交系统奖池额度
stake_count_key = concat(KEY_MY_STAKE_COUNT, sender) # 我的投注统计，包括投注的总 token，和获取奖励的总 token
count_value = GetArray(stake_count_key)
betting_amount = count_value[0] # 总共投注
reward_amount = int(count_value[1]) # 获得奖励
PutArray(stake_count_key, [betting_amount, str(reward_amount + withdraws_all_amount)]) # 提交自己投注记录
key = concat(concat(KEY_REDEMPTION_USER, draws), sender) # 兑奖信息
PutArray(key, [str(time), str(withdraws_all_amount)]) # 提交用户的兑奖信息
withdraw_status_key = concat(concat(KEY_WITZHDRAWS_STATUS, draws), sender)
Put(withdraw_status_key, True) # 将用户此期的兑奖状态改成true
ContractBalanceSend(sender, GARD_DENOM, withdraws_all_amount) # 给投注人转入获取的奖励
return True
else:
raise Exception("当前投注没有中奖")
def mint_disabled():
return Get(KEY_MINT_DISABLED)
def ppool(): # 查询活动奖池的额度
return Get(KEY_EVENT_POOL)
def freeze_disabled():
return Get(KEY_FREEZE_DISABLED)
def query_prize_number(draws): # 根据期数查询中奖号码
key = concat(KEY_PRIZE_NUMBER, draws)
return Get(key)
def total_supply():
return Get(KEY_SUPPLY)
def owner(): # 获取 owner 地址
return Get(KEY_OWNER)
