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

update_operators

requests

callback

balance_of

set_admin

transfer

setExpiry

permit

burn_token

mint_token

create_token

ledger

token_metadata

operators

admin

counter

default_expiry

max_expiry

permits

user_expiries

permit_expiries

extension

An example of permit contract (TZIP-17) written in cameligo

@ligo/permit

let requires_admin  = "NOT_AN_ADMIN"
let token_exist     = "TOKEN_ID_ALREADY_PRESENT"

(* TZIP-17 *)
let dup_permit      = "DUP_PERMIT"
let missigned       = "MISSIGNED"

let max_seconds_exceeded = "MAX_SECONDS_EXCEEDED"
let forbidden_expiry_update = "FORBIDDEN_EXPIRY_UPDATE"

let missing_expiry = "NO_EXPIRY_FOUND"


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

type seconds = nat
type permit_key = (address * bytes)
type permits = (permit_key, timestamp) big_map
type user_expiries = (address, seconds option) big_map
type permit_expiries = (permit_key, seconds option) big_map

type 'a t = {
    admin: address;
    counter: nat;
    default_expiry: seconds;
    max_expiry: seconds;
    permits: permits;
    user_expiries: user_expiries;
    permit_expiries: permit_expiries;
    extension : 'a;
}

let get_user_defined_expiry (type a) (from_: address) (ext: a t) : seconds option =
    match Big_map.find_opt from_ ext.user_expiries with
    | None -> (Some ext.default_expiry)
    | Some exp -> exp

let get_expiry (type a) (ext: a t) ((user, param_hash): permit_key) : seconds =
    match Big_map.find_opt (user, param_hash) ext.permit_expiries with
    | None ->
        begin
            match get_user_defined_expiry user ext with
            | None -> ext.default_expiry
            | Some exp -> exp
        end
    | Some (None) -> ext.default_expiry
    | Some (Some exp) -> exp

let assert_admin (type a)  (ext : a t) =
    assert_with_error (Tezos.get_sender() = ext.admin) Errors.requires_admin

let set_admin (type a)  (ext : a t) (admin:address) =
    let () = assert_admin(ext) in
    { ext with admin = admin }


let set_extension (type a) (ext : a t) (extension : a) =
    { ext with extension = extension }


let add_permit (type a)  (ext : a t) (permit_key: permit_key) =
    let now = Tezos.get_now() in
    { ext with
        permits = Big_map.add permit_key now ext.permits;
        counter = ext.counter + 1n
    }

let update_permit (type a) (ext : a t) (permit_key: permit_key) =
    let now = Tezos.get_now() in
    { ext with
        permits = Big_map.update permit_key (Some(now)) ext.permits;
        counter = ext.counter + 1n
    }

let _check_not_expired (type a) (ext : a t) (submission_timestamp: timestamp) (permit_key: permit_key) =
    let effective_expiry: seconds = get_expiry ext permit_key in
    if abs (Tezos.get_now() - submission_timestamp) < effective_expiry
    then failwith Errors.dup_permit

let transfer_presigned (type a) (ext : a t) (param_permit_key: permit_key): bool * a t =
    let permit_submit_time: timestamp =
        match Big_map.find_opt param_permit_key ext.permits with
        | None -> (0: timestamp)
        | Some exp -> exp
    in
    if permit_submit_time = (0: timestamp)
    then
        (false, ext)
    else
        let effective_expiry =
            match Big_map.find_opt param_permit_key ext.permit_expiries with
            | None ->
                begin
                    let user_address = param_permit_key.0 in 
                    match Big_map.find_opt user_address ext.user_expiries with
                    | None -> (Some ext.default_expiry)
                    | Some exp -> exp
                end
            | Some exp -> exp
        in
        match effective_expiry with
        | None -> (failwith Errors.missing_expiry: (bool * a t))
        | Some effective_exp ->
            let permits = Big_map.remove param_permit_key ext.permits in
            let is_authorised = abs ((Tezos.get_now()) - permit_submit_time) < effective_exp in
            (is_authorised, { ext with permits = permits })


#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"
#import "./constants.mligo" "Constants"
#import "./storage.mligo" "Storage"
#import "./extension.mligo" "Extension"
#import "./errors.mligo" "Errors"
#import "./token_total_supply.mligo" "TokenTotalSupply"

type token_total_supply = TokenTotalSupply.t
type gen_storage = Storage.t
type storage = token_total_supply gen_storage
type result = operation list * storage
type gen_extension = Extension.t
type extension = token_total_supply gen_extension

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

type permit_params = (key * (signature * bytes))
type expiry_params = (address * (nat * (bytes option)))

[@entry] let create_token (metadata,owner,amount : FA2.TokenMetadata.data * address * nat) (s : storage) =
    let () = Extension.assert_admin s.extension in
    let md = Storage.add_new_token s.token_metadata metadata.token_id metadata in
    let s = Storage.set_token_metadata s md in
    let ledger = FA2.Ledger.increase_token_amount_for_user s.ledger owner metadata.token_id amount in
    let s = FA2.Storage.set_ledger s ledger in
    let supply = TokenTotalSupply.create_supply s.extension.extension metadata.token_id amount in
    Constants.no_operation, {
      s with extension = Extension.set_extension s.extension supply
    }

[@entry] let mint_token (lst : mint_or_burn list) (s : storage) =
   let () = Extension.assert_admin s.extension in
   let process_one ((ledger,supply), {owner;token_id;amount_} : (FA2.Ledger.t * TokenTotalSupply.t) * mint_or_burn) =
      let () = FA2.Storage.assert_token_exist  s token_id in
      FA2.Ledger.increase_token_amount_for_user ledger owner token_id amount_,
      TokenTotalSupply.increase_supply supply token_id amount_
   in
   let (ledger, supply) = List.fold_left process_one (s.ledger, s.extension.extension) lst in
   let s = FA2.Storage.set_ledger s ledger in
   Constants.no_operation, {
      s with extension = Extension.set_extension s.extension supply
    }

[@entry] let burn_token (lst : mint_or_burn list) (s : storage) =
   let () = Extension.assert_admin s.extension in
   let process_one ((ledger,supply), {owner;token_id;amount_} : (FA2.Ledger.t * TokenTotalSupply.t) * mint_or_burn) =
      FA2.Ledger.decrease_token_amount_for_user ledger owner token_id amount_,
      TokenTotalSupply.decrease_supply supply token_id amount_
   in
   let (ledger, supply) = List.fold_left process_one (s.ledger, s.extension.extension) lst in
   let s = FA2.Storage.set_ledger s ledger in
   Constants.no_operation,{
      s with extension = Extension.set_extension s.extension supply
    }

(* TZIP-17 *)
[@entry] let permit (permits : (permit_params list)) (s : storage) =
    let process_permit (ext, permit : extension * permit_params) =
        let (pub_key, (sig_, hash_)) = permit in
        let packed = Bytes.pack (((Tezos.get_chain_id()), Tezos.get_self_address()), (ext.counter, hash_)) in
        if Crypto.check pub_key sig_ packed
        then
            let sender_ = Tezos.address (Tezos.implicit_account (Crypto.hash_key pub_key)) in
            let permit_key = sender_, hash_ in
            match Big_map.find_opt permit_key ext.permits with
            | None -> Extension.add_permit ext permit_key
            | Some submission_timestamp ->
                let () = Extension._check_not_expired s.extension submission_timestamp permit_key in
                Extension.update_permit ext permit_key
        else ([%Michelson ({| { FAILWITH } |} : string * bytes -> extension)]) (Errors.missigned, packed)
    in
    let extension = List.fold_left process_permit s.extension permits in
    Constants.no_operation, { s with extension = extension }

(* TZIP-17 *)
[@entry] let setExpiry (p : expiry_params) (s : storage) =
    let (user_address, (seconds, permit_hash_opt)) = p in
    let new_storage =
        if seconds > s.extension.max_expiry
        then (failwith Errors.max_seconds_exceeded : storage)
        else if Tezos.get_sender() <> user_address
        then (failwith Errors.forbidden_expiry_update : storage)
        else
                match permit_hash_opt with
                | None ->
                    {
                        s with extension.user_expiries = Big_map.add
                            user_address
                            (Some seconds)
                            s.extension.user_expiries
                    }
                | Some permit_hash ->
                    {
                        s with extension.permit_expiries = Big_map.add
                            (user_address, permit_hash)
                            (Some seconds)
                            s.extension.permit_expiries
                    }
    in Constants.no_operation, new_storage

(* TZIP-17 implementation of TZIP-12 Transfer *)
[@entry] let transfer (transfer:FA2.transfer) (s: storage) =
    let make_transfer (acc, transfer_from : (FA2.Ledger.t * extension) * FA2.transfer_from) =
        let (ledger, ext) = acc in
        let transfer_from_hash = Crypto.blake2b (Bytes.pack transfer_from) in
        let permit_key : Extension.permit_key = (transfer_from.from_, transfer_from_hash) in
        let (is_transfer_authorized, ext) = Extension.transfer_presigned ext permit_key in
        let {from_; txs} = transfer_from in
        let ledger = List.fold
          (fun (ledger, dst : FA2.Ledger.t * FA2.atomic_trans) ->
            let {token_id; amount; to_} = dst in
            let () = FA2.Storage.assert_token_exist s token_id in
            let () = if not is_transfer_authorized then
                FA2.Operators.assert_authorisation s.operators from_ token_id
            in
            let ledger = FA2.Ledger.decrease_token_amount_for_user ledger from_ token_id amount in
            let ledger = FA2.Ledger.increase_token_amount_for_user ledger to_ token_id amount in
            ledger
          ) txs ledger in
          (ledger, ext)
        in
    let (new_ledger, new_ext) = List.fold make_transfer transfer (s.ledger, s.extension)
    in Constants.no_operation, { s with ledger = new_ledger; extension = new_ext }

