An example of multisig contract in CameLIGO

sign_proposal

target_fa2

transfers

create_proposal

proposal_counter

proposal_map

signers

threshold

metadata

[@no_mutation] let only_signer = "Only one of the contract signer can create an proposal"
[@no_mutation] let amount_must_be_zero_tez = "You must not send Tezos to the smart contract"
[@no_mutation] let no_proposal_exist = "No proposal exists for this counter"
[@no_mutation] let has_already_signed = "You have already signed this proposal"
[@no_mutation] let unknown_contract_entrypoint = "Cannot connect to the target transfer token entrypoint"

[@no_mutation] let undefined_token = "FA2_TOKEN_UNDEFINED"
[@no_mutation] let ins_balance     = "FA2_INSUFFICIENT_BALANCE"
[@no_mutation] let no_transfer     = "FA2_TX_DENIED"
[@no_mutation] let not_owner       = "FA2_NOT_OWNER"
[@no_mutation] let not_operator    = "FA2_NOT_OPERATOR"
[@no_mutation] let not_supported   = "FA2_OPERATORS_UNSUPPORTED"
[@no_mutation] let rec_hook_fail   = "FA2_RECEIVER_HOOK_FAILED"
[@no_mutation] let send_hook_fail  = "FA2_SENDER_HOOK_FAILED"
[@no_mutation] let rec_hook_undef  = "FA2_RECEIVER_HOOK_UNDEFINED"
[@no_mutation] let send_hook_under = "FA2_SENDER_HOOK_UNDEFINED"


(**
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"

module Operators = struct
   type owner    = address
   type operator = address
   type token_id = nat
   type t = ((owner * operator), token_id set) big_map

(** if transfer policy is Owner_or_operator_transfer *)
   let assert_authorisation (operators : t) (from_ : address) (token_id : nat) : unit =
      let sender_ = (Tezos.get_sender ()) in
      if (sender_ = from_) then ()
      else
      let authorized = match Big_map.find_opt (from_,sender_) operators with
         Some (a) -> a | None -> Set.empty
      in if Set.mem token_id authorized then ()
      else failwith Errors.not_operator
(** if transfer policy is Owner_transfer
   let assert_authorisation (operators : t) (from_ : address) : unit =
      let sender_ = (Tezos.get_sender ()) in
      if (sender_ = from_) then ()
      else failwith Errors.not_owner
*)

(** if transfer policy is No_transfer
   let assert_authorisation (operators : t) (from_ : address) : unit =
      failwith Errors.no_owner
*)

   [@no_mutation] let assert_update_permission (owner : owner) : unit =
      assert_with_error (owner = (Tezos.get_sender ())) "The sender can only manage operators for his own token"
   (** For an administator
      let admin = tz1.... in
      assert_with_error ((Tezos.get_sender ()) = admiin) "Only administrator can manage operators"
   *)

   let add_operator (operators : t) (owner : owner) (operator : operator) (token_id : token_id) : t =
      if owner = operator then operators (* assert_authorisation always allow the owner so this case is not relevant *)
      else
         let () = assert_update_permission owner in
         let auth_tokens = match Big_map.find_opt (owner,operator) operators with
            Some (ts) -> ts | None -> Set.empty in
         let auth_tokens  = Set.add token_id auth_tokens in
         Big_map.update (owner,operator) (Some auth_tokens) operators

   let remove_operator (operators : t) (owner : owner) (operator : operator) (token_id : token_id) : t =
      if owner = operator then operators (* assert_authorisation always allow the owner so this case is not relevant *)
      else
         let () = assert_update_permission owner in
         let auth_tokens = match Big_map.find_opt (owner,operator) operators with
         None -> None | Some (ts) ->
            let ts = Set.remove token_id ts in
            [@no_mutation] let ts = if (Set.cardinal ts = 0n) then None else Some (ts) in
            ts
         in
         Big_map.update (owner,operator) auth_tokens operators
end

module Ledger = struct
   type token_id = nat
   type owner = address
   type t = (token_id,owner) big_map

   let is_owner_of (ledger:t) (token_id : token_id) (owner: address) : bool =
      (** We already sanitized token_id, a failwith here indicated a patological storage *)
      let current_owner = Option.unopt (Big_map.find_opt token_id ledger) in
      current_owner=owner

   let assert_owner_of (ledger:t) (token_id : token_id) (owner: address) : unit =
      assert_with_error (is_owner_of ledger token_id owner) Errors.ins_balance

   let transfer_token_from_user_to_user (ledger : t) (token_id : token_id) (from_ : owner) (to_ : owner) : t =
      let () = assert_owner_of ledger token_id from_ in
      let ledger = Big_map.update token_id (Some to_) ledger in
      ledger
end

module TokenMetadata = struct
   (**
      This should be initialized at origination, conforming to either
      TZIP-12 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#token-metadata
      or TZIP-16 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#contract-metadata-tzip-016
   *)
   type data = {token_id:nat;token_info:(string,bytes)map}
   type t = (nat, data) big_map
end

module Storage = struct
   type token_id = nat
   type t = {
      ledger : Ledger.t;
      token_metadata : TokenMetadata.t;
      operators : Operators.t;
   }

   let is_owner_of (s:t) (owner : address) (token_id : token_id) : bool =
      Ledger.is_owner_of s.ledger token_id owner

   let assert_token_exist (s:t) (token_id : nat) : unit  =
      let _ = Option.unopt_with_error (Big_map.find_opt token_id s.token_metadata)
         Errors.undefined_token in
      ()

   let set_ledger (s:t) (ledger:Ledger.t) = {s with ledger = ledger}

   let get_operators (s:t) = s.operators
   let set_operators (s:t) (operators:Operators.t) = {s with operators = operators}
end


type storage = Storage.t

(** Transfer entrypoint *)
type atomic_trans = [@layout:comb] {
   to_      : address;
   token_id : nat;
}

type transfer_from = {
   from_ : address;
   tx    : atomic_trans list
}
type transfer = transfer_from list

[@entry]
let transfer : transfer -> storage -> operation list * storage =
   fun (t:transfer) (s:storage) ->
   (* This function process the "tx" list. Since all transfer share the same "from_" address, we use a se *)
   let process_atomic_transfer (from_:address) (ledger, t:Ledger.t * atomic_trans) =
      let {to_;token_id} = t in
      let ()     = Storage.assert_token_exist s token_id in
      let ()     = Operators.assert_authorisation s.operators from_ token_id in
      let ledger = Ledger.transfer_token_from_user_to_user ledger token_id from_ to_ in
      ledger
   in
   let process_single_transfer (ledger, t:Ledger.t * transfer_from ) =
      let {from_;tx} = t in
      let ledger     = List.fold_left (process_atomic_transfer from_) ledger tx in
      ledger
   in
   let ledger = List.fold_left process_single_transfer s.ledger t in
   let s = Storage.set_ledger s ledger in
   ([]: operation list),s

type request = {
   owner    : address;
   token_id : nat;
}

type callback = [@layout:comb] {
   request : request;
   balance : nat;
}

type balance_of = [@layout:comb] {
   requests : request list;
   callback : callback list contract;
}

(** Balance_of entrypoint *)
[@entry]
let balance_of : balance_of -> storage -> operation list * storage =
   fun (b: balance_of) (s: storage) ->
   let {requests;callback} = b in
   let get_balance_info (request : request) : callback =
      let {owner;token_id} = request in
      let ()       = Storage.assert_token_exist  s token_id in
      [@no_mutation] let balance_ = if Storage.is_owner_of s owner token_id then 1n else 0n in
      {request=request;balance=balance_}
   in
   let callback_param = List.map get_balance_info requests in
   [@no_mutation] let operation = Tezos.transaction callback_param 0tez callback in
   ([operation]: operation list),s

(** Update_operators entrypoint *)
type operator = [@layout:comb] {
   owner    : address;
   operator : address;
   token_id : nat;
}
type unit_update      = Add_operator of operator | Remove_operator of operator
type update_operators = unit_update list

[@entry]
let update_operators : update_operators -> storage -> operation list * storage =
   fun (updates: update_operators) (s: storage) ->
   let update_operator (operators,update : Operators.t * unit_update) = match update with
      Add_operator    {owner=owner;operator=operator;token_id=token_id} -> Operators.add_operator    operators owner operator token_id
   |  Remove_operator {owner=owner;operator=operator;token_id=token_id} -> Operators.remove_operator operators owner operator token_id
   in
   let operators = Storage.get_operators s in
   let operators = List.fold_left update_operator operators updates in
   let s = Storage.set_operators s operators in
   ([]: operation list),s

(** If transfer_policy is  No_transfer or Owner_transfer
[@entry]
let update_operators : update_operators -> storage -> operation list * storage =
   fun (updates: update_operators) (s: storage) ->
   let () = failwith Errors.not_supported in
   ([]: operation list),s
*)

#import "../common/errors.mligo" "Errors"
#import "storage.mligo" "Storage"

[@inline]
let only_signer (storage : Storage.Types.t) : unit = 
    assert_with_error (Set.mem (Tezos.get_sender ()) storage.signers) Errors.only_signer

[@inline]
let amount_must_be_zero_tez (an_amout : tez) : unit =
    assert_with_error (an_amout = 0tez) Errors.amount_must_be_zero_tez

[@inline]
let not_yet_signer (proposal : Storage.Types.proposal) : unit = 
    assert_with_error (not Set.mem (Tezos.get_sender ()) proposal.approved_signers) Errors.has_already_signed



#import "../common/constants.mligo" "Constants"
#import "parameter.mligo" "Parameter"
#import "storage.mligo" "Storage"
#import "conditions.mligo" "Conditions"
#import "contracts/fa2.mligo" "FA2"

// ===============================================================================================

module Preamble = struct
    [@inline]
    let prepare_new_proposal (params, storage: Parameter.Types.proposal_params * Storage.Types.t) : Storage.Types.proposal =
        let () = Conditions.only_signer storage in
        let () = Conditions.amount_must_be_zero_tez (Tezos.get_amount ()) in
        Storage.Utils.create_proposal params

    [@inline]
    let retrieve_a_proposal (proposal_number, storage: Parameter.Types.proposal_number * Storage.Types.t) : Storage.Types.proposal =
        let () = Conditions.only_signer storage in
        let target_proposal = Storage.Utils.retrieve_proposal(proposal_number, storage) in
        let () = Conditions.not_yet_signer target_proposal in
        target_proposal
end

// ===============================================================================================

type result = operation list * Storage.Types.t

(**
 * Proposal creation
 *)
[@entry]
let create_proposal params (storage : Storage.Types.t) : result =
    let proposal = Preamble.prepare_new_proposal(params, storage) in
    let storage = Storage.Utils.register_proposal(proposal, storage) in
    (Constants.no_operation, storage)

(**
 * Proposal signature
 *)

[@entry]
let sign_proposal proposal_number (storage : Storage.Types.t) : result =
    let proposal = Preamble.retrieve_a_proposal(proposal_number, storage) in

    let proposal = Storage.Utils.add_signer_to_proposal(proposal, (Tezos.get_sender ()), storage.threshold) in
    let storage = Storage.Utils.update_proposal(proposal_number, proposal, storage) in

    let operations = FA2.perform_operations proposal in

    (operations, storage)

// ===============================================================================================

// This function is now only used for tests, and will be removed once tests are rewritten
let main (action: Parameter.Types.t) (storage: Storage.Types.t) : result =
    match action with
    | Create_proposal(proposal_params) ->
        create_proposal proposal_params storage
    | Sign_proposal(proposal_number) ->
        sign_proposal proposal_number storage


#import "../../common/errors.mligo" "Errors"
#import "../../common/constants.mligo" "Constants"
#import "../storage.mligo" "Storage"
#import "../../fa2/fa2.mligo" "FA2"

let send (transfers : FA2.transfer) (target_fa2_address : address) : operation = 
    [@no_mutation] let fa2_contract_opt : FA2.transfer contract option = Tezos.get_entrypoint_opt "%transfer" target_fa2_address in
    match fa2_contract_opt with
    | Some contr -> Tezos.transaction (transfers) 0mutez contr
    | None -> (failwith Errors.unknown_contract_entrypoint : operation)

let perform_operations (proposal: Storage.Types.proposal) : operation list =
    if proposal.executed
    then [ send proposal.transfers proposal.target_fa2 ]
    else Constants.no_operation

(*
#import "../lib/fa12/parameter.mligo" "FA12_Parameter"
#import "../lib/fa12/storage.mligo" "FA12_Storage"
#import "../lib/fa12/contract.mligo" "FA12"

#import "../lib/multisig/parameter.mligo" "Parameter"
#import "../lib/multisig/storage.mligo" "Storage"
#import "../lib/multisig/contract.mligo" "Multisign"

// ===== SIGNERS =====
let _create_accounts = Test.reset_state 6n ([] : tez list)
let alice   = Test.nth_bootstrap_account 0
let bob     = Test.nth_bootstrap_account 1
let charly  = Test.nth_bootstrap_account 2
let delta   = Test.nth_bootstrap_account 3
let echo    = Test.nth_bootstrap_account 4
let unknown = Test.nth_bootstrap_account 5

// ===== FAILWITH HELPER =======
let assert_string_failure (res : test_exec_result) (expected : string) : unit =
    let expected = Test.eval expected in
    match res with
    | Fail (Rejected (actual,_)) -> assert (Test.michelson_equal actual expected)
    | Fail (Other) -> failwith "Contract have failed"
    | Success -> failwith "Test should have failed"

// ========== DEPLOY CONTRACT HELPER ============
let originate (type s p) (storage: s) (main: (p * s) -> operation list * s) : (p,s) typed_address * p contract =
    let (typed_address, _, _) = Test.originate main storage 0tez in
    typed_address, Test.to_contract typed_address

// ===================================
// ========== BEGIN TESTS ============
// ===================================
let test_originate_contract_with_correct_storage_should_work =
    // Prepare data for initial storage
    let empty_bigmap : (nat, Storage.Types.proposal) big_map = Big_map.empty in 
    let initial_storage_multisig : Storage.Types.t = {
        proposal_counter = 0n;
        proposal_map = empty_bigmap;
        signers = (Set.add alice (Set.add bob (Set.add charly (Set.add delta (Set.empty : address set)))));
        threshold = 3n;
    } in
    // Originate contract
    let (typed_address_multi,_) = originate initial_storage_multisig Multisign.main in
    let storage_multi : Storage.Types.t = Test.get_storage typed_address_multi in
    // Assert that the storage is correct
    let () = assert (storage_multi.proposal_counter = initial_storage_multisig.proposal_counter ) in
    let () = assert (storage_multi.proposal_map = initial_storage_multisig.proposal_map ) in
    let () = assert (storage_multi.signers = initial_storage_multisig.signers ) in
    let () = assert (storage_multi.threshold = initial_storage_multisig.threshold ) in
    "✓"

let test_create_multisig_proposal_without_being_signer_should_fail =
    // Prepare data for initial storage
    let empty_bigmap : (nat, Storage.Types.proposal) big_map = Big_map.empty in 
    let initial_storage_multisig : Storage.Types.t = {
        proposal_counter = 0n;
        proposal_map = empty_bigmap;
        signers = (Set.add alice (Set.add bob (Set.add charly (Set.add delta (Set.empty : address set)))));
        threshold = 3n;
    } in
    // Originate contract multisig 
    let (_,contract_multisig) = originate initial_storage_multisig Multisign.main in
    // Create the initial fa12 storage
    let empty_bigmap : (FA12_Parameter.Types.allowance_key, nat) big_map = Big_map.empty in 
    let initial_storage_fa12 = {
        tokens = Big_map.add alice 1000n Big_map.empty;
        allowances = empty_bigmap;
        total_supply = 1000n;
    } in
    // Originate contract fa12 
    let (typed_address_fa12,contract_fa12) = originate initial_storage_fa12 FA12.main in
    // Create a new proposal
    let new_proposal : Parameter.Types.proposal_params = {
        target_fa12 = Tezos.address contract_fa12;
        target_to = echo;
        token_amount = 100n;
    } in
    // Send a new proposal without being a signer should fail
    let () = Test.set_source echo in
    let fail_tx : test_exec_result = Test.transfer_to_contract contract_multisig (Create_proposal(new_proposal)) 0mutez in
    let () = assert_string_failure (fail_tx: test_exec_result) ("Only one of the contract signer can create an proposal":string) in
    "✓"

let test_create_multisig_proposal_with_a_signer_should_work =
    // Prepare data for initial storage
    let empty_bigmap : (nat, Storage.Types.proposal) big_map = Big_map.empty in 
    // Create the initial multisig storage with specific values
    let initial_storage_multisig : Storage.Types.t = {
        proposal_counter = 0n;
        proposal_map = empty_bigmap;
        signers = (Set.add alice (Set.add bob (Set.add charly (Set.empty : address set))));
        threshold = 2n;
    } in
    // Originate contract multisig and cast a typed address to get the contract artefact
    let (typed_address_multi,contract_multisig) = originate initial_storage_multisig Multisign.main in
    // Create the initial fa12 storage
    let empty_bigmap : (FA12_Parameter.Types.allowance_key, nat) big_map = Big_map.empty in 
    let initial_storage_fa12 : FA12_Storage.Types.t = {
        tokens = Big_map.add alice 1000n Big_map.empty;
        allowances = empty_bigmap;
        total_supply = 1000n;
    } in
    // Originate contract fa12 and cast a typed address to get the contract artefact
    let (typed_address_fa,contract_fa12) = originate initial_storage_fa12 FA12.main in
    // Create a new proposal
    let new_proposal : Parameter.Types.proposal_params = {
        target_fa12 = Tezos.address contract_fa12;
        target_to = echo;
        token_amount = 100n;
    } in
    // Send a new proposal with a signer should work
    let () = Test.set_source alice in
    let tx : test_exec_result = Test.transfer_to_contract contract_multisig (Create_proposal(new_proposal)) 0mutez in
    let () = Test.log(tx) in
    let new_storage : Storage.Types.t = Test.get_storage typed_address_multi in
    let proposal : Storage.Types.proposal = match Map.find_opt 1n new_storage.proposal_map with
        Some value -> value
      | None -> failwith "f"
    in
    let () = assert ( proposal.approved_signers = (Set.add alice (Set.empty : address set)) ) in
    let () = assert ( proposal.executed = false) in
    let () = assert ( proposal.number_of_signer = 1n) in
    let () = assert ( proposal.target_fa12 = new_proposal.target_fa12) in
    let () = assert ( proposal.target_to = echo) in
    //let () = assert ( proposal.timestamp = (Tezos.now : timestamp)) in
    let () = assert ( proposal.token_amount = 100n) in
    "✓"

let test_sign_a_multisig_proposal_should_work =
    // Prepare data for initial storage
    let empty_bigmap : (nat, Storage.Types.proposal) big_map = Big_map.empty in 
    let address_1 : address = alice in
    let address_2 : address = bob in
    let address_3 : address = charly in
    // Create the initial multisig storage with specific values
    let initial_storage_multisig : Storage.Types.t = {
        proposal_counter = 0n;
        proposal_map = empty_bigmap;
        signers = (Set.add address_1 (Set.add address_2 (Set.add address_3 (Set.empty : address set))));
        threshold = 2n;
    } in
    // Originate contract multisig and cast a typed address to get the contract artefact
    let (typed_address_multi,contract_multisig) = originate initial_storage_multisig Multisign.main in
    // Create the initial fa12 storage
    let empty_bigmap : (FA12_Parameter.Types.allowance_key, nat) big_map = Big_map.empty in 
    let initial_storage_fa12 : FA12_Storage.Types.t = {
        tokens = Big_map.add alice 1000n Big_map.empty;
        allowances = empty_bigmap;
        total_supply = 1000n;
    } in
    // Originate contract fa12 and cast a typed address to get the contract artefact
    let (typed_address_fa,contract_fa12) = originate initial_storage_fa12 FA12.main in
    // Create a new proposal
    let new_proposal : Parameter.Types.proposal_params = {
        target_fa12 = Tezos.address contract_fa12;
        target_to = echo;
        token_amount = 100n;
    } in
    // Send a new proposal with a signer should work
    let () = Test.set_source alice in
    let tx : test_exec_result = Test.transfer_to_contract contract_multisig (Create_proposal(new_proposal)) 0mutez in
    let () = Test.set_source bob in
    let tx2 : test_exec_result = Test.transfer_to_contract contract_multisig (Sign_proposal(1n)) 0mutez in
 
    let new_storage : Storage.Types.t = Test.get_storage typed_address_multi in
    let proposal : Storage.Types.proposal = match Map.find_opt 1n new_storage.proposal_map with
        Some value -> value
      | None -> failwith "f"
    in

    //let () = assert ( proposal.approved_signers = (Set.add bob (Set.add alice (Set.empty : address set)))) in
    //let () = assert ( proposal.executed = true) in
    //let () = assert ( proposal.number_of_signer = 2n) in
    let () = assert ( proposal.target_fa12 = new_proposal.target_fa12) in
    let () = assert ( proposal.target_to = echo) in
    //let () = assert ( proposal.timestamp = (Tezos.now : timestamp)) in
    let () = assert ( proposal.token_amount = 100n) in
    "✓"
*)


    

#import "../fa2/fa2.mligo" "FA2"

module Types = struct
    type proposal_params = 
    [@layout:comb]
    {
        target_fa2 : address;
        transfers  : FA2.transfer;
    }

    type proposal_number = nat

    type t =
    | Create_proposal of (proposal_params)
    | Sign_proposal of (nat)
end


#import "parameter.mligo" "Parameter"
#import "../common/errors.mligo" "Errors"
#import "../fa2/fa2.mligo" "FA2"


module Types = struct
    type proposal =
    [@layout:comb]
    {
        approved_signers: address set;
        executed: bool;
        number_of_signer: nat;
        target_fa2: address;
        transfers: FA2.transfer;
        timestamp: timestamp;
    }

    type t =
    [@layout:comb]
    {
        proposal_counter: nat;
        proposal_map    : (nat, proposal) big_map;
        signers         : address set;
        threshold       : nat;
        metadata        : (string, bytes) big_map;
    }
end

module Utils = struct
    [@inline]
    let new_storage (signers, threshold: address set * nat) : Types.t =
        [@no_mutation] let proposal_counter = 0n in
        {
            proposal_counter ;
            proposal_map     = (Big_map.empty : (nat, Types.proposal) big_map);
            signers          = signers;
            threshold        = threshold;
            metadata         = (Big_map.empty: (string, bytes) big_map);
        }

    [@inline]
    let create_proposal (params: Parameter.Types.proposal_params) : Types.proposal =
        [@no_mutation] let number_of_signer = 1n in
        {
            approved_signers = Set.literal [(Tezos.get_sender ())];
            executed         = false;
            number_of_signer ;
            target_fa2       = params.target_fa2;
            timestamp        = (Tezos.get_now ());
            transfers        = params.transfers;
        }

    [@inline]
    let register_proposal (proposal, storage: Types.proposal * Types.t) : Types.t =
        [@no_mutation] let proposal_counter = storage.proposal_counter + 1n in
        let proposal_map = Big_map.add proposal_counter proposal storage.proposal_map in
        {
            storage with
            proposal_map     = proposal_map;
            proposal_counter = proposal_counter
        }

    [@inline]
    let retrieve_proposal (proposal_number, storage : nat * Types.t) : Types.proposal =
        match Big_map.find_opt proposal_number storage.proposal_map with
        | None -> failwith Errors.no_proposal_exist
        | Some(proposal) -> proposal


    [@inline]
    let add_signer_to_proposal (proposal, signer, threshold: Types.proposal * address * nat) : Types.proposal =
        let approved_signers : address set = Set.add signer proposal.approved_signers in
        let executed = Set.cardinal approved_signers >= threshold || proposal.executed in
        [@no_mutation] let number_of_signer = proposal.number_of_signer + 1n in
        {
            proposal with
            approved_signers = approved_signers;
            number_of_signer ;
            executed         = executed
        }

    [@inline]
    let update_proposal (proposal_number, proposal, storage: Parameter.Types.proposal_number * Types.proposal * Types.t) : Types.t =
        let proposal_map = Big_map.update proposal_number (Some proposal) storage.proposal_map in
        {
            storage with
            proposal_map = proposal_map
        }
end


#import "../fa2/fa2.mligo" "FA2"
#import "../src/contract.mligo" "Main"
#import "../src/parameter.mligo" "P"

import Types = P.Types

const assert_error = (res: test_exec_result, expected_error: string): unit => {
    const expected_error2 = Test.eval(expected_error);
    match(res) {
        when(Fail(x)):do{
        match (x) {
            when(Rejected(x)): assert(Test.michelson_equal(x[0], expected_error2));
            when(Balance_too_low(_)):failwith("contract failed: balance too low");
            when(Other(s)): failwith(s);
        }};
        when(Success(_)): failwith("Expected to fail but passed");
    };
};

const x = Test.reset_state (7 as nat, list([30000000 as tez]) as list <tez>);
const alice: address = Test.nth_bootstrap_account(1);
const bob: address = Test.nth_bootstrap_account(2);
const charly: address = Test.nth_bootstrap_account(3);
const delta: address = Test.nth_bootstrap_account(4);
const echo: address = Test.nth_bootstrap_account(5);
const unknown = Test.nth_bootstrap_account(6);
const signers: set<address> = Set.add(
    alice,
    Set.add(
        bob,
        Set.add(
            charly,
            Set.add(
                delta,
                Set.add(
                    echo,
                    Set.empty as set<address>
                )
            )
        )
    )
);
const threshold: nat = 3 as nat;
const proposal_map: big_map<nat, Main.Storage.Types.proposal> = Big_map.empty;
const proposal_counter: nat = 0 as nat;
const metadata_initial: big_map<string, bytes> = Big_map.empty;

const storage: Main.Storage.Types.t = ({
    signers: signers,
    threshold: threshold,
    proposal_map: proposal_map,
    proposal_counter: proposal_counter,
    metadata: metadata_initial
});

const atomic: FA2.atomic_trans = {
        to_: bob,
        token_id: 1 as nat
    };

const transfer_from: FA2.transfer_from = {
    from_: alice,
    tx: list([atomic]) as list<FA2.atomic_trans>
};

const transfers: FA2.transfer = list([transfer_from]) as FA2.transfer;

const create_proposal_params: Main.Parameter.Types.proposal_params = {
    target_fa2: bob as address,
    transfers: transfers
};
//_ = Test.log("here");


const test_signer_creates_proposal_works = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(alice);

    const expected_proposal: Main.Storage.Types.proposal = {
        approved_signers: Set.add(alice, Set.empty as set<address>),
        executed: false,
        number_of_signer: 1 as nat,
        target_fa2: bob as address,
        transfers:transfers,
        timestamp: 0 as timestamp
    };
    const _gas_used: nat = Test.transfer_exn(orig.addr, Create_proposal(create_proposal_params), 0 as mutez);
    Test.log(_gas_used);
    const end_storage = Test.get_storage(orig.addr);
    const end_proposal: Main.Storage.Types.proposal = match(Big_map.find_opt(1 as nat, end_storage.proposal_map)) {
        when(Some(op)): op;
        when(None): failwith(Main.Conditions.Errors.no_proposal_exist);
    };
    const final_proposal: Main.Storage.Types.proposal = {
        ...end_proposal,
        timestamp: (0 as timestamp)
    };
    assert(final_proposal == expected_proposal);
};

