example of a NFT Factory contract in CameLIGO 

reset

reveal

commit

participants

locked_tez

secrets

decoded_payloads

result_nat

last_seed

metadata

module Utils = struct 

    let power (x, y : nat * nat) : nat = 
        let rec multiply(acc, elt, last: nat * nat * nat ) : nat = if last = 0n then acc else multiply(acc * elt, elt, abs(last - 1n)) in
        multiply(1n, x, y)

    let hexa_to_nat(hexa : bytes) : nat =
        let _check_size : unit = assert_with_error (Bytes.length hexa = 1n) "Can only convert 1 byte" in    
        if hexa = 0x00 then 0n
        else if hexa = 0x01 then 1n
        else if hexa = 0x02 then 2n
        else if hexa = 0x03 then 3n
        else if hexa = 0x04 then 4n
        else if hexa = 0x05 then 5n
        else if hexa = 0x06 then 6n
        else if hexa = 0x07 then 7n
        else if hexa = 0x08 then 8n
        else if hexa = 0x09 then 9n
        else if hexa = 0x0A then 10n
        else if hexa = 0x0B then 11n
        else if hexa = 0x0C then 12n
        else if hexa = 0x0D then 13n
        else if hexa = 0x0E then 14n
        else if hexa = 0x0F then 15n
        else if hexa = 0x10 then 16n
        else if hexa = 0x11 then 17n
        else if hexa = 0x12 then 18n
        else if hexa = 0x13 then 19n
        else if hexa = 0x14 then 20n
        else if hexa = 0x15 then 21n
        else if hexa = 0x16 then 22n
        else if hexa = 0x17 then 23n
        else if hexa = 0x18 then 24n
        else if hexa = 0x19 then 25n
        else if hexa = 0x1A then 26n
        else if hexa = 0x1B then 27n
        else if hexa = 0x1C then 28n
        else if hexa = 0x1D then 29n
        else if hexa = 0x1E then 30n
        else if hexa = 0x1F then 31n
        else if hexa = 0x20 then 32n
        else if hexa = 0x21 then 33n
        else if hexa = 0x22 then 34n
        else if hexa = 0x23 then 35n
        else if hexa = 0x24 then 36n
        else if hexa = 0x25 then 37n
        else if hexa = 0x26 then 38n
        else if hexa = 0x27 then 39n
        else if hexa = 0x28 then 40n
        else if hexa = 0x29 then 41n
        else if hexa = 0x2A then 42n
        else if hexa = 0x2B then 43n
        else if hexa = 0x2C then 44n
        else if hexa = 0x2D then 45n
        else if hexa = 0x2E then 46n
        else if hexa = 0x2F then 47n
        else if hexa = 0x30 then 48n
        else if hexa = 0x31 then 49n
        else if hexa = 0x32 then 50n
        else if hexa = 0x33 then 51n
        else if hexa = 0x34 then 52n
        else if hexa = 0x35 then 53n
        else if hexa = 0x36 then 54n
        else if hexa = 0x37 then 55n
        else if hexa = 0x38 then 56n
        else if hexa = 0x39 then 57n
        else if hexa = 0x3A then 58n
        else if hexa = 0x3B then 59n
        else if hexa = 0x3C then 60n
        else if hexa = 0x3D then 61n
        else if hexa = 0x3E then 62n
        else if hexa = 0x3F then 63n
        else if hexa = 0x40 then 64n
        else if hexa = 0x41 then 65n
        else if hexa = 0x42 then 66n
        else if hexa = 0x43 then 67n
        else if hexa = 0x44 then 68n
        else if hexa = 0x45 then 69n
        else if hexa = 0x46 then 70n
        else if hexa = 0x47 then 71n
        else if hexa = 0x48 then 72n
        else if hexa = 0x49 then 73n
        else if hexa = 0x4A then 74n
        else if hexa = 0x4B then 75n
        else if hexa = 0x4C then 76n
        else if hexa = 0x4D then 77n
        else if hexa = 0x4E then 78n
        else if hexa = 0x4F then 79n
        else if hexa = 0x50 then 80n
        else if hexa = 0x51 then 81n
        else if hexa = 0x52 then 82n
        else if hexa = 0x53 then 83n
        else if hexa = 0x54 then 84n
        else if hexa = 0x55 then 85n
        else if hexa = 0x56 then 86n
        else if hexa = 0x57 then 87n
        else if hexa = 0x58 then 88n
        else if hexa = 0x59 then 89n
        else if hexa = 0x5A then 90n
        else if hexa = 0x5B then 91n
        else if hexa = 0x5C then 92n
        else if hexa = 0x5D then 93n
        else if hexa = 0x5E then 94n
        else if hexa = 0x5F then 95n
        else if hexa = 0x60 then 96n
        else if hexa = 0x61 then 97n
        else if hexa = 0x62 then 98n
        else if hexa = 0x63 then 99n
        else if hexa = 0x64 then 100n
        else if hexa = 0x65 then 101n
        else if hexa = 0x66 then 102n
        else if hexa = 0x67 then 103n
        else if hexa = 0x68 then 104n
        else if hexa = 0x69 then 105n
        else if hexa = 0x6A then 106n
        else if hexa = 0x6B then 107n
        else if hexa = 0x6C then 108n
        else if hexa = 0x6D then 109n
        else if hexa = 0x6E then 110n
        else if hexa = 0x6F then 111n
        else if hexa = 0x70 then 112n
        else if hexa = 0x71 then 113n
        else if hexa = 0x72 then 114n
        else if hexa = 0x73 then 115n
        else if hexa = 0x74 then 116n
        else if hexa = 0x75 then 117n
        else if hexa = 0x76 then 118n
        else if hexa = 0x77 then 119n
        else if hexa = 0x78 then 120n
        else if hexa = 0x79 then 121n
        else if hexa = 0x7A then 122n
        else if hexa = 0x7B then 123n
        else if hexa = 0x7C then 124n
        else if hexa = 0x7D then 125n
        else if hexa = 0x7E then 126n
        else if hexa = 0x7F then 127n
        else if hexa = 0x80 then 128n
        else if hexa = 0x81 then 129n
        else if hexa = 0x82 then 130n
        else if hexa = 0x83 then 131n
        else if hexa = 0x84 then 132n
        else if hexa = 0x85 then 133n
        else if hexa = 0x86 then 134n
        else if hexa = 0x87 then 135n
        else if hexa = 0x88 then 136n
        else if hexa = 0x89 then 137n
        else if hexa = 0x8A then 138n
        else if hexa = 0x8B then 139n
        else if hexa = 0x8C then 140n
        else if hexa = 0x8D then 141n
        else if hexa = 0x8E then 142n
        else if hexa = 0x8F then 143n
        else if hexa = 0x90 then 144n
        else if hexa = 0x91 then 145n
        else if hexa = 0x92 then 146n
        else if hexa = 0x93 then 147n
        else if hexa = 0x94 then 148n
        else if hexa = 0x95 then 149n
        else if hexa = 0x96 then 150n
        else if hexa = 0x97 then 151n
        else if hexa = 0x98 then 152n
        else if hexa = 0x99 then 153n
        else if hexa = 0x9A then 154n
        else if hexa = 0x9B then 155n
        else if hexa = 0x9C then 156n
        else if hexa = 0x9D then 157n
        else if hexa = 0x9E then 158n
        else if hexa = 0x9F then 159n
        else if hexa = 0xA0 then 160n
        else if hexa = 0xA1 then 161n
        else if hexa = 0xA2 then 162n
        else if hexa = 0xA3 then 163n
        else if hexa = 0xA4 then 164n
        else if hexa = 0xA5 then 165n
        else if hexa = 0xA6 then 166n
        else if hexa = 0xA7 then 167n
        else if hexa = 0xA8 then 168n
        else if hexa = 0xA9 then 169n
        else if hexa = 0xAA then 170n
        else if hexa = 0xAB then 171n
        else if hexa = 0xAC then 172n
        else if hexa = 0xAD then 173n
        else if hexa = 0xAE then 174n
        else if hexa = 0xAF then 175n
        else if hexa = 0xB0 then 176n
        else if hexa = 0xB1 then 177n
        else if hexa = 0xB2 then 178n
        else if hexa = 0xB3 then 179n
        else if hexa = 0xB4 then 180n
        else if hexa = 0xB5 then 181n
        else if hexa = 0xB6 then 182n
        else if hexa = 0xB7 then 183n
        else if hexa = 0xB8 then 184n
        else if hexa = 0xB9 then 185n
        else if hexa = 0xBA then 186n
        else if hexa = 0xBB then 187n
        else if hexa = 0xBC then 188n
        else if hexa = 0xBD then 189n
        else if hexa = 0xBE then 190n
        else if hexa = 0xBF then 191n
        else if hexa = 0xC0 then 192n
        else if hexa = 0xC1 then 193n
        else if hexa = 0xC2 then 194n
        else if hexa = 0xC3 then 195n
        else if hexa = 0xC4 then 196n
        else if hexa = 0xC5 then 197n
        else if hexa = 0xC6 then 198n
        else if hexa = 0xC7 then 199n
        else if hexa = 0xC8 then 200n
        else if hexa = 0xC9 then 201n
        else if hexa = 0xCA then 202n
        else if hexa = 0xCB then 203n
        else if hexa = 0xCC then 204n
        else if hexa = 0xCD then 205n
        else if hexa = 0xCE then 206n
        else if hexa = 0xCF then 207n
        else if hexa = 0xD0 then 208n
        else if hexa = 0xD1 then 209n
        else if hexa = 0xD2 then 210n
        else if hexa = 0xD3 then 211n
        else if hexa = 0xD4 then 212n
        else if hexa = 0xD5 then 213n
        else if hexa = 0xD6 then 214n
        else if hexa = 0xD7 then 215n
        else if hexa = 0xD8 then 216n
        else if hexa = 0xD9 then 217n
        else if hexa = 0xDA then 218n
        else if hexa = 0xDB then 219n
        else if hexa = 0xDC then 220n
        else if hexa = 0xDD then 221n
        else if hexa = 0xDE then 222n
        else if hexa = 0xDF then 223n
        else if hexa = 0xE0 then 224n
        else if hexa = 0xE1 then 225n
        else if hexa = 0xE2 then 226n
        else if hexa = 0xE3 then 227n
        else if hexa = 0xE4 then 228n
        else if hexa = 0xE5 then 229n
        else if hexa = 0xE6 then 230n
        else if hexa = 0xE7 then 231n
        else if hexa = 0xE8 then 232n
        else if hexa = 0xE9 then 233n
        else if hexa = 0xEA then 234n
        else if hexa = 0xEB then 235n
        else if hexa = 0xEC then 236n
        else if hexa = 0xED then 237n
        else if hexa = 0xEE then 238n
        else if hexa = 0xEF then 239n
        else if hexa = 0xF0 then 240n
        else if hexa = 0xF1 then 241n
        else if hexa = 0xF2 then 242n
        else if hexa = 0xF3 then 243n
        else if hexa = 0xF4 then 244n
        else if hexa = 0xF5 then 245n
        else if hexa = 0xF6 then 246n
        else if hexa = 0xF7 then 247n
        else if hexa = 0xF8 then 248n
        else if hexa = 0xF9 then 249n
        else if hexa = 0xFA then 250n
        else if hexa = 0xFB then 251n
        else if hexa = 0xFC then 252n
        else if hexa = 0xFD then 253n
        else if hexa = 0xFE then 254n
        else if hexa = 0xFF then 255n
        else
            (failwith("Wrong hexa") : nat)



    let bytes_to_nat(payload : bytes) : nat =
        let rec convert_to_nat(acc, indice, payload : nat * nat * bytes) : nat =
            if indice = 1n then
                acc + hexa_to_nat(payload)
            else
                let size : nat = (Bytes.length payload) in
                let one_left_bytes = Bytes.sub 0n 1n payload in
                let right_bytes = Bytes.sub 1n (abs(size - 1n)) payload in 
                let one_left_nat = hexa_to_nat(one_left_bytes) * power(256n, abs(indice - 1n)) in 
                convert_to_nat(acc + one_left_nat, abs(indice - 1n), right_bytes)
        in
        convert_to_nat(0n, Bytes.length payload, payload)

end

let not_authorized : string = "Not authorized"
let missing_bytes : string = "Missing some bytes"
let commit_expects_10_mutez_lock : string = "You must lock 10mutez"
let reveal_expects_0_mutez_lock : string = "You must not send tez (reveal entrypoint)"
let reset_expects_0_mutez_lock : string = "You must not send tez (reset entrypoint)"

let fail_open_bytes_timelock : string = "Could not open bytes: Fail_timelock"
let fail_open_bytes_decrypt : string = "Could not open bytes: Fail_decrypt"
let bytes_already_revealed : string = "Chest already revealed"
let unknown_user_account : string = "Unknown user account"
let wrong_user_balance : string = "User shold have locked some tez during commit bytes phase"
let bytes_already_committed : string = "Sender has already committed its bytes"
let wrong_amount_locked_tez : string = "The locked amount is incorrect"

#import "storage.mligo" "Storage"
#import "parameter.mligo" "Parameter"
#import "errors.mligo" "Errors"


type storage = Storage.Types.t
type parameter = Parameter.Types.t
type return = operation list * storage

 // Sender commits its bytes
[@entry] let commit(p : Parameter.Types.commit_param) (st : storage) : operation list * storage =
    let _check_authorized : unit = assert_with_error (Set.mem (Tezos.get_sender ()) st.participants) Errors.not_authorized in
    let _check_amount : unit = assert_with_error (Tezos.get_amount () >= 10mutez) Errors.commit_expects_10_mutez_lock in
    let new_secrets = match Map.find_opt (Tezos.get_sender ()) st.secrets with
    | None -> Map.add (Tezos.get_sender ()) p.secret_action st.secrets
    | Some _x -> (failwith(Errors.bytes_already_committed) : (address, bytes) map)
    in
    let new_locked : (address, tez) map = match Map.find_opt (Tezos.get_sender ()) st.locked_tez with
    | None -> Map.add (Tezos.get_sender ()) (Tezos.get_amount ()) st.locked_tez
    | Some v -> Map.update (Tezos.get_sender ()) (Some(v + Tezos.get_amount ())) st.locked_tez
    in
    (([] : operation list), { st with secrets=new_secrets; locked_tez=new_locked })


