Exemple of a NFT Factory contract in CameLIGO

token_metas

generateCollection

nothing

all_collections

metadata

owned_collections

(** 
   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

[@inline]
let main ((p,s):(parameter * 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, s) : (nat * extension storage)): nat =
      TokenUsage.get_token_usage p s.extension.token_usage

[@view] let get_balance (p, s : (Address.t * nat) * 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, s) : (nat * extension storage)):  nat =
      let () = NFT.Storage.assert_token_exist s token_id in
      1n

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

[@view] let token_metadata ((p, s) : (nat * 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

type lambda_create_contract = (key_hash option * tez * ext_storage) -> (operation * address) 
type fa2_main = (NFT_FA2.parameter * ext_storage) -> (operation list * ext_storage)

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 : lambda_create_contract =
      [%Michelson ( {| { 
            UNPAIR ;
            UNPAIR ;
            CREATE_CONTRACT 
#include "generic_fa2/compiled/fa2_nft.tz"  
               ;
            PAIR } |}
              : lambda_create_contract)]
    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})


let main(ep, store : parameter * 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 })

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

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

[@view] let active_proposals : (unit * storage) -> nat list = 
    fun ((_p, s) : (unit * storage)) -> 
        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

Exemple of a NFT Factory contract in JsLIGO Resources

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

let main ((p,s):(parameter * 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, s) : (nat * extension storage)): nat =
      TokenUsage.get_token_usage p s.extension.token_usage

[@view] let get_balance (p, s : (Address.t * nat) * 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, s) : (nat * extension storage)):  nat =
      let () = NFT.Storage.assert_token_exist s token_id in
      1n

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

[@view] let token_metadata ((p, s) : (nat * 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, store] : [Parameter.generateCollectionParam, 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 = (p: [option<key_hash>, tez, extStorage]) : [operation, address] =>
      (Michelson `{ 
            UNPAIR ;
            UNPAIR ;
            CREATE_CONTRACT 
#include "generic_fa2/compiled/fa2_nft.tz"  
               ;
            PAIR }`
            as ((p: [option<key_hash>, tez, extStorage]) => [operation, address]) )(p)
   ;

    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), {
      None: () => Big_map.add( Tezos.get_sender (), (list([originate[1]]) as list<address>), store.ownedCollections),
      Some: (addrLst: list<address>) => Big_map.update( Tezos.get_sender (), (Some( list([originate[1], ...addrLst]) )), store.ownedCollections)
    });
    return [list([originate[0]]), { ...store, allCollections:newAllCollections, ownedCollections:newOwnedCollections}];
};