[@entry] let set_admin (addr: address) (s: storage) =
    Constants.no_operation, { s with extension = Extension.set_admin s.extension addr }

[@entry] let balance_of (p : FA2.balance_of) (s : storage) =
    FA2.balance_of p s

[@entry] let update_operators (p : FA2.update_operators) (s : storage) =
    FA2.update_ops p s

(*
    Off-chain views required by TZIP-17

    Command to run to get the micheline expressions to put in the metadata:

    ligo compile expression cameligo '_get_counter' \
        --init-file src/main.mligo \
        --project-root . \
        --michelson-format json
*)
let _get_default_expiry ((_,s):(unit * storage)) : nat =
    s.extension.default_expiry

let _get_counter ((_,s):(unit * storage)) : nat =
    s.extension.counter



#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"
#import "./errors.mligo" "Errors"
#import "./extension.mligo" "Extension"

type storage = FA2.storage
type extension = Extension.t
type 'a t = 'a extension storage

let get_token_metadata (type a) (s:a t) = s.token_metadata
let set_token_metadata (type a) (s:a t) (token_metadata:FA2.TokenMetadata.t) =
    {s with token_metadata = token_metadata}

let add_new_token (md:FA2.TokenMetadata.t) (token_id : nat) (data:FA2.TokenMetadata.data) =
    let () = assert_with_error (not (Big_map.mem token_id md)) Errors.token_exist in
    let md = Big_map.add token_id data md in
    md


#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"

(* token_id -> total_supply *)
type t = (FA2.Ledger.token_id, nat) big_map

let get_supply (supply : t) (token_id : FA2.Ledger.token_id) =
   match Big_map.find_opt token_id supply with 
    Some (a) -> a 
    | None -> failwith FA2.Errors.undefined_token
    
let create_supply (supply : t) (new_token_id : FA2.Ledger.token_id) (amount_ : nat) = 
    Big_map.add new_token_id amount_ supply

let increase_supply (supply : t) (token_id : FA2.Ledger.token_id) (amount_ : nat) =
    let cur_amount = get_supply supply token_id in
    let new_amount = cur_amount + amount_ in
    Big_map.update token_id (Some(new_amount)) supply

let decrease_supply (supply : t) (token_id : FA2.Ledger.token_id) (amount_ : nat) =
    let cur_amount = get_supply supply token_id in
    let new_supply = abs(cur_amount - amount_) in
    Big_map.update token_id (Some(new_supply)) supply
 

#import "../helpers/token.mligo" "Token_helper"
#import "../helpers/fa2.mligo" "FA2_helper"
#import "../../src/main.mligo" "Token"

