def if_stake():
now_time = GetTime()
now_period = issue() # 当期
old_time = query_period_time(now_period)
if now_time - old_time > KEY_GAME_TIME_FOR_A_ROUND:
return True
return False
def init():
if Get(KEY_OWNER):
raise Exception("已经初始化过")
time = GetTime()
Put(KEY_OWNER, OWNER) # Put 合约的 owenr
now_period = get_period_generation()
Put(KEY_GAME_PERIOD, now_period) # Put 最开始的期号
time_key = concat(KEY_GAME_TIME, now_period)
Put(time_key, time) # Put 最开始的期号时间戳
period_ls = [now_period]
PutArray(KEY_GAME_LIST, period_ls) # Put 期数列表
def get_period_generation(): # 期数生成器
now_time = GetTime()
now_time = TimeFormat(now_time) # 格式 2019-09-25 17:15:30
time = split(now_time, " ") # 分成两个元素
time_01 = time[0] # 年月日
time_02 = time[1] # 分时秒
time_01 = split(time_01, "-")
time_02 = split(time_02, ":")
a = join("", time_01)
b = concat(concat(time_02[0], time_02[1]), time_02[2])
period = concat(a, b) # 拼接
return period
def stake(game_type, operation_type): # 用户购买
sender = GetTxSender()
user_list = emoji_random() # 随机表情列表
period = get_period_generation() # 当期期号
if query_user_time_condition(sender): # 查询是否过去5秒
stake_info_key = concat(concat(KEY_USER_STAKE_INFO, sender), period)
PutArray(stake_info_key, user_list) # Put 用户购买后产生的列表
# Put 用户的投注列表，最多保持24个记录
stake_list = query_user_stake_list(sender)
stake_list_key = concat(KEY_USER_STAKE_LIST, sender)
if len(stake_list) == 0:
PutArray(stake_list_key, [period])
if len(stake_list) == 24:
new_stake_list = []
for i in range(len(stake_list)):
if i != len(stake_list) - 1:
new_stake_list.append(stake_list[i + 1])
new_stake_list.append(period)
PutArray(stake_list_key, new_stake_list)
else:
new_stake_list = []
for i in range(len(stake_list)):
new_stake_list.append(stake_list[i])
new_stake_list.append(period)
PutArray(stake_list_key, new_stake_list)
period_type_key = concat(concat(KEY_USER_PERIOD_TYPE, sender), period)
Put(period_type_key, game_type) # Put 用户当期期数的类型，即表情包
amount = 200 * GARD_FACTOR
if BalanceOf(sender, [GARD_DENOM])[0] < amount:
raise Exception("余额不足")
inject_stake_pool(amount) # 给合约地址转钱
add_user_stake_amount(sender, amount) # 加入自己的消费额中
time = GetTime()
period_time_key = concat(concat(KEY_USER_PERIOD_TIME, sender), period)
Put(period_time_key, time) # Put 用户期数的时间戳
save_period_key = concat(KEY_SAVE_PERIOD, sender)
if operation_type == 1: # 1为 直接stake
save_period_key = concat(KEY_SAVE_PERIOD, sender)
PutArray(save_period_key, []) # 把用户保存的表清空
if operation_type != 1: # 0 为继续
save_period_list = GetArray(save_period_key) # 查询用户保存的期号列表
if len(save_period_list) == 0:
raise Exception("当期不是继续的场景")
return True
else:
raise Exception("请等待时间")
def get_periods_exceeds(address, rd): # 返回一个一天内的投注列表
stake_all_key = concat(KEY_MY_ALL_STAKE, address) # 我所有的投注期号记录，只记录三天以内的
stake_all_value = GetArray(stake_all_key) # 期数列表
now_time = GetTime()
list = []
for i in range(len(stake_all_value)):
time = query_periods_time(stake_all_value[i]) # 根据期数查询时间戳
sub = now_time - time
if rd != stake_all_value[i] and 0 < sub <= 60 * 60 * 24 * 1: # 小于1天和不重复的
list.append(stake_all_value[i])
list.append(rd)
return list
def transfer(from_address, to_address, amount):
# check if address freezing
timestamp = GetTime()
freeze_out_end = Get(concat(KEY_FREEZE_OUT, from_address))
freeze_in_end = Get(concat(KEY_FREEZE_IN, to_address))
if timestamp < freeze_out_end or timestamp < freeze_in_end:
raise Exception("There is currently a frozen address.")
#call StandardTokenContract transfer
param = state('string:transfer', '[string:', from_address, 'string:',
to_address, 'int:', amount, ']')
StandardTokenContract(param)
return True
def query_box_status(): # 查看盒子当前状态
now_time = GetTime()
interest_amount = query_interest_balance()
deposit_amount = query_deposit_amount()
if now_time <= BOX_START_TIME: # 小于开始时间为可存入利息的发行期
return ISSUE_STATUS
if interest_amount == BOX_INTEREST and BOX_START_TIME < now_time <= BOX_LOCK_TIME: # 利息等于该存入的利息，并且当前时间大于开始时间，小于开始计息的时间，为可存入存款的存款吸纳期
return DEPOSIT_STATUS
if deposit_amount > BOX_BOTTOM_LINE and BOX_LOCK_TIME < now_time <= BOX_END_TIME: # 存款数量大于最小存款数，并且当前时间大于存款吸纳期，小于最后的结束时间，为存款的锁定期
return LOCK_STATUS
if interest_amount == BOX_INTEREST and deposit_amount > BOX_BOTTOM_LINE and now_time > BOX_END_TIME: # 存款盒子结束，可以取出总收益
return BOX_END
return BOX_FAILED
def init():
if Get(KEY_OWNER):
return False
now_time = GetTime()
Put(KEY_OWNER, OWNER) # 添加owner 地址
Put(KEY_NUMBER_DRAWS, get_period_generation()) # 当前期数 ,格式：20190925
draws_time_key = concat(Get(KEY_NUMBER_DRAWS), KEY_PERIODS_TIME)
Put(draws_time_key, now_time) # 当前期号对应的时间戳
note_key = concat(Get(KEY_NUMBER_DRAWS), KEY_CALUCLATION_NOTE)
Put(note_key, 0) # 投注数
key = concat(Get(KEY_NUMBER_DRAWS), KEY_DRAWS_PID)
Put(key, get_pid()) # 初始期数的pid
PutArray(KEY_PERIODS_LIST, [Get(KEY_NUMBER_DRAWS)]) # 存放一天内的期号列表
return True
def query_user_time_condition(address): # 查询是否距离最后一期，是否过去5秒
if not IsValid(address):
raise Exception("地址格式错误")
stake_list = query_user_stake_list(address)
if len(stake_list) == 0:
return True
last_period = stake_list[len(stake_list) - 1] # 最后一期
old_time = query_user_period_time(address, last_period) # 最后一期的时间戳
now_time = GetTime()
if now_time - old_time > GAME_TIME_FOR_A_ROUND:
return True
return False
def save(number): # 用户保存号码
sender = GetTxSender()
numbers = split(number, "-")
stake_list = query_user_stake_list(sender) # 查询用户的投注列表
if len(stake_list) == 0:
raise Exception("当期用户没有投注")
last_stake = stake_list[len(stake_list) - 1]
old_time = query_user_period_time(sender, last_stake) # 最后一期的时间戳
now_time = GetTime()
if now_time - old_time > 30:
raise Exception("当期已经过了时间，无法标记")
last_stake_info = query_user_stake_info(sender, last_stake) # 查询用户该期的表单
if numbers[0] != numbers[1]:
raise Exception("标记的不是同一个")
num = 0
for i in range(len(last_stake_info)):
if last_stake_info[i] == numbers[0]:
num = num + 1
if num < 2:
raise Exception("标记的号码在表情中未出现两次")
save_num_key = concat(concat(KEY_SAVE_NUMBER, sender), last_stake)
Put(save_num_key, number) # 存取用户保存的号码
save_period_key = concat(KEY_SAVE_PERIOD, sender)
save_period = GetArray(save_period_key)
new_save = []
if len(save_period) != 0:
for i in range(len(save_period)):
new_save.append(save_period[i])
new_save.append(last_stake)
PutArray(save_period_key, new_save) # 存取用户保存的期号
return True
def remaining_time(sender, period): # 查询用户该期剩余时间
time = query_user_period_time(sender, period)
now_time = GetTime()
end_time = time + 30
return end_time - now_time
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
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 get_peroid_pid(): # 计算是否过去五分钟，五分钟为一个整数倍
now_time = GetTime()
pid = ((now_time - GMAE_START_TIME) - (
(now_time - GMAE_START_TIME) % KEY_GAME_TIME_FOR_A_ROUND)) / KEY_GAME_TIME_FOR_A_ROUND
return pid
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 get_pid(): # 获取当前期数pid，主要用于判断是否已经过了一小时
time = GetTime()
pid = ((time - KEY_GAME_START_TIME) - (time - KEY_GAME_START_TIME) %
KEY_GAME_TIME_FOR_A_ROUND) / KEY_GAME_TIME_FOR_A_ROUND
return pid
def get_call_pid(): # 每15秒叫号一次
now_time = GetTime()
pid = ((now_time - GMAE_START_TIME) - (
(now_time - GMAE_START_TIME) % KEY_GAME_TIME_FOR_CALL_NUMBER)) / KEY_GAME_TIME_FOR_CALL_NUMBER
return pid
def stake(multiple): # 用户购买卡单
if multiple != 1 and multiple != 2 and multiple != 5 and multiple != 10:
raise Exception("只支持一倍，两倍，五倍，十倍")
sender = GetTxSender() # 当前用户
if BalanceOf(sender, [GARD_DENOM])[0] < 200 * GARD_FACTOR:
raise Exception("当前余额不足购买")
now_time = GetTime()
if not issue(): # 如果当期没有期数
period = get_period_generation()
Put(KEY_GAME_PERIOD, period) # Put 初始的期号
pid_key = concat(KEY_GAME_PID, period)
Put(pid_key, get_peroid_pid()) # Put 初始期号的 pid
time_key = concat(KEY_ISSUE_TIME, period)
Put(time_key, now_time) # Put 初始的时间戳
if if_update_period(): # 已经过了五分钟 返回 true
period = get_period_generation() # 新的期号
Put(KEY_GAME_PERIOD, period) # Put 新的期号
now_pid = get_peroid_pid() # 当前 pid
pid_key = concat(KEY_GAME_PID, period)
Put(pid_key, now_pid) # Put 新的期号的pid
time_key = concat(KEY_ISSUE_TIME, period)
Put(time_key, now_time) # Put 新的期号的时间戳
now_period = Get(KEY_GAME_PERIOD) # 当前期
table_generation = get_table_generation() # 获取表格
period_lottery_key = concat(concat(KEY_USER_LOTTERY, sender), now_period)
user_table = query_user_table_generation(sender, now_period)
if len(user_table) > 0:
raise Exception("当期已经买过卡单")
PutArray(period_lottery_key, table_generation) # 如果没有购买过，则提交当前表单
stake_key = concat(KEY_USER_STAKE, sender)
stake_list = GetArray(stake_key) # 查询用户的投注列表
ls = []
if len(stake_list) == 0:
ls.append(now_period)
if len(stake_list) == 24:
for i in range(len(stake_list)):
if i != len(stake_list) - 1:
ls.append(stake_list[i + 1])
ls.append(now_period)
if 0 < len(stake_list) < 24:
for i in range(len(stake_list)):
ls.append(stake_list[i])
ls.append(now_period)
PutArray(stake_key, ls) # 只记录用户的24期
stake_amount = stakepool()
if not stake_amount:
Put(KEY_STAKE_POOL, 200 * GARD_FACTOR)
else:
stake_amount = stake_amount + 200 * GARD_FACTOR
Put(KEY_STAKE_POOL, stake_amount) # put 投注池子
multiple_key = concat(concat(KEY_MULTIPLE, sender), now_period) # 用户该期的倍数
Put(multiple_key, multiple)
call_numbers = query_period_call_number(now_period) # 返回一个列表, 查询本期的叫号列表
call_number_key = concat(KEY_GAME_PERIOD_CALL_NUMBER, now_period)
if len(call_numbers) == 0:
PutArray(call_number_key, call_number()) # Put 本期的叫号号码
amount = multiple * 200 * GARD_FACTOR
stake_amount_key = concat(KEY_USER_STAKE_AMOUNT, sender)
user_stake_amount = query_user_stake_amount(sender)
if not user_stake_amount:
Put(stake_amount_key, amount) # Put 用户总共购买过的金额
else:
user_stake_amount = user_stake_amount + amount
Put(stake_amount_key, user_stake_amount)
user_multiple_key = concat(concat(KEY_USER_ISSUE_MULTIPLE, sender), now_period) # 用户当期购买的倍数
Put(user_multiple_key, multiple)
ContractBalanceInject(sender, GARD_DENOM, amount) # 每次投注花费200个gard
return True