Smart-Contract Development Guide

void bet(ion::name user, std::string quantity, uint8_t roll_under, ion::checksum256 seed_hash, ion::checksum256 user_seed_hash, bool paySysCms);

require_auth(user);
ion::internal_use_do_not_use::require_auth2(user.value, plasma::accountPlasmaDicePermission.value);

assert_quantity(quantity);
assert_roll_under(roll_under, quantity);

uint64_t key = next_id();
auto it = bets_.find(key);

ion::check(it == bets_.end(), "duplicate bet ID");

ion::action(
    ion::permission_level{ user, ion::name("active") },
    ion::name(issuer),
    ion::name("transfer"),
    std::make_tuple(user, plasma::accountPlasmaDiceBank, quantity.amount, paySysCms, std::string("bet placed"))
).send();

auto commission = get_commission(paySysCms);
quantity = quantity - (quantity * commission.first) / (commission.second * 100);

plasma::allbets new_bet = { key, user, quantity, roll_under, seed_hash, user_seed_hash, ion::current_time_point() };
bets_.emplace(user, [&](auto& r) {
    r.id = new_bet.id;
        r.player = new_bet.player;
        r.amount = new_bet.amount;
        r.roll_under = new_bet.roll_under;
        r.seed_hash = new_bet.seed_hash;
        r.user_seed_hash = new_bet.user_seed_hash;
        r.created_at = new_bet.created_at;
});

dicepool_lock(new_bet.amount);

ion::action(
    ion::permission_level{ _self, ion::name("active") },
        ion::name(plasma::accountPlasmaDiceLogs),
        ion::name("receipt"),
        std::make_tuple(new_bet)
).send();

Implements the following algorithms within itself: 

It allows the user to play a bet that he (the user) made in advance. With a successful scenario, the user receives a payment to his account, or he receives nothing. Works in the following steps

void plasma_dice::dice(ion::name user, uint64_t id, ion::checksum256 seed)

1) Check the required permissions for the game. The smart contract asks for authorization for the user playing the game. The smart contract checks whether the user has the necessary permissions for the game in fair-dice.

require_auth(user);
ion::internal_use_do_not_use::require_auth2(user.value, plasma::accountPlasmaDicePermission.value);

2) Validation Check - Bid ID The transferred bet ID is searched inside the blockchain / table, and if the system does not see it, then the bet cannot be played. The method completes its work, no payments are made. If the bid is found - we save the iterator "it", which stores all the necessary information (amount, hashes, user name, etc.).

auto it = bets_.find(id);
if (it == bets_.end())
{
    printf("#info - bet not found");
        return ;
}

3) Random number generation and rate check. Using the hash_combine algorithm, we generate a random number, on the basis of which a decision will be made - a winning bid or not. Forms the amount of payment to the user - initially equal to 0.0 tokens. Then we compare the resulting number with the user number, and if the condition that the bet is lost is fulfilled, then we go to point "8" (below). No payment is made.

ion::asset payout = ion::asset(0, it->amount.symbol);
uint8_t random_roll = compute_random_roll(seed, it->user_seed_hash);
if (random_roll < it->roll_under)

4) Winning bet - payout On the basis of the bet made by the user, and the number-coefficient indicated by him, the preliminary payment is calculated. The formula for which the payment is considered is implemented in the business logic of the contract and is indicated above.

payout = compute_payout(it->roll_under, it->amount);

5) Winning bid - calculation of the commission to win On the payment generated above - the commission on a prize is considered. The smart contract has a constant commission of 0.2 percent of the winning amount. This commission is removed from the total payment amount to the user.

ion::asset commission = compute_comission(payout);

6) Winning Rate - Commission Processing Calculated above commission - sent to a special system account of the game. To do this, call the "transfer" method of the accountIonToken contract, in the parameters of which the data for transfer is transferred. We specify the account - the accepting payment (commission), we specify the sender - the stock account storage, which is used to pay rates. It is worth noting that in this case the transfer method is “free”, and we do not charge a commission for transferring commission. The method requests the necessary user permissions for the operation. We need to have "active" permission for the account accountPlasmaDiceBank to be able to transfer funds from the depository bank.

ion::action(
    ion::permission_level{ plasma::accountPlasmaDiceBank, ion::name("active") },
    plasma::accountIonToken,
    ion::name("transfer"),
    std::make_tuple(plasma::accountPlasmaDiceBank, plasma::accountPlasmaDice, commission, commission_memo(*it))
).send();

7) Winning bet - user payout The generated payment to the user minus the above commission is sent using the "transfer" method. To do this, use the marker smart contract method, for example, USDP It is worth noting that this method is not “free”, and the user pays a transfer fee. In the parameters of the method, we specify the sender account, this is our stock bank-storage, the recipient account is the user himself, and the payment amount. The method requests the necessary user permissions for the operation. We need to have an "active" perm for the accountPlasmaDiceBank account in order to be able to send funds from the vault bank.

ion::action(
    ion::permission_level{ plasma::accountPlasmaDiceBank, ion::name("active") },
    ion::name(issuer),
    ion::name("transfer"),
    std::make_tuple(plasma::accountPlasmaDiceBank, user, payout.amount - commission.amount, bool(false), winner_memo(*it))
).send();

8) Deposit unblocking - unlocking potential maximum payout to the user Since the bet is played, and all payments, in the case of a successful game, were made, we will unlock the amount previously blocked. From now on, our vault bank considers this bet played, and its reserve fund is increased by the amount of the potential maximum payout of the bet played.

dicepool_unlock(it->amount);

9) Formation of the check, the information message for the user. The method "prize" is called for the contract-assistant of the game, where the structure containing the information about the just played bet is sent. The “prize” method itself, similar to the “receipt” method, is a mock-stub, but thanks to this call, we explicitly display all information about the bet played. The user can visually see - the parameters of the bet played, a randomly generated number and his payment. In case of loss - the payment will be zero, but the format of the information message will not change.

ion::action(
    ion::permission_level{ _self, ion::name("active") },
        ion::name(plasma::accountPlasmaDiceLogs),
        ion::name("receipt"),
        std::make_tuple(new_bet)
).send();

10) Rate deletion - deletion of data from the table / blockchain. At this stage, the smart contract removes the newly played bet from the active bet table. This bet is no longer considered relevant and unique.

bets_.erase(it);