const test_unknown_creates_proposal_fails = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(unknown);
    const fail_tx = Test.transfer(orig.addr, Create_proposal(create_proposal_params), 0 as tez);
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(orig.addr);
    assert(curr_storage == storage);
};



const test_signer_signs_proposal_works = do {
    const init_proposal: Main.Storage.Types.proposal = {
        approved_signers: Set.add(alice, Set.empty as set<address>),
        executed: false,
        number_of_signer: 1 as nat,
        target_fa2: bob as address,
        transfers: transfers,
        timestamp: 5 as timestamp,
    };

    const orig = Test.originate(contract_of(Main), {
        ...storage, proposal_map: Big_map.literal(list([
        [1 as nat, init_proposal]
    ]))}
    , 0 as tez);
    Test.set_source(bob);
    const _gas_used: nat = Test.transfer_exn(orig.addr, (Sign_proposal(1 as nat) as parameter_of Main), 0 as tez);
    const curr_storage = Test.get_storage(orig.addr);
    const end_signed_proposal = match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
        when(Some(op)): op;
        when(None): failwith(Main.Conditions.Errors.no_proposal_exist);
    };
    const expected_signer: set<address> = Set.add(
        bob,
        Set.add(
            alice,
            Set.empty as set<address>
        )
    );
    assert(end_signed_proposal.approved_signers == expected_signer);
};


const test_unknown_signs_proposal_fails = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(unknown);
    const fail_tx = Test.transfer(orig.addr, (Sign_proposal(1 as nat) as parameter_of Main), 0 as tez);
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(orig.addr);
    assert(curr_storage == storage);
};



const test_unknown_signs_unknown_proposal_fails = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(unknown);
    const fail_sign_tx = Test.transfer(orig.addr, (Sign_proposal(2 as nat) as parameter_of Main), 0 as tez);
    assert_error(fail_sign_tx, Main.Conditions.Errors.only_signer);
};


const test_signer_signs_unknown_proposal_fails = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(alice);
    const fail_sign_tx = Test.transfer(orig.addr, (Sign_proposal(2 as nat) as parameter_of Main), 0 as tez);
    assert_error(fail_sign_tx, Main.Conditions.Errors.no_proposal_exist);
};



const signer_creates_proposal_signers_sign_proposal_execute_works = do {
    Test.set_source(alice);
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    const addr = Test.to_address(orig.addr);

    const ledger: FA2.Ledger.t = Big_map.literal(list([
        [1 as nat, alice],
        [2 as nat, bob],
        [3 as nat, charly]
    ]));

    const token_info = Map.empty as map<string, bytes>;
    const token_metadata = Big_map.literal(list([
        [1 as nat, {token_id:1 as nat, token_info: token_info}],
        [3 as nat, {token_id:3 as nat, token_info: token_info}],
        [2 as nat, {token_id:2 as nat, token_info: token_info}]
    ])) as FA2.TokenMetadata.t;

    const operators: FA2.Operators.t = Big_map.literal(list([
        [[alice, addr], Set.add(1 as nat, Set.empty as set<nat>)]
    ])) as FA2.Operators.t;

    const storage_fa2 = {
        ledger         : ledger,
        token_metadata : token_metadata,
        operators      : operators
    };

    const orig_fa2 = Test.originate(contract_of(FA2), storage_fa2, 0 as tez);
    const addr_fa2 = Test.to_address(orig_fa2.addr);
    const params: Main.Parameter.Types.proposal_params = {...create_proposal_params, target_fa2: addr_fa2};
    let _gas_used: nat = Test.transfer_exn(orig.addr, Create_proposal(params), 0 as mutez);



    Test.set_source(bob);
    _gas_used = Test.transfer_exn(orig.addr, (Sign_proposal(1 as nat) as parameter_of Main), 0 as tez);
    Test.set_source(charly);
    _gas_used = Test.transfer_exn(orig.addr, (Sign_proposal(1 as nat) as parameter_of Main), 0 as tez);

    const expected_executed_signers = Set.add(
        alice,
        Set.add(
            bob,
            Set.add(
                charly,
                Set.empty as set<address>
            )
        )
    );

    const curr_storage = Test.get_storage(orig.addr);
    const end_executed_proposal = match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
        when(Some(op)): op;
        when(None): failwith(Main.Conditions.Errors.no_proposal_exist);
    };

    assert(end_executed_proposal.executed);
    assert(end_executed_proposal.approved_signers == expected_executed_signers);
    const curr_fa2_storage = Test.get_storage(orig_fa2.addr);
    const owner: address = match(Big_map.find_opt(1 as nat, curr_fa2_storage.ledger)) {
        when(Some(val)): val;
        when(None): failwith(FA2.Errors.undefined_token);
    };
    assert(owner == bob);
};


const signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works = do {
    Test.set_source(alice);
    const storage_init = {...storage, threshold: 1 as nat};
    const orig = Test.originate(contract_of(Main), storage_init, 0 as tez);
    const addr: address = Test.to_address(orig.addr);

    const ledger: FA2.Ledger.t = Big_map.literal(list([
        [1 as nat, alice],
        [2 as nat, bob],
        [3 as nat, charly]
    ]));

    const token_info = Map.empty as map<string, bytes>;
    const token_metadata = Big_map.literal(list([
        [1 as nat, {token_id:1 as nat, token_info: token_info}],
        [2 as nat, {token_id:2 as nat, token_info: token_info}],
        [3 as nat, {token_id:3 as nat, token_info: token_info}]
    ])) as FA2.TokenMetadata.t;

    const operators: FA2.Operators.t = Big_map.literal(list([
        [[alice, addr], Set.add(1 as nat, Set.empty as set<nat>)]
    ])) as FA2.Operators.t;

    const storage_fa2 = {
        ledger         : ledger,
        token_metadata : token_metadata,
        operators      : operators
    };

    const orig_fa2 = Test.originate(contract_of(FA2), storage_fa2, 0 as tez);
    const addr_fa2 = Test.to_address(orig_fa2.addr);
    const params: Main.Parameter.Types.proposal_params = {...create_proposal_params, target_fa2: addr_fa2};
    let _gas_used: nat = Test.transfer_exn(orig.addr, Create_proposal(params), 0 as mutez);



    Test.set_source(bob);
    _gas_used = Test.transfer_exn(orig.addr, (Sign_proposal(1 as nat) as parameter_of Main), 0 as tez);

    const expected_executed_signers = Set.add(
        alice,
        Set.add(
            bob,
            Set.empty as set<address>
        )
    );

    const curr_storage = Test.get_storage(orig.addr);
    Test.log(curr_storage);
    const end_executed_proposal = match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
        when(Some(op)): op;
        when(None): failwith(Main.Conditions.Errors.no_proposal_exist);
    };

    assert(end_executed_proposal.executed);
    assert(end_executed_proposal.approved_signers == expected_executed_signers);
    const curr_fa2_storage = Test.get_storage(orig_fa2.addr);
    const owner: address = match(Big_map.find_opt(1 as nat, curr_fa2_storage.ledger)) {
        when(Some(val)): val;
        when(None): failwith(FA2.Errors.undefined_token);
    };
    assert(owner == bob);
};


#import "multisig.test.jsligo" "Test_Multisig"
/*
type main_tuple = (main_multisig: Test_Multisig.func_main, main_fa2: Test_Multisig.func_mainfa2) => unit;

const _test_mutation_complex = (func: main_tuple): unit => {
    match(Test.mutation_test([Test_Multisig.Main.main, Test_Multisig.FA2.main], ([a, b]) => func(a, b)), {
    None: () => unit,
    Some: pmutation => { 
        Test.log(pmutation[1]);
    }
    })
};


const _test_mutation_func = (func: (mainf: Test_Multisig.func_main) => unit): unit => {
    match(Test.mutation_test(Test_Multisig.Main.main, func), {
        None: () => unit,
        Some: pmutation => { 
            const _mut: option<string> = Test.save_mutation("mutations", pmutation[1]);
        }
    });
}
const _tests = list([
    Test_Multisig._test_signer_creates_proposal_works, Test_Multisig._test_unknown_creates_proposal_fails,
    Test_Multisig._test_signer_signs_proposal_works, Test_Multisig._test_unknown_signs_proposal_fails,
    Test_Multisig._test_unknown_signs_unknown_proposal_fails,
    Test_Multisig._test_signer_signs_unknown_proposal_fails
]);
const _tests_complex = list([
    Test_Multisig._signer_creates_proposal_signers_sign_proposal_execute_works,
    Test_Multisig._signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works
]);
const mutation_tests = (): unit => {
    List.iter(_test_mutation_func, _tests);
    List.iter(_test_mutation_complex, _tests_complex);
};  

const _ = mutation_tests();
*/

Multisig-Cameligo

An example of multisig contract in JsLIGO

[@no_mutation]
let only_signer = "Only one of the contract signer can create an proposal"

[@no_mutation]
let amount_must_be_zero_tez = "You must not send Tezos to the smart contract"

[@no_mutation]
let no_proposal_exist = "No proposal exists for this counter"

[@no_mutation]
let has_already_signed = "You have already signed this proposal"

[@no_mutation]
let unknown_contract_entrypoint =
  "Cannot connect to the target transfer token entrypoint"


[@no_mutation]
let undefined_token = "FA2_TOKEN_UNDEFINED"