// Sender reveals its bytes content
[@entry] let reveal(p : Parameter.Types.reveal_param) (s : storage) : operation list * storage =
    let sender_address : address = Tezos.get_sender () in
    let _check_amount : unit = assert_with_error (Tezos.get_amount () = 0mutez) Errors.reveal_expects_0_mutez_lock in
    let _check_authorized : unit = assert_with_error (Set.mem sender_address s.participants) Errors.not_authorized in
    // check all bytes has been received
    let committed = fun (acc, elt : bool * address) : bool -> match Map.find_opt elt s.secrets with
        | None -> acc && false
        | Some _x -> acc && true
    in
    let _all_bytes_committed = Set.fold committed s.participants true in

    let _check_all_bytes: unit = assert_with_error (_all_bytes_committed = true) Errors.missing_bytes in

    let (bytes, secret) = p in
    let sender_bytes : bytes = match Map.find_opt sender_address s.secrets with
    | None -> failwith(Errors.missing_bytes)
    | Some ch -> ch
    in
    // open bytes and stores the bytes content
    let encoded = Crypto.sha512 (Bytes.pack (bytes, secret)) in
    let decoded_payload =
        if encoded = sender_bytes
        then bytes
        else failwith(Errors.fail_open_bytes_decrypt)
    in
    let new_decoded_payloads = match Map.find_opt sender_address s.decoded_payloads with
    | None -> Map.add (Tezos.get_sender ()) decoded_payload s.decoded_payloads
    | Some _elt -> (failwith(Errors.bytes_already_revealed) : (address, bytes) map)
    in
    // check all bytes has been revealed
    let revealed = fun (acc, elt : bool * address) : bool -> match Map.find_opt elt new_decoded_payloads with
        | None -> acc && false
        | Some _x -> acc && true
    in
    let new_locked : (address, tez) map = match Map.find_opt (Tezos.get_sender ()) s.locked_tez with
    | None -> failwith(Errors.wrong_user_balance)
    | Some v ->
        (match v - 10mutez with
        | None -> failwith(Errors.wrong_amount_locked_tez)
        | Some new_val -> Map.update (Tezos.get_sender ()) (Some(new_val)) s.locked_tez)
    in
    let dest_opt : unit contract option = Tezos.get_contract_opt (Tezos.get_sender ()) in
    let destination : unit contract = match dest_opt with
    | None -> failwith(Errors.unknown_user_account)
    | Some ct -> ct
    in
    let op : operation = Tezos.transaction unit 10mutez destination in

    let all_bytes_revealed = Set.fold revealed s.participants true in
    if all_bytes_revealed = true then
        let (seed, value) = Storage.Utils.build_random_nat(new_decoded_payloads, s.min, s.max, s.last_seed) in
        ([op], { s with decoded_payloads=new_decoded_payloads; locked_tez=new_locked; result_nat=(Some(value)); last_seed=seed })
    else
        ([op], { s with decoded_payloads=new_decoded_payloads; locked_tez=new_locked })


[@entry] let reset (param : Parameter.Types.reset_param) (store : storage) : operation list * storage =
    // clean secrets_bytes and decoded_payloads
    let _check_amount : unit = assert_with_error (Tezos.get_amount () = 0mutez) Errors.reset_expects_0_mutez_lock in
    (([] : operation list), { store with
        decoded_payloads=(Map.empty : (address, bytes) map);
        secrets=(Map.empty : (address, bytes) map);
        result_nat=(None : nat option);
        min=param.min;
        max=param.max
    })

module Types = struct
    type commit_param = {
        secret_action : bytes
    }

    type reveal_param = bytes * nat

    type reset_param = {
        min : nat;
        max : nat
    }

    type t = Commit of commit_param | Reveal of reveal_param | Reset of reset_param
end 

#import "errors.mligo" "Errors"
#import "parameter.mligo" "Parameter"
#import "bytes_utils.mligo" "Convert"

module Types = struct
    type t = {
        participants : address set;
        locked_tez : (address, tez) map;
        secrets : (address, bytes) map;
        decoded_payloads: (address, bytes) map;
        result_nat : nat option;
        last_seed : nat;
        max : nat;
        min: nat;
        metadata: (string, bytes) big_map;
    }
end

module Utils = struct

    // Apply Mersenne twister algorithm to get a random number between min an max
    let random_range (state0: nat) (state1:nat) (min:nat) (max:nat) = 
        let random (state0: nat) (state1: nat) = 
            let s0 = state0 in
            let s1 = state1 in
            let s1 =  s1 lxor (s1 lsl 23n) in 
            let s1 =  s1 lxor (s1 lsr 17n) in 
            let s1 =  s1 lxor s0 in 
            let s1 =  s1 lxor (s0 lsr 26n) in 
            s0 + s1 in
        let ns = random state0 state1 in 
        (ns, ns mod (max + 1n - min) + min)
    
    // Once everybody has commit & reveal we can compute bytes seed
    let build_seed_bytes(payloads : (address, bytes) map) : bytes option =
        // hash all decoded payloads
        let hash_payload = fun(acc, elt: bytes list * (address * bytes)) : bytes list -> (Crypto.keccak elt.1) :: acc in
        let pl : bytes list = Map.fold hash_payload payloads ([]:bytes list) in
        // combine all hashes (concat and hash again)
        let hashthemall = fun(acc, elt: bytes option * bytes) : bytes option -> 
            match acc with 
            | None -> Some(elt)
            | Some pred -> Some(Crypto.keccak (Bytes.concat elt pred)) 
        in
        List.fold hashthemall pl (None : bytes option)

    // Compute a seed based on decoded bytes payloads
    let build_random_nat(payloads, min, max, last_seed : (address, bytes) map * nat * nat * nat) : nat * nat =
        // Compute a seed based on decoded bytes payloads
        let seed_bytes = build_seed_bytes payloads in 
        // convert hash seed into nat seed
        let seed : nat = match seed_bytes with 
        | None -> (failwith("could not construct a hash") : nat)
        | Some hsh -> Convert.Utils.bytes_to_nat(hsh)
        in
        // generate a random nat (between range) based on the computed nat seed
        random_range last_seed seed min max

end

#import "../src/main.mligo" "Random"

let create_bytes (payload: bytes) (secret:nat) : (bytes * bytes) =
    (Crypto.sha512 (Bytes.pack (payload, secret)), payload)

let test =
    let alice: address = Test.nth_bootstrap_account 0 in
    let bob: address = Test.nth_bootstrap_account 1 in

    let init_seed : nat = 3268854739249n in
    let init_storage : Random.Storage.Types.t = {
        participants= Set.add alice (Set.add bob (Set.empty : address set));
        locked_tez=(Map.empty : (address, tez) map);
        secrets=(Map.empty: (address, bytes) map);
        decoded_payloads=(Map.empty: (address, bytes) map);
        result_nat=(None : nat option);
        last_seed=init_seed;
        max=1000n;
        min=100n;
        metadata=(Big_map.empty: (string, bytes) big_map);
    } in
    // originate Random smart contract
    let orig = Test.originate (contract_of Random) init_storage 0tez in
    let _s_init = Test.get_storage orig.addr in
    //let () = Test.log(s_init) in

    let _test_should_works = (* bytes key/payload and time matches -> OK *)

        let payload : bytes = 0x0a in
        let time_secret : nat = 10n in
        let (my_bytes,bytes) = create_bytes payload time_secret in

        let payload2 : bytes = 0x0b in
        let time_secret2 : nat = 99n in
        let (my_bytes2,bytes2) = create_bytes payload2 time_secret2 in


        // alice commits
        let () = Test.set_source alice in
        let commit_args : Random.Parameter.Types.commit_param = {secret_action=my_bytes} in
        let _ = Test.transfer_exn orig.addr(Commit(commit_args)) 10mutez in

        let s : Random.storage = Test.get_storage orig.addr in
        let response : bool = match Map.find_opt alice s.secrets with
        | None -> false
        | Some _addr -> true
        in
        let () = assert (response) in

        // bob commits
        let () = Test.set_source bob in
        let commit_args2 : Random.Parameter.Types.commit_param = {secret_action=my_bytes2} in
        let _ = Test.transfer_exn orig.addr(Commit(commit_args2)) 10mutez in

        let s3 : Random.storage = Test.get_storage orig.addr in
        let response2 : bool = match Map.find_opt bob s3.secrets with
        | None -> false
        | Some _addr -> true
        in
        let () = assert (response2) in

        // alice reveals
        let () = Test.set_source alice in
        let reveal_args : Random.Parameter.Types.reveal_param = (bytes, time_secret) in
        let _ = Test.transfer_exn orig.addr(Reveal(reveal_args)) 0mutez in

        // bob reveals
        let () = Test.set_source bob in
        let reveal_args2 : Random.Parameter.Types.reveal_param = (bytes2, time_secret2) in
        let _ = Test.transfer_exn orig.addr(Reveal(reveal_args2)) 0mutez in

        let s2 : Random.storage = Test.get_storage orig.addr in
        let () = assert (s2.result_nat <> (None : nat option)) in
        "OK"
    in
    ()

let test2 =
    let alice: address = Test.nth_bootstrap_account 0 in
    let bob: address = Test.nth_bootstrap_account 1 in
    let init_seed : nat = 3268854739249n in
    let init_storage : Random.Storage.Types.t = {
        participants= Set.add alice (Set.add bob (Set.empty : address set));
        locked_tez=(Map.empty : (address, tez) map);
        secrets=(Map.empty: (address, bytes) map);
        decoded_payloads=(Map.empty: (address, bytes) map);
        result_nat=(None : nat option);
        last_seed=init_seed;
        max=1000n;
        min=1n;
        metadata=(Big_map.empty: (string, bytes) big_map);
    } in
    // originate Random smart contract
    let orig = Test.originate (contract_of Random) init_storage 0tez in
    let _s_init = Test.get_storage orig.addr in

    let _test_rollD1000 =

        let payload : bytes = 0x0a1234 in
        let time_secret : nat = 10n in
        let (my_bytes,bytes) = create_bytes payload time_secret in

        let payload2 : bytes = 0x0b455469 in
        let time_secret2 : nat = 84n in
        let (my_bytes2,bytes2) = create_bytes payload2 time_secret2 in


        // alice commits
        let () = Test.set_source alice in
        let commit_args : Random.Parameter.Types.commit_param = {secret_action=my_bytes} in
        let _ = Test.transfer_exn orig.addr(Commit(commit_args)) 10mutez in

        // bob commits
        let () = Test.set_source bob in
        let commit_args2 : Random.Parameter.Types.commit_param = {secret_action=my_bytes2} in
        let _ = Test.transfer_exn orig.addr(Commit(commit_args2)) 10mutez in

        // alice reveals
        let () = Test.set_source alice in
        let reveal_args : Random.Parameter.Types.reveal_param = (bytes, time_secret) in
        let _ = Test.transfer_exn orig.addr(Reveal(reveal_args)) 0mutez in

        // bob reveals
        let () = Test.set_source bob in
        let reveal_args2 : Random.Parameter.Types.reveal_param = (bytes2, time_secret2) in
        let _ = Test.transfer_exn orig.addr(Reveal(reveal_args2)) 0mutez in

        let s2 : Random.storage = Test.get_storage orig.addr in
        let () = Test.log(s2.result_nat) in
        let () = assert (s2.result_nat <> (None : nat option)) in
        "OK"
    in
    let _test_rollD20 =

        let payload : bytes = 0x0a1234 in
        let time_secret : nat = 10n in
        let (my_bytes,bytes) = create_bytes payload time_secret in

        let payload2 : bytes = 0x0b455469 in
        let time_secret2 : nat = 84n in
        let (my_bytes2,bytes2) = create_bytes payload2 time_secret2 in



        // alice reset
        let () = Test.set_source alice in
        let reset_args : Random.Parameter.Types.reset_param = {min=1n; max=20n} in
        let _ = Test.transfer_exn orig.addr(Reset(reset_args)) 0mutez in


        // alice commits
        let () = Test.set_source alice in
        let commit_args : Random.Parameter.Types.commit_param = {secret_action=my_bytes} in
        let _ = Test.transfer_exn orig.addr(Commit(commit_args)) 10mutez in

        // bob commits
        let () = Test.set_source bob in
        let commit_args2 : Random.Parameter.Types.commit_param = {secret_action=my_bytes2} in
        let _ = Test.transfer_exn orig.addr(Commit(commit_args2)) 10mutez in

        // alice reveals
        let () = Test.set_source alice in
        let reveal_args : Random.Parameter.Types.reveal_param = (bytes, time_secret) in
        let _ = Test.transfer_exn orig.addr(Reveal(reveal_args)) 0mutez in

        // bob reveals
        let () = Test.set_source bob in
        let reveal_args2 : Random.Parameter.Types.reveal_param = (bytes2, time_secret2) in
        let _ = Test.transfer_exn orig.addr(Reveal(reveal_args2)) 0mutez in

        let s2 : Random.storage = Test.get_storage orig.addr in
        let () = Test.log(s2.result_nat) in
        let () = assert (s2.result_nat <> (None : nat option)) in
        let result : nat = Option.unopt s2.result_nat in
        let () = assert (result <= s2.max) in
        let () = assert (result >= s2.min) in
        "OK"
    in
    let _test_rollD20_again =

        let payload : bytes = 0x0a1234 in
        let time_secret : nat = 10n in
        let (my_bytes,bytes) = create_bytes payload time_secret in

        let payload2 : bytes = 0x0b455469 in
        let time_secret2 : nat = 84n in
        let (my_bytes2,bytes2) = create_bytes payload2 time_secret2 in


        // alice reset
        let () = Test.set_source alice in
        let reset_args : Random.Parameter.Types.reset_param = {min=1n; max=20n} in
        let _ = Test.transfer_exn orig.addr(Reset(reset_args)) 0mutez in


        // alice commits
        let () = Test.set_source alice in
        let commit_args : Random.Parameter.Types.commit_param = {secret_action=my_bytes} in
        let _ = Test.transfer_exn orig.addr(Commit(commit_args)) 10mutez in

        // bob commits
        let () = Test.set_source bob in
        let commit_args2 : Random.Parameter.Types.commit_param = {secret_action=my_bytes2} in
        let _ = Test.transfer_exn orig.addr(Commit(commit_args2)) 10mutez in

        // alice reveals
        let () = Test.set_source alice in
        let reveal_args : Random.Parameter.Types.reveal_param = (bytes, time_secret) in
        let _ = Test.transfer_exn orig.addr(Reveal(reveal_args)) 0mutez in

        // bob reveals
        let () = Test.set_source bob in
        let reveal_args2 : Random.Parameter.Types.reveal_param = (bytes2, time_secret2) in
        let _ = Test.transfer_exn orig.addr(Reveal(reveal_args2)) 0mutez in

        let s2 : Random.storage = Test.get_storage orig.addr in
        let () = Test.log(s2.result_nat) in
        let () = assert (s2.result_nat <> (None : nat option)) in
        let result : nat = Option.unopt s2.result_nat in
        let () = assert (result <= s2.max) in
        let () = assert (result >= s2.min) in
        "OK"
    in
    let _test_rollD20_again_again =

        let payload : bytes = 0x0a1234 in
        let time_secret : nat = 10n in
        let (my_bytes,bytes) = create_bytes payload time_secret in

        let payload2 : bytes = 0x0b455469 in
        let time_secret2 : nat = 84n in
        let (my_bytes2,bytes2) = create_bytes payload2 time_secret2 in


        // alice reset
        let () = Test.set_source alice in
        let reset_args : Random.Parameter.Types.reset_param = {min=1n; max=20n} in
        let _ = Test.transfer_exn orig.addr(Reset(reset_args)) 0mutez in

        // alice commits
        let () = Test.set_source alice in
        let commit_args : Random.Parameter.Types.commit_param = {secret_action=my_bytes} in
        let _ = Test.transfer_exn orig.addr(Commit(commit_args)) 10mutez in

        // bob commits
        let () = Test.set_source bob in
        let commit_args2 : Random.Parameter.Types.commit_param = {secret_action=my_bytes2} in
        let _ = Test.transfer_exn orig.addr(Commit(commit_args2)) 10mutez in

        // alice reveals
        let () = Test.set_source alice in
        let reveal_args : Random.Parameter.Types.reveal_param = (bytes, time_secret) in
        let _ = Test.transfer_exn orig.addr(Reveal(reveal_args)) 0mutez in

        // check locked tez before bob reveals
        let _bob_balance_of_before_reveal = Test.get_balance_of_address bob in
        let storage_before_bob_reveals : Random.storage = Test.get_storage orig.addr in
        let bob_locked_tez_opt : tez option = Map.find_opt bob storage_before_bob_reveals.locked_tez in
        let bob_locked_tez_before_reveal : tez =  match bob_locked_tez_opt with
        | None -> 0tez
        | Some tez_val -> tez_val
        in
        let () = assert(bob_locked_tez_before_reveal = 10mutez) in

        // bob reveals
        let () = Test.set_source bob in
        let reveal_args2 : Random.Parameter.Types.reveal_param = (bytes2, time_secret2) in
        let _ = Test.transfer_exn orig.addr(Reveal(reveal_args2)) 0mutez in

        // check locked tez after bob reveals
        let storage_after_bob_reveals : Random.storage = Test.get_storage orig.addr in
        let bob_locked_tez_opt : tez option = Map.find_opt bob storage_after_bob_reveals.locked_tez in
        let bob_locked_tez_after_reveal : tez =  match bob_locked_tez_opt with
        | None -> 0tez
        | Some tez_val -> tez_val
        in
        let () = assert(bob_locked_tez_after_reveal = 0mutez) in

        let s2 : Random.storage = Test.get_storage orig.addr in
        let () = Test.log(s2.result_nat) in
        let () = assert (s2.result_nat <> (None : nat option)) in
        let result : nat = Option.unopt s2.result_nat in
        let () = assert (result <= s2.max) in
        let () = assert (result >= s2.min) in
        "OK"
    in
    ()