(* Some dummy value when they don't matter for a given test *)
let dummy_genesis_ts = ("2000-01-01t10:10:10Z" : timestamp)

(*
    Boostrapping of the test environment,
    init_ts is the initial timestamp of the genesis block
*)
let boot_state (init_ts : timestamp) =
    let () = Test.reset_state_at init_ts 7n ([10000000tez] : tez list) in

    (* don't use 0 because it the baking account and may run out of tez *)
    let admin = Test.nth_bootstrap_account 6 in

    let owners =
        Test.nth_bootstrap_account 0,
        Test.nth_bootstrap_account 1,
        Test.nth_bootstrap_account 2
    in

    let owners_with_keys =
        Test.get_bootstrap_account 0n,
        Test.get_bootstrap_account 1n,
        Test.get_bootstrap_account 2n
    in

    let ops =
        Test.nth_bootstrap_account 3,
        Test.nth_bootstrap_account 4,
        Test.nth_bootstrap_account 5
    in

    (admin, owners, owners_with_keys, ops)

(*
    Bootstrapping of the contract under test,
    init_tok_amount is the amount of token allocated to every
    bootstrapped accounts
*)

let boot_token (owners, ops, init_tok_amount, init_extended_storage
: (address * address * address) * (address * address * address) * nat * Token.extension) =
    let initial_fa2_storage = FA2_helper.get_initial_storage(
        owners, ops, init_tok_amount
    ) in

    (* supply matching initial ledger *)
    let supply = (Big_map.literal [
       (1n, init_tok_amount); 
       (2n, (init_tok_amount * 2n)); 
       (3n, init_tok_amount); 
    ] : Token.TokenTotalSupply.t) in

    let init_storage = {
        metadata = Big_map.literal [
            ("", Bytes.pack("tezos-storage:contents"));
            ("contents", ("": bytes))
        ];
        ledger         = initial_fa2_storage.ledger;
        token_metadata = initial_fa2_storage.token_metadata;
        operators      = initial_fa2_storage.operators;
        extension      = { init_extended_storage with extension = supply };
    } in

    Token_helper.originate(init_storage)


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/fa2.mligo" "FA2_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Burn_token] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n

let bootstrap () =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(
        admin, Token_helper.dummy_default_expiry, Token_helper.dummy_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful token mint *)
let test_success =
    let (tok, admin, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source admin in
    let token_id = 1n in
    let amount_ = 6n in
    let () = Token_helper.burn_token_success([{
       owner=owner1_addr;
       token_id=token_id;
       amount_=amount_;
    }], tok.contr) in
    let new_amount =  abs(init_tok_amount - amount_) in
    let () = Token_helper.assert_balance(tok.taddr, owner1_addr, token_id, new_amount) in
    Token_helper.assert_supply(tok.taddr, token_id, new_amount)

(* Failure because sender is not current admin *)
let test_failure_not_admin =
    let (tok, _, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source owner1_addr in
    let r = Token_helper.burn_token([{
       owner=owner1_addr;
       token_id=1n;
       amount_=1n;
    }], tok.contr) in
    Assert.string_failure r Token.Errors.requires_admin


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/fa2.mligo" "FA2_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Create_token] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n

let bootstrap () =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(
      admin, Token_helper.dummy_default_expiry, Token_helper.dummy_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful token creation *)
let test_success =
    let (tok, admin, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source admin in
    let token_id = 42n in
    let amount_ = 12n in
    let () = Token_helper.create_token_success
      (FA2_helper.get_dummy_token_data (token_id),
       owner1_addr, amount_, tok.contr) in
    let () = Token_helper.assert_balance(tok.taddr, owner1_addr, token_id, amount_) in
    Token_helper.assert_supply(tok.taddr, token_id, amount_)

(* Failure because token id already present *)
let test_failure_token_exist =
    let (tok, admin, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source admin in
    let r = Token_helper.create_token
      (FA2_helper.get_dummy_token_data (1n),
       owner1_addr, 12n, tok.contr) in
    Assert.string_failure r Token.Errors.token_exist

(* Failure because sender is not current admin *)
let test_failure_not_admin =
    let (tok, _, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source owner1_addr in
    let r = Token_helper.create_token
      (FA2_helper.get_dummy_token_data (42n),
       owner1_addr, 12n, tok.contr) in
    Assert.string_failure r Token.Errors.requires_admin


(* Assert contract call results in failwith with given string *)
let string_failure (res : test_exec_result) (expected : string) : unit =
    let expected = Test.eval expected in
    match res with
        | Fail (Rejected (actual,_)) -> assert (actual = expected)
        | Fail (Balance_too_low _) -> Test.failwith "contract failed: balance too low"
        | Fail (Other s) -> Test.failwith s
        | Success _ -> Test.failwith "Transaction should fail"

(* Assert contract result is successful *)
let tx_success (res: test_exec_result) : unit =
    match res with
        | Success(_) -> ()
        | Fail (Rejected (error,_)) -> let () = Test.log(error) in Test.failwith "Transaction should not fail"
        | Fail _ -> Test.failwith "Transaction should not fail"


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

let dummy_token_info = (Map.empty : (string, bytes) map)

let get_dummy_token_data (token_id : nat) : Token.FA2.TokenMetadata.data =
   {token_id=token_id;token_info=dummy_token_info}

(*
    Get the initial storage of FA2
    init_tok_amount is the amount of token allocated to every owner account
*)
let get_initial_storage (owners, ops, init_tok_amount
: (address * address * address) * (address * address * address) * nat) =
let (owner1, owner2, owner3) = owners in
    let (op1, _op2, op3) = ops in

    let ledger = Big_map.literal ([
        ((owner1, 1n), init_tok_amount);
        ((owner2, 2n), init_tok_amount);
        ((owner3, 3n), init_tok_amount);
        ((owner1, 2n), init_tok_amount);
    ]) in

    let operators  = Big_map.literal ([
        ((owner1, op1), Set.literal [1n; 2n]);
        ((owner2, op1), Set.literal [2n]);
        ((owner3, op1), Set.literal [3n]);
        ((op1   , op3), Set.literal [2n]);
    ]) in

    let token_metadata = (Big_map.literal [
        (1n, get_dummy_token_data(1n));
        (2n, get_dummy_token_data(2n));
        (3n, get_dummy_token_data(3n));
    ] : Token.FA2.TokenMetadata.t) in

    {
        ledger         = ledger;
        token_metadata = token_metadata;
        operators      = operators;
    }


(* Return str repeated n times *)
let repeat (str, n : string * nat) : string =
    let rec loop (n, acc: nat * string) : string = 
        if n = 0n then acc else loop (abs(n - 1n), acc ^ str)
    in loop(n, "")

(* 
    Log boxed lbl

    "+-----------+"
    "| My string |"
    "+-----------+"
*)
let describe (lbl : string) =
    let hr = "+" ^ repeat("-", String.length(lbl) + 2n) ^ "+" in 
    let () = Test.log hr in
    let () = Test.log ("| " ^ lbl ^ " |") in
    Test.log hr


#import "../../src/main.mligo" "Token"
#import "./assert.mligo" "Assert"

(* Some types for readability *)
type taddr = (Token parameter_of, Token.storage) typed_address
type contr = Token parameter_of contract
type originated = {
    addr: address;
    taddr: taddr;
    owners: address list;
    contr: contr;
}

(* Some dummy values when they don't matter for a given test *)
let dummy_default_expiry = 0n
let dummy_max_expiry = 0n

let get_initial_extended_storage (admin, default_expiry, max_expiry: address * nat * nat) =
{
    admin = admin;
    counter = 0n;
    default_expiry = default_expiry;
    max_expiry = max_expiry;
    permits = (Big_map.empty : Token.Extension.permits);
    user_expiries = (Big_map.empty : Token.Extension.user_expiries);
    permit_expiries = (Big_map.empty : Token.Extension.permit_expiries);
    extension = (Big_map.empty : Token.TokenTotalSupply.t)
}

(* Originate a Token contract with given init_storage storage *)
let originate (init_storage: Token.storage) =
    let orig = Test.originate (contract_of Token) init_storage 0tez in
    let contr = Test.to_contract orig.addr in
    let addr = Test.to_address orig.addr in
    { addr = addr; taddr = orig.addr; contr = contr }

(*
    Make a permit with given packed params and secret key
    The chain_id is equal to 0x00000000 in the test framework
*)
let make_permit (hash_, account, token_addr, counter : bytes * (address * key * string) * address * nat) : Token.permit_params =
    let (_, pub_key, secret_key) = account in
    let packed = Bytes.pack ((0x00000000, token_addr), (counter, hash_)) in
    let sig_ = Test.sign secret_key packed in
    (pub_key, (sig_, hash_))

(* Call entry point of Token contr contract *)
let call (p, contr : Token parameter_of * contr) =
    Test.transfer_to_contract contr p 0mutez

let permit (p, contr : Token.permit_params list * contr) =
    call(Permit(p), contr)

let set_expiry (p, contr : Token.expiry_params * contr) =
    call(SetExpiry(p), contr)

let set_admin (p, contr : address * contr) =
    call(Set_admin(p), contr)

let transfer (p, contr : Token.FA2.transfer * contr) =
    let p : Token parameter_of = Transfer(p) in
    call(p, contr)

let create_token (md, owner, amount, contr : Token.FA2.TokenMetadata.data * address * nat * contr) =
    call(Create_token(md, owner, amount), contr)

let mint_token (p, contr : Token.mint_or_burn list * contr) =
    call(Mint_token(p), contr)

let burn_token (p, contr : Token.mint_or_burn list * contr) =
    call(Burn_token(p), contr)

let permit_success (p, contr : Token.permit_params list * contr) =
    Assert.tx_success (permit(p, contr))

let set_expiry_success (p, contr : Token.expiry_params * contr) =
    Assert.tx_success (set_expiry(p, contr))

let set_admin_success (p, contr : address * contr) =
    Assert.tx_success (set_admin(p, contr))

let transfer_success (p, contr : Token.FA2.transfer * contr) =
    Assert.tx_success (transfer(p, contr))

let create_token_success (md, owner, amount, contr : Token.FA2.TokenMetadata.data * address * nat * contr) =
    Assert.tx_success (create_token(md, owner, amount, contr))

let mint_token_success (p, contr : Token.mint_or_burn list * contr) =
    Assert.tx_success (mint_token(p, contr))

let burn_token_success (p, contr : Token.mint_or_burn list * contr) =
    Assert.tx_success (burn_token(p, contr))

(* Assert Token contract at [taddr] has permit with [address, hash] key *)
let assert_has_permit (taddr, permit_key : taddr * Token.Extension.permit_key) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt permit_key s.extension.permits with
        Some _ -> ()
        | None -> Test.failwith("Permits Big_map key should not be missing")

(* Assert Token contract at [taddr] has no permit with [address, hash] key *)
let assert_no_permit (taddr, permit_key : taddr * Token.Extension.permit_key) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt permit_key s.extension.permits with
        Some _ -> Test.failwith("Permits Big_map key should be None")
        | None -> ()

(* Assert Token contract at [taddr] has counter equals to [counter] *)
let assert_counter (taddr, counter : taddr * nat) =
    let s = Test.get_storage taddr in
    assert_with_error
        (s.extension.counter = counter)
        "Counter does not have expected value"

(* Assert Token contract at [taddr] has user expiry for [user_addr] equal to [seconds] *)
let assert_user_expiry (taddr, user_addr, seconds : taddr * address * nat option) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt user_addr s.extension.user_expiries with
        Some s -> assert (s = seconds)
        | None -> Test.failwith("User epiries Big_map key should not be missing")

(* Assert Token contract at [taddr] has user permit expiry for [user_addr] and
hash [hash_] equal to [seconds] *)
let assert_permit_expiry (taddr, user_addr, hash_, seconds : taddr * address * bytes * nat option) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt (user_addr, hash_) s.extension.permit_expiries with
        Some s -> assert (s = seconds)
        | None -> Test.failwith("Permit epiries Big_map key should not be missing")

(* assert Token contract at [taddr] have [owner] address with [amount_] tokens in its ledger *)
let assert_balance (taddr, owner, token_id, amount_ : taddr * address * nat * nat) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt (owner, token_id) s.ledger with
        Some tokens -> assert(tokens = amount_)
        | None -> Test.failwith("Big_map key should not be missing")

(* assert Token contract at [taddr] have token_total_supply for [token_id] matching [amount_] *)
let assert_supply (taddr, token_id, amount_ : taddr * Token.FA2.Ledger.token_id * nat) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt token_id s.extension.extension with
        Some tokens -> assert(tokens = amount_)
        | None -> Test.failwith("Big_map key should not be missing")


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/fa2.mligo" "FA2_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Mint_token] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n

let bootstrap () =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(
      admin, Token_helper.dummy_default_expiry, Token_helper.dummy_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful token mint *)
let test_success =
    let (tok, admin, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source admin in
    let token_id = 1n in
    let amount_ = 56n in
    let () = Token_helper.mint_token_success([{
       owner=owner1_addr;
       token_id=token_id;
       amount_=amount_;
    }], tok.contr) in
    let new_amount =  init_tok_amount + amount_ in
    let () = Token_helper.assert_balance(tok.taddr, owner1_addr, token_id, new_amount) in
    Token_helper.assert_supply(tok.taddr, token_id, new_amount)

(* Failure because sender is not current admin *)
let test_failure_not_admin =
    let (tok, _, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source owner1_addr in
    let r = Token_helper.mint_token([{
       owner=owner1_addr;
       token_id=1n;
       amount_=1n;
    }], tok.contr) in
    Assert.string_failure r Token.Errors.requires_admin


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Permit] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_ts, init_default_expiry, init_max_expiry : timestamp * nat * nat) =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(init_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful permit creation *)
let test_success_add_permit_one =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let transfer_requests = ([
        ({from_=owner1_addr; txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)});
    ] : Token.FA2.transfer) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_requests) in
    let permit = Token_helper.make_permit(hash_, owner1, tok.addr, 0n) in
    let () = Token_helper.permit_success([permit], tok.contr) in
    let () = Token_helper.assert_has_permit(tok.taddr, (owner1_addr, hash_)) in
    Token_helper.assert_counter(tok.taddr, 1n)

(* Successful successive permit creation *)
let test_success_add_permit_list =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let transfer_requests = ([
        ({from_=owner1_addr; txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)});
    ] : Token.FA2.transfer) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_requests) in
    let permit1 = Token_helper.make_permit(hash_, owner1, tok.addr, 0n) in
    let transfer_requests = ([
        ({from_=owner2_addr; txs=([{to_=owner1_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)});
    ] : Token.FA2.transfer) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_requests) in
    let permit2 = Token_helper.make_permit(hash_, owner2, tok.addr, 1n) in
    let () = Token_helper.permit_success([permit1; permit2], tok.contr) in
    let () = Token_helper.assert_has_permit(tok.taddr, (owner2_addr, hash_)) in
    Token_helper.assert_counter(tok.taddr, 2n)

(* Successful permit update *)
let test_success_update_permit =
    let init_default_expiry = 86_400n in
    let init_max_expiry = 259_200n in
    let now = ("2000-01-03t10:10:10Z" : timestamp) in
    let expired = ("2000-01-01t10:10:10Z" : timestamp) in

    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(now) in
    let (owner1, owner2, _) = owners_with_keys in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in

    let transfer_requests = ([
        ({from_=owner1_addr; txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)});
    ] : Token.FA2.transfer) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_requests) in

    let extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let extended_storage = { extended_storage with
        permits = Big_map.literal [((owner1_addr, hash_), expired)];
        counter = 1n;
    } in

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage) in
    let permit = Token_helper.make_permit(hash_, owner1, tok.addr, 1n) in
    let () = Token_helper.permit_success([permit], tok.contr) in
    Token_helper.assert_has_permit(tok.taddr, (owner1_addr, hash_))

