def get_table_generation(): # 用户购买的单子，25个数字
options = []
result = []
for r in range(5):
row = []
base = 15 * r + 1
for i in range(base, base + 15):
row.append(str(i))
options.append(row)
result.append([])
road = GetRand(26)
index = 0
step = int(road[index])
for r in range(len(options)):
while len(result[r]) < 5:
step = (step + int(road[index + 1])) % len(options[r])
item = options[r][step]
if not elt_in(result[r], item):
result[r].append(item)
options[r] = list_remove_elt(options[r], item)
if index < len(road) - 1:
index = index + 1
generation = []
for _r in range(len(result)):
for _s in range(len(result[_r])):
generation.append(result[_r][_s])
generation[12] = "$"
return generation
def scatter_value_match(number): # 散值匹配规则
ls = []
for i in range(len(number)):
ls.append(int(number[i]))
for i in range(len(ls)):
same_frequency = 0
different_frequency = 0
for l in range(len(ls)):
if ls[i] == ls[l]:
same_frequency = same_frequency + 1
if ls[i] != ls[l]:
different_frequency = different_frequency + 1
if same_frequency == 3: # 3个同号
amount = 24000 * GARD_FACTOR
return amount
if same_frequency == 2: # 2 个同号
amount = 8000 * GARD_FACTOR
return amount
if different_frequency == 2: # 3个异号
amount = 4000 * GARD_FACTOR
return amount
def query_user_if_prize(address, period): # 查询用户指定的期数是否中奖
if not IsValid(address):
raise Exception("地址格式错误")
prize_number = query_period_prize_number(period) # 查询中奖号码
user_info = query_user_stake(address, period) # 查询用户得投注信息
user_numbers = user_info[2] # 用户的投注号码
mul = user_info[1] # 用户的倍数
if user_info[0] == "0" and prize_number == user_numbers: # 散号
amount = scatter_value_match(prize_number)
return amount * int(mul)
if user_info[0] == "1": # 和值
prize_sum = 0
for i in range(len(prize_number)):
prize_sum = int(prize_number[i]) + prize_sum
if prize_sum == int(user_numbers):
amount = sum_value_match(prize_number)
return amount * int(mul)
amount = 0
return amount
def call_number(): # 叫号
option = []
for n in range(1, 76):
option.append(n)
rd = GetRand(30)
res = []
for _rd in range(len(rd)):
step = int(rd[_rd]) * 9 % len(option)
res.append(str(option[step]))
option = list_remove_elt(option, option[step])
res.append("$")
return res
def draw_number(): # 开奖号码生成
number = []
for i in range(1, 7):
number.append(i)
result = []
rd = GetRand(3)
for i in range(len(rd)):
index = int(rd[i]) % len(number)
result.append(str(number[index]))
res = concat(concat(result[0], result[1]), result[2])
return res # 返回一个字符串
def sum_value_match(number): # 和值匹配规则
ls = []
for i in range(len(number)):
ls.append(int(number[i]))
sum = 0
for i in range(len(ls)):
sum = ls[i] + sum
amount = 0 # 应该获得的奖励
if sum == 4:
amount = 8000 * GARD_FACTOR
if sum == 5:
amount = 4000 * GARD_FACTOR
if sum == 6:
amount = 2500 * GARD_FACTOR
if sum == 7:
amount = 1600 * GARD_FACTOR
if sum == 8:
amount = 1200 * GARD_FACTOR
if sum == 9:
amount = 1000 * GARD_FACTOR
if sum == 10:
amount = 900 * GARD_FACTOR
if sum == 11:
amount = 900 * GARD_FACTOR
if sum == 12:
amount = 1000 * GARD_FACTOR
if sum == 13:
amount = 1200 * GARD_FACTOR
if sum == 14:
amount = 1600 * GARD_FACTOR
if sum == 15:
amount = 2500 * GARD_FACTOR
if sum == 16:
amount = 4000 * GARD_FACTOR
if sum == 17:
amount = 8000 * GARD_FACTOR
if sum == 18 or sum == 3:
amount = 24000 * GARD_FACTOR
return amount
def emoji_random(): # 表情随机取
rd = GetRand(24)
ls = []
for i in range(35):
ls.append(i)
result = []
for i in range(len(rd)):
index = (int(rd[i]) * 4) % len(ls)
value = ls[index]
result.append(str(value))
ls = list_remove_elt(ls, value)
repeat_index = (int(rd[int(rd[0])]) * 4) % len(result) # 取随机下标
old_value = result[repeat_index] # 取出一个重复的值
last_value = result[(int(rd[int(rd[len(rd) - 1])]) * 4) %
len(result)] # 取出要替换位置的值
result[(int(rd[int(rd[len(rd) - 1])]) * 4) % len(result)] = old_value
result.append(last_value)
return result
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% 不等
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% 不等
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 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])
if len(list) == 24:
list = list[1:]
list.append(draws)
PutArray(KEY_PERIODS_LIST, list) # 所有列表 24 个
ContractBalanceSend(sender, GARD_DENOM, lettry_amount) # 给开奖人奖金
return True
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 stake(mode, multipe, number): # 用户投注
ls = []
now_time = GetTime()
for i in range(len(number)):
ls.append(int(number[i]))
if mode == 0: # 散值
for i in range(len(ls)):
if ls[i] > 6:
raise Exception("每个数字在1到6之间")
if mode == 1: # 和值
if int(number) < 3 or int(number) > 18:
raise Exception("最大的和值为18")
if multipe > 99 or multipe < 1:
raise Exception("不支持的倍数")
if if_stake():
num = draw_number() # 开启下一期前，开放上一期的中奖号码
draw_num_key = concat(KEY_GAME_PRIZE, issue())
Put(draw_num_key, num) # Put 该期的中奖号码
update_period = get_period_generation()
Put(KEY_GAME_PERIOD, update_period) # Put 新的期数
time_key = concat(KEY_GAME_TIME, update_period)
Put(time_key, now_time) # Put新期数的时间戳
period_list = []
ls = GetArray(KEY_GAME_LIST)
for i in range(len(ls)):
if len(ls) < 24:
period_list.append(ls[i])
if len(ls) >= 24 and i < 23:
period_list.append(ls[i + 1])
period_list.append(update_period)
PutArray(KEY_GAME_LIST, period_list) # Put 24个期数列表
sender = GetTxSender()
period = issue()
amount = multipe * STAKE_AMOUNT
if BalanceOf(sender, [GARD_DENOM])[0] < amount:
raise Exception("余额不足")
if len(query_user_stake(sender, period)) > 0:
raise Exception("当期已经购买过")
user_stake_key = concat(concat(KEY_USER_STAKE, sender), period)
if mode == 0: # 0 为散号
PutArray(user_stake_key, [str(mode), str(multipe), number, str(amount)])
if mode == 1: # 1 为和值
PutArray(user_stake_key, [str(mode), str(multipe), number, str(amount)])
user_stake_list = []
ls = query_user_stake_list(sender)
for i in range(len(ls)):
if len(ls) < 24:
user_stake_list.append(ls[i])
if len(ls) >= 24 and i < 23:
user_stake_list.append(ls[i + 1])
user_stake_list.append(period)
user_stake_list_key = concat(KEY_USER_ISSUE, sender) # Put 24个用户投注的期数列表
PutArray(user_stake_list_key, user_stake_list)
stake_all_amount = query_user_stake_amount(sender)
stake_amount_key = concat(KEY_USER_STAKE, sender)
if not stake_all_amount:
Put(stake_amount_key, amount)
else:
stake_all_amount = stake_all_amount + amount
Put(stake_amount_key, stake_all_amount) # Put 用户的总共投注金额
inject_stake_pool(amount)
return True