#import "../src/bytes_utils.mligo" "Convert"


let test =

    let _test_convert_bytes_to_nat = (* chest key/payload and time matches -> OK *)
    
        let payload : bytes = 0x00 in
        let value : nat = Convert.Utils.bytes_to_nat(payload) in
        let () = assert(value = 0n) in

        let payload : bytes = 0x0a in
        let value : nat = Convert.Utils.bytes_to_nat(payload) in
        let () = assert(value = 10n) in

        let payload : bytes = 0x0A in
        let value : nat = Convert.Utils.bytes_to_nat(payload) in
        let () = assert(value = 10n) in

        let payload : bytes = 0x2c in
        let value : nat = Convert.Utils.bytes_to_nat(payload) in
        let () = assert(value = 44n) in

        let payload : bytes = 0x2C in
        let value : nat = Convert.Utils.bytes_to_nat(payload) in
        let () = assert(value = 44n) in

        let payload : bytes = 0xFF in
        let value : nat = Convert.Utils.bytes_to_nat(payload) in
        let () = assert(value = 255n) in

        let payload : bytes = 0x1234 in
        let value : nat = Convert.Utils.bytes_to_nat(payload) in
        let () = assert(value = 4660n) in

        let payload : bytes = 0x001234 in
        let value : nat = Convert.Utils.bytes_to_nat(payload) in
        let () = assert(value = 4660n) in

        let payload : bytes = 0x123400 in
        let value : nat = Convert.Utils.bytes_to_nat(payload) in
        let () = assert(value = 4660n * 256n) in


        Test.log("Test finished")
    in
    ()


Randomness-Cameligo

An example of a contract generating a random number in JsLIGO

export namespace Utils {

   

    const power = (x : nat, y : nat) : nat => {
        let multiply = (acc : nat, elt : nat, last : nat) : nat => { if (last == 0n) { return acc } else { return multiply(acc * elt, elt, abs(last - 1n)) } };
        return multiply(1n, x, y)
    };
        

    const hexa_to_nat = (hexa : bytes) : nat => {
        let _check_size : unit = assert_with_error( (Bytes.length(hexa) == 1n), "Can only convert 1 byte");
        let result : nat = 0n;
        switch (hexa) {
            case 0x00: result = 0n; break;
            case 0x01: result = 1n; break;
            case 0x02: result = 2n; break;
            case 0x03: result = 3n; break;
            case 0x04: result = 4n; break;
            case 0x05: result = 5n; break;
            case 0x06: result = 6n; break;
            case 0x07: result = 7n; break;
            case 0x08: result = 8n; break;
            case 0x09: result = 9n; break;
            case 0x0A: result = 10n; break;
            case 0x0B: result = 11n; break;
            case 0x0C: result = 12n; break;
            case 0x0D: result = 13n; break;
            case 0x0E: result = 14n; break;
            case 0x0F: result = 15n; break;
            case 0x10: result = 16n; break;
            case 0x11: result = 17n; break;
            case 0x12: result = 18n; break;
            case 0x13: result = 19n; break;
            case 0x14: result = 20n; break;
            case 0x15: result = 21n; break;
            case 0x16: result = 22n; break;
            case 0x17: result = 23n; break;
            case 0x18: result = 24n; break;
            case 0x19: result = 25n; break;
            case 0x1A: result = 26n; break;
            case 0x1B: result = 27n; break;
            case 0x1C: result = 28n; break;
            case 0x1D: result = 29n; break;
            case 0x1E: result = 30n; break;
            case 0x1F: result = 31n; break;
            case 0x20: result = 32n; break;
            case 0x21: result = 33n; break;
            case 0x22: result = 34n; break;
            case 0x23: result = 35n; break;
            case 0x24: result = 36n; break;
            case 0x25: result = 37n; break;
            case 0x26: result = 38n; break;
            case 0x27: result = 39n; break;
            case 0x28: result = 40n; break;
            case 0x29: result = 41n; break;
            case 0x2A: result = 42n; break;
            case 0x2B: result = 43n; break;
            case 0x2C: result = 44n; break;
            case 0x2D: result = 45n; break;
            case 0x2E: result = 46n; break;
            case 0x2F: result = 47n; break;
            case 0x30: result = 48n; break;
            case 0x31: result = 49n; break;
            case 0x32: result = 50n; break;
            case 0x33: result = 51n; break;
            case 0x34: result = 52n; break;
            case 0x35: result = 53n; break;
            case 0x36: result = 54n; break;
            case 0x37: result = 55n; break;
            case 0x38: result = 56n; break;
            case 0x39: result = 57n; break;
            case 0x3A: result = 58n; break;
            case 0x3B: result = 59n; break;
            case 0x3C: result = 60n; break;
            case 0x3D: result = 61n; break;
            case 0x3E: result = 62n; break;
            case 0x3F: result = 63n; break;
            case 0x40: result = 64n; break;
            case 0x41: result = 65n; break;
            case 0x42: result = 66n; break;
            case 0x43: result = 67n; break;
            case 0x44: result = 68n; break;
            case 0x45: result = 69n; break;
            case 0x46: result = 70n; break;
            case 0x47: result = 71n; break;
            case 0x48: result = 72n; break;
            case 0x49: result = 73n; break;
            case 0x4A: result = 74n; break;
            case 0x4B: result = 75n; break;
            case 0x4C: result = 76n; break;
            case 0x4D: result = 77n; break;
            case 0x4E: result = 78n; break;
            case 0x4F: result = 79n; break;
            case 0x50: result = 80n; break;
            case 0x51: result = 81n; break;
            case 0x52: result = 82n; break;
            case 0x53: result = 83n; break;
            case 0x54: result = 84n; break;
            case 0x55: result = 85n; break;
            case 0x56: result = 86n; break;
            case 0x57: result = 87n; break;
            case 0x58: result = 88n; break;
            case 0x59: result = 89n; break;
            case 0x5A: result = 90n; break;
            case 0x5B: result = 91n; break;
            case 0x5C: result = 92n; break;
            case 0x5D: result = 93n; break;
            case 0x5E: result = 94n; break;
            case 0x5F: result = 95n; break;
            case 0x60: result = 96n; break;
            case 0x61: result = 97n; break;
            case 0x62: result = 98n; break;
            case 0x63: result = 99n; break;
            case 0x64: result = 100n; break;
            case 0x65: result = 101n; break;
            case 0x66: result = 102n; break;
            case 0x67: result = 103n; break;
            case 0x68: result = 104n; break;
            case 0x69: result = 105n; break;
            case 0x6A: result = 106n; break;
            case 0x6B: result = 107n; break;
            case 0x6C: result = 108n; break;
            case 0x6D: result = 109n; break;
            case 0x6E: result = 110n; break;
            case 0x6F: result = 111n; break;
            case 0x70: result = 112n; break;
            case 0x71: result = 113n; break;
            case 0x72: result = 114n; break;
            case 0x73: result = 115n; break;
            case 0x74: result = 116n; break;
            case 0x75: result = 117n; break;
            case 0x76: result = 118n; break;
            case 0x77: result = 119n; break;
            case 0x78: result = 120n; break;
            case 0x79: result = 121n; break;
            case 0x7A: result = 122n; break;
            case 0x7B: result = 123n; break;
            case 0x7C: result = 124n; break;
            case 0x7D: result = 125n; break;
            case 0x7E: result = 126n; break;
            case 0x7F: result = 127n; break;
            case 0x80: result = 128n; break;
            case 0x81: result = 129n; break;
            case 0x82: result = 130n; break;
            case 0x83: result = 131n; break;
            case 0x84: result = 132n; break;
            case 0x85: result = 133n; break;
            case 0x86: result = 134n; break;
            case 0x87: result = 135n; break;
            case 0x88: result = 136n; break;
            case 0x89: result = 137n; break;
            case 0x8A: result = 138n; break;
            case 0x8B: result = 139n; break;
            case 0x8C: result = 140n; break;
            case 0x8D: result = 141n; break;
            case 0x8E: result = 142n; break;
            case 0x8F: result = 143n; break;
            case 0x90: result = 144n; break;
            case 0x91: result = 145n; break;
            case 0x92: result = 146n; break;
            case 0x93: result = 147n; break;
            case 0x94: result = 148n; break;
            case 0x95: result = 149n; break;
            case 0x96: result = 150n; break;
            case 0x97: result = 151n; break;
            case 0x98: result = 152n; break;
            case 0x99: result = 153n; break;
            case 0x9A: result = 154n; break;
            case 0x9B: result = 155n; break;
            case 0x9C: result = 156n; break;
            case 0x9D: result = 157n; break;
            case 0x9E: result = 158n; break;
            case 0x9F: result = 159n; break;
            case 0xA0: result = 160n; break;
            case 0xA1: result = 161n; break;
            case 0xA2: result = 162n; break;
            case 0xA3: result = 163n; break;
            case 0xA4: result = 164n; break;
            case 0xA5: result = 165n; break;
            case 0xA6: result = 166n; break;
            case 0xA7: result = 167n; break;
            case 0xA8: result = 168n; break;
            case 0xA9: result = 169n; break;
            case 0xAA: result = 170n; break;
            case 0xAB: result = 171n; break;
            case 0xAC: result = 172n; break;
            case 0xAD: result = 173n; break;
            case 0xAE: result = 174n; break;
            case 0xAF: result = 175n; break;
            case 0xB0: result = 176n; break;
            case 0xB1: result = 177n; break;
            case 0xB2: result = 178n; break;
            case 0xB3: result = 179n; break;
            case 0xB4: result = 180n; break;
            case 0xB5: result = 181n; break;
            case 0xB6: result = 182n; break;
            case 0xB7: result = 183n; break;
            case 0xB8: result = 184n; break;
            case 0xB9: result = 185n; break;
            case 0xBA: result = 186n; break;
            case 0xBB: result = 187n; break;
            case 0xBC: result = 188n; break;
            case 0xBD: result = 189n; break;
            case 0xBE: result = 190n; break;
            case 0xBF: result = 191n; break;
            case 0xC0: result = 192n; break;
            case 0xC1: result = 193n; break;
            case 0xC2: result = 194n; break;
            case 0xC3: result = 195n; break;
            case 0xC4: result = 196n; break;
            case 0xC5: result = 197n; break;
            case 0xC6: result = 198n; break;
            case 0xC7: result = 199n; break;
            case 0xC8: result = 200n; break;
            case 0xC9: result = 201n; break;
            case 0xCA: result = 202n; break;
            case 0xCB: result = 203n; break;
            case 0xCC: result = 204n; break;
            case 0xCD: result = 205n; break;
            case 0xCE: result = 206n; break;
            case 0xCF: result = 207n; break;
            case 0xD0: result = 208n; break;
            case 0xD1: result = 209n; break;
            case 0xD2: result = 210n; break;
            case 0xD3: result = 211n; break;
            case 0xD4: result = 212n; break;
            case 0xD5: result = 213n; break;
            case 0xD6: result = 214n; break;
            case 0xD7: result = 215n; break;
            case 0xD8: result = 216n; break;
            case 0xD9: result = 217n; break;
            case 0xDA: result = 218n; break;
            case 0xDB: result = 219n; break;
            case 0xDC: result = 220n; break;
            case 0xDD: result = 221n; break;
            case 0xDE: result = 222n; break;
            case 0xDF: result = 223n; break;
            case 0xE0: result = 224n; break;
            case 0xE1: result = 225n; break;
            case 0xE2: result = 226n; break;
            case 0xE3: result = 227n; break;
            case 0xE4: result = 228n; break;
            case 0xE5: result = 229n; break;
            case 0xE6: result = 230n; break;
            case 0xE7: result = 231n; break;
            case 0xE8: result = 232n; break;
            case 0xE9: result = 233n; break;
            case 0xEA: result = 234n; break;
            case 0xEB: result = 235n; break;
            case 0xEC: result = 236n; break;
            case 0xED: result = 237n; break;
            case 0xEE: result = 238n; break;
            case 0xEF: result = 239n; break;
            case 0xF0: result = 240n; break;
            case 0xF1: result = 241n; break;
            case 0xF2: result = 242n; break;
            case 0xF3: result = 243n; break;
            case 0xF4: result = 244n; break;
            case 0xF5: result = 245n; break;
            case 0xF6: result = 246n; break;
            case 0xF7: result = 247n; break;
            case 0xF8: result = 248n; break;
            case 0xF9: result = 249n; break;
            case 0xFA: result = 250n; break;
            case 0xFB: result = 251n; break;
            case 0xFC: result = 252n; break;
            case 0xFD: result = 253n; break;
            case 0xFE: result = 254n; break;
            case 0xFF: result = 255n; break;

            default: result = (failwith("Wrong hexa") as nat);
        };
        return result;
    };

