def deposit(amount): # 存款
sender = GetTxSender()
if BalanceOf(sender, [GARD_DENOM])[0] <= amount:
raise Exception("余额不足")
if amount % BOX_PRICE != 0:
raise Exception("存款必须是最少所存量的倍数")
if query_box_status() != DEPOSIT_STATUS:
raise Exception("当前不处于存款吸纳期，无法存款")
if amount > BOX_CEILING:
raise Exception("大于最大允许的存款量")
deposit_amount = query_deposit_amount() # 盒子存款总量
if not deposit_amount:
Put(KEY_BOX_DEPOSIT_AMOUNT, amount)
else:
sub = BOX_CEILING - deposit_amount
if amount > sub:
raise Exception("超过可存入的最大存款数")
else:
Put(KEY_BOX_DEPOSIT_AMOUNT, deposit_amount + amount) # 提交存款盒子总量
user_deposit_amount = query_user_deposit_amount(sender)
user_deposit_key = concat(KEY_USER_DEPOSIT_AMOUNT, sender)
if not user_deposit_amount:
Put(user_deposit_key, amount)
else:
Put(user_deposit_key, user_deposit_amount + amount) # 提交用户的的存款量
ContractBalanceInject(sender, GARD_DENOM, amount) # 给盒子转账
return True
def interest_injection(amount): # 利息注入
sender = GetTxSender()
interest_balance = query_interest_balance() # 查询盒子注入利息
user_interest_amount = query_user_inject_interest(sender) # 用户对盒子注入的利息
user_inject_key = concat(KEY_USER_INJECT_INTEREST, sender)
if BalanceOf(sender, [GARD_DENOM])[0] <= amount:
raise Exception("余额不足")
if query_box_status() != ISSUE_STATUS:
raise Exception("当前不处于发行期")
if amount > BOX_INTEREST:
raise Exception("大于最大应存利息数")
if not interest_balance:
Put(KEY_BOX_INTEREST, amount) # 记录利息
else:
sub = BOX_INTEREST - interest_balance
if amount > sub:
raise Exception("超过可存入的利息总额")
else:
Put(KEY_BOX_INTEREST, interest_balance + amount)
if not user_interest_amount: # 提交用户注入利息
Put(user_inject_key, amount)
else:
Put(user_inject_key, user_interest_amount + amount)
ContractBalanceInject(sender, GARD_DENOM, amount) # 转账利息到合约地址
return True
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 set_event_pool(amount): # 设立活动奖池
sender_address = GetTxSender()
if BalanceOf(sender_address, [GARD_DENOM])[0] < amount: # 判断余额是否足够初始化
raise Exception("余额不足")
event_pool = Get(KEY_EVENT_POOL)
if not event_pool:
ContractBalanceInject(sender_address, GARD_DENOM, amount)
Put(KEY_EVENT_POOL, amount)
return True
balance_amount = event_pool + amount
Put(KEY_EVENT_POOL, balance_amount)
ContractBalanceInject(sender_address, GARD_DENOM, balance_amount)
return True
def system_prize_pool_inject(amount): # 给系统奖池授予额度
sender = GetTxSender()
if BalanceOf(sender, [GARD_DENOM])[0] < amount: # 判断余额是否足够初始化
raise Exception("余额不足")
sys_pool = Get(KEY_SYSTEM_POOL)
if not sys_pool:
ContractBalanceInject(sender, GARD_DENOM, amount)
Put(KEY_SYSTEM_POOL, amount) # 记录系统奖池额度
return True
balance_amount = sys_pool + amount
ContractBalanceInject(sender, GARD_DENOM, balance_amount)
Put(KEY_SYSTEM_POOL, balance_amount) # 记录总的奖池额度
return True
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(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
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