export const main = ([ep, store] : [parameter, storage]) : return_ => {
    match(ep, { 
      GenerateCollection: (p: Parameter.generateCollectionParam) => generateCollection(p, store),
      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, store] : [Parameter.sell_proposal_param, 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, {
        None: () => (failwith(Errors.unknownViewGetBalance) as nat),
        Some: (v: nat) => v
    });
    let usageOpt : option<nat> = Tezos.call_view("token_usage", param.token_id, param.collectionContract);
    let usageVal : nat = match(usageOpt, {
        None: () => (failwith(Errors.unknownViewTokenUsage) as nat),
        Some: (v : nat) => 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, 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); 
    let propal : Storage.sell_proposal = match(Big_map.find_opt(param.proposal_id, store.sell_proposals), {
        None: () => (failwith(Errors.unknown_proposal) as Storage.sell_proposal),
        Some: (pr: Storage.sell_proposal) => 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, {
        None: () => (failwith("Unknwon owner") as contract<unit>), 
        Some: (c: contract<unit>) => 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, {
        None: () => (failwith(Errors.unknown_fa2_contract) as contract<NFT_FA2.NFT.transfer>), 
        Some: (ct: contract<NFT_FA2.NFT.transfer>) => 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 }]
};

export const main = ([ep, store] : [parameter, storage]) : return_ => {
    match(ep, { 
        Sell: (p: sell_proposal_param) => create_sell_proposal(p, store),
        Buy: (p: buy_param) => accept_proposal(p, store)
    });
};

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

// @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, 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_code, 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) );
        "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, blacklist] : [list<address>, 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]);
            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
        });
        _tst = 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
        });
        let _tst = 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
        });
        let _ass = 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
        });
        _tst = assert(collection2MetasTok4.token_info == (Map.literal( list([ ["QRcode", 0xdeadbeefdead], ["collection", collectionNameBytes] ])) as map<string, bytes>));
        "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));

        _print = Test.log("alice transfer tok 1 to bob");
        let _src = Test.set_source(alice);
        let taddr2 = (Test.cast_address(address2) as typed_address<Factory.NFT_FA2.parameter, extFa2Storage> );
        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);
        let _tst = assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22S))(bob))(1 as nat)) );
        _tst = assert( ((Factory.NFT_FA2.get_usage_of(fa22S))(1 as nat)) == (1 as nat) );
        _tst = assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22S))(alice))(2 as nat)) ); 
        _tst = assert( ((Factory.NFT_FA2.get_usage_of(fa22S))(2 as nat)) == (0 as nat) );
        _tst = assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22S))(alice))(3 as nat)) );
        _tst = assert( ((Factory.NFT_FA2.get_usage_of(fa22S))(3 as nat)) == (0 as nat) );
        _tst = assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22S))(alice))(4 as nat)) );
        _tst = assert( ((Factory.NFT_FA2.get_usage_of(fa22S))(4 as nat)) == (0 as nat) );
        _tst = assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22S))(alice))(5 as nat)) );
        _tst = assert( ((Factory.NFT_FA2.get_usage_of(fa22S))(5 as nat)) == (0 as nat) );

        _print = Test.log("bob transfer tok 1 to steven");
        _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)}]) }]);
        _exec = Test.transfer_to_contract_exn(fa22, (Transfer(transfer1Args)), 0 as mutez);

        let fa22SAfter : extFa2Storage = Test.get_storage(taddr2);
        _tst = assert( (((Factory.NFT_FA2.Storage.is_owner_of(fa22SAfter))(steven))(1 as nat)) );
        _tst = assert( ((Factory.NFT_FA2.get_usage_of(fa22SAfter))(1 as nat)) == (2 as nat) );
        "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_code, 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) );
        "OK"
    };

    const _exec = _generates_collection_1_should_works();
};

const test = _test();

NFT-Factory-JsLIGO

requests

callback

balance_of

burn_token

create_token

mint_token

permit

setExpiry

set_admin

transfer

update_operators

permits

user_expiries

extension

ledger

operators

token_metadata

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)))

let create (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
    }

let mint (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
    }

let burn (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 *)
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 *)
let set_expiry (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 *)
let transfer_permitted (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 }

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

type parameter = 
    | Transfer of FA2.transfer
    | Balance_of of FA2.balance_of
    | Update_operators of FA2.update_operators
    | Create_token of FA2.TokenMetadata.data * address * nat
    | Mint_token of mint_or_burn list
    | Burn_token of mint_or_burn list
    | Permit of permit_params list
    | SetExpiry of expiry_params
    | Set_admin of address

let main ((p,s):(parameter * storage)): result = match p with
   Transfer         p -> transfer_permitted p s
|  Balance_of       p -> FA2.balance_of     p s
|  Update_operators p -> FA2.update_ops     p s
|  Create_token     p -> create             p s
|  Mint_token       p -> mint               p s
|  Burn_token       p -> burn               p s
|  Permit           p -> permit             p s
|  SetExpiry        p -> set_expiry         p s
|  Set_admin        p -> set_admin          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, Token.storage) typed_address
type contr = Token.parameter 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 (taddr, _, _) = Test.originate Token.main init_storage 0tez in
    let contr = Test.to_contract taddr in
    let addr = Tezos.address contr in
    { addr = addr; taddr = taddr; 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 * 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 = 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

Exemple of a permit contract in JsLIGO Resources

setAdmin

userExpiries

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>) = 
(from_: address, ext: t<T>) => {
    return match (Big_map.find_opt(from_, ext.userExpiries), {
        None: () => (Some(ext.defaultExpiry)),
        Some: exp => exp
    });
};

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


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

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

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

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

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