    export const bytes_to_nat = (payload : bytes) : nat => {
        let convert_to_nat = (acc : nat, indice : nat, payload : bytes) : nat => {
            if (indice == 1n) {
                return acc + hexa_to_nat(payload)
            } 
            else {
                let size : nat = Bytes.length(payload);
                let one_left_bytes = Bytes.sub(0 as nat, 1 as nat, payload);
                let right_bytes = Bytes.sub(1 as nat, abs(size - 1n), payload);
                let one_left_nat = hexa_to_nat(one_left_bytes) * power(256n, abs(indice - 1n));
                return convert_to_nat(acc + one_left_nat, abs(indice - 1n), right_bytes)
            }
        };
        return convert_to_nat(0 as nat, Bytes.length(payload), payload)
    };

}

export const not_authorized : string = "Not authorized";
export const missing_bytes : string = "Missing some bytes";
export const commit_expects_10_mutez_lock : string = "You must lock 10mutez";
export const reveal_expects_0_mutez_lock : string = "You must not send tez (reveal entrypoint)";
export const reset_expects_0_mutez_lock : string = "You must not send tez (reset entrypoint)";

export const fail_open_bytes_timelock : string = "Could not open bytes: Fail_timelock";
export const fail_open_bytes_decrypt : string = "Could not open bytes: Fail_decrypt";
export const bytes_already_revealed : string = "Chest already revealed";
export const unknown_user_account : string = "Unknown user account";
export const wrong_user_balance : string = "User shold have locked some tez during commit bytes phase";
export const bytes_already_committed : string = "Sender has already committed its bytes";
export const wrong_amount_locked_tez : string = "The locked amount is incorrect";

#import "storage.jsligo" "Storage"
#import "parameter.jsligo" "Parameter"
#import "errors.jsligo" "Errors"


export type storage = Storage.Types.t;
export type parameter = Parameter.Types.t;
export type return_ = [list<operation>, storage];


// Sender commits its bytes
@entry
const commit = (p : Parameter.Types.commit_param, st : storage) : [list<operation>, storage] => {
    let _check_authorized : unit = assert_with_error(Set.mem(Tezos.get_sender(), st.participants), Errors.not_authorized);
    let _check_amount : unit = assert_with_error( (Tezos.get_amount() >= 10mutez), Errors.commit_expects_10_mutez_lock);
    let new_secrets = match (Map.find_opt(Tezos.get_sender(), st.secrets)) {
        when(None()): Map.add(Tezos.get_sender(), p.secret_action, st.secrets);
        when(Some(_x)): (failwith(Errors.bytes_already_committed) as map<address, bytes>);
    };
    let new_locked : map<address, tez> = match (Map.find_opt(Tezos.get_sender(), st.locked_tez)) {
        when(None()): Map.add(Tezos.get_sender(), Tezos.get_amount(), st.locked_tez);
        when(Some(value)): Map.update(Tezos.get_sender(), (Some(value + Tezos.get_amount())), st.locked_tez);
    };
    return [(list([]) as list<operation>), { ...st, secrets:new_secrets, locked_tez:new_locked }];
};

// Sender reveals its bytes content
@entry
const reveal = (p : Parameter.Types.reveal_param, s : storage) : [list<operation>, storage] => {
    let sender_address : address = Tezos.get_sender();
    let _check_amount : unit = assert_with_error( (Tezos.get_amount() == 0mutez), Errors.reveal_expects_0_mutez_lock);
    let _check_authorized : unit = assert_with_error( (Set.mem(sender_address, s.participants)), Errors.not_authorized);
    // check all bytes has been received
    let committed = ([acc, elt] : [bool, address]) : bool =>
        match (Map.find_opt(elt, s.secrets)) {
            when(None()): acc && false;
            when(Some(_x)): acc && true;
        };
    let _all_bytes_committed = Set.fold(committed, s.participants, true);
    let _check_all_bytes : unit = assert_with_error( (_all_bytes_committed == true), Errors.missing_bytes);

    let [decoded_payload, secret] = p;
    let sender_bytes : bytes = match (Map.find_opt(sender_address, s.secrets)) {
        when(None()): failwith(Errors.missing_bytes);
        when(Some(ch)): ch;
    };

    // open bytes and stores the bytes content
    if (Crypto.sha512(Bytes.pack([decoded_payload,secret])) != sender_bytes) {
        return failwith(Errors.fail_open_bytes_decrypt);
    };

    const new_decoded_payloads = match (Map.find_opt(sender_address, s.decoded_payloads)) {
        when(None()): Map.add(Tezos.get_sender(), decoded_payload, s.decoded_payloads);
        when(Some(_elt)): (failwith(Errors.bytes_already_revealed) as map<address, bytes>);
    };

    // check all bytes has been revealed
    let revealed = ([acc, elt] : [bool, address]) : bool =>
        match (Map.find_opt(elt, new_decoded_payloads)) {
            when(None()): acc && false;
            when(Some(_x)): acc && true;
        };
    let new_locked : map<address, tez> = match (Map.find_opt(Tezos.get_sender(), s.locked_tez)) {
        when(None()): failwith(Errors.wrong_user_balance);
        when(Some(value)): match (value - 10mutez) {
            when(None()): failwith(Errors.wrong_amount_locked_tez);
            when(Some(new_value)):Map.update(Tezos.get_sender(), Some(new_value), s.locked_tez);
            };
    };
    let dest_opt : option<contract<unit>> = Tezos.get_contract_opt(Tezos.get_sender());
    let destination : contract<unit> = match (dest_opt) {
        when(None()): failwith(Errors.unknown_user_account);
        when(Some(ct)): ct;
    };
    let op : operation = Tezos.transaction(unit, 10 as mutez, destination);

    let all_bytes_revealed = Set.fold(revealed, s.participants, true);
    if (all_bytes_revealed == true) {
        let rand = Storage.Utils.build_random_nat(new_decoded_payloads, s.min, s.max, s.last_seed);
        let seed = rand[0];
        let value = rand[1];
        return [(list([op]) as list<operation>) , { ...s, decoded_payloads:new_decoded_payloads, locked_tez:new_locked, result_nat:(Some(value)), last_seed:seed }]
    } else {
        return [(list([op]) as list<operation>), { ...s, decoded_payloads:new_decoded_payloads, locked_tez:new_locked }]
    }
};

@entry
const reset = (param : Parameter.Types.reset_param, store : storage) : [list<operation>, storage] => {
    // clean secrets_bytes and decoded_payloads
    let _check_amount : unit = assert_with_error( (Tezos.get_amount() == 0mutez), Errors.reset_expects_0_mutez_lock);
    return [(list([]) as list<operation>), { ...store,
        decoded_payloads: (Map.empty as map<address, bytes>),
        secrets: (Map.empty as map<address, bytes>),
        result_nat: (None() as option<nat>),
        min: param.min,
        max: param.max
    }];
};

export namespace Types {
    export type commit_param = {
        secret_action : bytes
    };

    export type reveal_param = [bytes, nat];

    export type reset_param = {
        min : nat,
        max : nat
    };

    export type t = ["Commit", commit_param] | ["Reveal", reveal_param] | ["Reset", reset_param];
} 

#import "errors.jsligo" "Errors"
#import "parameter.jsligo" "Parameter"
#import "bytes_utils.jsligo" "Convert"

export namespace Types {
    export type t = {
        participants : set<address>,
        locked_tez : map<address, tez>,
        secrets : map<address, bytes>,
        decoded_payloads: map<address, bytes>,
        result_nat : option<nat>,
        last_seed : nat,
        max : nat,
        min: nat,
        metadata: big_map<string, bytes>
    };
};

export namespace Utils {

    // Apply Mersenne twister algorithm to get a random number between min an max
    const random_range = (state0 : nat, state1 : nat, min : nat, max : nat) : [nat, nat] => {
        let random = (state0 : nat, state1 : nat) : nat => {
            let s0 = state0;
            let s1 = state1;
            let s1_ = Bitwise.xor(s1, Bitwise.shift_left(s1, 23 as nat)) ;
            let s1__ =  Bitwise.xor(s1_, Bitwise.shift_left(s1_, 17 as nat));
            let s1___ =  Bitwise.xor(s1__, s0);
            let s1____ =  Bitwise.xor(s1___, Bitwise.shift_left(s0, 26 as nat));
            return s0 + s1____
        }
        let ns = random (state0, state1);
        return [ns, ns % (max + 1n - min) + min]
    };

    // Once everybody has commit & reveal we can compute bytes seed
    const build_seed_bytes = (payloads : map<address, bytes>) : option<bytes> => {
        // hash all decoded payloads
        let hash_payload = ([acc, elt]: [list<bytes>,  [address, bytes]]) : list<bytes> => list([ Crypto.keccak(elt[1]), ...acc]);
        let pl : list<bytes> = Map.fold(hash_payload, payloads, list([]) as list<bytes>);
        // combine all hashes (concat and hash again)
        let hashthemall = ([acc, elt]: [option<bytes>, bytes]) : option<bytes> => {
            return match(acc) {
                when(None()): Some(elt);
                when(Some(pred)): Some(Crypto.keccak(Bytes.concat(elt, pred)));
            }
        };
        return List.fold(hashthemall, pl, (None() as option<bytes>))
    };

    // Compute a seed based on decoded bytes payloads
    export const build_random_nat = (payloads : map<address, bytes>, min : nat, max : nat, last_seed : nat) : [nat, nat] => {
        // Compute a seed based on decoded bytes payloads
        let seed_bytes = build_seed_bytes(payloads);
        // convert hash seed into nat seed
        let seed : nat = match (seed_bytes) {
            when(None()): (failwith("could not construct a hash") as nat);
            when(Some(hsh)): Convert.Utils.bytes_to_nat(hsh);
        };
        // generate a random nat (between range) based on the computed nat seed
        return random_range(last_seed, seed, min, max)
    };

}

#import "../src/main.jsligo" "Random"

const create_bytes = (payload: bytes, time_secret: nat): [bytes,bytes] =>
    [ Crypto.sha512(Bytes.pack([payload, time_secret])), payload ];