(* Failing permit update because it alredy exists and has not expired *)
let test_success_update_permit =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let transfer_requests = ([
        ({from_=owner1_addr; txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)});
    ] : Token.FA2.transfer) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_requests) in
    let permit = Token_helper.make_permit(hash_, owner1, tok.addr, 0n) in
    let () = Token_helper.permit_success([permit], tok.contr) in
    let permit = Token_helper.make_permit(hash_, owner1, tok.addr, 1n) in
    let r = Token_helper.permit([permit], tok.contr) in
    Assert.string_failure r Token.Errors.dup_permit


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Set_admin] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n

let bootstrap () =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(
      admin, Token_helper.dummy_default_expiry, Token_helper.dummy_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful setting of admin *)
let test_success_set_admin =
    let (tok, admin, owners) = bootstrap() in
    let (owner1, _, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let () = Test.set_source admin in
    let () = Token_helper.set_admin_success(owner1_addr, tok.contr) in
    let s = Test.get_storage tok.taddr in
    assert (s.extension.admin = owner1_addr)

(* Failure because sender is not current admin *)
let test_failure_not_admin =
    let (tok,_, owners) = bootstrap() in
    let (owner1, _, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let r = Token_helper.set_admin(owner1_addr, tok.contr) in
    Assert.string_failure r Token.Errors.requires_admin


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[SetExpiry] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_ts, init_default_expiry, init_max_expiry : timestamp * nat * nat) =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(init_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful setting of user expiry *)
let test_success_set_user_expiry =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, _, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let () = Test.set_source owner1_addr in
    let expiry_params : Token.expiry_params = (owner1_addr, (5400n, (None: bytes option))) in
    let () = Token_helper.set_expiry_success(expiry_params, tok.contr) in
    Token_helper.assert_user_expiry(tok.taddr, owner1_addr, Some(5400n))

(* Successful setting of permit expiry *)
let test_success_set_permit_expiry =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, _, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let () = Test.set_source owner1_addr in
    let hash_ = 0x01 in
    let expiry_params : Token.expiry_params = (owner1_addr, (5400n, (Some(hash_)))) in
    let () = Token_helper.set_expiry_success(expiry_params, tok.contr) in
    Token_helper.assert_permit_expiry(tok.taddr, owner1_addr, hash_, Some(5400n))

(* Failure because sender is not the updated user expiry *)
let test_failure_forbidden =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let () = Test.set_source owner2_addr in
    let expiry_params : Token.expiry_params = (owner1_addr, (5400n, (None: bytes option))) in
    let r = Token_helper.set_expiry(expiry_params, tok.contr) in
    Assert.string_failure r Token.Errors.forbidden_expiry_update

(* Failure because tried to set value exceeding max_expiry *)
let test_failure_max_seconds_exceeded =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let () = Test.set_source owner2_addr in
    let expiry_params : Token.expiry_params = (owner1_addr, (14_400n, (None: bytes option))) in
    let r = Token_helper.set_expiry(expiry_params, tok.contr) in
    Assert.string_failure r Token.Errors.max_seconds_exceeded




#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Transfer] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_ts, init_default_expiry, init_max_expiry : timestamp * nat * nat) =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(init_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful transfer with permit *)
let test_success =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let transfer_request = ({
        from_=owner1_addr;
        txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)
    }) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_request) in
    let permit = Token_helper.make_permit(hash_, owner1, tok.addr, 0n) in
    let () = Token_helper.permit_success([permit], tok.contr) in
    let transfer_requests = ([transfer_request] : Token.FA2.transfer) in
    let () = Test.set_source owner2_addr in
    let () = Token_helper.transfer_success(transfer_requests, tok.contr) in
    let () = Token_helper.assert_balance(tok.taddr, owner1_addr, 1n, 8n) in
    let () = Token_helper.assert_balance(tok.taddr, owner2_addr, 1n, 2n) in
    Token_helper.assert_no_permit(tok.taddr, (owner1_addr, hash_))

(* Successful with permit expired but sender is operator *)
let test_success_by_operator_with_expired_permit =
    let init_default_expiry = 86_400n in
    let init_max_expiry = 259_200n in
    let now = ("2000-01-03t10:10:10Z" : timestamp) in
    let expired = ("2000-01-01t10:10:10Z" : timestamp) in

    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(now) in
    let (owner1, owner2, _) = owners_with_keys in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let (op1, _, _) = ops in

    let transfer_request = ({
        from_=owner1_addr;
        txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)
    }) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_request) in

    let extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let extended_storage = { extended_storage with
        permits = Big_map.literal [((owner1_addr, hash_), expired)];
        counter = 1n;
    } in

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage) in
    let () = Test.set_source op1 in
    let transfer_requests = ([transfer_request] : Token.FA2.transfer) in
    let () = Token_helper.transfer_success(transfer_requests, tok.contr) in
    let () = Token_helper.assert_balance(tok.taddr, owner1_addr, 1n, 8n) in
    Token_helper.assert_balance(tok.taddr, owner2_addr, 1n, 2n)

(* Failing because the permit has expired *)
let test_failure_expired_permit =
    let init_default_expiry = 86_400n in
    let init_max_expiry = 259_200n in
    let now = ("2000-01-03t10:10:10Z" : timestamp) in
    let expired = ("2000-01-01t10:10:10Z" : timestamp) in

    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(now) in
    let (owner1, owner2, _) = owners_with_keys in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in

    let transfer_request = ({
        from_=owner1_addr;
        txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)
    }) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_request) in

    let extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let extended_storage = { extended_storage with
        permits = Big_map.literal [((owner1_addr, hash_), expired)];
        counter = 1n;
    } in

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage) in
    let () = Test.set_source owner2_addr in
    let r = Token_helper.transfer([transfer_request], tok.contr) in
    Assert.string_failure r Token.FA2.Errors.not_operator


Permit-Cameligo

example of a permit contract in JsLIGO Resources

setAdmin

defaultExpiry

maxExpiry

userExpiries

permitExpiries

An example of permit contract (TZIP-17) written in jsligo

export const noOperation : list<operation> = list([])


export const requiresAdmin  = "NOT_AN_ADMIN";
export const tokenExist     = "TOKEN_ID_ALREADY_PRESENT";

// TZIP-17
export const dupPermit      = "DUP_PERMIT";
export const missigned       = "MISSIGNED";

export const maxSecondsExceeded = "MAX_SECONDS_EXCEEDED";
export const forbiddenExpiryUpdate = "FORBIDDEN_EXPIRY_UPDATE";

export const missingExpiry = "NO_EXPIRY_FOUND"

#import "./errors.jsligo" "Errors"
#import "./token_total_supply.jsligo" "TokenTotalSupply"

type seconds = nat;
export type permitKey = [address, bytes];
export type permits = big_map<permitKey, timestamp>;
export type userExpiries = big_map<address, option<seconds>>;
export type permitExpiries = big_map<permitKey, option<seconds>>;

export type t<a> = {
    admin: address,
    counter: nat,
    defaultExpiry: seconds,
    maxExpiry: seconds,
    permits: permits,
    userExpiries: userExpiries,
    permitExpiries: permitExpiries,
    extension : a
};

const get_user_defined_expiry =
<T>(from_: address, ext: t<T>): option<seconds> => {
    return match (Big_map.find_opt(from_, ext.userExpiries)) {
        when(None()): (Some(ext.defaultExpiry));
        when(Some(exp)): exp;
    };
};

const getExpiry =
<T>(ext: t<T>, paramPermitKey: permitKey): seconds => {
    return match ((Big_map.find_opt([paramPermitKey[0], paramPermitKey[1]], ext.permitExpiries) as option<option<seconds>>)) {
        when(None()): match ((Big_map.find_opt(paramPermitKey[0], ext.userExpiries) as option<option<seconds>>)) {
                    when(None()): ext.defaultExpiry;
                    when(Some(exp)): match (exp) {
                            when(None()): ext.defaultExpiry;
                            when(Some(t)): t;
                    };
        };
        when(Some(p)): match (p) {
                    when(None()): ext.defaultExpiry;
                    when(Some(exp)): exp;
            };
    }
};


export const assertAdmin =
<T>(ext : t<T>) =>
    assert_with_error((Tezos.get_sender() == ext.admin), Errors.requiresAdmin);

export const setAdmin =
<T>(ext: t<T>, admin: address): t<T> => {
    assertAdmin(ext);
    return { ...ext, admin : admin };
};

export const setExtension =
<T>(ext: t<T>, extension: T): t<T> => {
    return { ...ext, extension : extension };
};

