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-Cameligov1.0

example of a NFT Factory contract in CameLIGO

Use template

Readme

Contract randomness

Compilation of randomness contract

Tests

Deployment

Contract informations

reset

Arguments

Marigold