const test_one_complete_cycle = () : unit => {
    const alice: address = Test.nth_bootstrap_account(0);
    const bob: address = Test.nth_bootstrap_account(1);

    let init_seed : nat = 3268854739249n;
    let init_storage : Random.Storage.Types.t = {
        participants: Set.add(alice, (Set.add(bob, (Set.empty as set<address>)))),
        locked_tez:(Map.empty as map<address, tez>),
        secrets:(Map.empty as map<address, bytes>),
        decoded_payloads:(Map.empty as map<address, bytes>),
        result_nat:(None() as option<nat>),
        last_seed:init_seed,
        max:1000n,
        min:100n,
        metadata: (Big_map.empty as big_map<string, bytes>)
    };
    // originate Random smart contract
    const orig = Test.originate(contract_of(Random), init_storage, 0tez);
    let _s_init = Test.get_storage(orig.addr);
    //Test.log(s_init);

    let _test_full_cycle_commit_reveal_should_works = () : string => {

        let payload : bytes = 0x0a;
        let time_secret : nat = 10n;
        let [my_bytes,bytes_key] = create_bytes(payload, time_secret);

        let payload2 : bytes = 0x0b;
        let time_secret2 : nat = 99n;
        let [my_bytes2,bytes_key2] = create_bytes(payload2,time_secret2);

        //Test.log("bytess created");


        // alice commits
        //Test.log("alice commits");
        Test.set_source(alice);
        let commit_args : Random.Parameter.Types.commit_param = { secret_action:my_bytes };
        //Test.log(commit_args);
        Test.transfer_exn(orig.addr, (Commit(commit_args)), 10mutez);

        //Test.log("check alice bytes");
        let s : Random.storage = Test.get_storage(orig.addr);
        let response : bool = match (Map.find_opt(alice, s.secrets)) {
            when(None()): false;
            when(Some(_x)): true;
        };
        //Test.log(s);
        assert (response);


        // bob commits
        //Test.log("bob commits");
        Test.set_source(bob);
        let commit_args2 : Random.Parameter.Types.commit_param = { secret_action:my_bytes2 };
        //Test.log(commit_args);
        Test.transfer_exn(orig.addr, (Commit(commit_args2)), 10mutez);

        //Test.log("check bob bytes");
        let s3 : Random.storage = Test.get_storage(orig.addr);
        let response2 : bool = match (Map.find_opt(bob, s3.secrets)) {
            when(None()): false;
            when(Some(_x)): true;
        };
        //Test.log(s3);
        assert (response2);

        // alice reveals
        //Test.log("alice reveals");
        Test.set_source(alice);
        let reveal_args : Random.Parameter.Types.reveal_param = [bytes_key, time_secret];
        //Test.log(reveal_args);
        Test.transfer_exn(orig.addr, (Reveal(reveal_args)), 0mutez);

        // bob reveals
        // Test.log("bob reveals");
        Test.set_source(bob);
        let reveal_args2 : Random.Parameter.Types.reveal_param = [bytes_key2, time_secret2];
        Test.transfer_exn(orig.addr, (Reveal(reveal_args2)), 0mutez);

        //Test.log("check storage");
        let s2 : Random.storage = Test.get_storage(orig.addr);
        Test.log(s2.result_nat);
        assert (s2.result_nat != (None() as option<nat>));
        return "OK"
        //Test.log("test finished")
    };
    // execution
    const _test = _test_full_cycle_commit_reveal_should_works();
};

const test_roll_dices = () : unit => {
    const alice: address = Test.nth_bootstrap_account(0);
    const bob: address = Test.nth_bootstrap_account(1);
    let init_seed : nat = 3268854739249n;
    let init_storage : Random.Storage.Types.t = {
        participants: Set.add(alice, (Set.add(bob, (Set.empty as set<address>)))),
        locked_tez:(Map.empty as map<address, tez>),
        secrets:(Map.empty as map<address, bytes>),
        decoded_payloads:(Map.empty as map<address, bytes>),
        result_nat:(None() as option<nat>),
        last_seed:init_seed,
        max:1000n,
        min:1n,
        metadata: (Big_map.empty as big_map<string, bytes>)
    };
    // originate Random smart contract
    const orig = Test.originate(contract_of(Random), init_storage, 0tez);
    let _s_init = Test.get_storage(orig.addr);
    //Test.log(s_init);


    let _test_rollD1000 = () : string => {

        let payload : bytes = 0x0a1234;
        let time_secret : nat = 10n;
        let [my_bytes,bytes_key] = create_bytes(payload, time_secret);

        let payload2 : bytes = 0x0b455469;
        let time_secret2 : nat = 84n;
        let [my_bytes2,bytes_key2] = create_bytes(payload2, time_secret2);

        //Test.log("bytess created");


        // alice commits
        //Test.log("alice commits");
        Test.set_source(alice);
        let commit_args : Random.Parameter.Types.commit_param = {secret_action:my_bytes};
        Test.transfer_exn(orig.addr, (Commit(commit_args)), 10mutez);

        // bob commits
        //Test.log("bob commits");
        Test.set_source(bob);
        let commit_args2 : Random.Parameter.Types.commit_param = {secret_action:my_bytes2};
        Test.transfer_exn(orig.addr, (Commit(commit_args2)), 10mutez);

        // alice reveals
        //Test.log("alice reveals");
        Test.set_source(alice);
        let reveal_args : Random.Parameter.Types.reveal_param = [bytes_key, time_secret];
        Test.transfer_exn(orig.addr, (Reveal(reveal_args)), 0mutez);

        // bob reveals
        //Test.log("bob reveals");
        Test.set_source(bob);
        let reveal_args2 : Random.Parameter.Types.reveal_param = [bytes_key2, time_secret2];
        Test.transfer_exn(orig.addr, (Reveal(reveal_args2)), 0mutez);

        //Test.log("check storage");
        let s2 : Random.storage = Test.get_storage(orig.addr);
        Test.log(s2.result_nat);
        assert (s2.result_nat != (None() as option<nat>));
        return "OK"
        //Test.log("test finished")
    };
    let _test_rollD20 = () : string => {

        let payload : bytes = 0x0a1234;
        let time_secret : nat = 10n;
        let [my_bytes,bytes_key] = create_bytes(payload, time_secret);

        let payload2 : bytes = 0x0b455469;
        let time_secret2 : nat = 84n;
        let [my_bytes2,bytes_key2] = create_bytes(payload2, time_secret2);

        //Test.log("bytess created");


        // alice reset
        //Test.log("alice reset");
        Test.set_source(alice);
        let reset_args : Random.Parameter.Types.reset_param = {min:1n, max:20n};
        Test.transfer_exn(orig.addr, (Reset(reset_args)), 0mutez);

        //Test.log("check storage");
        //let store_reseted : Random.storage = Test.get_storage(orig.addr);
        //Test.log(store_reseted);

        // alice commits
        //Test.log("alice commits");
        Test.set_source(alice);
        let commit_args : Random.Parameter.Types.commit_param = {secret_action:my_bytes};
        Test.transfer_exn(orig.addr, (Commit(commit_args)), 10mutez);

        // bob commits
        //Test.log("bob commits");
        Test.set_source(bob);
        let commit_args2 : Random.Parameter.Types.commit_param = {secret_action:my_bytes2};
        Test.transfer_exn(orig.addr, (Commit(commit_args2)), 10mutez);

        // alice reveals
        //Test.log("alice reveals");
        Test.set_source(alice);
        let reveal_args : Random.Parameter.Types.reveal_param = [bytes_key, time_secret];
        Test.transfer_exn(orig.addr, (Reveal(reveal_args)), 0mutez);

        // bob reveals
        //Test.log("bob reveals");
        Test.set_source(bob);
        let reveal_args2 : Random.Parameter.Types.reveal_param = [bytes_key2, time_secret2];
        Test.transfer_exn(orig.addr, (Reveal(reveal_args2)), 0mutez);

        //Test.log("check storage");
        let s2 : Random.storage = Test.get_storage(orig.addr);
        Test.log(s2.result_nat);
        assert (s2.result_nat != (None() as option<nat>));
        let result : nat =Option.unopt(s2.result_nat);
        assert (result <= s2.max);
        assert (result >= s2.min);
        return "OK"
        //Test.log("test finished")
    };

    let _test_rollD20_again = () : string => {

        let payload : bytes = 0x0a1234;
        let time_secret : nat = 10n;
        let [my_bytes,bytes_key] = create_bytes(payload, time_secret);

        let payload2 : bytes = 0x0b455469;
        let time_secret2 : nat = 84n;
        let [my_bytes2,bytes_key2] = create_bytes(payload2, time_secret2);

        //Test.log("bytess created");


        // alice reset
        //Test.log("alice reset");
        Test.set_source(alice);
        let reset_args : Random.Parameter.Types.reset_param = {min:1n, max:20n};
        Test.transfer_exn(orig.addr, (Reset(reset_args)), 0mutez);

        //Test.log("check storage");
        //let store_reseted : Random.storage = Test.get_storage(orig.addr);
        //Test.log(store_reseted);


        // alice commits
        //Test.log("alice commits");
        Test.set_source(alice);
        let commit_args : Random.Parameter.Types.commit_param = {secret_action:my_bytes};
        Test.transfer_exn(orig.addr, (Commit(commit_args)), 10mutez);

        // bob commits
        //Test.log("bob commits");
        Test.set_source(bob);
        let commit_args2 : Random.Parameter.Types.commit_param = {secret_action:my_bytes2};
        Test.transfer_exn(orig.addr, (Commit(commit_args2)), 10mutez);

        // alice reveals
        //Test.log("alice reveals");
        Test.set_source(alice);
        let reveal_args : Random.Parameter.Types.reveal_param = [bytes_key, time_secret];
        Test.transfer_exn(orig.addr, (Reveal(reveal_args)), 0mutez);

        // bob reveals
        //Test.log("bob reveals");
        Test.set_source(bob);
        let reveal_args2 : Random.Parameter.Types.reveal_param = [bytes_key2, time_secret2];
        Test.transfer_exn(orig.addr, (Reveal(reveal_args2)), 0mutez);

        //Test.log("check storage");
        let s2 : Random.storage = Test.get_storage(orig.addr);
        Test.log(s2.result_nat);
        assert (s2.result_nat != (None() as option<nat>));
        let result : nat =Option.unopt(s2.result_nat);
        assert (result <= s2.max);
        assert (result >= s2.min);
        return "OK"
        //Test.log("test finished")
    };

    let _test_rollD20_again_again = () : string => {

        let payload : bytes = 0x0a1234;
        let time_secret : nat = 10n;
        let [my_bytes,bytes_key] = create_bytes(payload, time_secret);

        let payload2 : bytes = 0x0b455469;
        let time_secret2 : nat = 84n;
        let [my_bytes2,bytes_key2] = create_bytes(payload2, time_secret2);

        //Test.log("bytess created");


        // alice reset
        //Test.log("alice reset");
        Test.set_source(alice);
        let reset_args : Random.Parameter.Types.reset_param = {min:1n, max:20n};
        Test.transfer_exn(orig.addr, (Reset(reset_args)), 0mutez);

        //Test.log("check storage");
        //let store_reseted : Random.storage = Test.get_storage(orig.addr);
        //Test.log(store_reseted);

        // alice commits
        //Test.log("alice commits");
        Test.set_source(alice);
        let commit_args : Random.Parameter.Types.commit_param = {secret_action:my_bytes};
        Test.transfer_exn(orig.addr, (Commit(commit_args)), 10mutez);

        // bob commits
        //Test.log("bob commits");
        Test.set_source(bob);
        let commit_args2 : Random.Parameter.Types.commit_param = {secret_action:my_bytes2};
        Test.transfer_exn(orig.addr, (Commit(commit_args2)), 10mutez);

        // alice reveals
        //Test.log("alice reveals");
        Test.set_source(alice);
        let reveal_args : Random.Parameter.Types.reveal_param = [bytes_key, time_secret];
        Test.transfer_exn(orig.addr, (Reveal(reveal_args)), 0mutez);

        // bob reveals
        //Test.log("bob reveals");
        Test.set_source(bob);
        let reveal_args2 : Random.Parameter.Types.reveal_param = [bytes_key2, time_secret2];
        Test.transfer_exn(orig.addr, (Reveal(reveal_args2)), 0mutez);

        //Test.log("check storage");
        let s2 : Random.storage = Test.get_storage(orig.addr);
        Test.log(s2.result_nat);
        assert (s2.result_nat != (None() as option<nat>));
        let result : nat = Option.unopt(s2.result_nat);
        assert (result <= s2.max);
        assert (result >= s2.min);
        return "OK"
        //Test.log("test finished")
    };

    // execution
    const _test_dice_1 = _test_rollD1000();
    const _test_dice_2 = _test_rollD20();
    const _test_dice_3 = _test_rollD20_again();
    const _test_dice_4 = _test_rollD20_again_again();

};

const test_1 = test_one_complete_cycle();
const test_2 = test_roll_dices();


#import "../src/bytes_utils.jsligo" "Convert"


const test = () : unit => {

    let _simple_convert_bytes_to_nat = () : unit => {
    
        let payload : bytes = 0x00;
        {
          let value : nat = Convert.Utils.bytes_to_nat(payload);
          assert(value == 0n)
        };

        {
          payload = 0x0a;
          let value : nat = Convert.Utils.bytes_to_nat(payload);
          assert(value == 10n);
        };

        {
          payload = 0x0A;
          let value : nat = Convert.Utils.bytes_to_nat(payload);
          assert(value == 10n);
        };

        {
          payload = 0x2c;
          let value : nat = Convert.Utils.bytes_to_nat(payload);
          assert(value == 44n);
        };

        {
          payload = 0x2C;
          let value : nat = Convert.Utils.bytes_to_nat(payload);
          assert(value == 44n);
        };

        {
          payload = 0xFF;
          let value : nat = Convert.Utils.bytes_to_nat(payload);
          assert(value == 255n);
        };

        {
          payload = 0x1234;
          let value : nat = Convert.Utils.bytes_to_nat(payload);
          assert(value == 4660n);
        };

        Test.log("Test _simple_convert_bytes_to_nat finished")
    };

    let _complex_convert_bytes_to_nat = () : unit => {
        
        let payload = 0x001234;
        
        {
          let value : nat = Convert.Utils.bytes_to_nat(payload);
          assert(value == 4660n);
        };

        {
          payload = 0x123400;
          let value : nat = Convert.Utils.bytes_to_nat(payload);
          assert(value == 4660n * 256n);
        };

        Test.log("Test _complex_convert_bytes_to_nat finished")
    };

    const _test_1 = _simple_convert_bytes_to_nat();
    const _test_2 = _complex_convert_bytes_to_nat();
};

const all_test = test();

Randomness-JsLIGO

An example of a shifumi game contract in CameLIGO

sessionId

roundId

player_key

player_secret

revealPlay

action

play

stopSession

total_rounds

players

createSession

next_session

sessions

board

#import "errors.mligo" "Errors"
#import "session.mligo" "Session"

[@inline]
let check_player_authorized (player : Session.player) (allowed_players: Session.player set) (error_message : string) : unit =
    assert_with_error (Set.mem player allowed_players) error_message

[@inline]
let check_session_end(result : Session.result) (expected : Session.result) : unit =
    assert_with_error (result = expected) Errors.session_finished

[@inline]
let check_asleep (current_session : Session.t) : unit = 
    assert_with_error ((Tezos.get_now ()) > current_session.asleep) Errors.must_wait_10_min