export const addPermit =
<T>(ext: t<T>, paramPermitKey: permitKey): t<T> => {
    return { ...ext,
        permits : Big_map.add(paramPermitKey, Tezos.get_now(), ext.permits),
        counter : ext.counter + 1n
    }
};

export const updatePermit =
<T>(ext: t<T>, paramPermitKey: permitKey): t<T> => {
    return { ...ext,
        permits : Big_map.update(paramPermitKey, (Some(Tezos.get_now())), ext.permits),
        counter : ext.counter + 1n
    }
};

export const _checkNotExpired =
<T>(ext: t<T>, submissionTimestamp: timestamp, paramPermitKey: permitKey): unit => {
    const effectiveExpiry: seconds = getExpiry(ext, paramPermitKey);
    assert_with_error((abs (Tezos.get_now() - submissionTimestamp) >= effectiveExpiry), Errors.dupPermit);
};

export const transferPresigned =
<T>(ext: t<T>, paramPermitKey: permitKey): [bool, t<T>] => {
    let permitSubmitTime: timestamp =
        match (Big_map.find_opt(paramPermitKey, ext.permits)) {
            when(None()): (0 as timestamp);
            when(Some(exp)): exp
        };
    if (permitSubmitTime == (0 as timestamp)) {
        return [false, ext]
    } else {
        let effectiveExpiry =
            match (Big_map.find_opt(paramPermitKey, ext.permitExpiries)) {
                when(None()): match (Big_map.find_opt(paramPermitKey[0], ext.userExpiries)) {
                        when(None()): (Some(ext.defaultExpiry));
                        when(Some(exp)): exp;
                };
                when(Some(exp)): exp;
            };
        return match (effectiveExpiry) {
            when(None()): failwith(Errors.missingExpiry);
            when(Some(effective_exp)): do {
                let permits = Big_map.remove(paramPermitKey, ext.permits);
                let isAuthorised = abs ((Tezos.get_now()) - permitSubmitTime) < effective_exp;
                return [isAuthorised, { ...ext, permits : permits }]
            }
        };
    }
};


#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"
#import "./constants.jsligo" "Constants"
#import "./storage.jsligo" "Storage"
#import "./extension.jsligo" "Extension"
#import "./errors.jsligo" "Errors"
#import "./token_total_supply.jsligo" "TokenTotalSupply"

type gen_storage = Storage.t
type token_total_supply = TokenTotalSupply.t
export type storage = gen_storage<token_total_supply>

type result = [list<operation>, storage]

type gen_extension = Extension.t
export type extension = gen_extension<token_total_supply>

export type mintOrBurn =
// @layout:comb
{
   owner    : address,
   tokenId : nat,
   amount_  : nat,
};

export type permitParams = [key, [signature, bytes]];
export type expiryParams = [address, [nat, option<bytes>]];

@entry const create_token = (paramCreate: [FA2.TokenMetadata.data, address, nat], s: storage) : result => {
    let [metadata,owner,amount] = paramCreate;
    Extension.assertAdmin(s.extension);
    let md = Storage.addNewToken(s.token_metadata, metadata.token_id, metadata);
    let store = Storage.setTokenMetadata(s, md);
    let ledger = FA2.Ledger.increase_token_amount_for_user(s.ledger)(owner)(metadata.token_id)(amount);
    let newStore = FA2.Storage.set_ledger(store)(ledger);
    let supply = TokenTotalSupply.createSupply(newStore.extension.extension, metadata.token_id, amount);
    return [Constants.noOperation, { ...newStore, extension : Extension.setExtension(s.extension, supply) }]
};

@entry const mint_token = (lst: list<mintOrBurn>, s: storage) : result => {
    Extension.assertAdmin(s.extension);
    let processOne = ([ledgerAndSupply, paramMint] : [[FA2.Ledger.t, TokenTotalSupply.t], mintOrBurn]) : [FA2.Ledger.t, TokenTotalSupply.t] => {
        let [ledger,supply] = ledgerAndSupply;
        let {owner,tokenId,amount_} = paramMint;
        FA2.Storage.assert_token_exist(s)(tokenId);
        return [
            FA2.Ledger.increase_token_amount_for_user(ledger)(owner)(tokenId)(amount_),
            Extension.TokenTotalSupply.increaseSupply(supply, tokenId, amount_)
        ]
    };
    let [ledger, supply] = List.fold_left(processOne, [s.ledger, s.extension.extension], lst);
    let store = FA2.Storage.set_ledger(s)(ledger);
    return [Constants.noOperation, { ...store, extension : Extension.setExtension(s.extension, supply) }]
};

@entry const burn_token = (lst: list<mintOrBurn>, s: storage) : result => {
   Extension.assertAdmin(s.extension);
   let processOne = ([ledgerAndSupply, paramBurn] : [[FA2.Ledger.t, Extension.TokenTotalSupply.t], mintOrBurn]) : [FA2.Ledger.t, Extension.TokenTotalSupply.t] => {
      let [ledger,supply] = ledgerAndSupply;
      let {owner,tokenId,amount_} = paramBurn;
      return [
        FA2.Ledger.decrease_token_amount_for_user(ledger)(owner)(tokenId)(amount_),
        Extension.TokenTotalSupply.decreaseSupply(supply, tokenId, amount_)
      ]
    };
   let [ledger, supply] = List.fold_left(processOne, [s.ledger, s.extension.extension], lst);
   let store = FA2.Storage.set_ledger(s)(ledger);
   return [Constants.noOperation,{ ...store, extension : Extension.setExtension(s.extension, supply) }]
};

// TZIP-17
@entry const permit = (permits: list<permitParams>, s: storage) : result => {
    let processPermit = ([ext, permit] : [extension, permitParams]) : extension => {
        let [pub_key, [sig, hash_]] = permit;
        let packed = Bytes.pack ([[(Tezos.get_chain_id()), Tezos.get_self_address()], [ext.counter, hash_]]);
        if (Crypto.check(pub_key, sig, packed)) {
            let sender_ = Tezos.address (Tezos.implicit_account (Crypto.hash_key(pub_key)));
            let paramPermitKey = [sender_, hash_];
            let extModified = match (Big_map.find_opt(paramPermitKey, ext.permits)) {
                when(None()): Extension.addPermit(ext, paramPermitKey);
                when(Some(submission_timestamp)): do {
                    Extension._checkNotExpired(s.extension, submission_timestamp, paramPermitKey);
                    return Extension.updatePermit(ext, paramPermitKey)
                };
            };
            return extModified;
        } else {
            return (Michelson `{FAILWITH}` as ((n: [string, bytes]) => extension)) ([Errors.missigned, packed])
        }
    };
    let extension = List.fold_left(processPermit, s.extension, permits);
    return [Constants.noOperation, { ...s, extension : extension }]
};

// TZIP-17
@entry const setExpiry = (p: expiryParams, s: storage) : result => {
    let [userAddress, [seconds, permitHashOpt]] = p;
    let _checkMaxExpiry : unit = assert_with_error((seconds <= s.extension.maxExpiry), Errors.maxSecondsExceeded);
    let _checkSender : unit = assert_with_error((Tezos.get_sender() == userAddress), Errors.forbiddenExpiryUpdate);
    return match (permitHashOpt) {
        when(None()): [
                Constants.noOperation,
                {...s, extension : { ...s.extension,
                    userExpiries : Big_map.add(userAddress, (Some(seconds)), s.extension.userExpiries) }}
            ];
        when(Some(permit_hash)):[
                Constants.noOperation,
                { ...s, extension : {...s.extension, permitExpiries : Big_map.add(
                    [userAddress, permit_hash],
                    (Some(seconds)),
                    s.extension.permitExpiries)
                }}
            ];
    };
};

// TZIP-17 implementation of TZIP-12 Transfer
@entry const transfer = (transfer: FA2.transfer, s: storage) : result => {
     let makeTransfer = ([acc, transferFrom] : [[FA2.Ledger.t, extension], FA2.transfer_from]) : [FA2.Ledger.t, extension] => {
        let [ledger, extension] = acc;
        let transferFromHash = Crypto.blake2b(Bytes.pack(transferFrom));
        let permitKey : Extension.permitKey = [transferFrom.from_, transferFromHash];
        const [isTransferAuthorized, ext] = Extension.transferPresigned(extension, permitKey);
        const {from_, txs} = transferFrom;
        let applyTransfer = ([ledger, dst] : [FA2.Ledger.t, FA2.atomic_trans]) : FA2.Ledger.t => {
            let {token_id, amount, to_} = dst;
            FA2.Storage.assert_token_exist(s)(token_id);
            if (!isTransferAuthorized) {
                FA2.Operators.assert_authorisation(s.operators)(from_)(token_id);
                let ledgerModified = FA2.Ledger.decrease_token_amount_for_user(ledger)(from_)(token_id)(amount);
                let ledgerFinal = FA2.Ledger.increase_token_amount_for_user(ledgerModified)(to_)(token_id)(amount);
                return ledgerFinal
            } else {
                let ledgerModified = FA2.Ledger.decrease_token_amount_for_user(ledger)(from_)(token_id)(amount);
                let ledgerFinal = FA2.Ledger.increase_token_amount_for_user(ledgerModified)(to_)(token_id)(amount);
                return ledgerFinal
            }
        };
        let l = List.fold(applyTransfer, txs, ledger);
        return [l, ext]
    };
    let [newLedger, newExt] = List.fold(makeTransfer, transfer, [s.ledger, s.extension]);
    return [Constants.noOperation, { ...s, ledger : newLedger, extension : newExt }]
};