export const _checkNotExpired : <T>((ext: t<T>, submissionTimestamp: timestamp, paramPermitKey: permitKey) => unit) = 
(ext: t<T>, submissionTimestamp: timestamp, paramPermitKey: permitKey) => {
    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>]) = 
(ext: t<T>, paramPermitKey: permitKey) => {
    let permitSubmitTime: timestamp =
        match (Big_map.find_opt(paramPermitKey, ext.permits), {
            None: () => (0 as timestamp),
            Some: (exp: timestamp) => exp
        });
    if (permitSubmitTime == (0 as timestamp)) {
        return [false, ext]
    } else {
        let effectiveExpiry =
            match (Big_map.find_opt(paramPermitKey, ext.permitExpiries), {
                None: () => {
                    return match (Big_map.find_opt(paramPermitKey[0], ext.userExpiries), {
                        None: () => (Some(ext.defaultExpiry)),
                        Some: exp => exp
                    })
                },
                Some: (exp: option<seconds>) => exp
            });
        return match (effectiveExpiry, {
            None: () => failwith(Errors.missingExpiry),
            Some: effective_exp => {  
                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>]];

const create = ([paramCreate, s] : [[FA2.TokenMetadata.data, address, nat], storage]) : result => {
    let [metadata,owner,amount] = paramCreate;
    Extension.assertAdmin(s.extension);
    let md = Storage.addNewToken(s.token_metadata, metadata.token_id, metadata);
    let s = 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(s)(ledger);
    let supply = TokenTotalSupply.createSupply(newStore.extension.extension, metadata.token_id, amount);
    return [Constants.noOperation, { ...newStore, extension : Extension.setExtension(s.extension, supply) }]
};

const mint = ([lst, s] : [list<mintOrBurn>, 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 s = FA2.Storage.set_ledger(s)(ledger);
    return [Constants.noOperation, { ...s, extension : Extension.setExtension(s.extension, supply) }]
};

const burn = ([lst, s] : [list<mintOrBurn>, 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 s = FA2.Storage.set_ledger(s)(ledger);
   return [Constants.noOperation,{ ...s, extension : Extension.setExtension(s.extension, supply) }]
};

// TZIP-17
const permit = ([permits, s] : [list<permitParams>, 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), {
                None: () => {
                    return Extension.addPermit(ext, paramPermitKey)
                },
                Some: (submission_timestamp: timestamp) => {
                    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
const setExpiry = ([p, s] : [expiryParams, 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, {
        None: () => {
            return [
                Constants.noOperation,
                {...s, extension : { ...s.extension, 
                    userExpiries : Big_map.add(userAddress, (Some(seconds)), s.extension.userExpiries) }}
            ];
        },
        Some: (permit_hash: bytes) => {
            return [
                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
const transferPermitted = ([transfer, s]: [FA2.transfer, storage]) : result => {
     let makeTransfer = ([acc, transferFrom] : [[FA2.Ledger.t, extension], FA2.transfer_from]) : [FA2.Ledger.t, extension] => {
        let [ledger, ext] = acc;
        let transferFromHash = Crypto.blake2b(Bytes.pack(transferFrom));
        let permitKey : Extension.permitKey = [transferFrom.from_, transferFromHash]; 
        const [isTransferAuthorized, ext] = Extension.transferPresigned(ext, 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 ledger = List.fold(applyTransfer, txs, ledger);
        return [ledger, ext]
    };
    let [newLedger, newExt] = List.fold(makeTransfer, transfer, [s.ledger, s.extension]);
    return [Constants.noOperation, { ...s, ledger : newLedger, extension : newExt }]
};

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

export type parameter = 
    ["Transfer", FA2.transfer] |
    ["Balance_of", FA2.balance_of] |
    ["Update_operators", FA2.update_operators] |
    ["Create_token", [FA2.TokenMetadata.data, address, nat]] |
    ["Mint_token", list<mintOrBurn>] |
    ["Burn_token", list<mintOrBurn>] |
    ["Permit", list<permitParams>] |
    ["SetExpiry", expiryParams] |
    ["SetAdmin", address];

export const main = ([p,s]: [parameter, storage]): result => {
    return match (p, {
        Transfer:         p => transferPermitted(p,s),
        Balance_of:       p => FA2.balance_of(p)(s),
        Update_operators: p => FA2.update_ops(p)(s),
        Create_token:     p => create(p, s),
        Mint_token:       p => mint(p, s),
        Burn_token:       p => burn(p, s),
        Permit:           p => permit(p, s),
        SetExpiry:        p => setExpiry(p, s),
        SetAdmin:         p => setAdmin(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) = (s: t<T>) => {
    return s.token_metadata
};

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

export const addNewToken = ([md, tokenId, data]: [FA2.TokenMetadata.t, nat, 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, tokenId] : [t, FA2.Ledger.token_id]) : nat =>
    match (Big_map.find_opt(tokenId, supply), { 
        Some: (a: nat) => a,
        None: () => (failwith(FA2.Errors.undefined_token) as nat)
   })

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

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

export const decreaseSupply = ([supply, tokenId, amount_] : [t, FA2.Ledger.token_id, 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 
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, (7 as nat), (list([(10000000 as tez)]) 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(0 as nat),
        Test.get_bootstrap_account(1 as nat),
        Test.get_bootstrap_account(2 as nat)];

    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, ops, init_tok_amount, init_extended_storage]
: [[address, address, address], [address, address, address], nat, 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([
       [(1 as nat), init_tok_amount],
       [(2 as nat), (init_tok_amount * (2 as nat))],
       [(3 as nat), 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 = (10 as nat);

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, _, _], _, _] = owners;
    Test.set_source (admin);
    let token_id = (1 as nat);
    let amount_ = (6 as nat);
    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, _, _], _, _] = owners;
    Test.set_source (owner1_addr);
    let r = Token_helper.burnToken(list([{
       owner:owner1_addr,
       tokenId:(1 as nat),
       amount_:(1 as nat)
    }]), 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 = (10 as nat);

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_addr, _, _], _, _] = owners;
    Test.set_source (admin);
    let token_id = (42 as nat);
    let amount_ = (12 as nat);
    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_addr, _, _], _, _] = owners;
    Test.set_source (admin);
    let r = Token_helper.createToken
      (FA2_helper.get_dummy_token_data ((1 as nat)),
       owner1_addr, (12 as nat), 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_addr, _, _], _, _] = owners;
    Test.set_source (owner1_addr);
    let r = Token_helper.createToken
      (FA2_helper.get_dummy_token_data ((42 as nat)),
       owner1_addr, (12 as nat), 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, expected]: [test_exec_result, string]) : unit => {
    let expected = Test.eval(expected);
    return match (res, {
        Fail: (x: test_exec_error) => (
            match (x, {
                Rejected: (x:[michelson_code,address]) => assert (Test.michelson_equal (x[0], expected)),
                Balance_too_low: (_: unit) => Test.failwith("contract failed: balance too low"),
                Other: (s: string) => failwith (s)
            })
        ),
        Success: (_:unit) => Test.failwith("Transaction should fail")
    });
};

// Assert contract result is successful
export const tx_success = (res: test_exec_result) : unit => {
    return match (res, {
        Success: (_: unit) => unit,
        Fail: (x: test_exec_result) => (
            match (x, {
                Rejected: (x:[michelson_code,address]) => {
                    Test.log(x[0]);
                    return Test.failwith("Transaction should not fail")
                },
                Balance_too_low: (_: unit) => Test.failwith("Transaction should not fail"),
                Other: (_: unit) => 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, ops, init_tok_amount]
: [[address, address,  address], [address, address, address], nat]) : common_storage => {
    let [owner1, owner2, owner3] = owners;
    let [op1, _op2, op3] = ops;

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

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

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

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


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

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

export const describe = (lbl : string) : unit => {
    let hr = "+" + repeat("-", String.length(lbl) + (2 as nat)) + "+"; 
    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<Token.parameter, Token.storage>;
type contr = contract<Token.parameter>;
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 
const dummyDefaultExpiry = (0 as nat);
const dummyMaxExpiry = (0 as nat);

export const getInitialExtendedStorage = ([admin, initDefaultExpiry, initMaxExpiry] : [address, nat, nat]) : initial_extended_storage => {
    return {
        admin : admin,
        counter : (0 as nat),
        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 [taddr, _, _] = Test.originate(Token.main, init_storage, 0 as tez);
    let contr = Test.to_contract (taddr);
    let addr = Tezos.address (contr);
    return { addr : addr, taddr : taddr, contr : contr };
};

export const originateFromFile = (init_storage : Token.storage) : originated => {
    let f = "./src/main.jsligo";
    let v_mich = Test.run( ((x: Token.storage) => x), init_storage);
    let [addr, _, _] = Test.originate_from_file(f, "main", (list(["getDefaultExpiry", "getCounter"]) as list<string>), v_mich, 0 as tez);
    let taddr : taddr = Test.cast_address (addr);
    let contr = Test.to_contract (taddr);
    return {addr : addr, taddr : taddr, 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_, account, token_addr, counter] : [bytes, [address, key, string], address, 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, contr] : [Token.parameter, contr]) : test_exec_result =>
    Test.transfer_to_contract(contr, p, (0 as mutez))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Assert Token contract at [taddr] has counter equals to [counter]
export const assertCounter = ([taddr, counter] : [taddr, 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, userAddr, seconds] : [taddr, address, option<nat>]) : unit => {
    let s = Test.get_storage (taddr);
    match (Big_map.find_opt(userAddr, s.extension.userExpiries), {
        Some: (s: option<seconds>) => 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 [userAddr] and
// hash [hash_] equal to [seconds] 
export const assertPermitExpiry = ([taddr, userAddr, hash_, seconds] : [taddr, address, bytes, option<nat>]) : unit => {
    let s = Test.get_storage (taddr);
    match (Big_map.find_opt([userAddr, hash_], s.extension.permitExpiries), {
        Some: (s: option<seconds>) => 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
export const assertBalance = ([taddr, owner, tokenId, amount_] : [taddr, address, nat, nat]) : unit => {
    let s = Test.get_storage (taddr);
    match (Big_map.find_opt([owner, tokenId], s.ledger), {
        Some: (tokens: nat) => assert(tokens == amount_),
        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, tokenId, amount_] : [taddr, Token.FA2.Ledger.token_id, nat]) : unit => {
    let s = Test.get_storage (taddr);
    match (Big_map.find_opt(tokenId, s.extension.extension), {
        Some: (tokens: nat) => assert(tokens == amount_),
        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 = 10 as nat;

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, _, _], _, _] = owners;
    Test.set_source (admin);
    let token_id = (1 as nat);
    let amount_ = (56 as nat);
    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, _, _], _, _] = owners;
    Test.set_source (owner1_addr);
    let r = Token_helper.mintToken(list([{
       owner: owner1_addr,
       tokenId: (1 as nat),
       amount_: (1 as nat),
    }]), 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 = 10 as nat;

const bootstrap = ([init_ts, initDefaultExpiry, initMaxExpiry] : [timestamp, nat, 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), 3600 as nat, 7200 as nat);
    let [owner1, owner2, _] = owners;
    let [owner1_addr, _, _] = owner1;
    let [owner2_addr, _, _] = owner2;
    let transfer_requests : Token.FA2.transfer = list([{
                from_:owner1_addr,
                txs: (list([{
                    to_:owner2_addr,
                    amount:(2 as nat),
                    token_id:(1 as nat)}]) as list<Token.FA2.atomic_trans>)
            }]);
    let hash_ = Crypto.blake2b (Bytes.pack(transfer_requests));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr, 0 as nat);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    Token_helper.assertHasPermit(tok.taddr, [owner1_addr, hash_]);
    Token_helper.assertCounter(tok.taddr, 1 as nat)
};

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

// Successful permit update 
const _test_success_update_permit = () : unit => {
    let initDefaultExpiry = 86_400 as nat;
    let initMaxExpiry = 259_200 as nat;
    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, _] = owners_with_keys;
    let [owner1_addr, _, _] = owner1;
    let [owner2_addr, _, _] = owner2;

    let transfer_requests : Token.FA2.transfer = list([
        ({from_: owner1_addr, txs: list([{to_:owner2_addr, amount:(2 as nat), token_id:(1 as nat)}])})
    ]);
    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 : (1 as nat)
    };

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage_modified);
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr,(1 as nat));
    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),(3600 as nat),(7200 as nat));
    let [owner1, owner2, _] = owners;
    let [owner1_addr, _, _] = owner1;
    let [owner2_addr, _, _] = owner2;
    let transfer_requests : Token.FA2.transfer = list([
        ({from_:owner1_addr, txs: list([{to_:owner2_addr, amount:(2 as nat), token_id:(1 as nat)}])})
    ]);
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_requests));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr,(0 as nat));
    Token_helper.permitSuccess(list([permit]), tok.contr);
    let permit2 = Token_helper.makePermit(hash_, owner1, tok.addr,(1 as nat));
    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 = (10 as nat);

const bootstrap = (_: unit) : [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, _, _] = owners;
    let [owner1_addr, _, _] = 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,_, owners] = bootstrap();
    let [owner1, _, _] = owners;
    let [owner1_addr, _, _] = 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 = 10 as nat;

const bootstrap = ([init_ts, initDefaultExpiry, initMaxExpiry] : [timestamp, nat, 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), 3600 as nat, 7200 as nat);
    let [owner1, _, _] = owners;
    let [owner1_addr, _, _] = owner1;
    Test.set_source (owner1_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [(5400 as nat), (None() as option<bytes>)]];
    Token_helper.setExpirySuccess(expiryParams, tok.contr);
    Token_helper.assertUserExpiry(tok.taddr, owner1_addr, Some(5400 as nat))
};

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

// 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), (3600 as nat), (7200 as nat));
    let [owner1, owner2, _] = owners;
    let [owner1_addr, _, _] = owner1;
    let [owner2_addr, _, _] = owner2;
    Test.set_source (owner2_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [(5400 as nat), (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), (3600 as nat), (7200 as nat));
    let [owner1, owner2, _] = owners;
    let [owner1_addr, _, _] = owner1;
    let [owner2_addr, _, _] = owner2;
    Test.set_source (owner2_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [14_400 as nat, (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 = (10 as nat);

const bootstrap = ([init_ts, initDefaultExpiry, initMaxExpiry] : [timestamp, nat, 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), (3600 as nat), (7200 as nat));
    let [owner1, owner2, _] = owners;
    let [owner1_addr, _, _] = owner1;
    let [owner2_addr, _, _] = owner2;
    let transfer_request : Token.FA2.transfer_from = {
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:(2 as nat), token_id:(1 as nat)}])
    };
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_request));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr, (0 as nat));
    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, (1 as nat), (8 as nat));
    Token_helper.assertBalance(tok.taddr, owner2_addr, (1 as nat), (2 as nat));
    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_400 as nat;
    let initMaxExpiry = 259_200 as nat;
    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, _] = owners_with_keys;
    let [owner1_addr, _, _] = owner1;
    let [owner2_addr, _, _] = owner2;
    let [op1, _, _] = ops;

    let transfer_request : Token.FA2.transfer_from = {
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:(2 as nat), token_id:(1 as nat)}])
    };
    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 : (1 as nat)
    };

    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, (1 as nat), (8 as nat));
    Token_helper.assertBalance(tok.taddr, owner2_addr, (1 as nat), (2 as nat));
};

// Failing because the permit has expired
const _test_failure_expired_permit = () : unit => {
    let initDefaultExpiry = 86_400 as nat;
    let initMaxExpiry = 259_200 as nat;
    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, _] = owners_with_keys;
    let [owner1_addr, _, _] = owner1;
    let [owner2_addr, _, _] = owner2;

    let transfer_request = ({
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:(2 as nat), token_id:(1 as nat)}])
    });
    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 : (1 as nat)
    };

    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();


Explore token

Marigold