let must_wait_10_min : string = "Must wait at least 600 seconds before claiming Victory (in case opponent is not playing)"
let unknown_session : string = "Unknown session"
let user_not_allowed_to_stop_session : string = "Not allowed to stop this session"
let user_not_allowed_to_play_in_session : string = "Not allowed to play this session"
let user_not_allowed_to_reveal_in_session : string = "Not allowed to reveal this session"
let session_finished : string = "this session is finished"
let wrong_current_round : string = "Wrong current round parameter"
let user_already_played : string = "You already have played for this round"
let missing_player_bytes : string = "a player has not played"
let missing_all_bytes : string = "no actions registered"
let missing_all_decoded_bytes : string = "no decoded actions registered"
let missing_sender_bytes : string = "user has not played"
let failed_to_open_bytes : string = "Failed to check bytes"
let user_already_revealed : string = "You already have revealed your play for this round"
let failed_to_unpack_payload : string = "Failed to unpack the payload"
let no_winner : string = "No players have played in the current round, thus cannot deduce troller"

#import "storage.mligo" "Storage"
#import "parameter.mligo" "Parameter"
#import "views.mligo" "Views"
#import "errors.mligo" "Errors"
#import "session.mligo" "Session"
#import "conditions.mligo" "Conditions"

type storage = Storage.t
type parameter = Parameter.t
type return = operation list * storage

// Anyone can create a session (must specify players and number of rounds)
[@entry] let createSession(param : Parameter.createsession_param) (store : Storage.t) : operation list * Storage.t =
    let new_session : Session.t = Session.new param.total_rounds param.players in
    let new_storage : Storage.t = {store with next_session=store.next_session + 1n; sessions=Map.add store.next_session new_session store.sessions} in
    (([]: operation list), new_storage)

// search for a non troller in the session
let find_me_a_name(sessionId, missing_players, current_session, store :nat * Session.player set * Session.t * Storage.t) : operation list * Storage.t =
    let rem_player(acc, elt : address set * address ) : address set = Set.remove elt acc in
    let winners_set : address set = Set.fold rem_player missing_players current_session.players in
    let _check_has_winner : unit = assert_with_error (Set.cardinal winners_set > 0n) Errors.no_winner in
    let add_player(acc, elt : address list * address) : address list = elt :: acc in
    let winners_list : address list = Set.fold add_player winners_set ([] : address list) in
    let winner : address = Option.unopt (List.head_opt winners_list) in
    let new_current_session : Session.t = { current_session with result=Winner(winner) } in
    let new_storage : Storage.t = Storage.update_sessions store sessionId new_current_session in
    (([]: operation list), new_storage )

// allow players to claim victory if opponent is a troller (refuse to play)
[@entry] let stopSession(param : Parameter.stopsession_param) (store : Storage.t) : operation list * Storage.t =
    let current_session : Session.t = Storage.getSession(param.sessionId, store) in
    let _check_players : unit = Conditions.check_player_authorized (Tezos.get_sender ()) current_session.players Errors.user_not_allowed_to_stop_session in
    let _check_session_end : unit = Conditions.check_session_end current_session.result Inplay in
    let _check_asleep : unit = Conditions.check_asleep(current_session) in
    let current_round = match Map.find_opt current_session.current_round current_session.rounds with
    | None -> ([] : Session.player_actions)
    | Some rnd -> rnd
    in
    let missing_players = Session.find_missing(current_round, current_session.players) in
    if Set.cardinal missing_players > 0n then
        find_me_a_name (param.sessionId, missing_players, current_session, store)
    else
        let current_decoded_round = match Map.find_opt current_session.current_round current_session.decoded_rounds with
        | None -> (failwith("SHOULD NOT BE HERE SESSION IS BROKEN") : Session.decoded_player_actions)
        | Some rnd -> rnd
        in
        let missing_players_for_reveal = Session.find_missing(current_decoded_round, current_session.players) in
        if Set.cardinal missing_players_for_reveal > 0n then
            find_me_a_name (param.sessionId, missing_players_for_reveal, current_session, store)
        else
            (([]: operation list), store )


// the player create a bytes with the chosen action (Stone | Paper | Cisor) in backend
// once the bytes is created, the player send its bytes to the smart contract
[@entry] let play(param : Parameter.play_param) (store : Storage.t) : operation list * Storage.t =
    let current_session : Session.t = Storage.getSession(param.sessionId, store) in
    let sender = Tezos.get_sender () in
    let _check_players : unit = Conditions.check_player_authorized sender current_session.players Errors.user_not_allowed_to_play_in_session in
    let _check_session_end : unit = Conditions.check_session_end current_session.result Inplay in
    let _check_round : unit = assert_with_error (current_session.current_round = param.roundId) Errors.wrong_current_round in
    // register action
    let new_rounds = Session.add_in_rounds current_session.current_round current_session sender param.action in

    let new_session : Session.t = Session.update_rounds current_session new_rounds in
    let new_storage : Storage.t = Storage.update_sessions store param.sessionId new_session in
    (([]: operation list), new_storage)


// Once all players have committed their bytes, they must reveal the content of their bytes
[@entry] let revealPlay (param : Parameter.reveal_param) (store : Storage.t) : operation list * Storage.t =
    // players can reveal only if all players have sent their bytes
    let current_session : Session.t = Storage.getSession(param.sessionId, store) in
    let sender = Tezos.get_sender () in
    let _check_players : unit = Conditions.check_player_authorized sender current_session.players Errors.user_not_allowed_to_reveal_in_session in
    let _check_session_end : unit = Conditions.check_session_end current_session.result Inplay in
    let _check_round : unit = assert_with_error (current_session.current_round = param.roundId) Errors.wrong_current_round in

    let current_round_actions : Session.player_actions = Session.get_round_actions current_session.current_round current_session in

    let numberOfPlayers : nat = Set.cardinal current_session.players in
    let listsize (acc, _elt: nat * Session.player_action) : nat = acc + 1n in
    let numberOfActions : nat = List.fold listsize current_round_actions 0n in
    let _check_all_players_have_played : unit = assert_with_error (numberOfPlayers = numberOfActions) Errors.missing_player_bytes in
    // retrieve user bytes (fails if not found)
    let user_bytes : bytes = Session.get_bytes_exn sender (Some(current_round_actions)) in
    // decode action
    let decoded_action : Session.action = Session.decode_bytes_exn param.player_key user_bytes param.player_secret in
    let new_decoded_rounds = Session.add_in_decoded_rounds current_session.current_round current_session sender decoded_action in
    let new_current_session : Session.t = Session.update_decoded_rounds current_session new_decoded_rounds in

    // compute board if all players have revealed
    let modified_new_current_session : Session.t = Session.finalize_current_round new_current_session in

    // if session is finished, we can compute the result winner
    let final_current_session = Session.finalize_session modified_new_current_session in

    let new_storage : Storage.t = Storage.update_sessions store param.sessionId final_current_session in
    (([]: operation list), new_storage)


[@view] let board(sessionId: nat) (store: storage): Views.sessionBoard =
    match Map.find_opt sessionId store.sessions with
    | Some (sess) -> Views.retrieve_board(sess)
    | None -> (failwith("Unknown session") : Views.sessionBoard)


#import "session.mligo" "Session"

type action = Session.action

type createsession_param = {
    total_rounds : nat;
    players : address set;
}

type stopsession_param = {
    sessionId : nat;
}

type play_param = {
    sessionId : nat;
    roundId : nat;
    action : bytes
}

type reveal_param = {
    sessionId : nat;
    roundId : nat;
    player_key : bytes;
    player_secret : nat
}

type t = CreateSession of createsession_param | Play of play_param | RevealPlay of reveal_param | StopSession of stopsession_param


#import "errors.mligo" "Errors"

type player = address
type round = nat
type action = Stone | Paper | Cisor
type result = Inplay | Draw | Winner of address

type 'a an_action = {
    player : player;
    action : 'a 
}

type player_action = bytes an_action
type decoded_player_action = action an_action

type player_actions = player_action list
type decoded_player_actions = decoded_player_action list

type 'a rounds = (round, 'a an_action list) map 

type board = (round, player option) map

type t = {
    total_rounds : nat;
    players : player set;
    current_round : nat;
    rounds : bytes rounds;
    decoded_rounds : action rounds;
    board : board;
    result : result;
    asleep : timestamp
}


[@inline]
let new (total_rounds: nat) (players: player set): t =
    { 
      asleep=(Tezos.get_now ()) + 600; 
      total_rounds=total_rounds; 
      players=players; 
      current_round=1n; 
      rounds=(Map.empty : bytes rounds);
      decoded_rounds=(Map.empty : action rounds); 
      board=(Map.empty : board); 
      result=Inplay 
    }  

[@inline]
let get_round_actions (roundId : nat) (session : t) : player_actions =
    match Map.find_opt roundId session.rounds with 
    | None -> failwith(Errors.missing_all_bytes)
    | Some (round_actions) -> round_actions 

[@inline]
let get_decoded_round_actions (roundId : nat) (session : t) : decoded_player_actions =
    match Map.find_opt roundId session.decoded_rounds with 
    | None -> failwith(Errors.missing_all_decoded_bytes)
    | Some (decoded_round_actions) -> decoded_round_actions 

[@inline]
let update_rounds (session: t) (rounds: (round, player_actions) map): t =
    { session with asleep=(Tezos.get_now ()) + 600; rounds=rounds }    

[@inline]
let update_decoded_rounds (session: t) (decoded_rounds: (round, decoded_player_actions) map): t =
    { session with asleep=(Tezos.get_now ()) + 600; decoded_rounds=decoded_rounds }    

[@inline]
let find_missing (type a) (pactions, all_players : a an_action list * player set) =
    let discard_player(acc, elt : address set * a an_action) : address set = Set.remove elt.player acc in
    List.fold discard_player pactions all_players 

[@inline]
let has_played (type a) (pactions: a an_action list) (player : player) : bool =
    let check_contains(acc, elt : bool * a an_action) : bool = if acc then acc else (elt.player = player) in
    List.fold check_contains pactions false 

[@inline]
let has_played_round (type a) (rounds: a rounds) (roundId: round) (player: player) : bool =
    match Map.find_opt roundId rounds with
    | Some (acts) -> has_played acts player
    | None -> false 

[@inline]
let add_in_decoded_rounds (roundId : nat) (session : t) (user : address) (decoded_action: action) : action rounds =
    match Map.find_opt roundId session.decoded_rounds with 
    | None -> Map.add roundId [{player=user; action=decoded_action}] session.decoded_rounds
    | Some (decodedPlayerActions) ->
        let _check_player_has_revealed_this_round = assert_with_error (has_played_round session.decoded_rounds roundId user = false) Errors.user_already_revealed in
        Map.update roundId (Some({player=user; action=decoded_action} :: decodedPlayerActions)) session.decoded_rounds

[@inline]
let add_in_rounds (roundId : nat) (session : t) (user : address) (action: bytes) : bytes rounds =
    match Map.find_opt roundId session.rounds with 
    | None -> Map.add roundId [{player=user; action=action}] session.rounds
    | Some (playerActions) ->
        let _check_player_has_played_this_round = assert_with_error (has_played_round session.rounds roundId user = false) Errors.user_already_played in
        Map.update roundId (Some({player=user; action=action} :: playerActions)) session.rounds

[@inline]
let get_bytes_exn (user : address) (actions_opt : player_actions option) : bytes =
    let rec find_bytes(addr, lst_opt : address * player_actions option) : bytes option =
        match lst_opt with
        | None -> (None : bytes option)
        | Some lst -> (match List.head_opt lst with
            | None -> (None : bytes option) 
            | Some elt -> if (elt.player = addr) then
                    (Some(elt.action) : bytes option)
                else
                    find_bytes(addr, (List.tail_opt lst)))
    in
    match find_bytes(user, actions_opt) with
    | None -> (failwith(Errors.missing_sender_bytes) : bytes)
    | Some ch -> ch

[@inline]
let decode_bytes_exn (player_action: bytes) (user_bytes: bytes) (player_secret: nat): action = 
    let hashed = Crypto.sha512 (Bytes.pack (player_action, player_secret)) in
    if hashed = user_bytes
    then ( match (Bytes.unpack player_action : action option) with
           | None -> failwith(Errors.failed_to_unpack_payload)
           | Some x -> x )
    else failwith(Errors.failed_to_open_bytes)

[@inline]
let resolve(first, second : decoded_player_action * decoded_player_action) : player option = 
    let result : player option = match first.action, second.action with
    | Stone, Stone -> None
    | Stone, Paper -> Some(second.player)
    | Stone, Cisor -> Some(first.player)
    | Paper, Stone -> Some(first.player)
    | Paper, Paper -> None
    | Paper, Cisor -> Some(second.player)
    | Cisor, Stone -> Some(second.player)
    | Cisor, Paper -> Some(first.player)
    | Cisor, Cisor -> None
    in
    result

// TODO , this implementation can handle only 2 players :(
let update_board(sess, current_round: t * round) : board =
    // process actions for current_round
    let pactions : decoded_player_actions = match Map.find_opt current_round sess.decoded_rounds with
    | None -> (failwith("Missing actions for current_round") : decoded_player_actions)
    | Some (pacts) -> pacts
    in
    let first : decoded_player_action = match List.head_opt(pactions) with
    | None -> (failwith("Missing actions for first player") : decoded_player_action)
    | Some (act) -> act
    in
    let next_players_opt : decoded_player_action list option = List.tail_opt pactions in
    let next_players : decoded_player_action list = match next_players_opt with
    | None -> (failwith("Missing actions for second player") : decoded_player_action list)
    | Some (tl) -> tl
    in
    let second : decoded_player_action = match List.head_opt(next_players) with
    | None -> (failwith("Missing actions for second player") : decoded_player_action)
    | Some (act) -> act
    in
    let result : player option = resolve(first, second) in 
    match result with 
    | None -> Map.update current_round (None : player option option) sess.board
    | Some (r) -> Map.update current_round (Some(Some(r))) sess.board


[@inline]
let finalize_current_round (session: t) : t =
    // retrieve decoded_player_actions of given roundId
    let performed_actions : decoded_player_actions = match Map.find_opt session.current_round session.decoded_rounds with
    | None -> ([] : decoded_player_actions)
    | Some (pacts) -> pacts
    in
    // verify all players have revealed
    let all_player_have_revealed((acc, pactions), elt : (bool * decoded_player_actions) * player) : (bool * decoded_player_actions) = (acc && has_played pactions elt, pactions) in
    let (check_all_players_have_revealed, _all_decoded_actions) : (bool * decoded_player_actions) = Set.fold all_player_have_revealed session.players (true, performed_actions) in
    // all players have given their actions, now the board can be updated and session goes to next round
    if (check_all_players_have_revealed = true) then 
        { session with current_round=session.current_round+1n; board=update_board(session, session.current_round) }
    else
        session

        