@entry const setAdmin = (addr: address, s: storage) : result => {
    return [Constants.noOperation, { ...s, extension : Extension.setAdmin(s.extension, addr) }]
};

@entry const balance_of = (p : FA2.balance_of, s : storage): result => FA2.balance_of(p)(s);
@entry const update_operators = (p : FA2.update_operators, s : storage): result => FA2.update_ops(p)(s);

//     Off-chain views required by TZIP-17
//     Command to run to get the micheline expressions to put in the metadata:
//     ligo compile expression cameligo '_get_counter' \
//         --init-file src/main.mligo \
//         --project-root . \
//         --michelson-format json

const getDefaultExpiry = ([_,s]: [unit, storage]) : nat => {
    return s.extension.defaultExpiry
};

const getCounter = ([_,s]: [unit, storage]) : nat => {
    return s.extension.counter
};


#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"
#import "./errors.jsligo" "Errors"
#import "./extension.jsligo" "Extension"

type storage = FA2.storage;
type extension = Extension.t;
export type t<a> = storage<extension<a>>;

const getTokenMetadata = <T>(s: t<T>): FA2.TokenMetadata.t => {
    return s.token_metadata
};

export const setTokenMetadata = 
<T>(s: t<T>, token_metadata: FA2.TokenMetadata.t): t<T> => {
    return {...s, token_metadata : token_metadata }
};

export const addNewToken = (md: FA2.TokenMetadata.t, tokenId: nat, data: FA2.TokenMetadata.data) : FA2.TokenMetadata.t => {
    assert_with_error((! (Big_map.mem(tokenId, md))), Errors.tokenExist);
    return Big_map.add(tokenId, data, md);
};


#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"

export type t = big_map<FA2.Ledger.token_id, nat>;

const getSupply = (supply: t, tokenId: FA2.Ledger.token_id) : nat =>
    match (Big_map.find_opt(tokenId, supply)) {
        when(Some(a)): a;
        when(None()): (failwith(FA2.Errors.undefined_token) as nat);
   }

export const createSupply = (supply: t, newTokenId: FA2.Ledger.token_id, amount_: nat) : t => {
    return Big_map.add(newTokenId, amount_, supply)
};

export const increaseSupply = (supply: t, tokenId: FA2.Ledger.token_id, amount_: nat) : t => {
    let curAmount = getSupply(supply, tokenId);
    let newAmount = curAmount + amount_;
    return Big_map.update(tokenId, (Some(newAmount)), supply)
};

export const decreaseSupply = (supply: t, tokenId: FA2.Ledger.token_id, amount_: nat) : t => {
    let curAmount = getSupply(supply, tokenId);
    let newSupply = abs(curAmount - amount_);
    return Big_map.update(tokenId, (Some(newSupply)), supply);
};


#import "../helpers/token.jsligo" "Token_helper"
#import "../helpers/fa2.jsligo" "FA2_helper"
#import "../../src/main.jsligo" "Token"

// Some dummy value when they don't matter for a given test
export const dummy_genesis_ts = ("2000-01-01t10:10:10Z" as timestamp);


// Boostrapping of the test environment,
// init_ts is the initial timestamp of the genesis block
export const boot_state = (init_ts : timestamp) :
    [address,
    [address, address, address],
    [[address, key, string], [address, key, string], [address, key, string]],
    [address, address, address]] => {
    Test.reset_state_at(init_ts, 7n, (list([10000000tez]) as list<tez>));

    // don't use 0 because it the baking account and may run out of tez
    let admin = Test.nth_bootstrap_account(6);

    let owners =
        [Test.nth_bootstrap_account(0),
        Test.nth_bootstrap_account(1),
        Test.nth_bootstrap_account(2)];

    let owners_with_keys =
        [Test.get_bootstrap_account(0n),
        Test.get_bootstrap_account(1n),
        Test.get_bootstrap_account(2n)];

    let ops =
        [Test.nth_bootstrap_account(3),
        Test.nth_bootstrap_account(4),
        Test.nth_bootstrap_account(5)];

    return [admin, owners, owners_with_keys, ops]
};

// Bootstrapping of the contract under test,
// init_tok_amount is the amount of token allocated to every
// bootstrapped accounts
export const boot_token =
(owners: [address, address, address],
 ops: [address, address, address],
 init_tok_amount: nat,
 init_extended_storage: Token.extension) : Token_helper.originated => {
    let initial_fa2_storage = FA2_helper.get_initial_storage(
        owners, ops, init_tok_amount
    );

    // supply matching initial ledger
    let supply : Token.TokenTotalSupply.t = Big_map.literal( list([
       [1n, init_tok_amount],
       [2n, (init_tok_amount * 2n)],
       [3n, init_tok_amount]
    ]));

    let init_storage = {
        metadata : Big_map.literal( list([
            ["", Bytes.pack("tezos-storage:contents")],
            ["contents", ("" as bytes)]
        ])),
        ledger         : initial_fa2_storage.ledger,
        token_metadata : initial_fa2_storage.token_metadata,
        operators      : initial_fa2_storage.operators,
        extension      : { ...init_extended_storage, extension : supply }
    };

    return Token_helper.originateFromFile(init_storage);
};


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/fa2.jsligo" "FA2_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Burn_token] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful token mint
const _test_success = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (admin);
    let token_id = 1n;
    let amount_ = 6n;
    Token_helper.burnTokenSuccess(list([{
       owner:owner1_addr,
       tokenId:token_id,
       amount_:amount_
    }]), tok.contr);
    let new_amount =  abs(init_tok_amount - amount_);
    Token_helper.assertBalance(tok.taddr, owner1_addr, token_id, new_amount);
    Token_helper.assertSupply(tok.taddr, token_id, new_amount)
};

// Failure because sender is not current admin
const _test_failure_not_admin = () : unit => {
    let [tok, _, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (owner1_addr);
    let r = Token_helper.burnToken(list([{
       owner:owner1_addr,
       tokenId:1n,
       amount_:1n
    }]), tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
};

const test_success : unit = _test_success();
const test_failure_not_admin : unit = _test_failure_not_admin();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/fa2.jsligo" "FA2_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Create_token] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful token creation
const _test_success = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source(admin);
    let token_id = 42n;
    let amount_ = 12n;
    Token_helper.createTokenSuccess
      (FA2_helper.get_dummy_token_data (token_id),
       owner1_addr, amount_, tok.contr);
    Token_helper.assertBalance(tok.taddr, owner1_addr, token_id, amount_);
    Token_helper.assertSupply(tok.taddr, token_id, amount_)
};

// Failure because token id already present
const _test_failure_token_exist = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (admin);
    let r = Token_helper.createToken
      (FA2_helper.get_dummy_token_data(1n),
       owner1_addr, 12n, tok.contr);
    Assert.string_failure(r, Token.Errors.tokenExist)
};