[@no_mutation]
let ins_balance = "FA2_INSUFFICIENT_BALANCE"

[@no_mutation]
let no_transfer = "FA2_TX_DENIED"

[@no_mutation]
let not_owner = "FA2_NOT_OWNER"

[@no_mutation]
let not_operator = "FA2_NOT_OPERATOR"

[@no_mutation]
let not_supported = "FA2_OPERATORS_UNSUPPORTED"

[@no_mutation]
let rec_hook_fail = "FA2_RECEIVER_HOOK_FAILED"

[@no_mutation]
let send_hook_fail = "FA2_SENDER_HOOK_FAILED"

[@no_mutation]
let rec_hook_undef = "FA2_RECEIVER_HOOK_UNDEFINED"

[@no_mutation]
let send_hook_under = "FA2_SENDER_HOOK_UNDEFINED"


(**
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"
module Operators = struct
  type owner = address

  type operator = address

  type token_id = nat

  type t = ((owner * operator), token_id set) big_map

  (** if transfer policy is Owner_or_operator_transfer *)

  let assert_authorisation (operators : t) (from_ : address) (token_id : nat)
  : unit =
    let sender_ = (Tezos.get_sender ()) in
    if (sender_ = from_)
    then ()
    else
      let authorized =
        match Big_map.find_opt (from_, sender_) operators with
          Some (a) -> a
        | None -> Set.empty in
      if Set.mem token_id authorized then () else failwith Errors.not_operator

  (** if transfer policy is Owner_transfer
   let assert_authorisation (operators : t) (from_ : address) : unit =
      let sender_ = (Tezos.get_sender ()) in
      if (sender_ = from_) then ()
      else failwith Errors.not_owner
*)
  (** if transfer policy is No_transfer
   let assert_authorisation (operators : t) (from_ : address) : unit =
      failwith Errors.no_owner
*)

  [@no_mutation]
  let assert_update_permission (owner : owner) : unit =
    assert_with_error
      (owner = (Tezos.get_sender ()))
      "The sender can only manage operators for his own token"

  (** For an administator
      let admin = tz1.... in
      assert_with_error ((Tezos.get_sender ()) = admiin) "Only administrator can manage operators"
   *)

  let add_operator
    (operators : t)
    (owner : owner)
    (operator : operator)
    (token_id : token_id)
  : t =
    if owner = operator
    then operators
    (* assert_authorisation always allow the owner so this case is not relevant *)

    else
      let () = assert_update_permission owner in
      let auth_tokens =
        match Big_map.find_opt (owner, operator) operators with
          Some (ts) -> ts
        | None -> Set.empty in
      let auth_tokens = Set.add token_id auth_tokens in
      Big_map.update (owner, operator) (Some auth_tokens) operators

  [@no_mutation]
  let remove_operator
    (operators : t)
    (owner : owner)
    (operator : operator)
    (token_id : token_id)
  : t =
    if owner = operator
    then operators
    (* assert_authorisation always allow the owner so this case is not relevant *)

    else
      let () = assert_update_permission owner in
      let auth_tokens =
        match Big_map.find_opt (owner, operator) operators with
          None -> None
        | Some (ts) ->
            let ts = Set.remove token_id ts in
            if (Set.cardinal ts = 0n) then None else Some (ts) in
      Big_map.update (owner, operator) auth_tokens operators

end

module Ledger = struct
  type token_id = nat

  type owner = address

  type t = (token_id, owner) big_map

  let is_owner_of (ledger : t) (token_id : token_id) (owner : address) : bool =
    (** We already sanitized token_id, a failwith here indicated a patological storage *)

    let current_owner = Option.unopt (Big_map.find_opt token_id ledger) in
    current_owner = owner

  let assert_owner_of (ledger : t) (token_id : token_id) (owner : address)
  : unit =
    assert_with_error (is_owner_of ledger token_id owner) Errors.ins_balance

  let transfer_token_from_user_to_user
    (ledger : t)
    (token_id : token_id)
    (from_ : owner)
    (to_ : owner)
  : t =
    let () = assert_owner_of ledger token_id from_ in
    let ledger = Big_map.update token_id (Some to_) ledger in
    ledger

end

module TokenMetadata = struct
  (**
      This should be initialized at origination, conforming to either
      TZIP-12 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#token-metadata
      or TZIP-16 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#contract-metadata-tzip-016
   *)

  type data =
    {
     token_id : nat;
     token_info : (string, bytes) map
    }

  type t = (nat, data) big_map

end

module Storage = struct
  type token_id = nat

  type t =
    {
     ledger : Ledger.t;
     token_metadata : TokenMetadata.t;
     operators : Operators.t
    }

  let is_owner_of (s : t) (owner : address) (token_id : token_id) : bool =
    Ledger.is_owner_of s.ledger token_id owner

  let assert_token_exist (s : t) (token_id : nat) : unit =
    let _ =
      Option.unopt_with_error
        (Big_map.find_opt token_id s.token_metadata)
        Errors.undefined_token in
    ()

  let set_ledger (s : t) (ledger : Ledger.t) = {s with ledger = ledger}

  let get_operators (s : t) = s.operators

  let set_operators (s : t) (operators : Operators.t) =
    {s with operators = operators}

end

type storage = Storage.t

(** Transfer entrypoint *)

type atomic_trans =
  [@layout comb]
  {
   to_ : address;
   token_id : nat
  }

type transfer_from =
  {
   from_ : address;
   tx : atomic_trans list
  }

type transfer = transfer_from list

[@entry]
let transfer : transfer -> storage -> operation list * storage =
  fun (t : transfer)
    (s : storage) -> (* This function process the "tx" list. Since all transfer share the same "from_" address, we use a se *)

    let process_atomic_transfer
      (from_ : address)
      (ledger, t : Ledger.t * atomic_trans) =
      let {
       to_;
       token_id
      } = t in
      let () = Storage.assert_token_exist s token_id in
      let () = Operators.assert_authorisation s.operators from_ token_id in
      let ledger =
        Ledger.transfer_token_from_user_to_user ledger token_id from_ to_ in
      ledger in
    let process_single_transfer (ledger, t : Ledger.t * transfer_from) =
      let {
       from_;
       tx
      } = t in
      let ledger = List.fold_left (process_atomic_transfer from_) ledger tx in
      ledger in
    let ledger = List.fold_left process_single_transfer s.ledger t in
    let s = Storage.set_ledger s ledger in
    ([] : operation list), s

type request =
  {
   owner : address;
   token_id : nat
  }

type callback =
  [@layout comb]
  {
   request : request;
   balance : nat
  }

type balance_of =
  [@layout comb]
  {
   requests : request list;
   callback : callback list contract
  }

(** Balance_of entrypoint *)

[@entry]
let balance_of : balance_of -> storage -> operation list * storage =
  fun (b : balance_of)
    (s : storage) -> let {
     requests;
     callback
    } = b in
    let get_balance_info (request : request) : callback =
      let {
       owner;
       token_id
      } = request in
      let () = Storage.assert_token_exist s token_id in
      [@no_mutation]
      let balance_ = if Storage.is_owner_of s owner token_id then 1n else 0n in
      {
       request = request;
       balance = balance_
      } in
    let callback_param = List.map get_balance_info requests in
    [@no_mutation]
    let operation = Tezos.transaction callback_param 0mutez callback in
    ([operation] : operation list), s

(** Update_operators entrypoint *)

type operator =
  [@layout comb]
  {
   owner : address;
   operator : address;
   token_id : nat
  }

type unit_update =
| Add_operator of operator
| Remove_operator of operator

type update_operators = unit_update list

[@entry]
let update_operators : update_operators -> storage -> operation list * storage =
  fun (updates : update_operators)
    (s : storage) -> let update_operator
      (operators, update : Operators.t * unit_update) =
      match update with
        Add_operator
          {
           owner = owner;
           operator = operator;
           token_id = token_id
          } -> Operators.add_operator operators owner operator token_id
      | Remove_operator
          {
           owner = owner;
           operator = operator;
           token_id = token_id
          } -> Operators.remove_operator operators owner operator token_id in
    let operators = Storage.get_operators s in
    let operators = List.fold_left update_operator operators updates in
    let s = Storage.set_operators s operators in
    ([] : operation list), s

(** If transfer_policy is  No_transfer or Owner_transfer
[@entry]
let update_operators : update_operators -> storage -> operation list * storage =
   fun (updates: update_operators) (s: storage) ->
   let () = failwith Errors.not_supported in
   ([]: operation list),s
*)



#import "../common/errors.mligo" "Errors"

#import "storage.jsligo" "Storage"

@inline
export const only_signer = (storage: Storage.Types.t): unit =>
    assert_with_error(
        Set.mem((Tezos.get_sender()), storage.signers),
        Errors.only_signer
    );

@inline
export const amount_must_be_zero_tez = (an_amout: tez): unit =>
    assert_with_error(an_amout == (0 as tez), Errors.amount_must_be_zero_tez);

@inline
export const not_yet_signer = (proposal: Storage.Types.proposal): unit =>
    assert_with_error(
        ! Set.mem((Tezos.get_sender()), proposal.approved_signers),
        Errors.has_already_signed
    );


#import "../common/constants.mligo" "Constants"

#import "parameter.jsligo" "Parameter"

#import "storage.jsligo" "Storage"

#import "conditions.jsligo" "Conditions"

#import "contracts/fa2.jsligo" "FA2"

// ===============================================================================================

namespace Preamble {
    export const prepare_new_proposal = (
        params: Parameter.Types.proposal_params,
        storage: Storage.Types.t
    ): Storage.Types.proposal => {
        Conditions.only_signer(storage);
        Conditions.amount_must_be_zero_tez((Tezos.get_amount()));
        return Storage.Utils.create_proposal(params);
    };
    export const retrieve_a_proposal = (
        proposal_number: nat,
        storage: Storage.Types.t
    ): Storage.Types.proposal => {
        Conditions.only_signer(storage);
        const target_proposal: Storage.Types.proposal =
            Storage.Utils.retrieve_proposal(proposal_number, storage);
        Conditions.not_yet_signer(target_proposal);
        return target_proposal;
    };
};

// ===============================================================================================

type request = [Parameter.Types.t, Storage.Types.t];

export type result = [list<operation>, Storage.Types.t];

@entry
export const create_proposal = (
    params: Parameter.Types.proposal_params,
    storage: Storage.Types.t
): result => {
    const proposal = Preamble.prepare_new_proposal(params, storage);
    const final_storage = Storage.Utils.register_proposal(proposal, storage);
    return [Constants.no_operation, final_storage];
};

@entry
export const sign_proposal = (proposal_number: nat, storage: Storage.Types.t): result => {
    let proposal = Preamble.retrieve_a_proposal(proposal_number, storage);
    proposal
    = Storage.Utils.add_signer_to_proposal(
          proposal,
          (Tezos.get_sender()),
          storage.threshold
      );
    const final_storage =
        Storage.Utils.update_proposal(proposal_number, proposal, storage);
    const operations = FA2.perform_operations(proposal);
    return [operations, final_storage];
};

// ===============================================================================================
// This function is now only used for tests, and will be removed once tests are rewritten

export const main = (action: Parameter.Types.t, store: Storage.Types.t): result =>
    match(action) {
        when (Create_proposal(p)):
            create_proposal(p, store)
        when (Sign_proposal(p)):
            sign_proposal(p, store)
    }


#import "../../common/errors.mligo" "Errors"

#import "../../common/constants.mligo" "Constants"

#import "../storage.jsligo" "Storage"

#import "../../fa2/fa2.mligo" "FA2"

export const send = (transfers: FA2.transfer, target_fa2_address: address): operation => {
    @no_mutation
    const fa2_contract_opt: option<contract<FA2.transfer>> =
        Tezos.get_entrypoint_opt("%transfer", target_fa2_address);
    return match(fa2_contract_opt) {
        when (Some(contr)):
            Tezos.transaction(transfers, 0 as tez, contr)
        when (None()):
            failwith(Errors.unknown_contract_entrypoint)
    };
}

export const perform_operations = (proposal: Storage.Types.proposal): list<
    operation
> => {
    if (proposal.executed) {
        return list([send(proposal.transfers, proposal.target_fa2)]) as
            list<operation>;
    } else return Constants.no_operation;
}


#import "../fa2/fa2.mligo" "FA2"

export namespace Types {
    export type proposal_params = {
        target_fa2: address,
        transfers: FA2.transfer
    };
    export type proposal_number = nat;
    export type t =
        | ["Create_proposal", proposal_params]
        | ["Sign_proposal", proposal_number];
};


#import "parameter.jsligo" "Parameter"

#import "../common/errors.mligo" "Errors"

#import "../fa2/fa2.mligo" "FA2"

export namespace Types {
    export type proposal = {
        approved_signers: set<address>,
        executed: bool,
        number_of_signer: nat,
        target_fa2: address,
        transfers: FA2.transfer,
        timestamp: timestamp
    };
    export type t = {
        proposal_counter: nat,
        proposal_map: big_map<nat, proposal>,
        signers: set<address>,
        threshold: nat,
        metadata: big_map<string, bytes>
    };
};

export namespace Utils {
    @inline
    const new_storage = ([signers, threshold]: [set<address>, nat]): Types.t =>
        (
            {
                proposal_counter: 0 as nat,
                proposal_map: Big_map.empty as big_map<nat, Types.proposal>,
                signers: signers,
                threshold: threshold,
                metadata: (Big_map.empty as big_map<string, bytes>)
            }
        );
    @inline
    export const create_proposal = (params: Parameter.Types.proposal_params): Types.
    proposal => {
        @no_mutation
        let number_of_signer = 1 as nat;
        return {
            approved_signers: Set.literal(list([(Tezos.get_sender())])),
            executed: false,
            number_of_signer,
            target_fa2: params.target_fa2,
            timestamp: (Tezos.get_now()),
            transfers: params.transfers
        }
    };
    @inline
    export const register_proposal = (
        proposal: Types.proposal,
        storage: Types.t
    ): Types.t => {
        @no_mutation
        const proposal_counter = storage.proposal_counter + (1 as nat);
        const proposal_map =
            Big_map.add(proposal_counter, proposal, storage.proposal_map);
        return {
            ...storage,
            proposal_map: proposal_map,
            proposal_counter: proposal_counter
        };
    };
    @inline
    export const retrieve_proposal = (proposal_number: nat, storage: Types.t): Types.
    proposal =>
        match(Big_map.find_opt(proposal_number, storage.proposal_map)) {
            when (None()):
                failwith(Errors.no_proposal_exist)
            when (Some(proposal)):
                proposal
        };
    @inline
    export const add_signer_to_proposal = (
        proposal: Types.proposal,
        signer: address,
        threshold: nat
    ): Types.proposal => {
        const approved_signers: set<address> =
            Set.add(signer, proposal.approved_signers);
        const executed: bool =
            Set.cardinal(approved_signers) >= threshold || proposal.executed;
        @no_mutation
        const number_of_signer = proposal.number_of_signer + (1 as nat);
        return {
            ...proposal,
            approved_signers: approved_signers,
            number_of_signer,
            executed: executed
        };
    };
    @inline
    export const update_proposal = (
        proposal_number: Parameter.Types.proposal_number,
        proposal: Types.proposal,
        storage: Types.t
    ): Types.t => {
        const proposal_map =
            Big_map.update(
                proposal_number,
                Some(proposal),
                storage.proposal_map
            );
        return { ...storage, proposal_map: proposal_map }
    };
}


#import "../fa2/fa2.mligo" "FA2"

#import "../src/contract.jsligo" "Main"

#import "../src/parameter.jsligo" "P"

import Types = P.Types

const assert_error = (res: test_exec_result, expected_error: string): unit => {
    const expected_error2 = Test.eval(expected_error);
    match(res) {
        when (Fail(x)):
            do {
                match(x) {
                    when (Rejected(x)):
                        assert(Test.michelson_equal(x[0], expected_error2))
                    when (Balance_too_low(_r)):
                        failwith("contract failed: balance too low")
                    when (Other(s)):
                        failwith(s)
                }
            }
        when (Success(_n)):
            failwith("Expected to fail but passed")
    };
};

const x = Test.reset_state(7 as nat, list([30000000 as tez]) as list<tez>);

const alice: address = Test.nth_bootstrap_account(1);

const bob: address = Test.nth_bootstrap_account(2);

const charly: address = Test.nth_bootstrap_account(3);

const delta: address = Test.nth_bootstrap_account(4);

const echo: address = Test.nth_bootstrap_account(5);

const unknown = Test.nth_bootstrap_account(6);

const signers: set<address> =
    Set.add(
        alice,
        Set.add(
            bob,
            Set.add(
                charly,
                Set.add(delta, Set.add(echo, Set.empty as set<address>))
            )
        )
    );

const threshold: nat = 3 as nat;

const proposal_map: big_map<nat, Main.Storage.Types.proposal> = Big_map.empty;

const proposal_counter: nat = 0 as nat;

const metadata_initial: big_map<string, bytes> = Big_map.empty;

const storage: Main.Storage.Types.t = (
    {
        signers: signers,
        threshold: threshold,
        proposal_map: proposal_map,
        proposal_counter: proposal_counter,
        metadata: metadata_initial
    }
);

const atomic: FA2.atomic_trans = { to_: bob, token_id: 1 as nat };

const transfer_from: FA2.transfer_from = {
    from_: alice,
    tx: list([atomic]) as list<FA2.atomic_trans>
};

const transfers: FA2.transfer = list([transfer_from]) as FA2.transfer;

const create_proposal_params: Main.Parameter.Types.proposal_params = {
    target_fa2: bob as address,
    transfers: transfers
};

const test_signer_creates_proposal_works = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(alice);
    const expected_proposal: Main.Storage.Types.proposal = {
        approved_signers: Set.add(alice, Set.empty as set<address>),
        executed: false,
        number_of_signer: 1 as nat,
        target_fa2: bob as address,
        transfers: transfers,
        timestamp: 0 as timestamp
    };
    const gas_used: nat =
        Test.transfer_exn(
            orig.addr,
            Create_proposal(create_proposal_params),
            0 as mutez
        );
    Test.log(gas_used);
    const end_storage = Test.get_storage(orig.addr);
    const end_proposal: Main.Storage.Types.proposal =
        match(Big_map.find_opt(1 as nat, end_storage.proposal_map)) {
            when (Some(op)):
                op
            when (None()):
                failwith(Main.Conditions.Errors.no_proposal_exist)
        };
    const final_proposal: Main.Storage.Types.proposal = {
        ...end_proposal, timestamp: (0 as timestamp)
    };
    assert(final_proposal == expected_proposal);
};

