Exemple #1
0
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 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 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 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