// Failure because sender is not current admin
const _test_failure_not_admin = () : unit => {
    let [tok, _, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (owner1_addr);
    let r = Token_helper.createToken
      (FA2_helper.get_dummy_token_data(42n),
       owner1_addr, 12n, tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
};

const test_success : unit = _test_success();
const test_failure_token_exist : unit = _test_failure_token_exist();
const test_failure_not_admin : unit = _test_failure_not_admin();


// Assert contract call results in failwith with given string
export const string_failure = (res: test_exec_result, expected: string) : unit => {
    let expect = Test.eval(expected);
    return match (res) {
        when(Fail(x)):
            match (x) {
                when(Rejected(x)): assert (Test.michelson_equal (x[0], expect));
                when(Balance_too_low(_)): Test.failwith("contract failed: balance too low");
                when(Other(s)): Test.failwith (s);
            };
        when(Success(_)): Test.failwith("Transaction should fail");
    };
};

// Assert contract result is successful
export const tx_success = (res: test_exec_result) : unit => {
    return match (res) {
        when(Success(_)): unit;
        when(Fail(x)):
            match (x) {
                when(Rejected(x)): do {
                    Test.log(x[0]);
                    return Test.failwith("Transaction should not fail")
                };
                when(Balance_too_low(_)): Test.failwith("Transaction should not fail");
                when(Other(_)): Test.failwith("Transaction should not fail");
            };
    }
}


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

type common_storage = {
    ledger : Token.FA2.Ledger.t,
    token_metadata : Token.FA2.TokenMetadata.t,
    operators : Token.FA2.Operators.t
}

const dummy_token_info = (Map.empty as map<string, bytes>);

export const get_dummy_token_data = (token_id : nat) : Token.FA2.TokenMetadata.data => {
   return { token_id: token_id, token_info: dummy_token_info};
};


// Get the initial storage of FA2
// init_tok_amount is the amount of token allocated to every owner account
export const get_initial_storage =
(owners: [address, address,  address], ops: [address, address, address], init_tok_amount: nat): common_storage => {
    let [owner1, owner2, owner3] = owners;
    let [op1, _op2, op3] = ops;

    let ledger = Big_map.literal( list([
        [[owner1, 1n], init_tok_amount],
        [[owner2, 2n], init_tok_amount],
        [[owner3, 3n], init_tok_amount],
        [[owner1, 2n], init_tok_amount]
    ]));

    let operators  = Big_map.literal( list([
        [[owner1, op1], Set.literal(list([1n, 2n]))],
        [[owner2, op1], Set.literal(list([2n]))],
        [[owner3, op1], Set.literal(list([3n]))],
        [[op1   , op3], Set.literal(list([2n]))]
    ]));

    let token_metadata : Token.FA2.TokenMetadata.t = Big_map.literal( list([
        [1n, get_dummy_token_data(1n)],
        [2n, get_dummy_token_data(2n)],
        [3n, get_dummy_token_data(3n)]
    ]));

    return {
        ledger         : ledger,
        token_metadata : token_metadata,
        operators      : operators
    }
};


// Return str repeated n times
const repeat = (str: string, n: nat) : string => {
    let loop = (n: nat, acc: string) : string => {
        if (n == 0n) {
            return acc;
        } else {
            return loop (abs(n - 1n), acc + str)
        }
    };
    return loop(n, "")
};
 
    // Log boxed lbl

    // "+-----------+"
    // "| My string |"
    // "+-----------+"

export const describe = (lbl : string) : unit => {
    let hr = "+" + repeat("-", String.length(lbl) + 2n) + "+"; 
    Test.log (hr);
    Test.log ("| " + lbl + " |");
    Test.log (hr);
}


#import "../../src/main.jsligo" "Token"
#import "./assert.jsligo" "Assert"

// Some types for readability
type taddr = typed_address<parameter_of Token, Token.storage>;
type contr = contract<parameter_of Token>;
export type originated = {
    addr: address,
    taddr: taddr,
    //owners: address list;
    contr: contr
};

type initial_extended_storage = {
    admin : address,
    counter : nat,
    defaultExpiry : nat,
    maxExpiry : nat,
    permits : Token.Extension.permits,
    userExpiries : Token.Extension.userExpiries,
    permitExpiries : Token.Extension.permitExpiries,
    extension : Token.Extension.TokenTotalSupply.t
};

// Some dummy values when they don't matter for a given test
export const dummyDefaultExpiry = 0n;
export const dummyMaxExpiry = 0n;

export const getInitialExtendedStorage = (admin: address, initDefaultExpiry: nat, initMaxExpiry: nat) : initial_extended_storage => {
    return {
        admin : admin,
        counter : 0n,
        defaultExpiry : initDefaultExpiry,
        maxExpiry : initMaxExpiry,
        permits : (Big_map.empty as Token.Extension.permits),
        userExpiries : (Big_map.empty as Token.Extension.userExpiries),
        permitExpiries : (Big_map.empty as Token.Extension.permitExpiries),
        extension : (Big_map.empty as Token.TokenTotalSupply.t)
    };
};

// Originate a Token contract with given init_storage storage
export const originate = (init_storage: Token.storage) : originated => {
    let orig = Test.originate(contract_of(Token), init_storage, 0tez);
    let contr = Test.to_contract (orig.addr);
    let addr = Test.to_address (orig.addr);
    return { addr : addr, taddr : orig.addr, contr : contr };
};

export const originateFromFile = (init_storage : Token.storage) : originated => {
    let f = "../../src/main.jsligo";
    let orig = Test.originate_from_file(f, init_storage, 0tez);
    let contr = Test.to_contract (orig.addr);
    let addr = Test.to_address (orig.addr);
    return {addr : addr, taddr : orig.addr , contr : contr}
};


// Make a permit with given packed params and secret key
// The chain_id is equal to 0x00000000 in the test framework
export const makePermit = (hash_: bytes, account: [address, key, string], token_addr: address, counter: nat) : Token.permitParams => {
    let [_, pubKey, secretKey] = account;
    let packed = Bytes.pack ([[0x00000000, token_addr], [counter, hash_]]);
    let sig = Test.sign(secretKey, packed);
    return [pubKey, [sig, hash_]]
};

// Call entry point of Token contr contract
const call = (p: parameter_of Token, contr: contr) : test_exec_result =>
    Test.transfer_to_contract(contr, p, 0mutez)

export const permit = (p: list<Token.permitParams>, contr: contr) : test_exec_result =>
    call(Permit(p), contr)

export const setExpiry = (p: Token.expiryParams, contr: contr) : test_exec_result =>
    call(SetExpiry(p), contr)

export const setAdmin = (p: address, contr: contr) : test_exec_result =>
    call(SetAdmin(p), contr)

export const transfer = (p: Token.FA2.transfer, contr: contr) : test_exec_result => {
    let param : parameter_of Token = Transfer(p);
    return call(param, contr)
};

export const createToken = (md: Token.FA2.TokenMetadata.data, owner: address, amount: nat, contr: contr) : test_exec_result =>
    call(Create_token([md, owner, amount]), contr);

export const mintToken = (p: list<Token.mintOrBurn>, contr: contr) : test_exec_result =>
    call(Mint_token(p), contr)

export const burnToken = (p: list<Token.mintOrBurn>, contr: contr) : test_exec_result =>
    call(Burn_token(p), contr)

export const permitSuccess = (p: list<Token.permitParams>, contr: contr) : unit =>
    Assert.tx_success (permit(p, contr))

export const setExpirySuccess = (p: Token.expiryParams, contr: contr) : unit =>
    Assert.tx_success (setExpiry(p, contr))

export const setAdminSuccess = (p: address, contr: contr) : unit =>
    Assert.tx_success (setAdmin(p, contr))

export const transferSuccess = (p: Token.FA2.transfer, contr: contr) : unit =>
    Assert.tx_success (transfer(p, contr))

export const createTokenSuccess = (md: Token.FA2.TokenMetadata.data, owner: address, amount: nat, contr: contr) : unit =>
    Assert.tx_success (createToken(md, owner, amount, contr))

export const mintTokenSuccess = (p: list<Token.mintOrBurn>, contr: contr) : unit =>
    Assert.tx_success (mintToken(p, contr))

export const burnTokenSuccess = (p: list<Token.mintOrBurn>, contr: contr) : unit => {
    Assert.tx_success (burnToken(p, contr));
};

// Assert Token contract at [taddr] has permit with [address, hash] key
export const assertHasPermit = (taddr: taddr, paramPermitKey: Token.Extension.permitKey) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(paramPermitKey, s.extension.permits)) {
        when(Some(_)): unit;
        when(None()): Test.failwith("Permits Big_map key should not be missing");
    }
};

// Assert Token contract at [taddr] has no permit with [address, hash] key
export const assertNoPermit = (taddr: taddr, paramPermitKey: Token.Extension.permitKey) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(paramPermitKey, s.extension.permits)) {
        when(Some(_)): Test.failwith("Permits Big_map key should be None");
        when(None()): unit;
    }
};

// Assert Token contract at [taddr] has counter equals to [counter]
export const assertCounter = (taddr: taddr, counter: nat) : unit => {
    let s = Test.get_storage (taddr);
    assert_with_error( (s.extension.counter == counter), "Counter does not have expected value");
};

// Assert Token contract at [taddr] has user expiry for [userAddr] equal to [seconds]
export const assertUserExpiry = (taddr: taddr, userAddr: address, seconds: option<nat>) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(userAddr, s.extension.userExpiries)) {
        when(Some(s)): assert (s == seconds);
        when(None()): Test.failwith("User epiries Big_map key should not be missing");
    }
};

// Assert Token contract at [taddr] has user permit expiry for [userAddr] and
// hash [hash_] equal to [seconds]
export const assertPermitExpiry = (taddr: taddr, userAddr: address, hash_: bytes, seconds: option<nat>) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt([userAddr, hash_], s.extension.permitExpiries)) {
        when(Some(s)): assert (s == seconds);
        when(None()): Test.failwith("Permit epiries Big_map key should not be missing");
    }
};

// assert Token contract at [taddr] have [owner] address with [amount_] tokens in its ledger
export const assertBalance = (taddr: taddr, owner: address, tokenId: nat, amount_: nat) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt([owner, tokenId], s.ledger)) {
        when(Some(tokens)): assert(tokens == amount_);
        when(None()): Test.failwith("Big_map key should not be missing");
    }
};

// assert Token contract at [taddr] have tokenTotalSupply for [tokenId] matching [amount_]
export const assertSupply = (taddr: taddr, tokenId: Token.FA2.Ledger.token_id, amount_: nat) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(tokenId, s.extension.extension)) {
        when(Some(tokens)): assert(tokens == amount_);
        when(None()): Test.failwith("Big_map key should not be missing");
    }
};


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/fa2.jsligo" "FA2_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Mint_token] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful token mint
const _test_success = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (admin);
    let token_id = 1n;
    let amount_ = 56n;
    Token_helper.mintTokenSuccess(list([{
       owner: owner1_addr,
       tokenId: token_id,
       amount_: amount_
    }]), tok.contr);
    let new_amount =  init_tok_amount + amount_;
    Token_helper.assertBalance(tok.taddr, owner1_addr, token_id, new_amount);
    Token_helper.assertSupply(tok.taddr, token_id, new_amount);
};