let compute_result(sess: t) : result =
    // parse board and compute who won
    let compute_points(acc, elt : (address, nat) map * (round * player option)) : (address, nat) map = match elt.1 with
    | None -> acc
    | Some winner_round -> (match Map.find_opt winner_round acc with
        | None -> Map.add winner_round 1n acc
        | Some old_value -> Map.update winner_round (Some(old_value + 1n)) acc)
    in
    let final_scores = Map.fold compute_points sess.board (Map.empty : (address, nat) map) in
    let (winner_addr, winner_points, multiple_winners) : (address option * nat * bool) = ((None : address option), 0n, false) in
    let leader_score((win_addr, win_points, multiple), elt : (address option * nat * bool) * (address * nat)) : (address option * nat * bool) =
        match win_addr with
        | None -> (Some(elt.0), elt.1, false)
        | Some _temp_win_addr -> 
            if elt.1 > win_points then 
                (Some(elt.0), elt.1, false)
            else
                if elt.1 = win_points then
                    (win_addr, win_points, true)
                else
                    (win_addr, win_points, multiple)
    in 
    let (final_winner_addr, _final_winner_points, final_multiple) = Map.fold leader_score final_scores (winner_addr, winner_points, multiple_winners) in
    if final_multiple then
        Draw
    else
        match final_winner_addr with
        | None -> Draw
        | Some x -> Winner(x)



[@inline]
let finalize_session (session: t) : t =
    if session.current_round > session.total_rounds then
        { session with result=compute_result(session) }
    else
        session


#import "errors.mligo" "Errors"
#import "parameter.mligo" "Parameter"
#import "session.mligo" "Session"
#import "conditions.mligo" "Conditions"

type t = {
    metadata: (string, bytes) big_map;
    next_session : nat;
    sessions : (nat, Session.t) map
}

[@inline]
let update_sessions (storage: t) (sessionId: nat) (new_session: Session.t): t =
    { storage with sessions=Map.update sessionId (Some(new_session)) storage.sessions}

[@inline]
let getSession (sessionId, store : nat * t) : Session.t =
    match Map.find_opt sessionId store.sessions with
    | None -> (failwith(Errors.unknown_session) : Session.t)
    | Some (sess) -> sess


#import "session.mligo" "Session"


type sessionBoard = {
    points : (address, nat) map
}

let retrieve_board(sess : Session.t) : sessionBoard =
    let scores : (address, nat) map = (Map.empty : (address, nat) map) in
    let myfunc(acc, elt : (address, nat) map * (Session.round * address option)) : (address, nat) map = match elt.1 with
    | None -> acc
    | Some winner_round -> (match Map.find_opt winner_round acc with
        | None -> Map.add winner_round 1n acc
        | Some old_value -> Map.update winner_round (Some(old_value + 1n)) acc)
    in
    let final_scores = Map.fold myfunc sess.board scores in
    { points=final_scores }


Shifumi-Cameligo

An example of a shifumi game contract in JsLIGO

gameStatus

newRound

#import "errors.jsligo" "Errors"
#import "session.jsligo" "Session"
#import "listUtils.jsligo" "ListUtils"



export const check_player_authorized = (player : Session.player, allowed_players : list<Session.player>, error_message : string) : unit => {
    assert_with_error( (ListUtils.find_opt(( (a : address) => a == player), allowed_players) != (None() as option<Session.player>))  , error_message);
};

export const check_session_end = (result : Session.result, expected : Session.result) : unit => {
    assert_with_error( (result == expected), Errors.session_finished);
};

export const check_asleep = (current_session : Session.t) : unit => {
    assert_with_error( ((Tezos.get_now ()) > current_session.asleep), Errors.must_wait_10_min);
};

export const must_wait_10_min : string = "Must wait at least 600 seconds before claiming Victory (in case opponent is not playing)";
export const unknown_session : string = "Unknown session";
export const user_not_allowed_to_stop_session : string = "Not allowed to stop this session";
export const user_not_allowed_to_play_in_session : string = "Not allowed to play this session";
export const user_not_allowed_to_reveal_in_session : string = "Not allowed to reveal this session";
export const session_finished : string = "this session is finished";
export const wrong_current_round : string = "Wrong current round parameter";
export const user_already_played : string = "You already have played for this round";
export const missing_player_bytes : string = "a player has not played";
export const missing_all_bytes : string = "no actions registered";
export const missing_all_decoded_bytes : string = "no decoded actions registered";
export const missing_sender_bytes : string = "user has not played";
export const failed_to_open_bytes : string = "Failed to check bytes";
export const user_already_revealed : string = "You already have revealed your play for this round";
export const failed_to_unpack_payload : string = "Failed to unpack the payload";
export const no_winner : string = "No players have played in the current round, thus cannot deduce troller";
export const player_needs_to_pay_to_play = "Player needs to pay 1 Tez to play a round";
export const player_contract_address_not_found = "Cannot find the contract from player address";

//redefining find_opt function
export const find_opt = <T>(f : (x : T) => bool, xs : list<T>) : option<T> =>
  match (xs) {
    when([] : list<T>): None();
    when([x,... xs] : list<T>): do {
      if(f(x)) { return Some(x); } else {return find_opt(f, xs); }
    }
  };

//redefining reverse
export const reverse = <T>(xs : list<T>) : list<T> => {
        let f = ([ys, x] : [list<T>, T]) : list<T> => list([x, ...ys]);
        return List.fold_left(f, list([]) as list<T>, xs);
    };

//redefining concat
export const concat = <T>(xs : list<T>, ys : list<T>) : list<T> => {
   let f = ([x,ys] : [T,list<T>]) : list<T> => list([x,...ys]);
   return List.fold_right(f ,xs ,ys)
  };

export const remove = <T>(f : (x : T) => bool, xs : list<T>, acc : list<T>) : list<T> =>
  match(xs) {
    when([] : list<T>): reverse(acc);
    when([x,... xs] : list<T>): do {
      if(f(x)) { return concat(reverse(acc),xs); } else {return remove(f, xs, list([x,...acc])); }
    }
  };

#import "storage.jsligo" "Storage"
#import "parameter.jsligo" "Parameter"
#import "views.jsligo" "Views"
#import "errors.jsligo" "Errors"
#import "session.jsligo" "Session"
#import "conditions.jsligo" "Conditions"
#import "listUtils.jsligo" "ListUtils"

export type storage = Storage.t;
export type parameter = Parameter.t;
export type return_ = [list<operation>, storage];

// Anyone can create a session (must specify players and number of rounds)
@entry
const createSession = (param : Parameter.createsession_param, store : Storage.t) : return_ => {
    let new_session : Session.t = Session.new(param.total_rounds, param.players);
    let new_storage : Storage.t = { ...store,
        next_session: store.next_session + 1n,
        sessions: Map.add(store.next_session, new_session, store.sessions)
    };
    return [list([]) as list<operation>, new_storage];
};


// search for a non troller in the session
const find_me_a_name = (sessionId : nat, missing_players : list<Session.player>, current_session : Session.t, store : Storage.t) : return_ => {

    assert_with_error( List.size(missing_players) == 1n, Errors.no_winner);

    const loser = Option.unopt(List.head_opt(missing_players));
    let winners_list : list<address> = ListUtils.remove(( (a : address) => a == loser), current_session.players, (list([]) as list<address>));
    let winner : address = Option.unopt(List.head_opt(winners_list));
    let new_current_session : Session.t = {...current_session, result:Winner(winner) };
    let new_storage : Storage.t = Storage.update_sessions(store, sessionId, new_current_session);
    let opToRedeem : operation = Tezos.transaction(unit,(new_current_session.pool as tez),Tezos.get_contract_with_error(winner,Errors.player_contract_address_not_found));
    return [list([opToRedeem , Tezos.emit("%gameStatus",sessionId) ]) as list<operation>, new_storage];
};

//declare a draw if game is blocked because people don't reveal
const declare_a_draw = (sessionId : nat, current_session : Session.t, store: Storage.t) : return_ => {
    let new_current_session : Session.t = {...current_session, result:Draw() };
    let new_storage : Storage.t = Storage.update_sessions(store, sessionId, new_current_session);
    let player1ToRedeemOp : operation = Tezos.transaction(unit,(new_current_session.pool / 2tez) * 1tez ,Tezos.get_contract_with_error(Option.unopt(List.head_opt(new_current_session.players)),Errors.player_contract_address_not_found));
    let player2ToRedeemOp : operation = Tezos.transaction(unit,(new_current_session.pool / 2tez) * 1tez,Tezos.get_contract_with_error(Option.unopt(List.head_opt(Option.unopt(List.tail_opt(new_current_session.players)))),Errors.player_contract_address_not_found));
    return [list([player1ToRedeemOp,player2ToRedeemOp,Tezos.emit("%gameStatus",sessionId)]) as list<operation>, new_storage];
};

const is_none = <T>(x : option<T>) : bool =>
   match(x) {
     when(Some(_)): false;
     when(None()): true
     };

// allow players to claim victory if opponent is a troller (refuse to play)
@entry
const stopSession = (param : Parameter.stopsession_param, store : Storage.t) : return_ => {
    let current_session : Session.t = Storage.getSession(param.sessionId, store);
    let _check_players : unit = Conditions.check_player_authorized((Tezos.get_sender ()), current_session.players, Errors.user_not_allowed_to_stop_session);
    let _check_session_end : unit = Conditions.check_session_end(current_session.result, Inplay());
    let _check_asleep : unit = Conditions.check_asleep(current_session);
    let current_round = match (Map.find_opt(current_session.current_round, current_session.rounds)) {
        when(None()): (list([]) as Session.player_actions);
        when(Some(rnd)): rnd;
    };
    let missing_players = Session.find_missing(current_round, current_session.players);
    if (List.size(missing_players) > 0n) {
        return find_me_a_name (param.sessionId, missing_players, current_session, store);
    } else {

        let current_decoded_round_opt = Map.find_opt(current_session.current_round, current_session.decoded_rounds);

        if( is_none(current_decoded_round_opt)) {
            return declare_a_draw (param.sessionId, current_session, store);
            }
        else {
            let current_decoded_round = Option.unopt(current_decoded_round_opt);
            let missing_players_for_reveal = Session.find_missing(current_decoded_round, current_session.players);
            if (List.size(missing_players_for_reveal) > 0n) {
                return find_me_a_name (param.sessionId, missing_players_for_reveal, current_session, store);
            } else {
                return [list([]) as list<operation>, store]
            }
        }
    }
};

// the player create a bytes with the chosen action (Stone | Paper | Cisor) in backend
// once the bytes is created, the player send its bytes to the smart contract
@entry
const play = (param : Parameter.play_param, store : Storage.t) : return_ => {
    let current_session : Session.t = Storage.getSession(param.sessionId, store);
    let _check_players : unit = Conditions.check_player_authorized((Tezos.get_sender ()), current_session.players, Errors.user_not_allowed_to_play_in_session);
    let _check_session_end : unit = Conditions.check_session_end(current_session.result, Inplay());
    let _check_round : unit = assert_with_error( (current_session.current_round == param.roundId), Errors.wrong_current_round);


    // you can play only once per round, so we take money for every round
    if(Tezos.get_amount() < 1tez) return failwith(Errors.player_needs_to_pay_to_play);

    // register action
    let new_rounds = Session.add_in_rounds(current_session.current_round, current_session, (Tezos.get_sender ()), param.action);
    let new_session : Session.t = Session.update_rounds({...current_session,pool:(current_session.pool + 1tez)}, new_rounds);
    let new_storage : Storage.t = Storage.update_sessions(store, param.sessionId, new_session);

    return match (Map.find_opt(new_session.current_round,new_session.rounds)) {
        when(None()): [list([]) as list<operation>, new_storage];
        when(Some(current_round)): do {
            if( List.size( current_round  ) != 2n ){ return [list([]) as list<operation>, new_storage]}
            else { return  [list([ Tezos.emit("%reveal",param.sessionId)  ]) as list<operation>, new_storage]}
        };
    };
};

// Once all players have committed their bytes, they must reveal the content of their bytes
@entry
const revealPlay = (param : Parameter.reveal_param, store : Storage.t) : return_ => {
    // players can reveal only if all players have sent their bytes
    let current_session : Session.t = Storage.getSession(param.sessionId, store);
    let _check_players : unit = Conditions.check_player_authorized((Tezos.get_sender ()), current_session.players, Errors.user_not_allowed_to_reveal_in_session);
    let _check_session_end : unit = Conditions.check_session_end(current_session.result, Inplay());
    let _check_round : unit = assert_with_error( (current_session.current_round == param.roundId), Errors.wrong_current_round);
    let current_round_actions : Session.player_actions = Session.get_round_actions(current_session.current_round, current_session);
    let numberOfPlayers : nat = List.size(current_session.players);
    let listsize = ([acc, _elt]: [nat, Session.player_action]) : nat => acc + 1n;
    let numberOfActions : nat = List.fold(listsize, current_round_actions, 0n);
    let _check_all_players_have_played : unit = assert_with_error( (numberOfPlayers == numberOfActions), Errors.missing_player_bytes);
    // retrieve user bytes (fails if not found)
    let user_bytes : bytes = Session.get_bytes_exn((Tezos.get_sender ()), (Some(current_round_actions)));
    // decode action
    let decoded_action : Session.action = Session.decode_bytes_exn(param.player_key, user_bytes, param.player_secret);
    let new_decoded_rounds = Session.add_in_decoded_rounds(current_session.current_round, current_session, (Tezos.get_sender ()), decoded_action);
    let new_current_session : Session.t = Session.update_decoded_rounds(current_session, new_decoded_rounds);

    // compute board if all players have revealed
    let modified_new_current_session : Session.t = Session.finalize_current_round(new_current_session);

    // if session is finished, we can compute the result winner
    let final_current_session = Session.finalize_session(modified_new_current_session);

    let new_storage : Storage.t = Storage.update_sessions(store, param.sessionId, final_current_session);
    return match(final_current_session.result) {
        when(Inplay()): do { if(final_current_session.current_round == current_session.current_round) {return [list([]) as list<operation>, new_storage]}
                         else {return [list([Tezos.emit("%newRound",param.sessionId)]) as list<operation>, new_storage]}};
        when(Draw()): do {
            let player1ToRedeemOp : operation = Tezos.transaction(unit,(new_current_session.pool / 2tez) * 1tez ,Tezos.get_contract_with_error(Option.unopt(List.head_opt(new_current_session.players)),Errors.player_contract_address_not_found));
            let player2ToRedeemOp : operation = Tezos.transaction(unit,(new_current_session.pool / 2tez) * 1tez,Tezos.get_contract_with_error(Option.unopt(List.head_opt(Option.unopt(List.tail_opt(new_current_session.players)))),Errors.player_contract_address_not_found));
            return [list([player1ToRedeemOp, player2ToRedeemOp, Tezos.emit("%gameStatus",param.sessionId)  ]) as list<operation>, new_storage]};
        when(Winner(winner)): do {
            let opToRedeem : operation = Tezos.transaction(unit,(new_current_session.pool as tez),Tezos.get_contract_with_error(winner,Errors.player_contract_address_not_found));
            return [list([ opToRedeem , Tezos.emit("%gameStatus",param.sessionId)  ]) as list<operation>, new_storage]
            }
    };
};