export const test_unknown_creates_proposal_fails = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(unknown);
    const fail_tx =
        Test.transfer(
            orig.addr,
            Create_proposal(create_proposal_params),
            0 as tez
        );
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(orig.addr);
    assert(curr_storage == storage);
};

const test_signer_signs_proposal_works = do {
    const init_proposal: Main.Storage.Types.proposal = {
        approved_signers: Set.add(alice, Set.empty as set<address>),
        executed: false,
        number_of_signer: 1 as nat,
        target_fa2: bob as address,
        transfers: transfers,
        timestamp: 5 as timestamp,
    };
    const orig =
        Test.originate(
            contract_of(Main),
            {
                ...storage,
                proposal_map: Big_map.literal(list([[1 as nat, init_proposal]]))
            },
            0 as tez
        );
    Test.set_source(bob);
    const _gas_used: nat =
        Test.transfer_exn(
            orig.addr,
            (Sign_proposal(1 as nat) as parameter_of Main),
            0 as tez
        );
    const curr_storage = Test.get_storage(orig.addr);
    const end_signed_proposal =
        match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
            when (Some(op)):
                op
            when (None()):
                failwith(Main.Conditions.Errors.no_proposal_exist)
        };
    const expected_signer: set<address> =
        Set.add(bob, Set.add(alice, Set.empty as set<address>));
    assert(end_signed_proposal.approved_signers == expected_signer);
};

export const test_unknown_signs_proposal_fails = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(unknown);
    const fail_tx =
        Test.transfer(
            orig.addr,
            (Sign_proposal(1 as nat) as parameter_of Main),
            0 as tez
        );
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(orig.addr);
    assert(curr_storage == storage);
};

export const test_unknown_signs_unknown_proposal_fails = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(unknown);
    const fail_sign_tx =
        Test.transfer(
            orig.addr,
            (Sign_proposal(2 as nat) as parameter_of Main),
            0 as tez
        );
    assert_error(fail_sign_tx, Main.Conditions.Errors.only_signer);
};

const test_signer_signs_unknown_proposal_fails = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(alice);
    const fail_sign_tx =
        Test.transfer(
            orig.addr,
            (Sign_proposal(2 as nat) as parameter_of Main),
            0 as tez
        );
    assert_error(fail_sign_tx, Main.Conditions.Errors.no_proposal_exist);
};