// Failure because sender is not current admin
const _test_failure_not_admin = () : unit => {
    let [tok, _, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (owner1_addr);
    let r = Token_helper.mintToken(list([{
       owner: owner1_addr,
       tokenId: 1n,
       amount_: 1n,
    }]), tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
}

const test_success : unit = _test_success();
const test_failure_not_admin : unit = _test_failure_not_admin();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Permit] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = (init_ts: timestamp, initDefaultExpiry: nat, initMaxExpiry: nat) : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(init_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful permit creation
const _test_success_add_permit_one = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_requests : Token.FA2.transfer = list([{
                from_:owner1_addr,
                txs: (list([{
                    to_:owner2_addr,
                    amount:2n,
                    token_id:1n}]) as list<Token.FA2.atomic_trans>)
            }]);
    let hash_ = Crypto.blake2b (Bytes.pack(transfer_requests));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr, 0n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    Token_helper.assertHasPermit(tok.taddr, [owner1_addr, hash_]);
    Token_helper.assertCounter(tok.taddr, 1n)
};

// Successful successive permit creation
const _test_success_add_permit_list = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n,7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_requests : Token.FA2.transfer = list([
        {
            from_: owner1_addr,
            txs: list([
                {to_:owner2_addr, amount:2n, token_id:1n}
            ])
        }
    ]);
    let hash_ = Crypto.blake2b (Bytes.pack(transfer_requests));
    let permit1 = Token_helper.makePermit(hash_, owner1, tok.addr,0n);
    let transfer_requests2 : Token.FA2.transfer = list([
        {
            from_:owner2_addr,
            txs: list([
                { to_:owner1_addr, amount:2n, token_id:1n}
            ])
        }
    ]);
    let hash_2 = Crypto.blake2b (Bytes.pack (transfer_requests2));
    let permit2 = Token_helper.makePermit(hash_2, owner2, tok.addr,1n);
    Token_helper.permitSuccess(list([permit1, permit2]), tok.contr);
    Token_helper.assertHasPermit(tok.taddr, [owner2_addr, hash_2]);
    Token_helper.assertCounter(tok.taddr,2n)
};

// Successful permit update
const _test_success_update_permit = () : unit => {
    let initDefaultExpiry = 86_400n;
    let initMaxExpiry = 259_200n;
    let now = ("2000-01-03t10:10:10Z" as timestamp);
    let expired = ("2000-01-01t10:10:10Z" as timestamp);

    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(now);
    let [owner1, owner2, _owner3] = owners_with_keys;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;

    let transfer_requests : Token.FA2.transfer = list([
        ({from_: owner1_addr, txs: list([{to_:owner2_addr, amount:2n, token_id:1n}])})
    ]);
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_requests));

    let extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let extended_storage_modified = { ...extended_storage,
        permits : Big_map.literal (list([[
            [owner1_addr, hash_], expired
            ]])),
        counter : 1n
    };

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage_modified);
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr,1n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    Token_helper.assertHasPermit(tok.taddr, [owner1_addr, hash_])
};

// Failing permit update because it alredy exists and has not expired
const _test_success_update_permit_already_exist = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp),3600n,7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_requests : Token.FA2.transfer = list([
        ({from_:owner1_addr, txs: list([{to_:owner2_addr, amount:2n, token_id:1n}])})
    ]);
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_requests));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr,0n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    let permit2 = Token_helper.makePermit(hash_, owner1, tok.addr,1n);
    let r = Token_helper.permit(list([permit2]), tok.contr);
    Assert.string_failure(r, Token.Errors.dupPermit)
};

const test_success_add_permit_one : unit = _test_success_add_permit_one();
const test_success_add_permit_list : unit = _test_success_add_permit_list();
const test_success_update_permit : unit = _test_success_update_permit();
const test_success_update_permit_already_exist : unit = _test_success_update_permit_already_exist();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Set_admin] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful setting of admin
const _test_success_set_admin = (_: unit) : unit => {
    let [tok, admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source(admin);
    Token_helper.setAdminSuccess(owner1_addr, tok.contr);
    let s = Test.get_storage(tok.taddr);
    assert (s.extension.admin == owner1_addr)
};

// Failure because sender is not current admin
const _test_failure_not_admin = (_: unit) : unit => {
    let [tok,_admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let r = Token_helper.setAdmin(owner1_addr, tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
};

const test_success_set_admin : unit = _test_success_set_admin();
const test_failure_not_admin : unit = _test_failure_not_admin();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[SetExpiry] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = (init_ts: timestamp, initDefaultExpiry: nat, initMaxExpiry: nat) : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(init_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful setting of user expiry
const _test_success_set_user_expiry = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (owner1_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [5400n, (None() as option<bytes>)]];
    Token_helper.setExpirySuccess(expiryParams, tok.contr);
    Token_helper.assertUserExpiry(tok.taddr, owner1_addr, Some(5400n))
};

// Successful setting of permit expiry
const _test_success_set_permit_expiry = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (owner1_addr);
    let hash_ = 0x01;
    let expiryParams : Token.expiryParams = [owner1_addr, [5400n, (Some(hash_))]];
    Token_helper.setExpirySuccess(expiryParams, tok.contr);
    Token_helper.assertPermitExpiry(tok.taddr, owner1_addr, hash_, Some(5400n));
};

// Failure because sender is not the updated user expiry
const _test_failure_forbidden = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    Test.set_source (owner2_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [5400n, (None() as option<bytes>)]];
    let r = Token_helper.setExpiry(expiryParams, tok.contr);
    Assert.string_failure(r, Token.Errors.forbiddenExpiryUpdate)
};

// Failure because tried to set value exceeding maxExpiry
const _test_failure_max_seconds_exceeded = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    Test.set_source (owner2_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [14_400n, (None() as option<bytes>)]];
    let r = Token_helper.setExpiry(expiryParams, tok.contr);
    Assert.string_failure(r, Token.Errors.maxSecondsExceeded)
};

const test_success_set_user_expiry : unit = _test_success_set_user_expiry();
const test_success_set_permit_expiry : unit = _test_success_set_permit_expiry();
const test_failure_forbidden : unit = _test_failure_forbidden();
const test_failure_max_seconds_exceeded : unit = _test_failure_max_seconds_exceeded();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Transfer] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = (init_ts: timestamp, initDefaultExpiry: nat, initMaxExpiry: nat) : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(init_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful transfer with permit
const _test_success = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_request : Token.FA2.transfer_from = {
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:2n, token_id:1n}])
    };
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_request));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr, 0n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    let transfer_requests  : Token.FA2.transfer = list([transfer_request]);
    Test.set_source (owner2_addr);
    Token_helper.transferSuccess(transfer_requests, tok.contr);
    Token_helper.assertBalance(tok.taddr, owner1_addr, 1n, 8n);
    Token_helper.assertBalance(tok.taddr, owner2_addr, 1n, 2n);
    Token_helper.assertNoPermit(tok.taddr, [owner1_addr, hash_])
};

// Successful with permit expired but sender is operator
const _test_success_by_operator_with_expired_permit = () : unit => {
    let initDefaultExpiry = 86_400n;
    let initMaxExpiry = 259_200n;
    let now = ("2000-01-03t10:10:10Z" as timestamp);
    let expired = ("2000-01-01t10:10:10Z" as timestamp);

    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(now);
    let [owner1, owner2, _owner3] = owners_with_keys;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let [op1, _op2, _op3] = ops;

    let transfer_request : Token.FA2.transfer_from = {
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:2n, token_id:1n}])
    };
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_request));

    let extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let extended_storage_modified = { ...extended_storage,
        permits : Big_map.literal(list([ [[owner1_addr, hash_], expired] ])),
        counter : 1n
    };

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage_modified);
    Test.set_source (op1);
    let transfer_requests : Token.FA2.transfer = list([transfer_request]);
    Token_helper.transferSuccess(transfer_requests, tok.contr);
    Token_helper.assertBalance(tok.taddr, owner1_addr, 1n, 8n);
    Token_helper.assertBalance(tok.taddr, owner2_addr, 1n, 2n);
};

// Failing because the permit has expired
const _test_failure_expired_permit = () : unit => {
    let initDefaultExpiry = 86_400n;
    let initMaxExpiry = 259_200n;
    let now = ("2000-01-03t10:10:10Z" as timestamp);
    let expired = ("2000-01-01t10:10:10Z" as timestamp);

    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(now);
    let [owner1, owner2, _owner3] = owners_with_keys;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;

    let transfer_request = ({
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:2n, token_id:1n}])
    });
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_request));

    let extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let extended_storage_modified = { ...extended_storage,
        permits : Big_map.literal(list([
            [[owner1_addr, hash_], expired]
        ])),
        counter : 1n
    };

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage_modified);
    Test.set_source (owner2_addr);
    let r = Token_helper.transfer(list([transfer_request]), tok.contr);
    Assert.string_failure(r, Token.FA2.Errors.not_operator)
};

const test_success : unit = _test_success();
const test_success_by_operator_with_expired_permit : unit = _test_success_by_operator_with_expired_permit();
const test_failure_expired_permit : unit = _test_failure_expired_permit();


Permit-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";

Governance

Token

Utilities

Marigold