@view
const board = (sessionId: nat, store: storage): Views.sessionBoard => {
    return match (Map.find_opt(sessionId, store.sessions)) {
        when(Some(sess)): Views.retrieve_board(sess);
        when(None()): (failwith("Unknown session") as Views.sessionBoard)
    };
};


export type createsession_param = {
    total_rounds : nat,
    players : list<address>
};

export type stopsession_param = {
    sessionId : nat
};

export type play_param = {
    sessionId : nat,
    roundId : nat,
    action : bytes
};

export type reveal_param = {
    sessionId : nat,
    roundId : nat,
    player_key : bytes,
    player_secret : nat
};

export type t = ["CreateSession", createsession_param] | ["Play", play_param] | ["RevealPlay", reveal_param] | ["StopSession", stopsession_param];


#import "errors.jsligo" "Errors"
#import "listUtils.jsligo" "ListUtils"

export type player = address;
export type round = nat;
export type action = ["Stone"] | ["Paper"] | ["Cisor"];
export type result = ["Inplay"] | ["Draw"] | ["Winner", address];

type an_action<a> = {
    player : player,
    action : a
};

export type player_action = an_action<bytes>;
export type decoded_player_action = an_action<action>;

export type player_actions = list<player_action>;
export type decoded_player_actions = list<decoded_player_action>;

export type rounds<a> = map<round, list<an_action<a>> >;

type board = map<round, option<player> >;

export type t = {
    total_rounds : nat,
    players : list<player>,
    current_round : nat,
    rounds : rounds<bytes>,
    decoded_rounds : rounds<action>,
    board : board,
    result : result,
    asleep : timestamp,
    pool : tez     //bet pool in tez. 1 tez / round play movement
};

export const new = (total_rounds : nat, players : list<player>): t => {
    return {
      asleep:(Tezos.get_now ()) + 600,
      total_rounds:total_rounds,
      players:players,
      current_round:1n,
      rounds:(Map.empty as rounds<bytes>),
      decoded_rounds:(Map.empty as rounds<action>),
      board:(Map.empty as board),
      result: Inplay(),
      pool : 0 as tez
    };
};

export const get_round_actions = (roundId : nat, session : t) : player_actions => {
    return match (Map.find_opt(roundId, session.rounds)) {
        when(None): failwith(Errors.missing_all_bytes);
        when(Some(round_actions)): round_actions;
    };
};

// @inline
const get_decoded_round_actions = (roundId : nat, session : t) : decoded_player_actions => {
    return match (Map.find_opt(roundId, session.decoded_rounds)) {
        when(None): failwith(Errors.missing_all_decoded_bytes);
        when(Some(decoded_round_actions)): decoded_round_actions;
    };
};

export const update_rounds = (session : t, rounds :  map<round, player_actions>): t => {
    return { ...session, asleep:(Tezos.get_now ()) + 600, rounds:rounds }
};

export const update_decoded_rounds = (session : t, decoded_rounds : map<round, decoded_player_actions>): t => {
    return { ...session, asleep:(Tezos.get_now ()) + 600, decoded_rounds:decoded_rounds };
};


export const find_missing = <_a>(pactions : list<an_action<_a>>, all_players : list<player>) => {
    let addIfNotParticipant = ([acc, elt] : [list<player>, player]) : list<player> =>
        match(ListUtils.find_opt( ((paction : an_action<_a>) => paction.player == elt), pactions )) {
            when(None): list([elt,...acc]);
            when(Some(_an)): acc;
        };
    return List.fold(addIfNotParticipant, all_players, list([]) as list<player>);
};

// @inline
const has_played = <_a>(pactions : list<an_action<_a>>, player : player) : bool => {
    let check_contains = ([acc, elt] : [bool, an_action<_a>]) : bool => { if (acc) { return acc } else { return (elt.player == player) } };
    return List.fold(check_contains, pactions, false);
};

// @inline
const has_played_round = <_a>(rounds : rounds<_a>, roundId : round, player : player) : bool => {
    return match (Map.find_opt(roundId, rounds)) {
        when(Some(acts)): has_played(acts, player);
        when(None): false ;
    };
};

export const add_in_decoded_rounds = (roundId : nat, session : t, user : address, decoded_action : action) : rounds<action> => {
    return match (Map.find_opt(roundId, session.decoded_rounds)) {
        when(None()): Map.add(roundId, list([{ player:user, action:decoded_action }]), session.decoded_rounds);
        when(Some(decodedPlayerActions)): do {
            let _check_player_has_revealed_this_round = assert_with_error( (has_played_round(session.decoded_rounds, roundId, user) == false), Errors.user_already_revealed);
            return Map.update(roundId, (Some( list([ {player:user, action:decoded_action}, ...decodedPlayerActions]))), session.decoded_rounds);
        };
    };
};

export const add_in_rounds = (roundId : nat, session : t, user : address, action : bytes) : rounds<bytes> => {
    return match (Map.find_opt(roundId, session.rounds)) {
        when(None()): Map.add(roundId, list([{player:user, action:action}]), session.rounds);
        when(Some(playerActions)): do {
            let _check_player_has_played_this_round = assert_with_error( (has_played_round(session.rounds, roundId, user) == false), Errors.user_already_played);
            return Map.update(roundId, (Some( list([ {player:user, action:action},  ...playerActions]))), session.rounds);
        };
    };
};

export const get_bytes_exn = (user : address, actions_opt : option<player_actions>) : bytes => {
    let find_bytes = (addr : address, lst_opt : option<player_actions>) : option<bytes> => {
        return match (lst_opt) {
            when(None()): (None() as option<bytes>);
            when(Some(lst)): match (List.head_opt(lst)) {
                when(None()): (None() as option<bytes>);
                when(Some(elt)): do {
                        if (elt.player == addr) {
                            return (Some(elt.action) as option<bytes>)
                        } else {
                            return find_bytes(addr, List.tail_opt(lst));
                        }
                    };
                };
        };
    };
    return match (find_bytes(user, actions_opt)) {
        when(None()): (failwith(Errors.missing_sender_bytes) as bytes);
        when(Some(ch)): ch;
    };
};

export const decode_bytes_exn = (player_bytes : bytes, user_bytes : bytes, player_secret : nat): action => {
    let hashed = Crypto.sha512(Bytes.pack([player_bytes, player_secret]));
    if (hashed == user_bytes) {
        return match ((Bytes.unpack(player_bytes) as option<action>)) {
            when(None()): failwith(Errors.failed_to_unpack_payload);
            when(Some(x)): x;
        };
    } else {
        return failwith(Errors.failed_to_open_bytes);
    }
};

// @inline
const resolve = (first : decoded_player_action, second : decoded_player_action) : option<player> => {
    let result : option<player> = match (first.action) {
        when(Stone()): match (second.action) {
            when(Stone()): None();
            when(Paper()): Some(second.player);
            when(Cisor()): Some(first.player);
        };
        when(Paper()): match (second.action) {
            when(Stone()): Some(first.player);
            when(Paper()): None();
            when(Cisor()): Some(second.player);
        };
        when(Cisor()): match (second.action) {
            when(Stone()): Some(second.player);
            when(Paper()): Some(first.player);
            when(Cisor()): None();
        };
    };
    return result;
};

// TODO , this implementation can handle only 2 players :(
const update_board = (sess : t, current_round : round) : board => {
    // process actions for current_round
    let pactions : decoded_player_actions = match (Map.find_opt(current_round, sess.decoded_rounds)) {
        when(None()): (failwith("Missing actions for current_round") as decoded_player_actions);
        when(Some(pacts)): pacts;
    };
    let first : decoded_player_action = match (List.head_opt(pactions)) {
        when(None()): (failwith("Missing actions for first player") as decoded_player_action);
        when(Some(act)): act;
    };
    let next_players_opt : option<list<decoded_player_action>> = List.tail_opt(pactions);
    let next_players : list<decoded_player_action> = match (next_players_opt) {
        when(None()): (failwith("Missing actions for second player") as list<decoded_player_action>);
        when(Some(tl)): tl;
    };
    let second : decoded_player_action = match (List.head_opt(next_players)) {
        when(None()): (failwith("Missing actions for second player") as decoded_player_action);
        when(Some(act)): act;
    };
    let result : option<player> = resolve(first, second);
    return match (result) {
        when(None()): Map.update(current_round, (None() as option<option<player>>), sess.board);
        when(Some(r)): Map.update(current_round, (Some(Some(r))), sess.board);
    };
};

export const finalize_current_round = (session: t) : t => {
    // retrieve decoded_player_actions of given roundId
    let performed_actions : decoded_player_actions = match (Map.find_opt(session.current_round, session.decoded_rounds)) {
        when(None()): (list([]) as decoded_player_actions);
        when(Some(pacts)): pacts;
    };
    // verify all players have revealed
    let all_player_have_revealed = ([accAndList, elt] : [[bool, decoded_player_actions], player]) : [bool, decoded_player_actions] => {
        let [acc, pactions] = accAndList;
        return [acc && has_played(pactions, elt), pactions];
    };
    let [check_all_players_have_revealed, _all_decoded_actions] : [bool, decoded_player_actions] = List.fold(all_player_have_revealed, session.players, [true, performed_actions]);
    // all players have given their actions, now the board can be updated and session goes to next round
    if (check_all_players_have_revealed == true) {
        return { ...session, current_round:session.current_round+1n, board:update_board(session, session.current_round) };
    } else {
        return session;
    }
};

const compute_result = (sess: t) : result => {
    // parse board and compute who won
    let compute_points = ([acc, elt] : [map<address, nat> , [round, option<player>]]) : map<address, nat> => {
        return match (elt[1]) {
            when(None()): acc;
            when(Some(winner_round)): match (Map.find_opt(winner_round, acc)) {
                when(None()): Map.add(winner_round, 1n, acc);
                when(Some(old_value)): Map.update(winner_round, (Some(old_value + 1n)), acc);
            };
        };
    };
    let final_scores = Map.fold(compute_points, sess.board, (Map.empty as map<address, nat>));
    let [winner_addr, winner_points, multiple_winners] : [option<address>, nat, bool] = [(None() as option<address>), 0n, false];
    let leader_score = ([acc, elt] : [[option<address>, nat, bool], [address, nat]]) : [option<address>, nat, bool] => {
        let [win_addr, win_points, multiple] = acc;
        return match (win_addr) {
            when(None()): [Some(elt[0]), elt[1], false];
            when(Some(_temp_win_addr)): do {
                if (elt[1] > win_points) {
                    return [Some(elt[0]), elt[1], false]
                } else {
                    if (elt[1] == win_points) {
                        return [win_addr, win_points, true]
                    } else {
                        return [win_addr, win_points, multiple]
                    }
                }
            };
        };
    };
    let [final_winner_addr, _final_winner_points, final_multiple] = Map.fold(leader_score, final_scores, [winner_addr, winner_points, multiple_winners]);
    if (final_multiple) {
        return Draw()
    } else {
        return match (final_winner_addr) {
            when(None()): Draw();
            when(Some(x)): Winner(x);
        }
    }
};

export const finalize_session = (session: t) : t => {
    if (session.current_round > session.total_rounds) {
        return { ...session, result: compute_result(session) };
    } else  {
        return session;
    }
};


#import "errors.jsligo" "Errors"
#import "parameter.jsligo" "Parameter"
#import "session.jsligo" "Session"
#import "conditions.jsligo" "Conditions"

export type t = {
    metadata : big_map<string, bytes>,
    next_session : nat,
    sessions : map<nat, Session.t>
};

export const update_sessions = (storage : t, sessionId : nat, new_session : Session.t): t => {
    return { ...storage, sessions: Map.update(sessionId, (Some(new_session)), storage.sessions)}
};

export const getSession = (sessionId : nat, store : t) : Session.t => {
    return match (Map.find_opt(sessionId, store.sessions)) {
        when(None()): (failwith(Errors.unknown_session) as Session.t);
        when(Some(sess)): sess;
    };
};


#import "session.jsligo" "Session"


export type sessionBoard = {
    points : map<address, nat>
};

export const retrieve_board = (sess : Session.t) : sessionBoard => {
    let scores : map<address, nat> = (Map.empty as map<address, nat>);
    let myfunc = ([acc, elt] : [map<address, nat>, [Session.round, option<address>]]) : map<address, nat> =>
        match (elt[1]) {
            when(None()): acc;
            when(Some(winner_round)): match (Map.find_opt(winner_round, acc)) {
                when(None()): Map.add(winner_round, 1n, acc);
                when(Some(old_value)): Map.update(winner_round, (Some(old_value + 1n)), acc)
            };
        };
    let final_scores = Map.fold(myfunc, sess.board, scores);
    return { points:final_scores }
};

Explore utilities

Marigold