const signer_creates_proposal_signers_sign_proposal_execute_works = do {
    Test.set_source(alice);
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    const addr = Test.to_address (orig.addr);
    const ledger: FA2.Ledger.t =
        Big_map.literal(
            list([[1 as nat, alice], [2 as nat, bob], [3 as nat, charly]])
        );
    const _token_info = Map.empty as map<string, bytes>;
    const token_metadata =
        Big_map.literal(
            list(
                [
                    [
                        1 as nat,
                        {
                            token_id: 1 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ],
                    [
                        2 as nat,
                        {
                            token_id: 2 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ],
                    [
                        3 as nat,
                        {
                            token_id: 3 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ]
                ]
            )
        ) as FA2.TokenMetadata.t;
    const operators: FA2.Operators.t =
        Big_map.literal(list([[[alice, addr], Set.literal(list([1 as nat]))]])) as
            FA2.Operators.t;
    const storage_fa2 = {
        ledger: ledger,
        token_metadata: token_metadata,
        operators: operators
    };
    const orig_fa2 = Test.originate(contract_of(FA2), storage_fa2, 0 as tez);
    const addr_fa2 = Test.to_address(orig_fa2.addr);
    const params: Main.Parameter.Types.proposal_params = {
        ...create_proposal_params, target_fa2: addr_fa2
    };
    let _gas_used: nat =
        Test.transfer_exn(
            orig.addr,
            Create_proposal(params),
            0 as mutez
        );
    Test.set_source(bob);
    _gas_used
    = Test.transfer_exn(
          orig.addr,
          (Sign_proposal(1 as nat)),
          0 as tez
      );
    Test.set_source(charly);
    _gas_used
    = Test.transfer_exn(
          orig.addr,
          (Sign_proposal(1 as nat)),
          0 as tez
      );
    const expected_executed_signers =
        Set.add(alice, Set.add(bob, Set.add(charly, Set.empty as set<address>)));
    const curr_storage = Test.get_storage(orig.addr);
    const end_executed_proposal =
        match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
            when (Some(op)):
                op
            when (None()):
                failwith(Main.Conditions.Errors.no_proposal_exist)
        };
    assert(end_executed_proposal.executed);
    assert(end_executed_proposal.approved_signers == expected_executed_signers);
    const curr_fa2_storage: FA2.storage = Test.get_storage(orig_fa2.addr);
    const owner: address =
        match(Big_map.find_opt(1 as nat, curr_fa2_storage.ledger)) {
            when (Some(val)):
                val
            when (None()):
                failwith(FA2.Errors.undefined_token)
        };
    assert(owner == bob);
};

const _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works = do {
    Test.set_source(alice);
    const storage_init = { ...storage, threshold: 1 as nat };
    const orig = Test.originate(contract_of(Main), storage_init, 0 as tez);
    const addr: address = Test.to_address (orig.addr);
    const ledger: FA2.Ledger.t =
        Big_map.literal(
            list([[1 as nat, alice], [2 as nat, bob], [3 as nat, charly]])
        );
    const _token_info = Map.empty as map<string, bytes>;
    const token_metadata =
        Big_map.literal(
            list(
                [
                    [
                        1 as nat,
                        {
                            token_id: 1 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ],
                    [
                        2 as nat,
                        {
                            token_id: 2 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ],
                    [
                        3 as nat,
                        {
                            token_id: 3 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ]
                ]
            )
        ) as FA2.TokenMetadata.t;
    const operators: FA2.Operators.t =
        Big_map.literal(list([[[alice, addr], Set.literal(list([1 as nat]))]])) as
            FA2.Operators.t;
    const storage_fa2 = {
        ledger: ledger,
        token_metadata: token_metadata,
        operators: operators
    };
    const orig_fa2 = Test.originate(contract_of(FA2), storage_fa2, 0 as tez);
    const addr_fa2 = Test.to_address(orig_fa2.addr);
    const params: Main.Parameter.Types.proposal_params = {
        ...create_proposal_params, target_fa2: addr_fa2
    };
    let _gas_used: nat =
        Test.transfer_exn(
            orig.addr,
            Create_proposal(params),
            0 as mutez
        );
    Test.set_source(bob);
    _gas_used
    = Test.transfer_exn(
          orig.addr,
          (Sign_proposal(1n)),
          0 as tez
      );
    const expected_executed_signers =
        Set.add(alice, Set.add(bob, Set.empty as set<address>));
    const curr_storage = Test.get_storage(orig.addr);
    Test.log(curr_storage);
    const end_executed_proposal =
        match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
            when (Some(op)):
                op
            when (None()):
                failwith(Main.Conditions.Errors.no_proposal_exist)
        };
    assert(end_executed_proposal.executed);
    assert(end_executed_proposal.approved_signers == expected_executed_signers);
    const curr_fa2_storage: FA2.storage = Test.get_storage(orig_fa2.addr);
    const owner: address =
        match(Big_map.find_opt(1 as nat, curr_fa2_storage.ledger)) {
            when (Some(val)):
                val
            when (None()):
                failwith(FA2.Errors.undefined_token)
        };
    assert(owner == bob);
};

#import "multisig.test.jsligo" "Test_Multisig"

/*
type main_tuple =
    (
        main_multisig: Test_Multisig.func_main,
        main_fa2: Test_Multisig.func_mainfa2
    ) => unit;

const _test_mutation_complex = (func: main_tuple): unit => {
    match(
        Test.mutation_test(
            [Test_Multisig.Main.main, Test_Multisig.FA2.main],
            ([a, b]) => func(a, b)
        )
    ) {
        when (None()):
            []
        when (Some(pmutation)):
            do { Test.log(pmutation[1]); }
    }
};

const _test_mutation_func = (func: (mainf: Test_Multisig.func_main) => unit): unit => {
    match(Test.mutation_test(Test_Multisig.Main.main, func)) {
        when (None()):
            []
        when (Some(pmutation)):
            do {
                const _mut: option<string> =
                    Test.save_mutation("mutations", pmutation[1]);
            }
    };
}

const _tests =
    list(
        [
            Test_Multisig._test_signer_creates_proposal_works,
            Test_Multisig._test_unknown_creates_proposal_fails,
            Test_Multisig._test_signer_signs_proposal_works,
            Test_Multisig._test_unknown_signs_proposal_fails,
            Test_Multisig._test_unknown_signs_unknown_proposal_fails,
            Test_Multisig._test_signer_signs_unknown_proposal_fails
        ]
    );

const _tests_complex =
    list(
        [
            Test_Multisig.
            _signer_creates_proposal_signers_sign_proposal_execute_works,
            Test_Multisig.
            _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works
        ]
    );

const mutation_tests = (): unit => {
    List.iter(_test_mutation_func, _tests);
    List.iter(_test_mutation_complex, _tests_complex);
};

const _ = mutation_tests();
*/


Multisig-Jsligo

example of a NFT Factory contract in CameLIGO

name

token_ids

token_metas

generateCollection

nothing

all_collections

owned_collections

An example of NFT factory contract written in cameligo

nft-factory-cameligo

(** 
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"
#import "address.mligo" "Address"
#import "operators.mligo" "Operators"
#import "tokenMetadata.mligo" "TokenMetadata"
#import "ledger.mligo" "Ledger"
#import "storage.mligo" "Storage"

type storage = Storage.t

(** Transfer entrypoint *)
type atomic_trans = [@layout:comb] {
   to_      : Address.t;
   token_id : nat;
}

type transfer_from = {
   from_ : Address.t;
   tx    : atomic_trans list
}
type transfer = transfer_from list

let transfer (type a) (t:transfer) (s:a storage) : operation list * a storage = 
   (* This function process the "tx" list. Since all transfer share the same "from_" address, we use a se *)
   let process_atomic_transfer (from_:Address.t) (ledger, t:Ledger.t * atomic_trans) =
      let {to_;token_id} = t in
      let ()     = Storage.assert_token_exist s token_id in
      let ()     = Operators.assert_authorisation s.operators from_ token_id in
      let ledger = Ledger.transfer_token_from_user_to_user ledger token_id from_ to_ in
      ledger
   in
   let process_single_transfer (ledger, t:Ledger.t * transfer_from ) =
      let {from_;tx} = t in
      let ledger     = List.fold_left (process_atomic_transfer from_) ledger tx in
      ledger
   in
   let ledger = List.fold_left process_single_transfer s.ledger t in
   let s = Storage.set_ledger s ledger in
   ([] : operation list), s
   
type request = {
   owner    : Address.t;
   token_id : nat;
}

type callback = [@layout:comb] {
   request : request;
   balance : nat;
}

type balance_of = [@layout:comb] {
   requests : request list;
   callback : callback list contract;
}

(** Balance_of entrypoint *)
let balance_of (type a) (b: balance_of) (s: a storage) : operation list * a storage =
   let {requests;callback} = b in
   let get_balance_info (request : request) : callback =
      let {owner;token_id} = request in
      let balance_ = Storage.get_balance s owner token_id in
      {request=request;balance=balance_}
   in
   let callback_param = List.map get_balance_info requests in
   let operation = Tezos.transaction callback_param 0tez callback in
   ([operation]: operation list),s

(** Update_operators entrypoint *)
type operator = [@layout:comb] {
   owner    : Address.t;
   operator : Address.t;
   token_id : nat; 
}
type unit_update      = Add_operator of operator | Remove_operator of operator
type update_operators = unit_update list

let update_ops (type a) (updates: update_operators) (s: a storage) : operation list * a storage =
   let update_operator (operators,update : Operators.t * unit_update) = match update with 
      Add_operator    {owner=owner;operator=operator;token_id=token_id} -> Operators.add_operator    operators owner operator token_id
   |  Remove_operator {owner=owner;operator=operator;token_id=token_id} -> Operators.remove_operator operators owner operator token_id
   in
   let operators = Storage.get_operators s in
   let operators = List.fold_left update_operator operators updates in
   let s = Storage.set_operators s operators in
   ([]: operation list),s

[@view] let get_balance (type a) (p, s : (Address.t * nat) * a storage) : nat = 
      let (owner, token_id) = p in
      let balance_ = Storage.get_balance s owner token_id in
      balance_

[@view] let total_supply (type a) ((token_id, s) : (nat * a storage)):  nat =
      let () = Storage.assert_token_exist s token_id in
      1n

[@view] let all_tokens (type a) ((_, s) : (unit * a storage)): nat list =
   s.token_ids
   
[@view] let is_operator (type a) ((op, s) : (operator * a storage)): bool =
      Operators.is_operator (s.operators, op.owner, op.operator, op.token_id)

[@view] let token_metadata (type a) ((p, s) : (nat * a storage)): TokenMetadata.data = 
      TokenMetadata.get_token_metadata p s.token_metadata

(** 
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

type t = address

[@no_mutation] let equal (a : t) (b : t) = a = b

type t = string

let undefined_token = "FA2_TOKEN_UNDEFINED"
let ins_balance     = "FA2_INSUFFICIENT_BALANCE"
let no_transfer     = "FA2_TX_DENIED"
let not_owner       = "FA2_NOT_OWNER"
let not_operator    = "FA2_NOT_OPERATOR"
let not_supported   = "FA2_OPERATORS_UNSUPPORTED"
let rec_hook_fail   = "FA2_RECEIVER_HOOK_FAILED"
let send_hook_fail  = "FA2_SENDER_HOOK_FAILED"
let rec_hook_undef  = "FA2_RECEIVER_HOOK_UNDEFINED"
let send_hook_under = "FA2_SENDER_HOOK_UNDEFINED"

let only_sender_manage_operators = "The sender can only manage operators for his own token"
let only_admin = "FA2_NOT_ADMIN"

(** 
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"
#import "address.mligo" "Address"

type token_id = nat
type owner = Address.t
type t = (token_id,owner) big_map

let is_owner_of (ledger:t) (token_id : token_id) (owner: Address.t) : bool =
   (** We already sanitized token_id, a failwith here indicated a patological storage *)
   let current_owner = Option.unopt (Big_map.find_opt token_id ledger) in
   Address.equal current_owner owner

let assert_owner_of (ledger:t) (token_id : token_id) (owner: Address.t) : unit =
   assert_with_error (is_owner_of ledger token_id owner) Errors.ins_balance

let transfer_token_from_user_to_user (ledger : t) (token_id : token_id) (from_ : owner) (to_ : owner) : t = 
   let () = assert_owner_of ledger token_id from_ in
   let ledger = Big_map.update token_id (Some to_) ledger in
   ledger 

(** 
This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"
#import "address.mligo" "Address"

type owner    = Address.t
type operator = Address.t
type token_id = nat
type t = ((owner * operator), token_id set) big_map

(** if transfer policy is Owner_or_operator_transfer *)
let assert_authorisation (operators : t) (from_ : Address.t) (token_id : nat) : unit = 
   let sender_ = Tezos.get_sender () in
   if (Address.equal sender_ from_) then ()
   else 
   let authorized = match Big_map.find_opt (from_,sender_) operators with
      Some (a) -> a | None -> Set.empty
   in if Set.mem token_id authorized then ()
   else failwith Errors.not_operator
(** if transfer policy is Owner_transfer
let assert_authorisation (operators : t) (from_ : Address.t) : unit = 
   let sender_ = Tezos.get_sender () in
   if (sender_ = from_) then ()
   else failwith Errors.not_owner
*)

(** if transfer policy is No_transfer
let assert_authorisation (operators : t) (from_ : Address.t) : unit = 
   failwith Errors.no_owner
*)

let is_operator (operators, owner, operator, token_id : (t * Address.t * Address.t * nat)) : bool =
   let authorized = match Big_map.find_opt (owner,operator) operators with
      Some (a) -> a | None -> Set.empty in
   (owner = operator || Set.mem token_id authorized)

let assert_update_permission (owner : owner) : unit =
   assert_with_error (Address.equal owner (Tezos.get_sender ())) Errors.only_sender_manage_operators

let add_operator (operators : t) (owner : owner) (operator : operator) (token_id : token_id) : t =
   if owner = operator then operators (* assert_authorisation always allow the owner so this case is not relevant *)
   else
      let () = assert_update_permission owner in
      let auth_tokens = match Big_map.find_opt (owner,operator) operators with
         Some (ts) -> ts | None -> Set.empty in
      let auth_tokens  = Set.add token_id auth_tokens in
      Big_map.update (owner,operator) (Some auth_tokens) operators
      
let remove_operator (operators : t) (owner : owner) (operator : operator) (token_id : token_id) : t =
   if owner = operator then operators (* assert_authorisation always allow the owner so this case is not relevant *)
   else
      let () = assert_update_permission owner in
      let auth_tokens = match Big_map.find_opt (owner,operator) operators with
      None -> None | Some (ts) ->
         let ts = Set.remove token_id ts in
         [@no_mutation] let is_empty = Set.cardinal ts = 0n in 
         if is_empty then None else Some (ts)
      in
      Big_map.update (owner,operator) auth_tokens operators

(** 
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"
#import "address.mligo" "Address"
#import "operators.mligo" "Operators"
#import "tokenMetadata.mligo" "TokenMetadata"
#import "ledger.mligo" "Ledger"

type token_id = nat
type 'a t = {
   ledger : Ledger.t;
   token_metadata : TokenMetadata.t;
   operators : Operators.t;
   token_ids : token_id list;
   extension : 'a;
}

let is_owner_of (type a) (s:a t) (owner : Address.t) (token_id : token_id) : bool = 
   Ledger.is_owner_of s.ledger token_id owner

let assert_token_exist (type a) (s:a t) (token_id : nat) : unit  = 
   let _ = Option.unopt_with_error (Big_map.find_opt token_id s.token_metadata)
      Errors.undefined_token in
   ()

let set_ledger (type a) (s:a t) (ledger:Ledger.t) = {s with ledger = ledger}

let get_operators (type a) (s:a t) = s.operators
let set_operators (type a) (s:a t) (operators:Operators.t) = {s with operators = operators}

let get_balance (type a) (s:a t) (owner : Address.t) (token_id : nat) : nat =
   let ()       = assert_token_exist s token_id in 
   if is_owner_of s owner token_id then 1n else 0n

(** 
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"

(**
   This should be initialized at origination, conforming to either 
   TZIP-12 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#token-metadata
   or TZIP-16 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#contract-metadata-tzip-016 
*)
type data = {token_id:nat;token_info:(string,bytes)map}
type t = (nat, data) big_map 

let get_token_metadata (token_id : nat) (tm : t) =
   match Big_map.find_opt token_id tm with
      Some data -> data
   | None -> failwith Errors.undefined_token

let helper_add_global_metadata(acc , elt : (t * (string, bytes)map) * nat) : (t * (string, bytes)map) = 
   let current_metadata = match Big_map.find_opt elt acc.0 with
   | None -> (failwith(Errors.undefined_token) : data)
   | Some c -> c
   in
   let add_field(infos, field: (string, bytes)map * (string * bytes)) : (string, bytes)map = 
         match Map.find_opt field.0 infos with
         | None -> Map.add field.0 field.1 infos
         | Some _old -> infos 
   in
   let modified_current_token_info = Map.fold add_field acc.1 current_metadata.token_info in
   let modified_current_metadata : data = { current_metadata with token_info=modified_current_token_info } in
   (Big_map.update elt (Some(modified_current_metadata)) acc.0, acc.1)

let add_global_metadata (token_ids : nat list) (metadatas : t) (global_metadatas : (string, bytes) map) : t =
   let result, _gl_metas = List.fold helper_add_global_metadata token_ids (metadatas, global_metadatas) in
   result


#import "../common/errors.mligo" "Errors"
#import "../common/address.mligo" "Address"
#import "../common/storage.mligo" "Storage"
#import "../common/ledger.mligo" "Ledger"
#import "../common/tokenMetadata.mligo" "TokenMetadata"
#import "../common/NFT.mligo" "NFT"

(*
   Specialization corner
*)

module TokenUsage = struct 
   type token_id = nat
   type t = (token_id, nat) big_map

   let update_usage_token (usage : t) (token_id : token_id) : t = 
      match Big_map.find_opt token_id usage with
      | None -> (failwith("This token is not initialized in usage map") : t)
      | Some old -> Big_map.update token_id (Some (old + 1n)) usage 

   let get_token_usage (token_id : nat) (tu : t) =
      match Big_map.find_opt token_id tu with
         Some data -> data
      | None -> failwith Errors.undefined_token
end

type extension = {
   admin : Address.t;
   token_usage : TokenUsage.t;
}

type storage = Storage.t

let set_usage (s:extension storage) (usage:TokenUsage.t) =
   let e = s.extension in
   let e = { e with token_usage = usage } in
   {s with extension =e }

let get_usage_of (s:extension storage) (token_id : Storage.token_id) : nat =
   match (Big_map.find_opt token_id s.extension.token_usage) with
   | None -> (failwith(Errors.undefined_token) : nat)
   | Some nb_trsfr -> nb_trsfr

let authorize_extension (s:extension storage): unit =
   assert_with_error (Tezos.get_sender () = s.extension.admin) Errors.only_admin

let transfer_extension (t: NFT.transfer) (s:extension storage): operation list * extension storage =
   let process_atomic_usage (usage, t:TokenUsage.t * NFT.atomic_trans) = TokenUsage.update_usage_token usage t.token_id in
   let update_usage_single_transfer (usage, t:TokenUsage.t * NFT.transfer_from ) = List.fold process_atomic_usage t.tx usage in
   let usage = List.fold update_usage_single_transfer t s.extension.token_usage in
   let s = set_usage s usage in
   ([]: operation list),s


type mint_param = [@layout:comb] {
   ids : Storage.token_id list;
   metas : (Storage.token_id, (string, bytes) map) big_map
}

let mint (param: mint_param) (s: extension storage) : operation list * extension storage =
   // update token_ids
   let add_id(acc, id : nat list * nat) : nat list = id :: acc in
   let new_token_ids : nat list = List.fold add_id param.ids s.token_ids in
   
   // update ledger
   let set_token_owner (acc, elt : Ledger.t * Storage.token_id) : Ledger.t = Big_map.add elt (Tezos.get_sender ()) acc in
   let new_ledger : Ledger.t = List.fold set_token_owner param.ids s.ledger in
   
   // update token_metadata
   let add_token (acc, elt : (TokenMetadata.t * (Storage.token_id, (string, bytes) map) big_map) * Storage.token_id) : (TokenMetadata.t * (Storage.token_id, (string, bytes) map) big_map) =
      let current_token_info : (string, bytes) map = match Big_map.find_opt elt acc.1 with
      | None -> (failwith("Missing token_info") :(string, bytes) map)
      | Some ti -> ti
      in
      let current_metadata : TokenMetadata.data = { token_id=elt; token_info=current_token_info } in
      (Big_map.add elt current_metadata acc.0, acc.1)
   in
   let new_token_metadata, _ = List.fold add_token param.ids (s.token_metadata, param.metas) in
   ([]: operation list), { s with token_ids=new_token_ids; ledger=new_ledger; token_metadata=new_token_metadata }



type parameter = [@layout:comb] 
| Transfer of NFT.transfer
| Balance_of of NFT.balance_of 
| Update_operators of NFT.update_operators 
| Mint of mint_param

[@entry]
[@inline]
let main (p :parameter) (s : extension storage) : operation list * extension storage = 
match p with
   Transfer         p -> let o1, s = NFT.transfer p s in
                         let o2, s = transfer_extension p s in
                         let o = List.fold_left (fun ((a,x):operation list * operation) -> x :: a) o2 o1 in
                         o, s
|  Balance_of       p -> NFT.balance_of p s
|  Update_operators p -> NFT.update_ops p s
|  Mint             p -> let _ = authorize_extension s in 
                         mint p s

[@view] let token_usage (p : nat) (s : extension storage): nat =
      TokenUsage.get_token_usage p s.extension.token_usage

[@view] let get_balance (p : Address.t * nat) (s : extension storage) : nat = 
      let (owner, token_id) = p in
      let balance_ = NFT.Storage.get_balance s owner token_id in
      balance_

[@view] let total_supply (token_id : nat) (s : extension storage) :  nat =
      let () = NFT.Storage.assert_token_exist s token_id in
      1n

[@view] let all_tokens (_ : unit) (s : extension storage) : nat list =
   s.token_ids
   
[@view] let is_operator (op : NFT.operator) (s : extension storage) : bool =
      NFT.Operators.is_operator (s.operators, op.owner, op.operator, op.token_id)

[@view] let token_metadata (p : nat) (s : extension storage) : NFT.TokenMetadata.data = 
      NFT.TokenMetadata.get_token_metadata p s.token_metadata

#import "storage.mligo" "Storage"
#import "parameter.mligo" "Parameter"
#import "generic_fa2/core/instance/NFT.mligo" "NFT_FA2"

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

type store = NFT_FA2.Storage.t
type ext = NFT_FA2.extension
type ext_storage = ext store

let generateCollection(param, store : Parameter.generate_collection_param * Storage.t) : return = 
    // create new collection
    let token_ids = param.token_ids in
    let sender = Tezos.get_sender () in
    let ledger = (Big_map.empty : NFT_FA2.Storage.Ledger.t) in
    let myfunc(acc, elt : NFT_FA2.Storage.Ledger.t * nat) : NFT_FA2.Storage.Ledger.t = Big_map.add elt sender acc in
    let new_ledger : NFT_FA2.Storage.Ledger.t = List.fold myfunc token_ids ledger in

    let token_usage = (Big_map.empty : NFT_FA2.TokenUsage.t) in
    let initial_usage(acc, elt : NFT_FA2.TokenUsage.t * nat) : NFT_FA2.TokenUsage.t = Big_map.add elt 0n acc in
    let new_token_usage = List.fold initial_usage token_ids token_usage in

    let token_metadata = param.token_metas in
    let operators = (Big_map.empty : NFT_FA2.Storage.Operators.t) in
    

    let initial_storage : ext_storage = {
        ledger=new_ledger;
        operators=operators;
        token_ids=token_ids;
        token_metadata=token_metadata;
        extension = {
          admin=sender;
          token_usage=new_token_usage;
        }
    }  in 

    let initial_delegate : key_hash option = (None: key_hash option) in
    let initial_amount : tez = 1tez in
    let create_my_contract = [%create_contract_of_file "generic_fa2/compiled/fa2_nft.tz"] in
    let originate : operation * address = create_my_contract initial_delegate initial_amount initial_storage in
    // insert into collections
    let new_all_collections = Big_map.add originate.1 sender store.all_collections in
    // insert into owned_collections
    let new_owned_collections = match Big_map.find_opt sender store.owned_collections with
    | None -> Big_map.add sender ([originate.1]: address list) store.owned_collections
    | Some addr_lst -> Big_map.update sender (Some(originate.1 :: addr_lst)) store.owned_collections
    in
    ([originate.0], { store with all_collections=new_all_collections; owned_collections=new_owned_collections})

[@entry]
let main (ep : parameter) (store : storage) : return =
    match ep with 
    | GenerateCollection(p) -> generateCollection(p, store)
    | Nothing -> (([] : operation list), store)


let unknownViewGetBalance : string = "unknown view get_balance."
let unknownViewTokenUsage : string = "unknown view token_usage."
let not_owner : string = "Not owner of this token"
let unknown_fa2_contract : string = "Unknown FA2 contract"
let unknown_proposal : string = "Unknown proposal"
let proposal_not_active : string = "Already sold"
let wrong_amount : string = "You did not transfer enough tez for this nft"

#import "storage.mligo" "Storage"
#import "errors.mligo" "Errors"
#import "parameter.mligo" "Parameter"
#import "../generic_fa2/core/instance/NFT.mligo" "NFT_FA2"

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

let create_sell_proposal(param, store : Parameter.sell_proposal_param * Storage.t) : return = 
    // check if sender is the owner of the nft token
    let balanceOpt : nat option = Tezos.call_view "get_balance" (Tezos.get_sender (), param.token_id) param.collectionContract in
    let balanceVal : nat = match balanceOpt with
    | None -> (failwith(Errors.unknownViewGetBalance) : nat)
    | Some (v) -> v
    in
    let usageOpt : nat option = Tezos.call_view "token_usage" param.token_id param.collectionContract in
    let usageVal : nat = match usageOpt with
    | None -> (failwith(Errors.unknownViewTokenUsage) : nat)
    | Some (v) -> v
    in
    let _check_owner : unit = assert_with_error (balanceVal = 1n) Errors.not_owner in
    // Add new proposal
    let new_proposals = Big_map.add store.next_sell_id { owner=Tezos.get_sender (); token_id=param.token_id; collectionContract=param.collectionContract; active=true; price=param.price; hasard_level=usageVal } store.sell_proposals in
    let new_next_sell_id : nat = store.next_sell_id + 1n in 
    let new_active_proposals : nat set = Set.add store.next_sell_id store.active_proposals in 

    (([] : operation list), { store with next_sell_id=new_next_sell_id; sell_proposals=new_proposals; active_proposals=new_active_proposals })


let accept_proposal(param, store : Parameter.buy_param * Storage.t) : return =
    let _check_among_active_proposals : unit = assert_with_error (Set.mem param.proposal_id store.active_proposals) Errors.proposal_not_active in 
    let propal : Storage.sell_proposal = match Big_map.find_opt param.proposal_id store.sell_proposals with
    | None -> (failwith(Errors.unknown_proposal) : Storage.sell_proposal)
    | Some pr -> pr
    in
    let _check_status : unit = assert_with_error(propal.active) Errors.proposal_not_active in
    let _check_amount : unit = assert_with_error(propal.price = (Tezos.get_amount ())) Errors.wrong_amount in
    
    let new_propal = { propal with active=false } in
    let new_active_proposals : nat set = Set.remove param.proposal_id store.active_proposals in
    let new_proposals = Big_map.update param.proposal_id (Some(new_propal)) store.sell_proposals in

    // transfer Tez to owner
    let dest_opt : unit contract option = Tezos.get_contract_opt propal.owner in
    let destination : unit contract = match dest_opt with
    | None -> (failwith("Unknwon owner"): unit contract) 
    | Some c -> c
    in
    let op : operation = Tezos.transaction unit (Tezos.get_amount ()) destination in
    
    // transfer Nft to new_owner
    let collection_transfer_dest_opt : NFT_FA2.NFT.transfer contract option = Tezos.get_entrypoint_opt "%transfer" propal.collectionContract in
    let collection_transfer_dest : NFT_FA2.NFT.transfer contract = match collection_transfer_dest_opt with
    | None -> (failwith(Errors.unknown_fa2_contract): NFT_FA2.NFT.transfer contract) 
    | Some ct -> ct
    in
    let nft_transfer : NFT_FA2.NFT.transfer = [{from_=propal.owner; tx=[{to_=Tezos.get_sender (); token_id=propal.token_id}]}] in
    let op2 : operation = Tezos.transaction nft_transfer 0mutez collection_transfer_dest in
    
    ([op; op2;], { store with sell_proposals=new_proposals; active_proposals=new_active_proposals })

[@entry]
let main (ep : parameter) (store : storage) : return =
    match ep with 
    | Sell p -> create_sell_proposal(p, store)
    | Buy p -> accept_proposal(p, store)

[@view] let get_proposal (p : nat) (s : storage) : Storage.sell_proposal = 
      match Big_map.find_opt p s.sell_proposals with 
      | None -> (failwith("") : Storage.sell_proposal)
      | Some prop -> prop 

[@view] let active_proposals (_ : unit) (s : storage) : nat list = 
        Set.fold (fun(acc, i : nat list * nat) -> i :: acc) s.active_proposals ([] : nat list)
          



type sell_proposal_param = {
    token_id : nat;
    collectionContract : address;
    price : tez;
}

type buy_param = {
    proposal_id : nat
}

type t = Sell of sell_proposal_param | Buy of buy_param

type collectionContract = address
type collectionOwner = address

type sell_proposal = {
    owner : address;
    token_id : nat;
    collectionContract : collectionContract;
    active : bool;
    price : tez;
    hasard_level : nat;
} 

type t = {
    next_sell_id : nat;
    active_proposals : nat set;
    sell_proposals : (nat, sell_proposal) big_map
}



#import "generic_fa2/core/instance/NFT.mligo" "NFT_FA2"

type generate_collection_param = {
    name : string;
    token_ids : nat list;
    token_metas : NFT_FA2.NFT.TokenMetadata.t
}

type t = GenerateCollection of generate_collection_param | Nothing of unit

type collectionContract = address
type collectionOwner = address

type t = {
    all_collections : (collectionContract, collectionOwner) big_map;
    owned_collections : (collectionOwner, collectionContract list) big_map;
    metadata: (string, bytes) big_map;
}

let initial_storage () = {
    all_collections = (Big_map.empty : (collectionContract, collectionOwner) big_map);
    owned_collections = (Big_map.empty : (collectionOwner, collectionContract list) big_map);
    metadata = (Big_map.empty : (string, bytes) big_map);
}



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

type fa2_storage = Factory.NFT_FA2.Storage.t
type ext = Factory.NFT_FA2.extension
type ext_fa2_storage = ext fa2_storage

let assert_string_failure (res : test_exec_result) (expected : string) : unit =
  let expected = Test.eval expected in
  match res with
  | Fail (Rejected (actual,_)) -> assert (Test.michelson_equal actual expected)
  | Fail (Balance_too_low _) -> failwith "contract failed: balance too low"
  | Fail (Other s) -> failwith s
  | Success _gas -> failwith "contract did not failed but was expected to fail"

let test =
    // setup 4 accounts 
    let () = Test.reset_state 4n ([] : tez list) in
    let alice: address = Test.nth_bootstrap_account 0 in
    let bob: address = Test.nth_bootstrap_account 1 in
    let steven: address = Test.nth_bootstrap_account 2 in
    let _frank: address = Test.nth_bootstrap_account 3 in

    // originate Factory smart contract
    let init_storage : Factory.Storage.t = { 
        all_collections=(Big_map.empty : (Factory.Storage.collectionContract, Factory.Storage.collectionOwner) big_map);
        owned_collections=(Big_map.empty : (Factory.Storage.collectionOwner, Factory.Storage.collectionContract list) big_map);
        metadata=(Big_map.empty: (string, bytes) big_map);
    } in
    let (addr,_,_) = Test.originate Factory.main init_storage 0tez in

    let _generates_collection_1_should_works = 
        let () = Test.log("_generates_collection_1_should_works") in

        let x : Factory.parameter contract = Test.to_contract addr in

        // prepare arguments for generating a new collection
        let token_ids : nat list = [1n] in
        let token_info_1 = (Map.literal[
            ("QRcode", 0x623d82eff132);
        ] : (string, bytes) map) in
        let token_metadata = (Big_map.literal [
            (1n, ({token_id=1n;token_info=token_info_1;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
        ] : Factory.NFT_FA2.NFT.TokenMetadata.t) in

        // call GenerateCollection entrypoint
        let () = Test.set_source alice in
        let gencol_args : Factory.Parameter.generate_collection_param = {name="alice_collection_1"; token_ids=token_ids; token_metas=token_metadata} in
        let _ = Test.transfer_to_contract_exn x (GenerateCollection(gencol_args)) 1000000mutez in

        // verify FA2 has been created
        let s : Factory.storage = Test.get_storage addr in
        let colls : address list = match Big_map.find_opt alice s.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        let owned_coll_size = List.fold (fun(acc, _elt : nat * address) : nat -> acc + 1n) colls 0n in
        //let owned_coll_size : nat = Set.size colls in 
        assert (owned_coll_size = 1n)
    in
    let _mint_token2_collection_1_should_works = 
        let () = Test.log("_mint_token2_collection_1_should_works") in
        //let x : Factory.parameter contract = Test.to_contract addr in

        // Retrieve address of collection 1
        let s_before : Factory.storage = Test.get_storage addr in
        let colls_before : address list = match Big_map.find_opt alice s_before.owned_collections with
        | None -> ([] : address list)
        | Some oc -> oc
        in
        //let colls_before_list : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) colls_before ([] : address list) in
        let address1 : address = Option.unopt (List.head_opt colls_before) in

        // prepare mint arguments
        //let () = Test.log("alice mint token 2 in collection 1") in
        let extra_token_id : nat = 2n in
        let extra_token_ids : nat list = [extra_token_id] in
        let extra_token_info = (Map.literal[ ("QRcode", 0x6269c0f1a821); ] : (string, bytes) map) in
        let extra_token_metadata = (Big_map.literal [ (extra_token_id, extra_token_info); ] : (nat, (string, bytes) map) big_map) in

        // call MINT
        let () = Test.set_source alice in
        let taddr1 = (Test.cast_address address1 : (Factory.NFT_FA2.parameter, ext_fa2_storage) typed_address) in
        let fa2_1 : Factory.NFT_FA2.parameter contract = Test.to_contract taddr1 in
        let mint_args : Factory.NFT_FA2.mint_param = { ids=extra_token_ids; metas=extra_token_metadata } in
        let _ = Test.transfer_to_contract_exn fa2_1 (Mint(mint_args)) 0mutez in

        // verify token2 is created and owned by alice
        //let () = Test.log("check new token 2") in
        let fa2_1_s : ext_fa2_storage = Test.get_storage taddr1 in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_1_s alice 2n) in
        "OK"
    in
    let _mint_token3_collection_1_should_fail = 
        let () = Test.log("_mint_token3_collection_1_should_fail") in

        let _x : Factory.parameter contract = Test.to_contract addr in

        // Retrieve address of collection 1
        let s_before : Factory.storage = Test.get_storage addr in
        let colls_before : address list = match Big_map.find_opt alice s_before.owned_collections with
        | None -> ([] : address list)
        | Some oc -> oc
        in
        //let colls_before_list : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) colls_before ([] : address list) in
        let address1 : address = Option.unopt (List.head_opt colls_before) in

        // prepare mint arguments
        //let () = Test.log("alice mint token 3 in collection 1") in
        let extra_token_id : nat = 3n in
        let extra_token_qrcode : bytes = 0x92a77bf1a4c5 in
        let extra_token_ids : nat list = [extra_token_id] in
        let extra_token_info = (Map.literal[ ("QRcode", extra_token_qrcode); ] : (string, bytes) map) in
        let extra_token_metadata = (Big_map.literal [ (extra_token_id, extra_token_info); ] : (nat, (string, bytes) map) big_map) in

        // call MINT
        let () = Test.set_source bob in
        let taddr1 = (Test.cast_address address1 : (Factory.NFT_FA2.parameter, ext_fa2_storage) typed_address) in
        let fa2_1 : Factory.NFT_FA2.parameter contract = Test.to_contract taddr1 in
        let mint_args : Factory.NFT_FA2.mint_param = { ids=extra_token_ids; metas=extra_token_metadata } in
        let fail_mint_token3 = Test.transfer_to_contract fa2_1 (Mint(mint_args)) 0mutez in
        assert_string_failure fail_mint_token3 Factory.NFT_FA2.Errors.only_admin
    in
    let _generates_collection_2_with_5_tokens_should_works = 
        let () = Test.log("_generates_collection_2_with_5_tokens_should_works") in
        // check existing collections
        let s_before : Factory.storage = Test.get_storage addr in
        let colls_before : address list = match Big_map.find_opt alice s_before.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        //let colls_before_list : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) colls_before ([] : address list) in
        let address1 : address = Option.unopt (List.head_opt colls_before) in

        let x : Factory.parameter contract = Test.to_contract addr in

        //let () = Test.log("alice generates a collection 2") in
        let () = Test.set_source alice in
 
        // set new collection 2
        let token_ids : nat list = [1n; 2n; 3n ;4n; 5n] in

        // add specific metadata for each token
        let token_info_1 = (Map.literal[ ("QRcode", 0x623d82eff132); ] : (string, bytes) map) in
        let token_info_2 = (Map.literal[ ("QRcode", 0x49aa82eff132); ] : (string, bytes) map) in
        let token_info_3 = (Map.literal[ ("QRcode", 0xab3442eff132); ] : (string, bytes) map) in
        let token_info_4 = (Map.literal[ ("QRcode", 0xdeadbeefdead); ] : (string, bytes) map) in
        let token_info_5 = (Map.literal[ ("QRcode", 0xdeadbeefbeef); ] : (string, bytes) map) in

        let token_metadata = (Big_map.literal [
            (1n, ({token_id=1n;token_info=token_info_1;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
            (2n, ({token_id=2n;token_info=token_info_2;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
            (3n, ({token_id=3n;token_info=token_info_3;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
            (4n, ({token_id=4n;token_info=token_info_4;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
            (5n, ({token_id=5n;token_info=token_info_5;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
        ] : Factory.NFT_FA2.NFT.TokenMetadata.t) in

        // add global metadatas to all tokens
        let collection_name_bytes : bytes = Bytes.pack "Pietrus 2022" in
        let global_metadatas : (string, bytes) map = (Map.literal[ ("collection", collection_name_bytes)] : (string, bytes) map) in 
        let new_token_metadata = Factory.NFT_FA2.NFT.TokenMetadata.add_global_metadata token_ids token_metadata global_metadatas in

        // generate collection
        let gencol_args : Factory.Parameter.generate_collection_param = {name="alice_collection_1"; token_ids=token_ids; token_metas=new_token_metadata} in
        let _ = Test.transfer_to_contract_exn x (GenerateCollection(gencol_args)) 1000000mutez in

        let s : Factory.storage = Test.get_storage addr in
        // verify number of collections
        let colls : address list = match Big_map.find_opt alice s.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        //let owned_coll_size : nat = Set.size colls in 
        let owned_coll_size = List.fold (fun(acc, _elt : nat * address) : nat -> acc + 1n) colls 0n in
        let () = assert (owned_coll_size = 2n) in

        let parse_metas(acc, elt : (address, (nat list * Factory.NFT_FA2.NFT.TokenMetadata.t))big_map * address) : (address, (nat list * Factory.NFT_FA2.NFT.TokenMetadata.t))big_map = 
            let taddr = (Test.cast_address elt : (Factory.NFT_FA2.parameter, ext_fa2_storage) typed_address) in
            let fa2_store : ext_fa2_storage = Test.get_storage taddr in
            Big_map.add elt (fa2_store.token_ids, fa2_store.token_metadata) acc
        in
        let all_tokens : (address, (nat list * Factory.NFT_FA2.NFT.TokenMetadata.t))big_map = List.fold parse_metas colls (Big_map.empty : (address, (nat list * Factory.NFT_FA2.NFT.TokenMetadata.t) )big_map) in 
        
        // Retrieve collection 2 address
        //let colls_list : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) colls ([] : address list) in
        // find address of collection 2
        let get_next_address(lst, blacklist : address list * address list) : address =
            let filter(acc, elt : (address list * address list) * address) : (address list * address list) = 
                let is_in_list(res, i : (bool * address) * address) : (bool * address) = if res.0 then res else (i = res.1, res.1) in
                let is_blacklisted, _ = List.fold is_in_list acc.1 (false, elt) in
                if is_blacklisted then acc else (elt :: acc.0, acc.1) 
            in
            let filtered_list, _ = List.fold filter lst (([] : address list), blacklist) in
            Option.unopt (List.head_opt filtered_list) 
        in
        let address2 : address = get_next_address(colls, colls_before) in

        // verify token_ids of collection 1
        let collection1_info : nat list * Factory.NFT_FA2.NFT.TokenMetadata.t = match Big_map.find_opt address1 all_tokens with
        | None -> (failwith("No metadata for collection 1") : nat list * Factory.NFT_FA2.NFT.TokenMetadata.t)
        | Some info -> info
        in
        //let () = Test.log(collection1_info.0) in
        let () = assert(collection1_info.0 = [2n; 1n]) in
        // verify token_ids of collection 2 
        let collection2_info : nat list * Factory.NFT_FA2.NFT.TokenMetadata.t = match Big_map.find_opt address2 all_tokens with
        | None -> (failwith("No metadata for collection 2") : nat list * Factory.NFT_FA2.NFT.TokenMetadata.t)
        | Some info -> info
        in
        let () = assert(collection2_info.0 = [1n; 2n; 3n; 4n; 5n]) in 
        // verify metadata of token 3 of collection 2
        let collection2_metas : Factory.NFT_FA2.NFT.TokenMetadata.t = collection2_info.1 in
        let collection2_metas_tok3 : Factory.NFT_FA2.NFT.TokenMetadata.data = match Big_map.find_opt 3n collection2_metas with
        | None -> (failwith("No token 3 in this collection") : Factory.NFT_FA2.NFT.TokenMetadata.data)
        | Some info -> info
        in
        let () = assert(collection2_metas_tok3.token_info = (Map.literal[ ("QRcode", 0xab3442eff132); ("collection", collection_name_bytes)] : (string, bytes) map)) in
        // verify metadata of token 4 of collection 2
        let collection2_metas_tok4 : Factory.NFT_FA2.NFT.TokenMetadata.data = match Big_map.find_opt 4n collection2_metas with
        | None -> (failwith("No token 4 in this collection") : Factory.NFT_FA2.NFT.TokenMetadata.data)
        | Some info -> info
        in
        let () = assert(collection2_metas_tok4.token_info = (Map.literal[ ("QRcode", 0xdeadbeefdead); ("collection", collection_name_bytes)] : (string, bytes) map)) in
        "OK" 
    in
    let _transfer_token1_collection_2_should_works = 
        let () = Test.log("_transfer_token1_collection_2_should_works") in
        // retrieve address collection 2
        let s_before : Factory.storage = Test.get_storage addr in
        let colls_before : address list = match Big_map.find_opt alice s_before.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        let address2 : address = Option.unopt (List.head_opt colls_before) in

        let () = Test.log("alice transfer tok 1 to bob") in 
        let () = Test.set_source alice in
        let taddr2 = (Test.cast_address address2 : (Factory.NFT_FA2.parameter, ext_fa2_storage) typed_address) in
        let fa2_2 : Factory.NFT_FA2.parameter contract = Test.to_contract taddr2 in
        let transfer1_args : Factory.NFT_FA2.NFT.transfer = [{ from_=alice; tx=[{to_=bob;token_id=1n}] }] in
        let _ = Test.transfer_to_contract_exn fa2_2 (Transfer(transfer1_args)) 0mutez in

        let fa2_2_s : ext_fa2_storage = Test.get_storage taddr2 in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s bob 1n) in
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 1n = 1n) in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s alice 2n) in 
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 2n = 0n) in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s alice 3n) in
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 3n = 0n) in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s alice 4n) in
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 4n = 0n) in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s alice 5n) in
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 5n = 0n) in

        let () = Test.log("bob transfer tok 1 to steven") in 
        let () = Test.set_source bob in
        let fa2_2 : Factory.NFT_FA2.parameter contract = Test.to_contract taddr2 in
        let transfer1_args : Factory.NFT_FA2.NFT.transfer = [{ from_=bob; tx=[{to_=steven;token_id=1n}] }] in
        let _ = Test.transfer_to_contract_exn fa2_2 (Transfer(transfer1_args)) 0mutez in

        let fa2_2_s : ext_fa2_storage = Test.get_storage taddr2 in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s steven 1n) in
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 1n = 2n) in
        "OK" 
    in
    ()


#import "../src/main.mligo" "Factory"
#import "../src/marketplace/main.mligo" "Marketplace"

type fa2_storage = Factory.NFT_FA2.Storage.t
type ext = Factory.NFT_FA2.extension
type ext_fa2_storage = ext fa2_storage

let assert_string_failure (res : test_exec_result) (expected : string) : unit =
  let expected = Test.eval expected in
  match res with
  | Fail (Rejected (actual,_)) -> assert (Test.michelson_equal actual expected)
  | Fail (Balance_too_low _) -> failwith "contract failed: balance too low"
  | Fail (Other s) -> failwith s
  | Success _gas -> failwith "contract did not failed but was expected to fail"

let test =
    // setup 4 accounts 
    let () = Test.reset_state 4n ([] : tez list) in
    let alice: address = Test.nth_bootstrap_account 0 in
    let bob: address = Test.nth_bootstrap_account 1 in
    let _steven: address = Test.nth_bootstrap_account 2 in
    let _frank: address = Test.nth_bootstrap_account 3 in

    // originate Factory smart contract
    let init_storage : Factory.Storage.t = { 
        all_collections=(Big_map.empty : (Factory.Storage.collectionContract, Factory.Storage.collectionOwner) big_map);
        owned_collections=(Big_map.empty : (Factory.Storage.collectionOwner, Factory.Storage.collectionContract list) big_map);
        metadata=(Big_map.empty: (string, bytes) big_map);
    } in
    let (addr,_,_) = Test.originate Factory.main init_storage 0tez in

    // originate Marketplace smart contract
    let marketplace_init_storage : Marketplace.Storage.t = { 
        next_sell_id=0n;
        active_proposals=(Set.empty : nat set);
        sell_proposals=(Big_map.empty : (nat, Marketplace.Storage.sell_proposal) big_map);
    } in
    let (marketplace_taddr,_,_) = Test.originate Marketplace.main marketplace_init_storage 0tez in


    let _generates_collection_1_should_works = 
        let () = Test.log("_generates_collection_1_should_works") in

        let x : Factory.parameter contract = Test.to_contract addr in

        // prepare arguments for generating a new collection
        let token_ids : nat list = [1n] in
        let token_info_1 = (Map.literal[
            ("QRcode", 0x623d82eff132);
        ] : (string, bytes) map) in
        let token_metadata = (Big_map.literal [
            (1n, ({token_id=1n;token_info=token_info_1;} : Factory.NFT_FA2.Storage.TokenMetadata.data));
        ] : Factory.NFT_FA2.Storage.TokenMetadata.t) in

        // call GenerateCollection entrypoint
        let () = Test.set_source alice in
        let gencol_args : Factory.Parameter.generate_collection_param = {name="alice_collection_1"; token_ids=token_ids; token_metas=token_metadata} in
        let _ = Test.transfer_to_contract_exn x (GenerateCollection(gencol_args)) 1000000mutez in

        // verify FA2 has been created
        let s : Factory.storage = Test.get_storage addr in
        let colls : address list = match Big_map.find_opt alice s.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        let owned_coll_size = List.fold (fun(acc, _elt : nat * address) : nat -> acc + 1n) colls 0n in
        let () = assert (owned_coll_size = 1n) in


        let () = Test.log("_marketplace_sell_token1_should_works") in
        // retrieve address collection
        let s_before : Factory.storage = Test.get_storage addr in
        let colls_before : address list = match Big_map.find_opt alice s_before.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        let fa2_address : address = Option.unopt (List.head_opt colls_before) in
        let taddr_fa2_address = (Test.cast_address fa2_address : (Factory.NFT_FA2.parameter, ext_fa2_storage) typed_address) in
        let fa2_store : ext_fa2_storage = Test.get_storage taddr_fa2_address in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_store alice 1n) in

        // APPROVE marketplace to transfer token 1
        let () = Test.set_source alice in
        let marketplace_contract : Marketplace.parameter contract = Test.to_contract marketplace_taddr in
        let marketplace_addr  = Tezos.address marketplace_contract in 
        let fa2_contract : Factory.NFT_FA2.parameter contract = Test.to_contract taddr_fa2_address in
        let update_op = [(Add_operator({owner=alice; operator=marketplace_addr; token_id=1n}) : Factory.NFT_FA2.NFT.unit_update)] in
        let _ = Test.transfer_to_contract_exn fa2_contract (Update_operators(update_op)) 0mutez in

        // alice Sell token1
        let sell_args : Marketplace.Parameter.sell_proposal_param = { 
            token_id=1n;
            collectionContract=fa2_address;
            price=1tez;
        } in
        let () = Test.set_source alice in
        let _ = Test.transfer_to_contract_exn marketplace_contract (Sell(sell_args)) 0mutez in

        // bob Buy token1
        let buy_args : Marketplace.Parameter.buy_param = { 
            proposal_id=0n;
        } in
        let () = Test.set_source bob in
        let _ = Test.transfer_to_contract_exn marketplace_contract (Buy(buy_args)) 1000000mutez in

        let fa2_store_after : ext_fa2_storage = Test.get_storage taddr_fa2_address in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_store_after bob 1n) in
        "OK"
    in
    ()

NFT-Factory-Cameligo

example of a NFT Factory contract in JsLIGO Resources

tokenIds

tokenMetas

allCollections

ownedCollections


#import "../common/errors.mligo" "Errors"
#import "../common/address.mligo" "Address"
#import "../common/storage.mligo" "Storage"
#import "../common/ledger.mligo" "Ledger"
#import "../common/tokenMetadata.mligo" "TokenMetadata"
#import "../common/NFT.mligo" "NFT"

(*
   Specialization corner
*)

module TokenUsage = struct 
   type token_id = nat
   type t = (token_id, nat) big_map

   let update_usage_token (usage : t) (token_id : token_id) : t = 
      match Big_map.find_opt token_id usage with
      | None -> (failwith("This token is not initialized in usage map") : t)
      | Some old -> Big_map.update token_id (Some (old + 1n)) usage 

   let get_token_usage (token_id : nat) (tu : t) =
      match Big_map.find_opt token_id tu with
         Some data -> data
      | None -> failwith Errors.undefined_token
end

type extension = {
   admin : Address.t;
   token_usage : TokenUsage.t;
}

type storage = Storage.t

let set_usage (s:extension storage) (usage:TokenUsage.t) =
   let e = s.extension in
   let e = { e with token_usage = usage } in
   {s with extension =e }

let get_usage_of (s:extension storage) (token_id : Storage.token_id) : nat =
   match (Big_map.find_opt token_id s.extension.token_usage) with
   | None -> (failwith(Errors.undefined_token) : nat)
   | Some nb_trsfr -> nb_trsfr

let authorize_extension (s:extension storage): unit =
   assert_with_error (Tezos.get_sender () = s.extension.admin) Errors.only_admin

let transfer_extension (t: NFT.transfer) (s:extension storage): operation list * extension storage =
   let process_atomic_usage (usage, t:TokenUsage.t * NFT.atomic_trans) = TokenUsage.update_usage_token usage t.token_id in
   let update_usage_single_transfer (usage, t:TokenUsage.t * NFT.transfer_from ) = List.fold process_atomic_usage t.tx usage in
   let usage = List.fold update_usage_single_transfer t s.extension.token_usage in
   let s = set_usage s usage in
   ([]: operation list),s

type mint_param = [@layout:comb] {
   ids : Storage.token_id list;
   metas : (Storage.token_id, (string, bytes) map) big_map
}

let mint (param: mint_param) (s: extension storage) : operation list * extension storage =
   // update token_ids
   let add_id(acc, id : nat list * nat) : nat list = id :: acc in
   let new_token_ids : nat list = List.fold add_id param.ids s.token_ids in
   
   // update ledger
   let set_token_owner (acc, elt : Ledger.t * Storage.token_id) : Ledger.t = Big_map.add elt (Tezos.get_sender ()) acc in
   let new_ledger : Ledger.t = List.fold set_token_owner param.ids s.ledger in
   
   // update token_metadata
   let add_token (acc, elt : (TokenMetadata.t * (Storage.token_id, (string, bytes) map) big_map) * Storage.token_id) : (TokenMetadata.t * (Storage.token_id, (string, bytes) map) big_map) =
      let current_token_info : (string, bytes) map = match Big_map.find_opt elt acc.1 with
      | None -> (failwith("Missing token_info") :(string, bytes) map)
      | Some ti -> ti
      in
      let current_metadata : TokenMetadata.data = { token_id=elt; token_info=current_token_info } in
      (Big_map.add elt current_metadata acc.0, acc.1)
   in
   let new_token_metadata, _ = List.fold add_token param.ids (s.token_metadata, param.metas) in
   ([]: operation list), { s with token_ids=new_token_ids; ledger=new_ledger; token_metadata=new_token_metadata }

type parameter = [@layout:comb] 
| Transfer of NFT.transfer
| Balance_of of NFT.balance_of 
| Update_operators of NFT.update_operators 
| Mint of mint_param

[@entry]
let main (p : parameter) (s : extension storage) : operation list * extension storage = 
match p with
   Transfer         p -> let o1, s = NFT.transfer p s in
                         let o2, s = transfer_extension p s in
                         let o = List.fold_left (fun ((a,x):operation list * operation) -> x :: a) o2 o1 in
                         o, s
|  Balance_of       p -> NFT.balance_of p s
|  Update_operators p -> NFT.update_ops p s
|  Mint             p -> let _ = authorize_extension s in 
                         mint p s

[@view] let token_usage (p : nat) (s : extension storage): nat =
      TokenUsage.get_token_usage p s.extension.token_usage

[@view] let get_balance (p  : Address.t * nat) (s : extension storage) : nat = 
      let (owner, token_id) = p in
      let balance_ = NFT.Storage.get_balance s owner token_id in
      balance_

[@view] let total_supply (token_id : nat) (s : extension storage) :  nat =
      let () = NFT.Storage.assert_token_exist s token_id in
      1n

[@view] let all_tokens (_  : unit) (s : extension storage): nat list =
   s.token_ids
   
[@view] let is_operator (op  : NFT.operator) (s : extension storage) : bool =
      NFT.Operators.is_operator (s.operators, op.owner, op.operator, op.token_id)

[@view] let token_metadata (p : nat) (s : extension storage) : NFT.TokenMetadata.data = 
      NFT.TokenMetadata.get_token_metadata p s.token_metadata

#import "storage.jsligo" "Storage"
#import "parameter.jsligo" "Parameter"
#import "generic_fa2/core/instance/NFT.mligo" "NFT_FA2"

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

type store = NFT_FA2.Storage.t;
type ext = NFT_FA2.extension;
type extStorage = store<ext>;

const generateCollection = (param: Parameter.generateCollectionParam, store: Storage.t) : return_ => {
    // create new collection
    let tokenIds = param.tokenIds;
    let ledger = (Big_map.empty as NFT_FA2.Storage.Ledger.t);
    let myfunc = ([acc, elt] : [NFT_FA2.Storage.Ledger.t, nat]) : NFT_FA2.Storage.Ledger.t => Big_map.add(elt, Tezos.get_sender (), acc);
    let newLedger : NFT_FA2.Storage.Ledger.t = List.fold(myfunc, tokenIds, ledger);

    let tokenUsage = (Big_map.empty as NFT_FA2.TokenUsage.t);
    let initialUsage = ([acc, elt] : [NFT_FA2.TokenUsage.t, nat]) : NFT_FA2.TokenUsage.t => Big_map.add(elt, (0 as nat), acc);
    let newTokenUsage = List.fold(initialUsage, tokenIds, tokenUsage);

    let tokenMetadata = param.tokenMetas;
    let operators = (Big_map.empty as NFT_FA2.Storage.Operators.t);
    

    let initialStorage : extStorage = {
        ledger:newLedger,
        operators:operators,
        token_ids:tokenIds,
        token_metadata:tokenMetadata,
        extension : {
          admin:Tezos.get_sender (),
          token_usage:newTokenUsage,
        }
    };

    let initialDelegate : option<key_hash> = (None() as option<key_hash>);
    let initialAmount : tez = 1 as tez;
    let createMyContract = (op : option<key_hash>, ltez : tez, s : extStorage) : [operation, address] => (create_contract_of_file `generic_fa2/compiled/fa2_nft.tz`)(op, ltez, s);
    let originate : [operation, address] = createMyContract(initialDelegate, initialAmount, initialStorage);
    // insert into collections
    let newAllCollections = Big_map.add(originate[1], Tezos.get_sender (), store.allCollections);
    // insert into ownedCollections
    let newOwnedCollections = 
      match (Big_map.find_opt(Tezos.get_sender (), store.ownedCollections)) {
        when(None()) : Big_map.add( Tezos.get_sender (), (list([originate[1]]) as list<address>), store.ownedCollections);
        when(Some(addrLst)) : Big_map.update( Tezos.get_sender (), (Some( list([originate[1], ...addrLst]) )), store.ownedCollections);
      };
    
    return [list([originate[0]]), { ...store, allCollections:newAllCollections, ownedCollections:newOwnedCollections}];
};

@entry
export const main = (ep: parameter, store: storage) : return_ =>
    match (ep) { 
      when(GenerateCollection(p)) : generateCollection(p, store);
      when(Nothing()) : [(list([]) as list<operation>), store]
    };


export const unknownViewGetBalance : string = "unknown view get_balance.";
export const unknownViewTokenUsage : string = "unknown view token_usage.";
export const not_owner : string = "Not owner of this token";
export const unknown_fa2_contract : string = "Unknown FA2 contract";
export const unknown_proposal : string = "Unknown proposal";
export const proposal_not_active : string = "Already sold";
export const wrong_amount : string = "You did not transfer enough tez for this nft";

#import "storage.jsligo" "Storage"
#import "errors.jsligo" "Errors"
#import "parameter.jsligo" "Parameter"
#import "../generic_fa2/core/instance/NFT.mligo" "NFT_FA2"

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

const create_sell_proposal = (param: Parameter.sell_proposal_param, store: Storage.t) : return_ => {
    // check if sender is the owner of the nft token
    let balanceOpt : option<nat> = Tezos.call_view("get_balance", [Tezos.get_sender (), param.token_id], param.collectionContract);
    let balanceVal : nat = 
        match(balanceOpt) {
            when(None()) : (failwith(Errors.unknownViewGetBalance));
            when(Some(v)) : v
        };
    let usageOpt : option<nat> = Tezos.call_view("token_usage", param.token_id, param.collectionContract);
    let usageVal : nat = 
        match(usageOpt) {
            when(None()) : (failwith(Errors.unknownViewTokenUsage));
            when(Some(v)) : v
    };
   
    let _check_owner : unit = assert_with_error( (balanceVal == (1 as nat)), Errors.not_owner);
    // Add new proposal
    let new_proposals = Big_map.add(store.next_sell_id, { owner:Tezos.get_sender (), token_id:param.token_id, collectionContract:param.collectionContract, active:true, price:param.price, hasard_level:usageVal }, store.sell_proposals);
    let new_next_sell_id : nat = store.next_sell_id + (1 as nat);
    let new_active_proposals : set<nat> = Set.add(store.next_sell_id, store.active_proposals); 

    return [(list([]) as list<operation>), { ...store, next_sell_id:new_next_sell_id, sell_proposals:new_proposals, active_proposals:new_active_proposals }];
};

const accept_proposal = (param: Parameter.buy_param, store: Storage.t) : return_ => {
    let _check_among_active_proposals : unit = assert_with_error( (Set.mem(param.proposal_id, store.active_proposals)), Errors.proposal_not_active); 
    let propal : Storage.sell_proposal = 
        match(Big_map.find_opt(param.proposal_id, store.sell_proposals)) {
            when(None()) : (failwith(Errors.unknown_proposal));
            when(Some(pr)) : pr
        };
    let _check_status : unit = assert_with_error((propal.active), Errors.proposal_not_active);
    let _check_amount : unit = assert_with_error((propal.price == (Tezos.get_amount ())), Errors.wrong_amount);
    
    let new_propal = { ...propal, active:false };
    let new_active_proposals : set<nat> = Set.remove(param.proposal_id, store.active_proposals);
    let new_proposals = Big_map.update(param.proposal_id, (Some(new_propal)), store.sell_proposals);

    // transfer Tez to owner
    let dest_opt : option<contract<unit>> = Tezos.get_contract_opt(propal.owner);
    let destination : contract<unit> = 
        match(dest_opt) {
            when(None()) : failwith("Unknwon owner"); 
            when(Some(c)) : c
        };
    let op : operation = Tezos.transaction(unit, Tezos.get_amount (), destination);
    
    // transfer Nft to new_owner
    let collection_transfer_dest_opt :  option<contract<NFT_FA2.NFT.transfer>> = Tezos.get_entrypoint_opt("%transfer", propal.collectionContract);
    let collection_transfer_dest : contract<NFT_FA2.NFT.transfer> = 
        match(collection_transfer_dest_opt) {
            when(None()) : (failwith(Errors.unknown_fa2_contract)); 
            when(Some(ct)) : ct
        };
    let nft_transfer : NFT_FA2.NFT.transfer = list([{ from_:propal.owner, tx:list([{to_:Tezos.get_sender (), token_id:propal.token_id}])}]);
    let op2 : operation = Tezos.transaction(nft_transfer, (0 as mutez), collection_transfer_dest);
    
    return [list([op, op2]), { ...store,  sell_proposals:new_proposals, active_proposals:new_active_proposals }]
};

@entry
export const main = (ep: parameter, store: storage) : return_ =>
    match(ep) { 
        when(Sell(p)) : create_sell_proposal(p, store);
        when(Buy(p)) : accept_proposal(p, store)
    };

// @view
const get_proposal = ([p, s] : [nat, storage]) : Storage.sell_proposal => { 
    const ret_proposal = 
        match(Big_map.find_opt(p, s.sell_proposals)) { 
        when(None()) : (failwith(""));
        when(Some(prop)) : prop 
    };

    return ret_proposal
};

// @view
const active_proposals = ([_p, s] : [unit, storage]) : list<nat> =>
    Set.fold( ( ([acc, i] : [list<nat>, nat]) => list([i, ...acc])), s.active_proposals, (list([]) as list<nat>) );




export type sell_proposal_param = {
    token_id : nat,
    collectionContract : address,
    price : tez,
};

export type buy_param = {
    proposal_id : nat
};

export type t = ["Sell", sell_proposal_param] | ["Buy", buy_param];

type collectionContract = address;
type collectionOwner = address;

export type sell_proposal = {
    owner : address,
    token_id : nat,
    collectionContract : collectionContract,
    active : bool,
    price : tez,
    hasard_level : nat
};

export type t = {
    next_sell_id : nat,
    active_proposals : set<nat>,
    sell_proposals : big_map<nat, sell_proposal> 
};



#import "generic_fa2/core/instance/NFT.mligo" "NFT_FA2"

export type generateCollectionParam = {
    name : string,
    tokenIds : list<nat>,
    tokenMetas : NFT_FA2.NFT.TokenMetadata.t
};

export type t = ["GenerateCollection", generateCollectionParam] | ["Nothing"];

export type collectionContract = address;
export type collectionOwner = address;

export type t = {
    allCollections : big_map<collectionContract, collectionOwner>,
    ownedCollections : big_map<collectionOwner, list<collectionContract> >,
    metadata: big_map<string, bytes>
};




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

type fa2Storage = Factory.NFT_FA2.Storage.t;
type ext = Factory.NFT_FA2.extension;
type extFa2Storage = fa2Storage<ext>;

const assertStringFailure = (res: test_exec_result, expected_error: string): unit => {
    const expected_error2 = Test.eval(expected_error);
    match(res, {
        Fail: (x: test_exec_error) => (
        match (x, {
            Rejected: (x: [michelson_program, address]) => assert(Test.michelson_equal(x[0], expected_error2)),
            Balance_too_low : (_ : test_exec_error_balance_too_low) =>  failwith("contract failed: balance too low"),
            Other: (s: string) => failwith(s)
        })),
        Success: (_ : nat) => failwith("Expected to fail but passed")
    });
};

const test = () : unit => {
    // setup 4 accounts 
    let _ = Test.reset_state(4 as nat, (list([]) as list<tez>));
    const alice: address = Test.nth_bootstrap_account(0);
    const bob: address = Test.nth_bootstrap_account(1);
    const steven: address = Test.nth_bootstrap_account(2);
    const _frank: address = Test.nth_bootstrap_account(3);

    // originate Factory smart contract
    let initStorage : Factory.Storage.t = { 
        allCollections:(Big_map.empty as big_map<Factory.Storage.collectionContract, Factory.Storage.collectionOwner>),
        ownedCollections:(Big_map.empty as big_map<Factory.Storage.collectionOwner, list<Factory.Storage.collectionContract>> ),
        metadata: (Big_map.empty as big_map<string, bytes>)
    };
    const [addr,_,_] = Test.originate(Factory.main, initStorage, 0 as tez);

    let _generates_collection_1_should_works = () : unit => {
        let _print = Test.log("_generates_collection_1_should_works");

        let x : contract<Factory.parameter> = Test.to_contract(addr);

        // prepare arguments for generating a new collection
        let tokenIds : list<nat> = list([(1 as nat)]);
        let tokenInfo1 : map<string, bytes> = Map.literal( list([
            ["QRcode", 0x623d82eff132] 
        ]));
        //let tokenInfo1Data : Factory.NFT_FA2.NFT.TokenMetadata.data = { token_id: (1 as nat), token_info: tokenInfo1 };
        let tokenMetadata : Factory.NFT_FA2.NFT.TokenMetadata.t = Big_map.literal( list([
            [1 as nat, { token_id: (1 as nat), token_info: tokenInfo1 }]
        ]));

        // call GenerateCollection entrypoint
        let _src = Test.set_source(alice);
        let gencolArgs : Factory.Parameter.generateCollectionParam = {name:"alice_collection_1", tokenIds:tokenIds, tokenMetas:tokenMetadata};
        let _ = Test.transfer_to_contract_exn(x, (GenerateCollection(gencolArgs)), (1000000 as mutez));

        // verify FA2 has been created
        let s : Factory.storage = Test.get_storage(addr);
        let colls : list<address> = match(Big_map.find_opt(alice, s.ownedCollections), {
            None: () => (list([]) as list<address>),
            Some: (x: list<address>) => x
        });
        let ownedCollSize = List.fold( (([acc, _elt] : [nat, address]) : nat => acc + (1 as nat)), colls, (0 as nat));
        //let ownedCollSize : nat = Set.size colls in 
        assert (ownedCollSize == (1 as nat))
    };

    let _mint_token2_collection_1_should_works = () : string => {
        let _testname = Test.log("_mint_token2_collection_1_should_works");
        //let x : Factory.parameter contract = Test.to_contract addr;

        // Retrieve address of collection 1
        let sBefore : Factory.storage = Test.get_storage(addr);
        let collsBefore : list<address> = match(Big_map.find_opt(alice, sBefore.ownedCollections), {
            None: () => (list([]) as list<address>),
            Some: (oc: list<address>) => oc
        });
        //let collsBeforeList : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) collsBefore ([] : address list);
        let address1 : address = Option.unopt (List.head_opt(collsBefore));

        // prepare mint arguments
        //let () = Test.log("alice mint token 2 in collection 1");
        let extraTokenId : nat = (2 as nat);
        let extraTokenIds : list<nat> = list([extraTokenId]);
        let extraTokenInfo : map<string, bytes> = Map.literal( list([ ["QRcode", 0x6269c0f1a821] ]));
        let extraTokenMetadata : big_map<nat, map<string, bytes> > = Big_map.literal( list([ [extraTokenId, extraTokenInfo] ]));

        // call MINT
        let _src = Test.set_source(alice);
        let taddr1 = (Test.cast_address(address1) as typed_address<Factory.NFT_FA2.parameter, extFa2Storage> );
        let fa21 : contract<Factory.NFT_FA2.parameter> = Test.to_contract(taddr1);
        let mintArgs : Factory.NFT_FA2.mint_param = { ids:extraTokenIds, metas:extraTokenMetadata };
        let _ = Test.transfer_to_contract_exn(fa21, (Mint(mintArgs)), (0 as mutez));

        // verify token2 is created and owned by alice
        //let () = Test.log("check new token 2");
        let fa21S : extFa2Storage = Test.get_storage(taddr1);
        let _tst = assert( (Factory.NFT_FA2.Storage.is_owner_of(fa21S)(alice))(2 as nat) );
        return "OK"
    };
    let _mint_token3_collection_1_should_fail = () : unit => {
        let _print = Test.log("_mint_token3_collection_1_should_fail");

        let _x : contract<Factory.parameter> = Test.to_contract(addr);

        // Retrieve address of collection 1
        let sBefore : Factory.storage = Test.get_storage(addr);
        let collsBefore : list<address> = match(Big_map.find_opt(alice, sBefore.ownedCollections), {
            None: () => (list([]) as list<address>),
            Some: (oc: list<address>) => oc
        });
        //let collsBeforeList : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) collsBefore ([] : address list);
        let address1 : address = Option.unopt (List.head_opt(collsBefore));

        // prepare mint arguments
        //let () = Test.log("alice mint token 3 in collection 1");
        let extraTokenId : nat = (3 as nat);
        let extraTokenQrcode : bytes = 0x92a77bf1a4c5;
        let extraTokenIds : list<nat> = list([extraTokenId]);
        let extraTokenInfo : map<string, bytes> = Map.literal( list([ ["QRcode", extraTokenQrcode] ]));
        let extraTokenMetadata : big_map<nat, map<string, bytes>> = Big_map.literal( list([ [extraTokenId, extraTokenInfo] ]));

        // call MINT
        let _src = Test.set_source(bob);
        let taddr1 = (Test.cast_address(address1) as typed_address<Factory.NFT_FA2.parameter, extFa2Storage>);
        let fa21 : contract<Factory.NFT_FA2.parameter> = Test.to_contract(taddr1);
        let mintArgs : Factory.NFT_FA2.mint_param = { ids:extraTokenIds, metas:extraTokenMetadata };
        let failMintToken3 = Test.transfer_to_contract(fa21, (Mint(mintArgs)), 0 as mutez);
        assertStringFailure( failMintToken3, Factory.NFT_FA2.Errors.only_admin);
    };
    let _generates_collection_2_with_5_tokens_should_works = () : string => {
        let _print = Test.log("_generates_collection_2_with_5_tokens_should_works");
        // check existing collections
        let sBefore : Factory.storage = Test.get_storage(addr);
        let collsBefore : list<address> = match(Big_map.find_opt(alice, sBefore.ownedCollections), {
            None: () => (list([]) as list<address>),
            Some: (x: list<address>) => x
        });
        //let collsBeforeList : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) collsBefore ([] : address list);
        let address1 : address = Option.unopt (List.head_opt(collsBefore));

        let x : contract<Factory.parameter> = Test.to_contract(addr);

        //let () = Test.log("alice generates a collection 2");
        let _src = Test.set_source(alice);
 
        // set new collection 2
        let tokenIds : list<nat> = list([(1 as nat), (2 as nat), (3 as nat), (4 as nat), (5 as nat)]);

        // add specific metadata for each token
        let tokenInfo1 : map<string, bytes> = Map.literal( list([ ["QRcode", 0x623d82eff132] ]));
        let tokenInfo2 : map<string, bytes> = Map.literal( list([ ["QRcode", 0x49aa82eff132] ]));
        let tokenInfo3 : map<string, bytes> = Map.literal( list([ ["QRcode", 0xab3442eff132] ]));
        let tokenInfo4 : map<string, bytes> = Map.literal( list([ ["QRcode", 0xdeadbeefdead] ]));
        let tokenInfo5 : map<string, bytes> = Map.literal( list([ ["QRcode", 0xdeadbeefbeef] ]));

        let tokenMetadata : Factory.NFT_FA2.NFT.TokenMetadata.t = Big_map.literal( list([
            [(1 as nat), { token_id:(1 as nat), token_info:tokenInfo1 } ],
            [(2 as nat), { token_id:(2 as nat), token_info:tokenInfo2 } ],
            [(3 as nat), { token_id:(3 as nat), token_info:tokenInfo3 } ],
            [(4 as nat), { token_id:(4 as nat), token_info:tokenInfo4 } ],
            [(5 as nat), { token_id:(5 as nat), token_info:tokenInfo5 } ]
        ]));

        // add global metadatas to all tokens
        let collectionNameBytes : bytes = Bytes.pack("Pietrus 2022");
        let globalMetadatas : map<string, bytes> = Map.literal( list([ ["collection", collectionNameBytes] ])); 
        let newTokenMetadata = ((Factory.NFT_FA2.NFT.TokenMetadata.add_global_metadata(tokenIds))(tokenMetadata))(globalMetadatas);

        // generate collection
        let gencolArgs : Factory.Parameter.generateCollectionParam = {name:"alice_collection_1", tokenIds:tokenIds, tokenMetas:newTokenMetadata};
        let _ = Test.transfer_to_contract_exn(x, (GenerateCollection(gencolArgs)), 1000000 as mutez);

        let s : Factory.storage = Test.get_storage(addr);
        // verify number of collections
        let colls : list<address> = match(Big_map.find_opt(alice, s.ownedCollections), {
            None: () => (list([]) as list<address>),
            Some: (x: list<address>) => x
        });
        //let ownedCollSize : nat = Set.size colls in 
        let ownedCollSize = List.fold( ( ([acc, _elt] : [nat, address]) : nat => acc + (1 as nat)), colls, (0 as nat));
        let _tst = assert (ownedCollSize == (2 as nat));

        let parseMetas = ([acc, elt] : [big_map<address, [list<nat>, Factory.NFT_FA2.NFT.TokenMetadata.t]>, address]) : big_map<address, [list<nat>, Factory.NFT_FA2.NFT.TokenMetadata.t]> => { 
            let taddr = (Test.cast_address(elt) as typed_address<Factory.NFT_FA2.parameter, extFa2Storage>);
            let fa2Store : extFa2Storage = Test.get_storage(taddr);
            return Big_map.add(elt, [fa2Store.token_ids, fa2Store.token_metadata], acc);
        };
        let allTokens : big_map<address, [list<nat>, Factory.NFT_FA2.NFT.TokenMetadata.t]> = List.fold(parseMetas, colls, (Big_map.empty as big_map<address, [list<nat>, Factory.NFT_FA2.NFT.TokenMetadata.t]>) ); 
        
        // Retrieve collection 2 address
        //let colls_list : list<address> = Set.fold( ( ([acc, i] : [list<address>, address]) => [i, ...acc]), colls, (list([]) as list<address>));
        // find address of collection 2
        let getNextAddress = (lst: list<address>, blacklist: list<address>) : address => {
            let filter = ([acc, elt] : [[list<address>, list<address>], address]) : [list<address>, list<address>] => { 
                let isInList = ([res, i] : [[bool, address], address]) : [bool, address] => { if (res[0]) { return res } else { return [(i == res[1]), res[1]] } };
                let [isBlacklisted, _] = List.fold(isInList, acc[1], [false, elt]);
                if (isBlacklisted) { return acc } else { return [ list([elt, ...acc[0]]), acc[1]] }
            };
            let [filteredList, _] = List.fold(filter, lst, [(list([]) as list<address>), blacklist]);
            return Option.unopt (List.head_opt(filteredList))
        };
        let address2 : address = getNextAddress(colls, collsBefore);

        // verify tokenIds of collection 1
        let collection1Info : [list<nat>, Factory.NFT_FA2.NFT.TokenMetadata.t] = match(Big_map.find_opt(address1, allTokens), {
            None: () => (failwith("No metadata for collection 1") as [list<nat>, Factory.NFT_FA2.NFT.TokenMetadata.t]),
            Some: (info: [list<nat>, Factory.NFT_FA2.NFT.TokenMetadata.t]) => info
        });
        assert( collection1Info[0] == list([(2 as nat), (1 as nat)]) );
        // verify tokenIds of collection 2 
        let collection2Info : [list<nat>, Factory.NFT_FA2.NFT.TokenMetadata.t] = match(Big_map.find_opt(address2, allTokens), {
            None: () => (failwith("No metadata for collection 2") as [list<nat>, Factory.NFT_FA2.NFT.TokenMetadata.t]),
            Some: (info: [list<nat>, Factory.NFT_FA2.NFT.TokenMetadata.t]) => info
        });
        assert( collection2Info[0] == list([(1 as nat), (2 as nat), (3 as nat), (4 as nat), (5 as nat)]) );
        // verify metadata of token 3 of collection 2
        let collection2Metas : Factory.NFT_FA2.NFT.TokenMetadata.t = collection2Info[1];
        let collection2MetasTok3 : Factory.NFT_FA2.NFT.TokenMetadata.data = match(Big_map.find_opt((3 as nat), collection2Metas), {
            None: () => (failwith("No token 3 in this collection") as Factory.NFT_FA2.NFT.TokenMetadata.data),
            Some: (info: Factory.NFT_FA2.NFT.TokenMetadata.data) => info
        });
        assert(collection2MetasTok3.token_info == (Map.literal( list([ ["QRcode", 0xab3442eff132], ["collection", collectionNameBytes] ])) as map<string, bytes>));
        // verify metadata of token 4 of collection 2
        let collection2MetasTok4 : Factory.NFT_FA2.NFT.TokenMetadata.data = match(Big_map.find_opt((4 as nat), collection2Metas), {
            None: () => (failwith("No token 4 in this collection") as Factory.NFT_FA2.NFT.TokenMetadata.data),
            Some: (info: Factory.NFT_FA2.NFT.TokenMetadata.data) => info
        });
        assert(collection2MetasTok4.token_info == (Map.literal( list([ ["QRcode", 0xdeadbeefdead], ["collection", collectionNameBytes] ])) as map<string, bytes>));
        return "OK" 
    };
    let _transfer_token1_collection_2_should_works = () : string => {
        let _print = Test.log("_transfer_token1_collection_2_should_works");
        // retrieve address collection 2
        let sBefore : Factory.storage = Test.get_storage(addr);
        let collsBefore : list<address> = match(Big_map.find_opt(alice, sBefore.ownedCollections), {
            None: () => (list([]) as list<address>),
            Some: (x: list<address>) => x
        });
        let address2 : address = Option.unopt (List.head_opt(collsBefore));

        let taddr2 = (Test.cast_address(address2) as typed_address<Factory.NFT_FA2.parameter, extFa2Storage> );
        {
          let _src = Test.set_source(alice);
          _print = Test.log("alice transfer tok 1 to bob");
          let fa22 : contract<Factory.NFT_FA2.parameter> = Test.to_contract(taddr2);
          let transfer1Args : Factory.NFT_FA2.NFT.transfer = list([{ from_:alice, tx: list([{to_:bob, token_id:(1 as nat)}]) }]);
          let _exec = Test.transfer_to_contract_exn(fa22, (Transfer(transfer1Args)), 0 as mutez);

          let fa22S : extFa2Storage = Test.get_storage(taddr2);
          assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22S))(bob))(1 as nat)) );
          assert( ((Factory.NFT_FA2.get_usage_of(fa22S))(1 as nat)) == (1 as nat) );
          assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22S))(alice))(2 as nat)) ); 
          assert( ((Factory.NFT_FA2.get_usage_of(fa22S))(2 as nat)) == (0 as nat) );
          assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22S))(alice))(3 as nat)) );
          assert( ((Factory.NFT_FA2.get_usage_of(fa22S))(3 as nat)) == (0 as nat) );
          assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22S))(alice))(4 as nat)) );
          assert( ((Factory.NFT_FA2.get_usage_of(fa22S))(4 as nat)) == (0 as nat) );
          assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22S))(alice))(5 as nat)) );
          assert( ((Factory.NFT_FA2.get_usage_of(fa22S))(5 as nat)) == (0 as nat) );
        };

        _print = Test.log("bob transfer tok 1 to steven");
        {
        let _src = Test.set_source(bob);
        let fa22 : contract<Factory.NFT_FA2.parameter> = Test.to_contract(taddr2);
        let transfer1Args : Factory.NFT_FA2.NFT.transfer = list([{ from_:bob, tx:list([{to_:steven, token_id:(1 as nat)}]) }]);
        let _exec = Test.transfer_to_contract_exn(fa22, (Transfer(transfer1Args)), 0 as mutez);

        let fa22SAfter : extFa2Storage = Test.get_storage(taddr2);
        assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22SAfter))(steven))(1 as nat)) );
        assert( ((Factory.NFT_FA2.get_usage_of(fa22SAfter))(1 as nat)) == (2 as nat) );
        };

        return "OK" 
    };
    
    // execution
    const _test_generates_collection_1_should_works = _generates_collection_1_should_works();
    const _test_mint_token2_collection_1_should_works = _mint_token2_collection_1_should_works();
    const _test_mint_token3_collection_1_should_fail = _mint_token3_collection_1_should_fail();
    const _test_generates_collection_2_with_5_tokens_should_works = _generates_collection_2_with_5_tokens_should_works();
    const _test_transfer_token1_collection_2_should_works = _transfer_token1_collection_2_should_works();
};


const test_1 = test();



#import "../src/main.jsligo" "Factory"
#import "../src/marketplace/main.jsligo" "Marketplace"

type fa2_storage = Factory.NFT_FA2.Storage.t;
type ext = Factory.NFT_FA2.extension;
type ext_fa2_storage = fa2_storage<ext>;

const assertStringFailure = ([res, expected_error]: [test_exec_result, string]): unit => {
    const expected_error2 = Test.eval(expected_error);
    match(res, {
        Fail: (x: test_exec_error) => (
        match (x, {
            Rejected: (x: [michelson_program, address]) => assert(Test.michelson_equal(x[0], expected_error2)),
            Balance_too_low : (_ : { contract_too_low : address , contract_balance : tez , spend_request : tez }) 
                =>  failwith("contract failed: balance too low"),
            Other: (s: string) => failwith(s)
        })),
        Success: (_ : nat) => failwith("Expected to fail but passed")
    });
};

const _test = () : unit => {
    // setup 4 accounts 
    let _ = Test.reset_state(4 as nat, (list([]) as list<tez>));
    const alice: address = Test.nth_bootstrap_account(0);
    const bob: address = Test.nth_bootstrap_account(1);
    const _steven: address = Test.nth_bootstrap_account(2);
    const _frank: address = Test.nth_bootstrap_account(3);

   // originate Factory smart contract
    let init_storage : Factory.Storage.t = { 
        allCollections:(Big_map.empty as big_map<Factory.Storage.collectionContract, Factory.Storage.collectionOwner>),
        ownedCollections:(Big_map.empty as big_map<Factory.Storage.collectionOwner, list<Factory.Storage.collectionContract>> ),
        metadata: (Big_map.empty as big_map<string, bytes>)
    };
    const [addr,_,_] = Test.originate(Factory.main, init_storage, 0 as tez);

    // originate Marketplace smart contract
    let marketplaceInitStorage : Marketplace.Storage.t = { 
        next_sell_id: 0 as nat,
        active_proposals:(Set.empty as set<nat>),
        sell_proposals:(Big_map.empty as big_map<nat, Marketplace.Storage.sell_proposal>)
    };
    const [marketplace_taddr,_,_] = Test.originate(Marketplace.main, marketplaceInitStorage, 0 as tez);


    let _generates_collection_1_should_works = () : string => { 
        let _print = Test.log("_generates_collection_1_should_works");

        let x : contract<Factory.parameter> = Test.to_contract(addr);

        // prepare arguments for generating a new collection
        let tokenIds : list<nat> = list([ 1 as nat]);
        let tokenInfo1 : map<string, bytes> = Map.literal( list([
            ["QRcode", 0x623d82eff132]
        ])); 
        let tokenInfo1Data : Factory.NFT_FA2.Storage.TokenMetadata.data = { token_id:(1 as nat), token_info:tokenInfo1 };
        let tokenMetadata : Factory.NFT_FA2.Storage.TokenMetadata.t = Big_map.literal( list([
            [1 as nat, tokenInfo1Data]
        ])); 

        // call GenerateCollection entrypoint
        let _src = Test.set_source(alice);
        let gencolArgs : Factory.Parameter.generateCollectionParam = { name:"alice_collection_1", tokenIds:tokenIds, tokenMetas:tokenMetadata };
        let _exec = Test.transfer_to_contract_exn(x, (GenerateCollection(gencolArgs)), (1000000 as mutez));

        // verify FA2 has been created
        let s : Factory.storage = Test.get_storage(addr);
        let colls : list<address> = match(Big_map.find_opt(alice, s.ownedCollections), {
            None: () => (list([]) as list<address>),
            Some: (x: list<address>) => x
        });
        let ownedCollSize = List.fold( ( ([acc, _elt] : [nat, address]) : nat => acc + (1 as nat)), colls, (0 as nat));
        //let ownedCollSize : nat = Set.size colls in 
        let _tst = assert (ownedCollSize == (1 as nat));


        _print = Test.log("_marketplace_sell_token1_should_works");
        // retrieve address collection
        let storageBefore : Factory.storage = Test.get_storage(addr);
        let collsBefore : list<address> = match(Big_map.find_opt(alice, storageBefore.ownedCollections), {
            None: () => (list([]) as list<address>),
            Some: (x: list<address>) => x
        });
        let fa2Address : address = Option.unopt (List.head_opt(collsBefore));
        let taddrFa2Address = (Test.cast_address(fa2Address) as typed_address<Factory.NFT_FA2.parameter, ext_fa2_storage>);
        let fa2Store : ext_fa2_storage = Test.get_storage (taddrFa2Address);
        _tst = assert( ((Factory.NFT_FA2.Storage.is_owner_of(fa2Store))(alice))(1 as nat) );

        // APPROVE marketplace to transfer token 1
        _src = Test.set_source (alice);
        let marketplaceContract : contract<Marketplace.parameter> = Test.to_contract (marketplace_taddr);
        let marketplaceAddress  = Tezos.address (marketplaceContract);
        let fa2Contract : contract<Factory.NFT_FA2.parameter> = Test.to_contract (taddrFa2Address);
        let updateOperatorsParam = list([(Add_operator({owner:alice, operator:marketplaceAddress, token_id:(1 as nat)}) as Factory.NFT_FA2.NFT.unit_update)]);
        _exec = Test.transfer_to_contract_exn(fa2Contract, (Update_operators(updateOperatorsParam)), 0 as mutez);

        // alice Sell token1
        let sellArgs : Marketplace.Parameter.sell_proposal_param = { 
            token_id:1 as nat,
            collectionContract:fa2Address,
            price:1 as tez
        };
        _src = Test.set_source (alice);
        _exec = Test.transfer_to_contract_exn(marketplaceContract, (Sell(sellArgs)), 0 as mutez);

        // bob Buy token1
        let buyArgs : Marketplace.Parameter.buy_param = { 
            proposal_id:0 as nat
        };
        let _src = Test.set_source (bob);
        _exec = Test.transfer_to_contract_exn(marketplaceContract, (Buy(buyArgs)), 1000000 as mutez);

        let fa2StoreAfter : ext_fa2_storage = Test.get_storage (taddrFa2Address);
        _tst = assert( ((Factory.NFT_FA2.Storage.is_owner_of(fa2StoreAfter))(bob))(1 as nat) );
        return "OK"
    };

    const _exec = _generates_collection_1_should_works();
};

const test = _test();

NFT-Factory-JsLIGO

example of a NFT Factory contract in CameLIGO 

reset

reveal

commit

participants

locked_tez

secrets

decoded_payloads

result_nat

last_seed

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 }
};

Governance

Token

Utilities

Marigold