ligo-extendable-fa2

ligo-breathalyzer

An example of NFT factory contract written in cameligo

nft-factory-cameligo

ligo-generic-fa2.1

checker

A LIGO library with a neat abstraction over list

@ligo/bigarray

A FA2 contract with nft, single asset & multi asset contracts

@ligo/fa

A math library for LIGO with support for Float & Rational numbers

@ligo/math-lib

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

@ligo/permit

description_link

hash

propose

cancel

lock

release

outcome_key

packed

execute

vote

end_vote

metadata

governance_token

deposit_amount

refund_threshold

quorum_threshold

super_majority

start_delay

voting_period

timelock_delay

timelock_period

burn_address

config

vault

proposal

outcomes

next_outcome_id

#import "../src/lambda.mligo" "Lambda"

(* 
    Sample lambda code for an empty list of operations
    Notice that a type from the Lambda module is used
    See Makefile compile-lambda target for usage with ligo CLI
*)

let lambda_ : Lambda.operation_list =
  fun () -> ([] : operation list)


#import "../src/lambda.mligo" "Lambda"
#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "SingleAsset"

(* Sample lambda that calls an FA2 transfer entrypoint *)

let lambda_ : Lambda.operation_list =
  fun () ->
    match (Tezos.get_entrypoint_opt
             "%transfer"
             ("KT1QAShr81NcaFZyJR4srfYGuvPyD8ibbMtT"
              : address)
           : SingleAsset.transfer contract option)
    with
      None -> failwith ("TOKEN_CONTRACT_NOT_FOUND")
    | Some (c) ->
        let transfer_requests =
          ([({from_ =
                ("KT1BWSmjEhEknnBWSYrrSdhH217osBbwdVos"
                 : address);
              tx =
                ([{to_ =
                     ("tz1burnburnburnburnburnburnburjAYjjX"
                      : address);
                   amount = 4000n}]
                 : SingleAsset.atomic_trans list)})]
           : SingleAsset.transfer) in
        let op =
          Tezos.transaction transfer_requests 0mutez c in
        [op]


#import "../src/lambda.mligo" "Lambda"

(* 
    A parameter change lambda is just a new record of type Config.t, 
    the storage will be updated with the differences when the lambda is 
    executed
*)

let lambda_ : Lambda.parameter_change =
  fun () ->
    {deposit_amount = 400n;
     refund_threshold = 32n;
     quorum_threshold = 67n;
     super_majority = 80n;
     start_delay = 86400n;
     voting_period = 604800n;
     timelock_delay = 86400n;
     timelock_period = 259200n;
     burn_address =
       ("tz1burnburnburnburnburnburnburjAYjjX" : address)}


(*
    quorum_threshold, refund_threshold and super_majority
    are represented with scale = 2, ex. 80 = .80 = 80%

    x_delay and x_period are represented by time units in seconds
*)
type t =
    [@layout:comb]
    {
        deposit_amount: nat;
        (* ^ The amount of tokens required to be deposited when creating a proposal *)

        refund_threshold: nat;
        (* ^ The minimal amount of participating tokens required for the deposit to be refunded *)

        quorum_threshold: nat;
        (* ^ The minimal participation percentage needed for a proposal to pass *)

        super_majority: nat;
        (* ^ The percentage needed for a super majority ("yes" votes) *)

        start_delay: nat;
        (* ^ The delay for the vote to start *)

        voting_period: nat;
        (* ^ The period during which voting is live *)

        timelock_delay: nat;
        (* ^ Delay before an approved proposal can be executed *)

        timelock_period: nat;
        (* ^ The period during which a timelock can be executed *)

        burn_address: address;
        (* ^ The burn address for unrefunded deposits *)
    }


let proposal_already_exists = "PROPOSAL_ALREADY_EXISTS"
let voting_period = "VOTING_PERIOD"
let not_voting_period = "NOT_VOTING_PERIOD"
let no_proposal = "NO_PROPOSAL"
let not_creator = "NOT_CREATOR"
let timelock_not_found = "TIMELOCK_NOT_FOUND"
let timelock_locked = "TIMELOCK_LOCKED"
let timelock_unlocked = "TIMELOCK_UNLOCKED"
let not_zero_amount = "NOT_ZERO_AMOUNT"
let no_locked_tokens = "NO_LOCKED_TOKENS"
let not_enough_balance = "NOT_ENOUGH_BALANCE"
let receiver_not_found = "RECEIVER_NOT_FOUND"
let fa2_total_supply_not_found = "FA2_TOTAL_SUPPLY_NOT_FOUND"
let outcome_not_found = "OUTCOME_NOT_FOUND"
let already_executed = "ALREADY_EXECUTED"
let not_executable = "NOT_EXECUTABLE"
let hash_not_found = "HASH_NOT_FOUND"
let hash_not_match = "HASH_NOT_MATCH"
let unpack_mismatch = "UNPACK_MISMATCH"
let nothing_to_cancel = "NOTHING_TO_CANCEL"


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

type parameter_change = (unit -> Config.t)
type operation_list = (unit -> operation list)

type t =
    ParameterChange of parameter_change
    | OperationList of operation_list

let unpack (hash_opt, packed : bytes option * bytes) =
    match hash_opt with
        None -> (failwith Errors.hash_not_found : t)
      | Some hash_ -> let _check_hash =
        assert_with_error
          (hash_ = Crypto.sha256 packed)
          Errors.hash_not_match
      in (match (Bytes.unpack packed : t option) with
        None -> failwith(Errors.unpack_mismatch)
        | Some lambda_ -> lambda_)


#import "./constants.mligo" "Constants"
#import "./errors.mligo" "Errors"
#import "./lambda.mligo" "Lambda"
#import "./outcome.mligo" "Outcome"
#import "./proposal.mligo" "Proposal"
#import "./storage.mligo" "Storage"
#import "./vote.mligo" "Vote"
#import "./token.mligo" "Token"
#import "./vault.mligo" "Vault"
#import "./timelock.mligo" "Timelock"

type parameter =
    [@layout:comb]
    | Propose of Proposal.make_params
    | Cancel of nat option
    | Lock of Vault.amount_
    | Release of Vault.amount_
    | Execute of Outcome.execute_params
    | Vote of Vote.choice
    | End_vote

type storage = Storage.t
type result = operation list * storage

let execute (outcome_key, packed, s: nat * bytes * storage) : result =
    let proposal = (match Big_map.find_opt outcome_key s.outcomes with
        None -> failwith Errors.outcome_not_found
        | Some(o) -> Outcome.get_executable_proposal(o)) in

    let () = Timelock._check_unlocked(proposal.timelock) in
    let lambda_ = Lambda.unpack(proposal.hash, packed) in

    match lambda_ with
        OperationList f ->
            f(),
            Storage.update_outcome(outcome_key, (proposal, Executed), s)
        | ParameterChange f ->
            Constants.no_operation,
            Storage.update_outcome(
                outcome_key,
                (proposal, Executed),
                Storage.update_config(f,s)
            )

let propose (p, s : Proposal.make_params * storage) : result =
    match s.proposal with
        Some(_) -> failwith Errors.proposal_already_exists
        | None -> [
            Token.transfer(
                s.governance_token,
                Tezos.get_sender(),
                Tezos.get_self_address(),
                s.config.deposit_amount
        )], Storage.create_proposal(
                Proposal.make(p, s.config.start_delay, s.config.voting_period),
                s)

let cancel (outcome_key_opt, s : nat option * storage) : result =
   [Token.transfer(
        s.governance_token,
        Tezos.get_self_address(),
        s.config.burn_address,
        s.config.deposit_amount)
   ], (match outcome_key_opt with
        None -> (match s.proposal with
            None -> failwith Errors.nothing_to_cancel
            | Some(p) -> let () = Proposal._check_not_voting_period(p) in
                let _check_sender_is_creator = assert_with_error
                    (p.creator = Tezos.get_sender())
                    Errors.not_creator in
                Storage.add_outcome((p, Canceled), s))
        | Some(outcome_key) -> (match Big_map.find_opt outcome_key s.outcomes with
            None -> failwith Errors.outcome_not_found
            | Some(o) -> let (p, state) = o in
            let _check_sender_is_creator = assert_with_error
                (p.creator = Tezos.get_sender())
                Errors.not_creator in
            let _check_not_executed = assert_with_error
                (state <> (Executed : Outcome.state))
                Errors.already_executed in
            let () = Timelock._check_locked(p.timelock) in
            Storage.update_outcome(outcome_key, (p, Canceled), s)))

let lock (amount_, s : nat * storage) : result =
    let () = Proposal._check_no_vote_ongoing(s.proposal) in
    let current_amount = Vault.get_for_user(s.vault, Tezos.get_sender()) in

    [Token.transfer(
        s.governance_token,
        Tezos.get_sender(),
        Tezos.get_self_address(), amount_)
    ], Storage.update_vault(Vault.update_for_user(
        s.vault,
        Tezos.get_sender(),
        current_amount + amount_), s)

let release (amount_, s : nat * storage) : result =
    let () = Proposal._check_no_vote_ongoing(s.proposal) in
    let current_amount = Vault.get_for_user_exn(s.vault, Tezos.get_sender()) in
    let _check_balance = assert_with_error
        (current_amount >= amount_)
        Errors.not_enough_balance in

    [Token.transfer(s.governance_token, Tezos.get_self_address(), Tezos.get_sender(), amount_)],
    Storage.update_vault(Vault.update_for_user(
        s.vault,
        Tezos.get_sender(),
        abs(current_amount - amount_)), s)

let vote (choice, s : bool * storage) : storage =
    match s.proposal with
        None -> failwith Errors.no_proposal
        | Some(p) -> let () = Proposal._check_is_voting_period(p) in
            let amount_ = Vault.get_for_user_exn(s.vault, Tezos.get_sender()) in
            Storage.update_votes(p, (choice, amount_), s)

let end_vote (s : storage) : result =
    match s.proposal with
        None -> failwith Errors.no_proposal
        | Some(p) -> let () = Proposal._check_voting_period_ended(p) in
            let total_supply = (match Token.get_total_supply(s.governance_token) with
                None -> failwith Errors.fa2_total_supply_not_found
                | Some n -> n) in
            let outcome = Outcome.make(
                    p,
                    total_supply,
                    s.config.refund_threshold,
                    s.config.quorum_threshold,
                    s.config.super_majority
                ) in
            let (_, state) = outcome in
            let transfer_to_addr = match state with
                Rejected_(WithoutRefund) -> s.config.burn_address
                | _ -> p.creator
            in
            ([Token.transfer(
                s.governance_token,
                Tezos.get_self_address(),
                transfer_to_addr,
                s.config.deposit_amount)]
            ), Storage.add_outcome(outcome, s)

let main (action, store : parameter * storage) : result =
    let _check_amount_is_zero = assert_with_error
        (Tezos.get_amount() = 0tez)
        Errors.not_zero_amount
    in match action with
        Propose p -> propose(p, store)
        | Cancel n_opt -> cancel(n_opt, store)
        | Lock n -> lock(n, store)
        | Release n -> release(n, store)
        | Execute p -> execute(p.outcome_key, p.packed, store)
        | Vote v -> Constants.no_operation, vote(v, store)
        | End_vote -> end_vote(store)


(* tzip-16 https://tzip.tezosagora.org/proposal/tzip-16/ *)
type t = (string, bytes) big_map


#import "./proposal.mligo" "Proposal"
#import "./vote.mligo" "Vote"
#import "./errors.mligo" "Errors"
// #import "./outcome.mligo" "Outcome"

type rejected_state_extra = WithRefund | WithoutRefund
type state = Accepted | Rejected_ of rejected_state_extra | Executed | Canceled

type t = (Proposal.t * state)

type execute_params =
    [@layout:comb]
    {
        outcome_key: nat;
        packed: bytes;
        // ^ the packed Lambda.t
    }

let make (
    p,
    total_supply,
    refund_threshold,
    quorum_threshold,
    super_majority
    : Proposal.t * nat * nat * nat * nat
) : t =
    let (total, for, against) = Vote.count(p.votes) in
    let state = (if ((total / total_supply * 100n) < refund_threshold)
        then Rejected_(WithoutRefund)
        else if ((for / total * 100n) < super_majority)
            || ((total / total_supply * 100n) < quorum_threshold)
        then Rejected_(WithRefund)
        else if for > against then (Accepted : state) else Rejected_(WithRefund)) in
    (p, state)

let get_executable_proposal(outcome : t) : Proposal.t =
    match outcome with
        (proposal, Accepted) -> proposal
        | (_,_) -> (failwith Errors.not_executable : Proposal.t)


#import "./errors.mligo" "Errors"
#import "./vote.mligo" "Vote"
#import "./timelock.mligo" "Timelock"

type t =
    [@layout:comb]
    {
        description_link: string;
        hash: bytes option;
        start_at: timestamp;
        end_at: timestamp;
        votes: Vote.votes;
        creator: address;
        timelock: Timelock.t option;
    }

type make_params =
    [@layout:comb]
    {
        description_link: string;
        hash: bytes option;
    }

let make (p, start_delay, voting_period : make_params * nat * nat) : t =
    let start_at = Tezos.get_now() + int(start_delay) in
    {
        description_link = p.description_link;
        hash = p.hash;
        start_at = start_at;
        end_at = start_at + int(voting_period);
        votes = (Map.empty: Vote.votes);
        creator = Tezos.get_sender();
        timelock = (None : Timelock.t option);
    }

let is_voting_period (p : t) =
    ((Tezos.get_now() >= p.start_at) && (Tezos.get_now() < p.end_at))

let _check_not_voting_period (p : t) =
    assert_with_error
        (not is_voting_period(p))
        Errors.voting_period

let _check_is_voting_period (p : t) =
    assert_with_error
        (is_voting_period(p))
        Errors.not_voting_period

let _check_no_vote_ongoing (p_opt : t option) =
    match p_opt with
        Some(p) -> _check_not_voting_period(p)
        | None -> ()

let _check_voting_period_ended (p : t) =
    assert_with_error
        (Tezos.get_now() > p.end_at)
        Errors.voting_period


#import "./config.mligo" "Config"
#import "./lambda.mligo" "Lambda"
#import "./metadata.mligo" "Metadata"
#import "./outcome.mligo" "Outcome"
#import "./proposal.mligo" "Proposal"
#import "./timelock.mligo" "Timelock"
#import "./token.mligo" "Token"
#import "./vault.mligo" "Vault"
#import "./vote.mligo" "Vote"

type outcomes = (nat, Outcome.t) big_map

type t =
    [@layout:comb]
    {
        metadata: Metadata.t;
        governance_token: Token.t;
        config: Config.t;
        vault: Vault.t;
        proposal: Proposal.t option;
        outcomes: outcomes;
        next_outcome_id: nat;
    }

let create_proposal (p, s : Proposal.t * t) : t =
    { s with proposal = Some(p) }

let update_config (f, s : Lambda.parameter_change * t) : t =
    { s with config = f() }

let update_vault (v, s : Vault.t * t) : t =
    { s with vault = v }

let update_votes (p, v, s : Proposal.t * Vote.t * t) : t =
    let new_votes = Map.update (Tezos.get_sender()) (Some(v)) p.votes in
    let new_proposal = { p with votes = new_votes } in
    { s with proposal = Some(new_proposal) }

let update_outcome (k, o, s : nat * Outcome.t * t) : t =
    { s with outcomes = Big_map.update k (Some(o)) s.outcomes }

let add_outcome (o, s : Outcome.t * t) : t =
    let (proposal, status) = o in
    let proposal = (match status with
        (* If proposal is accepted, also create timelock *)
        Accepted -> let unlock_at = Tezos.get_now() + int(s.config.timelock_delay) in
            { proposal with timelock = Some(Timelock.make(
                unlock_at,
                s.config.timelock_period)
            )}
        | _ -> proposal)
    in
    { s with
        proposal = (None : Proposal.t option);
        outcomes = Big_map.update s.next_outcome_id (Some(proposal, status)) s.outcomes;
        next_outcome_id = s.next_outcome_id + 1n
    }


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

type t =
    [@layout:comb]
    {
        unlock_at: timestamp;
        (* ^ timestamp for the unlock to happen *)

        relock_at: timestamp;
        (* ^ timestamp for the relock to happen *)
    }

let make (unlock_at, timelock_period : timestamp * nat) : t =
    {
       unlock_at = unlock_at;
       relock_at = unlock_at + int(timelock_period);
    }

let is_locked (t : t) = ((Tezos.get_now() < t.unlock_at) || (Tezos.get_now() >= t.relock_at))

let _check_unlocked (t_opt : t option) =
    match t_opt with
        None -> failwith Errors.timelock_not_found
        | Some(t) -> assert_with_error
            (not is_locked(t))
            Errors.timelock_locked

let _check_locked (t_opt : t option) =
    match t_opt with
        None -> failwith Errors.timelock_not_found
        | Some(t) -> assert_with_error
            (is_locked(t))
            Errors.timelock_unlocked


#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "FA2"
#import "./errors.mligo" "Errors"

type t = address

let get_transfer_entrypoint (addr : address) : FA2.transfer contract =
    match (Tezos.get_entrypoint_opt "%transfer" addr : FA2.transfer contract option) with
        None -> failwith Errors.receiver_not_found
        | Some c -> c

let transfer (token_addr, from_, to_, amount_: t * address * address * nat) : operation =
    let dest = get_transfer_entrypoint (token_addr) in
    let transfer_requests = ([
      ({from_=from_; txs=([{to_;amount=amount_;token_id=0n}] : FA2.atomic_trans list)});
    ] : FA2.transfer) in
    Tezos.transaction transfer_requests 0mutez dest

let get_total_supply (token_addr : t) : nat option = Tezos.call_view "total_supply" unit token_addr


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

type owner = address
type amount_ = nat
type t = (owner, amount_) big_map

let get_for_user (vault, owner: t * owner) : amount_ =
    match Big_map.find_opt owner vault with
        Some (tokens) -> tokens
        | None -> 0n

let get_for_user_exn (vault, owner: t * owner) : amount_ =
    let amount_ = get_for_user(vault, owner) in
    if (amount_ = 0n)
        then failwith Errors.no_locked_tokens
        else amount_

let update_for_user (vault, owner, amount_ : t * owner * nat) : t =
    Big_map.update owner (Some amount_) vault


type choice = bool
type t = (choice * nat)
type votes = (address, t) map

(**
    [count (votes)] is the count of [votes].
    Returns a triple of:
        - total votes (for + against),
        - sum of votes for,
        - sum of votes against.
*)
let count (votes : votes) : (nat * nat * nat) =
  let sum =
    fun ((for, against), (_, (choice, nb)) : (nat * nat) * (address * (t))) ->
      if choice
      then (for + nb, against)
      else (for, against + nb) in
  let (for, against) = Map.fold sum votes (0n, 0n) in
  (for + against, for, against)


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "../helpers/token.mligo" "Token_helper"
#import "../helpers/dao.mligo" "DAO_helper"
#import "../../src/main.mligo" "DAO"

(*
    Boostrapping of the test environment,
    init_tok_amount is the amount of token allocated to every
    bootstrapped accounts
*)
let boot (init_tok_amount, init_dao_storage : nat * DAO.storage) =
    (* Originate the token contract and the contract under test *)
    let tok = Token_helper.originate(init_tok_amount) in
    (* Override governance token with test token *)
    let init_dao_storage = { init_dao_storage with governance_token = tok.addr } in
    let dao = DAO_helper.originate(init_dao_storage) in

    (* Add the dao as operator for all the FA2 owner addresses
        TODO: ... in the real world, remove operator? *)
    let () = List.iter (fun (owner: address) ->
        let () = Test.set_source owner in
        Token_helper.add_operators(
            [{ owner = owner; operator = dao.addr; token_id = 0n } ],
            tok.contr
        )) tok.owners in

    (* Set a token owner as sender in the Test framework *)
    let sender_ = List_helper.nth_exn 1 tok.owners in
    let () = Test.set_source sender_ in

    (* Set the baker to 5th account *)
    let baker = Test.nth_bootstrap_account 5 in
    let () = Test.set_baker baker in

    (tok, dao, sender_)


#include "@ligo/fa/lib/fa2/asset/single_asset.mligo"

(* Extension of FA2 to be used as governance token of the DAO *)

[@view] let total_supply (_, _s : unit * storage) : nat =
    30n


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/suite.mligo" "Suite_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

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

(* Boostrapping of the test environment, *)
let init_tok_amount = 33n
let bootstrap (init_dao_storage : DAO.storage) =
    Bootstrap.boot(init_tok_amount, init_dao_storage)
let empty_nat_option = (None: nat option)
let base_config = DAO_helper.base_config
let base_storage = DAO_helper.base_storage


(* Successful cancel of current proposal *)
let test_success_current_proposal =
    let config = { base_config with start_delay = 86400n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, sender_) = bootstrap(dao_storage) in

    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in
    let () = DAO_helper.cancel_success(empty_nat_option, dao.contr) in
    let dao_storage = Test.get_storage dao.taddr in
    let () = DAO_helper.assert_proposal_state(dao_storage.outcomes, 1n, Canceled) in
    Token_helper.assert_balance_amount(
        tok.taddr,
        sender_,
        abs(init_tok_amount - dao_storage.config.deposit_amount)
    )

(* Succesful cancel of accepted proposal, before timelock is unlocked *)
let test_success_accepted_proposal =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n;
        timelock_delay = 3000n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in
    let () = DAO_helper.cancel_success(Some(1n), dao.contr) in
    let dao_storage = Test.get_storage dao.taddr in
    DAO_helper.assert_proposal_state(dao_storage.outcomes, 1n, Canceled)

(* Failing cancel because there is nothing to cancel *)
let test_failure_nothing_to_cancel =
    let (_, dao, _) = bootstrap(base_storage) in

    let r = DAO_helper.cancel(empty_nat_option, dao.contr) in
    Assert.string_failure r DAO.Errors.nothing_to_cancel

(* Failing cancel because the outcome was not found *)
let test_failure_outcome_not_found =
    let (_, dao, _) = bootstrap(base_storage) in

    let r = DAO_helper.cancel(Some(23n), dao.contr) in
    Assert.string_failure r DAO.Errors.outcome_not_found

(* Failing cancel proposal because not creator *)
let test_failure_not_creator =
    let config = { base_config with start_delay = 1200n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in
    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let sender_ = List_helper.nth_exn 2 tok.owners in
    let () = Test.set_source sender_ in
    let r = DAO_helper.cancel(empty_nat_option, dao.contr) in
    Assert.string_failure r DAO.Errors.not_creator

(* Failing cancel proposal because timelock is unlocked *)
let test_failure_timelock_unlocked =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n; } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let r = DAO_helper.cancel(Some(1n), dao.contr) in
    Assert.string_failure r DAO.Errors.timelock_unlocked

(* Failing cancel proposal because it was already executed *)
let test_failure_already_executed =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n; } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in
    let () = DAO_helper.execute_success(1n, DAO_helper.dummy_packed, dao.contr) in

    let r = DAO_helper.cancel(Some(1n), dao.contr) in
    Assert.string_failure r DAO.Errors.already_executed


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/suite.mligo" "Suite_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

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

(* Boostrapping of the test environment, *)
let init_tok_amount = 33n
let bootstrap () =
    let base_config = DAO_helper.base_config in
    let base_storage = DAO_helper.base_storage in
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n;
    } in
    let dao_storage = { base_storage with config = config } in
    Bootstrap.boot(init_tok_amount, dao_storage)

(* Successful end_vote with proposal accepted *)
let test_success_prop_accepted =
    let (tok, dao, _) = bootstrap() in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in
    let dao_storage = Test.get_storage dao.taddr in
    let () = assert (dao_storage.proposal = (None: DAO.Proposal.t option)) in
    DAO_helper.assert_proposal_state(dao_storage.outcomes, 1n, Accepted)

(* Successful end_vote with proposal rejected because quorum was not reached *)
let test_success_prop_rejected_quorum_not_reached =
    let (tok, dao, _) = bootstrap() in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 5n, true); (1, 5n, true); (2, 5n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let dao_storage = Test.get_storage dao.taddr in
    DAO_helper.assert_proposal_state(dao_storage.outcomes, 1n, Rejected_(WithoutRefund))

(* Successful end_vote with proposal rejected because super_majority was not reached *)
let test_success_prop_rejected_super_maj_not_reached =
    let (tok, dao, _) = bootstrap() in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 15n, true); (1, 15n, true); (2, 15n, false)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in
    let dao_storage = Test.get_storage dao.taddr in
    DAO_helper.assert_proposal_state(dao_storage.outcomes, 1n, Rejected_(WithRefund))

(* Failing end_vote because proposal voting period ongoing *)
let test_failure_voting_period =
    let (_, dao, _) = bootstrap() in

    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let r = DAO_helper.end_vote(dao.contr) in
    Assert.string_failure r DAO.Errors.voting_period

(* TODO: test for total_supply_not_found error *)


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/suite.mligo" "Suite_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

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

(* Boostrapping of the test environment, *)
let init_tok_amount = 33n
let bootstrap (init_dao_storage : DAO.storage) =
    Bootstrap.boot(init_tok_amount, init_dao_storage)
let base_config = DAO_helper.base_config
let base_storage = DAO_helper.base_storage

(* Successful timelock execution of an operation list *)
let test_success =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n; } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(
        tok,
        dao,
        Some(DAO_helper.dummy_hash),
        votes
    ) in

    let () = DAO_helper.execute_success(1n, DAO_helper.dummy_packed, dao.contr) in
    DAO_helper.assert_executed(dao.taddr, 1n)

(* Successful execution of a parameter change *)
let test_success_parameter_changed =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n; } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let base_config = DAO_helper.base_config in
    let packed = Bytes.pack (ParameterChange(
        fun() -> { base_config with quorum_threshold = 51n }
    ) : DAO.Lambda.t) in
    let hash_ = Some(Crypto.sha256 packed) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let () = DAO_helper.execute_success(1n, packed, dao.contr) in
    let () = DAO_helper.assert_executed(dao.taddr, 1n) in
    let dao_storage = Test.get_storage dao.taddr in

    (* Assert that the config has been updated *)
    assert(dao_storage.config.quorum_threshold = 51n)

(* Successful execution of an operation list *)
let test_success_operation_list =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n; } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in
    let owner2 = List_helper.nth_exn 2 tok.owners in
    let owner2_initial_balance = Token_helper.get_balance_for(tok.taddr, owner2) in

    (* Pack an operation that will send 2 tokens from DAO to owner2 *)
    let owner2_amount_to_receive = 2n in
    let op_list = Token_helper.create_transfer_callable (
            tok.addr, dao.addr, owner2, owner2_amount_to_receive
    ) in
    let packed = Bytes.pack(OperationList(op_list) : DAO.Lambda.t) in

    let owner2_amount_locked = 25n in
    let hash_ = Some(Crypto.sha256 packed) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, owner2_amount_locked, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let () = DAO_helper.execute_success(1n, packed, dao.contr) in
    let () = DAO_helper.assert_executed(dao.taddr, 1n) in

    let owner2_expected_balance : nat = abs(
        owner2_initial_balance
        - owner2_amount_locked
        + owner2_amount_to_receive)
    in
    Token_helper.assert_balance_amount(tok.taddr, owner2, owner2_expected_balance)

(* Failing because no outcome *)
let test_failure_no_outcome =
    let (_, dao, _) = bootstrap(base_storage) in

    let r = DAO_helper.execute(1n, DAO_helper.dummy_packed, dao.contr) in
    Assert.string_failure r DAO.Errors.outcome_not_found

(* Failing because timelock delay not elapsed *)
let test_failure_timelock_delay_not_elapsed =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n;
        timelock_delay = 1800n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let r = DAO_helper.execute(1n, DAO_helper.dummy_packed, dao.contr) in
    Assert.string_failure r DAO.Errors.timelock_locked

(* Failing because timelock has been relocked *)
let test_failure_timelock_relocked =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n;
        timelock_period = 10n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let r = DAO_helper.execute(1n, DAO_helper.dummy_packed, dao.contr) in
    Assert.string_failure r DAO.Errors.timelock_locked

(* Failing because the packed data is not matching expected type *)
let test_failure_unpack_mismatch =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let packed = Bytes.pack("") in
    let hash_ = Some(Crypto.sha256(packed)) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let r = DAO_helper.execute(1n, packed, dao.contr) in
    Assert.string_failure r DAO.Errors.unpack_mismatch

(* Failing because the hash doesn't match the packed bytes *)
let test_failure_hash_not_match =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 1800n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(0x01) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let r = DAO_helper.execute(1n, DAO_helper.dummy_packed, dao.contr) in
    Assert.string_failure r DAO.Errors.hash_not_match


(* 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" "DAO"
#import "./assert.mligo" "Assert"

(* Some types for readability *)
type taddr = (DAO.parameter, DAO.storage) typed_address
type contr = DAO.parameter contract
type originated = {
    addr: address;
    taddr: taddr;
    contr: contr;
}

(* Some dummy values intended to be used as placeholders *)
let dummy_packed = Bytes.pack (OperationList(fun () -> ([] : operation list)) : DAO.Lambda.t)
let dummy_hash = Crypto.sha256 dummy_packed

let dummy_proposal : DAO.Proposal.make_params = {
    description_link = "ipfs://QmbKq7QriWWU74NSq35sDSgUf24bYWTgpBq3Lea7A3d7jU";
    hash = Some(dummy_hash)
}
let dummy_governance_token = ("KT1VqarPDicMFn1ejmQqqshUkUXTCTXwmkCN": address)

(* Some default values *)
let default_votes = (Map.empty : DAO.Vote.votes)
let default_timelock = (None : DAO.Timelock.t option)

let base_config : DAO.Storage.Config.t = {
    deposit_amount = 4n;
    refund_threshold = 32n;
    quorum_threshold = 67n;
    super_majority = 80n;
    start_delay = 360n;
    voting_period = 1440n;
    timelock_delay = 360n;
    timelock_period = 720n;
    burn_address = ("tz1burnburnburnburnburnburnburjAYjjX": address);
}

let base_storage : DAO.storage = {
    metadata = Big_map.literal [
        ("", Bytes.pack("tezos-storage:contents"));
        ("contents", ("": bytes))
    ];
    governance_token = dummy_governance_token;
    vault = (Big_map.empty : DAO.Storage.Vault.t);
    proposal = (None : DAO.Proposal.t option);
    config = base_config;
    next_outcome_id = 1n;
    outcomes = (Big_map.empty : DAO.Storage.outcomes);
}

(* Originate a DAO contract with given init_storage storage *)
let originate (init_storage: DAO.storage) =
    let (taddr, _, _) = Test.originate DAO.main init_storage 0tez in
    let contr = Test.to_contract taddr in
    let addr = Tezos.address contr in
    { addr = addr; taddr = taddr; contr = contr }

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

(* Entry points call helpers *)
let cancel (outcome_key_opt, contr : nat option * contr) = call(Cancel(outcome_key_opt), contr)

let end_vote (contr : contr) = call(End_vote, contr)

let execute (k, packed, contr : nat * bytes * contr) =
    call(Execute({ outcome_key = k; packed = packed; }), contr)

let lock (amount_, contr: nat * contr) = call(Lock(amount_), contr)

let propose (proposal, contr : DAO.Proposal.make_params * contr) =
    call(Propose(proposal), contr)

let release (amount_, contr: nat * contr) = call(Release(amount_), contr)

let vote (choice, contr: bool * contr) = call(Vote(choice), contr)

(* Asserter helper for successful entry point calls *)
let cancel_success (outcome_key_opt, contr : nat option * contr) =
    Assert.tx_success (cancel(outcome_key_opt, contr))

let end_vote_success (contr : contr) =
    Assert.tx_success (end_vote(contr))

let execute_success (k, packed, contr : nat * bytes * contr) =
    Assert.tx_success (execute(k, packed, contr))

let lock_success (amount_, contr: nat * contr) =
    Assert.tx_success (lock(amount_, contr))

let propose_success (proposal, contr : DAO.Proposal.make_params * contr) =
    Assert.tx_success (propose(proposal, contr))

let release_success (amount_, contr: nat * contr) =
    Assert.tx_success (release(amount_, contr))

let vote_success (choice, contr: DAO.Vote.choice * contr) =
    Assert.tx_success (vote(choice, contr))


(* Batch call of lock entry point, WARNING: changes Test framework source *)
let batch_lock (addr_lst, amount_, contr : address list * nat * contr) =
    let lock = fun (addr : address) ->
        let () = Test.set_source addr in lock_success(amount_, contr)
    in List.iter lock addr_lst

(* Batch call of vote entry point, WARNING: changes Test framework source *)
let batch_vote (addr_lst, choice, contr : address list * DAO.Vote.choice * contr) =
    let vote = fun (addr : address) ->
        let () = Test.set_source addr in vote_success(choice, contr)
    in List.iter vote addr_lst

(* Assert DAO contract at [taddr] has [owner] [amount_] of tokens locked *)
let assert_locked (taddr, owner, amount_ : taddr * DAO.Storage.Vault.owner *  nat) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt owner s.vault with
        Some tokens -> assert(tokens = amount_)
        | None -> Test.failwith("Big_map key should not be missing")

(* Assert DAO contract at [taddr] have registered [voter] [choice] with [amount_] votes *)
let assert_voted (taddr, voter, choice, amount_ : taddr * address * bool * nat) =
    let s = Test.get_storage taddr in
    let p = Option.unopt(s.proposal) in
    match Map.find_opt voter p.votes with
        Some vote -> assert(vote.0 = choice && vote.1 = amount_)
        | None -> Test.failwith("Map key should not be missing")

(* Assert DAO contract at [taddr] have an outcome occuring for [n] key in Executed state *)
let assert_executed (taddr, n : taddr * nat) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt n s.outcomes with
        None -> Test.failwith "The outcome should exists"
        | Some(_, state) -> assert(state = (Executed : DAO.Outcome.state))

(* Assert outcomes [bm] big map have an entry for key [k] and has given [s] state *)
let assert_proposal_state (bm, k, s : DAO.Storage.outcomes * nat * DAO.Outcome.state) =
    match Big_map.find_opt k bm with
        Some(outcome) -> let (proposal, state) = outcome in
            (* just checking timelock existence *)
            let _check_timelock = proposal.timelock in
            (* check that the proposal have been accepted *)
            assert(state = s)
        | None -> Test.failwith("outcome not found")



(* 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 "./token.mligo" "Token_helper"
#import "./dao.mligo" "DAO_helper"
#import "@ligo/fa/test/helpers/list.mligo" "List_helper"

(*
    Creates a proposal on [dao] with [tok] as governance_token,
    using given [hash_] for the proposal lambda.
    The proposal creator is the first token owner registered in
    the given [tok] token contract owners list.
    Every token owner locks [amount_] of tokens in the DAO,
    and votes "yes" to the created proposal,
    eventually, the end_vote entry point is called.
    Can lead to either accepted or rejected proposal, according to
    the given [amount_] of tokens.
    Requires appropriate config of various periods and delays
*)
let create_and_vote_proposal (
    tok, dao, hash_, votes : Token_helper.originated *
    DAO_helper.originated * bytes option * (int * nat * bool)
    list
) =
    (* set up the sender for propose and end_vote entry points *)
    let sender_ = List_helper.nth_exn 1 tok.owners in

    (* impersonate token owners and call lock entry point *)
    let do_lock (nth_account, amount_, _ : int * nat * bool) =
        let () = Test.set_source (List_helper.nth_exn nth_account tok.owners) in
        DAO_helper.lock_success(amount_, dao.contr)
    in
    let () = List.iter do_lock votes in

    (* create proposal *)
    let () = Test.set_source sender_ in
    let proposal = DAO_helper.dummy_proposal in
    let proposal = { proposal with hash = hash_ } in
    let () = DAO_helper.propose_success(proposal, dao.contr) in

    (* impersonate token owners and call vote entry point *)
    let do_vote (nth_account, _, choice : int * nat * bool) =
        let () = Test.set_source (List_helper.nth_exn nth_account tok.owners) in
        DAO_helper.vote_success(choice, dao.contr)
    in
    let () = List.iter do_vote votes in

    let () = Test.set_source sender_ in
    DAO_helper.end_vote_success(dao.contr)


#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "SingleAsset"
#import "@ligo/fa/test/fa2/single_asset.test.mligo" "SingleAsset_helper"
#import "./assert.mligo" "Assert"

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

let originate (tok_amount : nat) =
    let f = "../bootstrap/single_asset.mligo" in
    let init_storage, owners, ops = SingleAsset_helper.get_initial_storage(
        tok_amount, tok_amount, tok_amount
    ) in
    let v_mich = Test.run (fun (x:SingleAsset.Storage.t) -> x) init_storage in
    let (addr, _, _) = Test.originate_from_file f "main" (["total_supply"]: string list) v_mich 0tez in
    let taddr : taddr = Test.cast_address addr in
    let contr = Test.to_contract taddr in
    {
        addr = addr;
        taddr = taddr;
        owners = owners;
        ops = ops;
        contr = contr;
    }

type single_asset_transfer_param = {
    contr: contr;
    source: address;
    from: address;
    to: address;
    amount: nat;
}

(* Transfer token in [contr] between [from_] and [to_] addresses with [amount_] tokens,
 WARNING: changes Test framework source  *)
let transfer (contr, from_, to_, amount_ : contr * address * address * nat) =
    let () = Test.set_source from_ in
    let transfer_requests = ([
      ({from_=from_; txs=([{to_;amount=amount_;token_id=0n}] : SingleAsset.atomic_trans list)});
    ] : SingleAsset.transfer) in
    Test.transfer_to_contract_exn contr (Transfer transfer_requests) 0tez

(* Batch add [operators] to [contr] contract *)
let add_operators (operators, contr : SingleAsset.operator list * SingleAsset.parameter contract) =
    let f (ys,x : (SingleAsset.unit_update list * SingleAsset.operator)) : SingleAsset.unit_update list = (Add_operator(x) : SingleAsset.unit_update) :: ys in
    let add_operator = List.fold_left f ([] : SingleAsset.unit_update list) operators in
    let r = Test.transfer_to_contract contr (Update_operators(add_operator)) 0mutez in
    Assert.tx_success r

(* assert for FA2 insuffiscient balance string failure *)
let assert_ins_balance_failure (r : test_exec_result) =
    Assert.string_failure r SingleAsset.Errors.ins_balance

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

(* get balance in [taddr] contract for [owner] address *)
let get_balance_for (taddr, owner : taddr * SingleAsset.Ledger.owner) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt owner s.ledger with
        Some amount_ -> amount_
        | None -> 0n

(**
    Create a lambda of type (operation list) that would call the "transfer"
    entrypoint of a FA2 contract residing at [addr], making a token transfer between
    [from_] and [to_] addresses with [amount_] tokens.
*)
let create_transfer_callable (addr, from_, to_, amount_ : address * address * address * nat) =
    fun() -> match (Tezos.get_entrypoint_opt "%transfer" addr : SingleAsset.transfer contract option) with
        Some(c) ->
            let transfer_requests = ([
              ({from_=from_; txs=([{to_;amount=amount_;token_id=0n}] : SingleAsset.atomic_trans list)});
            ] : SingleAsset.transfer) in
            let op = Tezos.transaction transfer_requests 0mutez c in [op]
        | None -> failwith("TOKEN_CONTRACT_NOT_FOUND")


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

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

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_dao_storage : DAO.storage) =
    Bootstrap.boot(init_tok_amount, init_dao_storage)
let base_config = DAO_helper.base_config
let base_storage = DAO_helper.base_storage


(* Succesful lock *)
let test_success =
    let (tok, dao, sender_) = bootstrap(base_storage) in

    let amount_ = 3n in
    let r = DAO_helper.lock(amount_, dao.contr) in
    let () = Assert.tx_success r in

    let () = DAO_helper.assert_locked(dao.taddr, sender_, amount_) in
    Token_helper.assert_balance_amount(
        tok.taddr,
        sender_,
        abs(init_tok_amount - amount_))

(* Succesful lock before voting starts *)
let test_success_before_voting_starts =
    (* Add suffiscient start_delay *)
    let config = { base_config with start_delay = 86400n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, sender_) = bootstrap(dao_storage) in
    let dao_storage = Test.get_storage dao.taddr in

    let amount_ = 3n in
    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in
    let () = DAO_helper.lock_success(amount_, dao.contr) in

    let () = DAO_helper.assert_locked(dao.taddr, sender_, amount_) in
    Token_helper.assert_balance_amount(
        tok.taddr,
        sender_,
        abs(init_tok_amount - amount_ - dao_storage.config.deposit_amount)
    )

(* Failing lock because sender has insuffiscient balance *)
let test_failure_ins_balance =
    let (_, dao, _) = bootstrap(base_storage) in
    let r = DAO_helper.lock(30n, dao.contr) in
    Token_helper.assert_ins_balance_failure(r)

(* Failing lock because voting is underway *)
let test_failure_voting_period =
    (* Really short start_delay *)
    let config = { base_config with start_delay = 10n } in
    let dao_storage = { base_storage with config = config } in
    let (_, dao, _) = bootstrap(dao_storage) in

    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in
    let r = DAO_helper.lock(3n, dao.contr) in

    Assert.string_failure r DAO.Errors.voting_period


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

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

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap () = Bootstrap.boot(init_tok_amount, DAO_helper.base_storage)

(* Successful proposal creation *)
let test_success =
    let (tok, dao, sender_) = bootstrap() in

    let r = DAO_helper.propose(DAO_helper.dummy_proposal, dao.contr) in
    let () = Assert.tx_success r in

    let dao_storage = Test.get_storage dao.taddr in
    let proposal = Option.unopt(dao_storage.proposal) in
    let () = assert(proposal.creator = sender_) in
    let () = assert(proposal.description_link = "ipfs://QmbKq7QriWWU74NSq35sDSgUf24bYWTgpBq3Lea7A3d7jU") in
    let () = assert(proposal.hash = Some(DAO_helper.dummy_hash)) in

    let () = Token_helper.assert_balance_amount(tok.taddr, dao.addr, dao_storage.config.deposit_amount) in
    Token_helper.assert_balance_amount(
        tok.taddr,
        sender_,
        abs(init_tok_amount - dao_storage.config.deposit_amount)
    )

(* Failing proposal creation because there is already a proposal *)
let test_failure_proposal_exists =
    let (_, dao, _) = bootstrap() in

    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in
    let r = DAO_helper.propose(DAO_helper.dummy_proposal, dao.contr) in

    Assert.string_failure r DAO.Errors.proposal_already_exists

(* Failing because the proposing account doesn't have sufiscient balance for the deposit amount *)
let test_failure_insufiscient_balance =
    let (tok, dao, sender_) = bootstrap() in

    (* Burn all the sender tokens *)
    let burn_addr = ("tz1ZZZZZZZZZZZZZZZZZZZZZZZZZZZZNkiRg": address) in
    let _ = Token_helper.transfer(tok.contr, sender_, burn_addr, init_tok_amount) in
    let r = DAO_helper.propose(DAO_helper.dummy_proposal, dao.contr) in

    Token_helper.assert_ins_balance_failure(r)


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

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

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_dao_storage : DAO.storage) =
    Bootstrap.boot(init_tok_amount, init_dao_storage)
let base_config = DAO_helper.base_config
let base_storage = DAO_helper.base_storage

(* Successful release *)
let test_success =
    let (tok, dao, sender_) = bootstrap(base_storage) in

    let () = DAO_helper.lock_success(3n, dao.contr) in
    let () = DAO_helper.release_success(3n, dao.contr) in

    let () = DAO_helper.assert_locked(dao.taddr, sender_, 0n) in
    Token_helper.assert_balance_amount(
        tok.taddr,
        sender_,
        init_tok_amount
    )

(* Failing release because no locked tokens *)
let test_failure_no_locked_tokens =
    let (_, dao, _) = bootstrap(base_storage) in
    let r = DAO_helper.release(3n, dao.contr) in
    Assert.string_failure r DAO.Errors.no_locked_tokens

(* Failing release because insuffiscient balance *)
let test_failure_ins_balance =
    let (_, dao, _) = bootstrap(base_storage) in
    let () = DAO_helper.lock_success(2n, dao.contr) in
    let r = DAO_helper.release(3n, dao.contr) in
    Assert.string_failure r DAO.Errors.not_enough_balance

(* Failing release because voting is underway *)
let test_failure_voting_period =
    (* Really short start_delay *)
    let config = { base_config with start_delay = 10n } in
    let dao_storage = { base_storage with config = config } in
    let (_, dao, _) = bootstrap(dao_storage) in

    let () = DAO_helper.lock_success(3n, dao.contr) in
    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let r = DAO_helper.release(3n, dao.contr) in

    Assert.string_failure r DAO.Errors.voting_period


#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

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

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_dao_storage : DAO.storage) =
    Bootstrap.boot(init_tok_amount, init_dao_storage)
let base_config = DAO_helper.base_config
let base_storage = DAO_helper.base_storage

(* Successful vote *)
let test_success =
    let config = { base_config with start_delay = 10n } in
    let dao_storage = { base_storage with config = config } in
    let (_, dao, sender_) = bootstrap(dao_storage) in

    let amount_ = 3n in
    let () = DAO_helper.lock_success(amount_, dao.contr) in
    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let choice = true in
    let () = DAO_helper.vote_success(choice, dao.contr) in
    DAO_helper.assert_voted(dao.taddr, sender_, choice, amount_)

(* Failing vote because no proposal *)
let test_failure_no_proposal =
    let (_, dao, _) = bootstrap(base_storage) in

    let r = DAO_helper.vote(true, dao.contr) in
    Assert.string_failure r DAO.Errors.no_proposal

(* Failing vote because proposal is not in voting period *)
let test_failure_not_voting_period =
    let (_, dao, _) = bootstrap(base_storage) in

    let amount_ = 3n in
    let () = DAO_helper.lock_success(amount_, dao.contr) in
    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let r = DAO_helper.vote(true, dao.contr) in
    Assert.string_failure r DAO.Errors.not_voting_period

(* Failing because no locked tokens in vault *)
let test_failure_no_locked_tokens =
    (* Really short start_delay *)
    let config = { base_config with start_delay = 10n } in
    let dao_storage = { base_storage with config = config } in
    let (_, dao, _) = bootstrap(dao_storage) in

    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let r = DAO_helper.vote(true, dao.contr) in
    Assert.string_failure r DAO.Errors.no_locked_tokens


DAO-Cameligo

descriptionLink

outcomeKey

endVote

governanceToken

depositAmount

refundThreshold

quorumThreshold

superMajority

startDelay

votingPeriod

timelockDelay

timelockPeriod

burnAddress

nextOutcomeId

#import "../src/lambda.jsligo" "Lambda"

// Sample lambda code for an empty list of operations
// Notice that a type from the Lambda module is used
// See Makefile compile-lambda target for usage with ligo CLI

const lambda_ : Lambda.operationList = () => list([]) as list<operation>;


#import "../src/lambda.jsligo" "Lambda"
#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "SingleAsset"

// Sample lambda that calls an FA2 transfer entrypoint

const lambda_ : Lambda.operationList = () => {
    const addr = "KT1QAShr81NcaFZyJR4srfYGuvPyD8ibbMtT" as address;
    const transferOpt: option<contract<SingleAsset.transfer>> =
        Tezos.get_entrypoint_opt("%transfer", addr);

    match (transferOpt, {
        None: () => failwith ("TOKEN_CONTRACT_NOT_FOUND"),
        Some: (c: contract<SingleAsset.transfer>) => {
            const transfer_requests: SingleAsset.transfer =
                list([({
                    from_: "KT1BWSmjEhEknnBWSYrrSdhH217osBbwdVos" as address,
                    txs: list([{
                        to_: "tz1burnburnburnburnburnburnburjAYjjX" as address,
                        amount: 4000 as nat
                    }]) as list<SingleAsset.atomic_trans>
                })]);

            const op = Tezos.transaction (transfer_requests, 0 as tez, c);
            list([op]);
        }
    });
};


#import "../src/lambda.jsligo" "Lambda"

// A parameter change lambda is just a new record of type Config.t,
// the storage will be updated with the differences when the lambda is
// executed

const lambda_ : Lambda.parameterChange = () => ({
    depositAmount: 400 as nat,
    refundThreshold: 32 as nat,
    quorumThreshold: 67 as nat,
    superMajority: 80 as nat,
    startDelay: 86400 as nat,
    votingPeriod: 604800 as nat,
    timelockDelay: 86400 as nat,
    timelockPeriod: 259200 as nat,
    burnAddress: "tz1burnburnburnburnburnburnburjAYjjX" as address
});


// quorum_threshold, refund_threshold and super_majority
// are represented with scale = 2, ex. 80 = .80 = 80%
// x_delay and x_period are represented by time units in seconds
export type t =
    // @layout:comb
    {
        depositAmount: nat,
        // ^ The amount of tokens required to be deposited when creating a proposal

        refundThreshold: nat,
        // ^ The minimal amount of participating tokens required for the deposit to be refunded

        quorumThreshold: nat,
        // ^ The minimal participation percentage needed for a proposal to pass

        superMajority: nat,
        // ^ The percentage needed for a super majority ("yes" votes)

        startDelay: nat,
        // ^ The delay for the vote to start

        votingPeriod: nat,
        // ^ The period during which voting is live

        timelockDelay: nat,
        // ^ Delay before an approved proposal can be executed

        timelockPeriod: nat,
        // ^ The period during which a timelock can be executed

        burnAddress: address,
        // ^ The burn address for unrefunded deposits
    }


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


const proposalAlreadyExists = "PROPOSAL_ALREADY_EXISTS"
const votingPeriod = "VOTING_PERIOD"
const notVotingPeriod = "NOT_VOTING_PERIOD"
const noProposal = "NO_PROPOSAL"
const notCreator = "NOT_CREATOR"
const canceled = "CANCELED"
const timelockNotFound = "TIMELOCK_NOT_FOUND"
const timelockLocked = "TIMELOCK_LOCKED"
const timelockUnlocked = "TIMELOCK_UNLOCKED"
const notZeroAmount = "NOT_ZERO_AMOUNT"
const noLockedTokens = "NO_LOCKED_TOKENS"
const notEnoughBalance = "NOT_ENOUGH_BALANCE"
const receiverNotFound = "RECEIVER_NOT_FOUND"
const fa2TotalSupplyNotFound = "FA2_TOTAL_SUPPLY_NOT_FOUND"
const outcomeNotFound = "OUTCOME_NOT_FOUND"
const alreadyExecuted = "ALREADY_EXECUTED"
const notExecutable = "NOT_EXECUTABLE"
const hashNotFound = "HASH_NOT_FOUND"
const hashNotMatch = "HASH_NOT_MATCH"
const unpackMismatch = "UNPACK_MISMATCH"
const nothingToCancel = "NOTHING_TO_CANCEL"


#import "./config.jsligo" "Config"
#import "./errors.jsligo" "Errors"

export type parameterChange = (n: unit) => Config.t
export type operationList = (n: unit) => list<operation>;

export type t =
    | ["ParameterChange", parameterChange]
    | ["OperationList", operationList];

const unpack = (hashOpt: option<bytes>, packed: bytes): t => {
    return match(hashOpt, {
        None: () => failwith(Errors.hashNotFound),
        Some: (hash_: bytes) => {
            assert_with_error(
                hash_ == Crypto.sha256(packed),
                Errors.hashNotMatch
            );

            return match((Bytes.unpack(packed) as option<t>), {
                None: () => failwith(Errors.unpackMismatch),
                Some: (lambda_: t) => lambda_
            });
        }
    });
};


#import "./constants.jsligo" "Constants"
#import "./errors.jsligo" "Errors"
#import "./lambda.jsligo" "Lambda"
#import "./outcome.jsligo" "Outcome"
#import "./proposal.jsligo" "Proposal"
#import "./storage.jsligo" "Storage"
#import "./vote.jsligo" "Vote"
#import "./token.jsligo" "Token"
#import "./vault.jsligo" "Vault"
#import "./timelock.jsligo" "Timelock"

export type parameter =
    // @layout:comb
    | ["Propose", Proposal.makeParams]
    | ["Cancel", option<nat>]
    | ["Lock", Vault.amount_]
    | ["Release", Vault.amount_]
    | ["Execute", Outcome.executeParams]
    | ["Vote", Vote.choice]
    | ["EndVote"]
;

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

const execute = (outcomeKey: nat, packed: bytes, s: storage) : result => {
    const proposal = match(Big_map.find_opt(outcomeKey, s.outcomes), {
        None: () => failwith(Errors.outcomeNotFound),
        Some: (o: Outcome.t) => Outcome.getExecutableProposal(o)
    });

    Timelock._checkUnlocked(proposal.timelock);
    const lambda_ : Lambda.t = Lambda.unpack(proposal.hash, packed);

    return match(lambda_, {
        OperationList: (f: Lambda.operationList) => [
            f(),
            Storage.updateOutcome(outcomeKey, [proposal, Executed()], s)
        ],
        ParameterChange: (f: Lambda.parameterChange) => [
            Constants.noOperation,
            Storage.updateOutcome(
                outcomeKey,
                [proposal, Executed()],
                Storage.updateConfig(f,s)
            )]
    });
};

const propose = (p: Proposal.makeParams, s: storage) : result =>
    match(s.proposal, {
        Some: (_: Proposal.t) => failwith(Errors.proposalAlreadyExists),
        None: () => [
            list([Token.transfer(
                s.governanceToken,
                Tezos.get_sender(),
                Tezos.get_self_address(),
                s.config.depositAmount
            )]), Storage.createProposal(
                Proposal.make(p, s.config.startDelay, s.config.votingPeriod),
                s)
        ]
    });

const cancel = (outcomeKeyOpt: option<nat>, s: storage) : result =>
   [list([Token.transfer(
        s.governanceToken,
        Tezos.get_self_address(),
        s.config.burnAddress,
        s.config.depositAmount)
   ]), match(outcomeKeyOpt, {
        None: () => match(s.proposal, {
            None: () => failwith(Errors.nothingToCancel),
            Some: (p: Proposal.t) => {
                Proposal._checkNotVotingPeriod(p);
                assert_with_error(
                    p.creator == Tezos.get_sender(),
                    Errors.notCreator
                );

                Storage.addOutcome([p, Canceled()], s);
            }}),
        Some: (outcomeKey: nat) => match(Big_map.find_opt(outcomeKey, s.outcomes), {
            None: () => failwith(Errors.outcomeNotFound),
            Some: (o: Outcome.t) => {
                const [p, state] = o;
                assert_with_error(
                    p.creator == Tezos.get_sender(),
                    Errors.notCreator
                );
                assert_with_error(
                    state != (Executed() as Outcome.state),
                    Errors.alreadyExecuted
                );
                Timelock._checkLocked(p.timelock);

                Storage.updateOutcome(outcomeKey, [p, Canceled()], s)
            }})
        })
   ];

const lock = (amount_: nat, s: storage) : result => {
    Proposal._checkNoVoteOngoing(s.proposal);
    const currentAmount = Vault.getForUser(s.vault, Tezos.get_sender());

    return [
        list([Token.transfer(
            s.governanceToken,
            Tezos.get_sender(),
            Tezos.get_self_address(), amount_)]),
        Storage.updateVault(Vault.updateForUser(
            s.vault,
            Tezos.get_sender(),
            currentAmount + amount_), s)
    ];
};

const release = (amount_: nat, s: storage) : result => {
    Proposal._checkNoVoteOngoing(s.proposal);
    const currentAmount = Vault.getForUserExn(s.vault, Tezos.get_sender());
    assert_with_error( (currentAmount >= amount_), Errors.notEnoughBalance);

    return [
        list([Token.transfer(
            s.governanceToken,
            Tezos.get_self_address(),
            Tezos.get_sender(), amount_)]),
        Storage.updateVault(Vault.updateForUser(
            s.vault,
            Tezos.get_sender(),
            abs(currentAmount - amount_)), s)
    ];
};

const vote = (choice: bool, s: storage) : storage =>
    match(s.proposal, {
        None: () => failwith(Errors.noProposal),
        Some: (p: Proposal.t) => {
            Proposal._checkIsVotingPeriod(p);
            const amount_ = Vault.getForUserExn(s.vault, Tezos.get_sender());
            return Storage.updateVotes(p, [choice, amount_], s);
        }});

const endVote = (s: storage) : result =>
    match(s.proposal,{
        None: () => failwith(Errors.noProposal),
        Some: (p: Proposal.t) => {
            Proposal._checkVotingPeriodEnded(p);
            const totalSupply = match(Token.getTotalSupply(s.governanceToken),{
                None: () => failwith(Errors.fa2TotalSupplyNotFound),
                Some: (n: nat) => n
            });
            const outcome = Outcome.make(
                    p,
                    totalSupply,
                    s.config.refundThreshold,
                    s.config.quorumThreshold,
                    s.config.superMajority
                );
            const [_, state] = outcome;

            let transferToAddr = p.creator;
            if (Rejected_(WithoutRefund()) == state) {
                transferToAddr = s.config.burnAddress;
            }
            return [
                list([Token.transfer(
                    s.governanceToken,
                    Tezos.get_self_address(),
                    transferToAddr,
                    s.config.depositAmount)])
                , Storage.addOutcome(outcome, s)
            ];
        }});

const main = (action: parameter, store: storage) : result => {
    assert_with_error(Tezos.get_amount() == (0 as tez), Errors.notZeroAmount);
    return match(action, {
        Propose: (p: Propose.makeParams) => propose(p, store),
        Cancel: (nOpt: option<nat>) => cancel(nOpt, store),
        Lock: (n: nat) => lock(n, store),
        Release: (n: nat) => release(n, store),
        Execute: (p: Outcome.executeParams) => execute(p.outcomeKey, p.packed, store),
        Vote: (v: Vote.choice) => [Constants.noOperation, vote(v, store)],
        EndVote: () => endVote(store)
    });
};


// tzip-16 https://tzip.tezosagora.org/proposal/tzip-16/
export type t = big_map<string, bytes>;


#import "./proposal.jsligo" "Proposal"
#import "./vote.jsligo" "Vote"
#import "./errors.jsligo" "Errors"

export type rejectedStateExtra =
    | ["WithRefund"]
    | ["WithoutRefund"];

export type state =
    | ["Accepted"]
    | ["Rejected_", rejectedStateExtra]
    | ["Executed"]
    | ["Canceled"];

export type t = [Proposal.t, state];

export type executeParams =
    // @layout:comb
    {
        outcomeKey: nat,
        packed: bytes
        // ^ the packed Lambda.t
    }

const makeState = (
    [total, for_, against]: [nat, nat, nat],
    totalSupply: nat,
    refundThreshold: nat,
    quorumThreshold: nat,
    superMajority: nat
): state => {
    if ((total / totalSupply * (100 as nat)) < refundThreshold) {
        return Rejected_(WithoutRefund());
    } else if ((for_ / total * (100 as nat)) < superMajority
        || ((total / totalSupply * (100 as nat)) < quorumThreshold)) {
        return Rejected_(WithRefund())
    } else if (for_ > against) {
        return Accepted()
    } else {
        return Rejected_(WithRefund())
    }
}

const make = (p: Proposal.t,
    totalSupply: nat,
    refundThreshold: nat,
    quorumThreshold: nat,
    superMajority: nat
) : t => [
    p,
    makeState(
        Vote.count(p.votes),
        totalSupply,
        refundThreshold,
        quorumThreshold,
        superMajority
    )
];

const getExecutableProposal = (outcome: t) : Proposal.t => {
    const [p, state] = outcome;

    if ((Accepted() as state) == state) {
        return p;
    }

    return failwith(Errors.notExecutable);
};


#import "./errors.jsligo" "Errors"
#import "./vote.jsligo" "Vote"
#import "./timelock.jsligo" "Timelock"

export type t =
    // @layout:comb
    {
        descriptionLink: string,
        hash: option<bytes>,
        startAt: timestamp,
        endAt: timestamp,
        votes: Vote.votes,
        creator: address,
        timelock: option<Timelock.t>
    }

export type makeParams =
    // @layout:comb
    {
        descriptionLink: string,
        hash: option<bytes>
    }

const make = (p: makeParams, startDelay: nat, votingPeriod: nat) : t => {
    const startAt = Tezos.get_now() + int(startDelay);

    return {
        descriptionLink: p.descriptionLink,
        hash: p.hash,
        startAt: startAt,
        endAt: startAt + int(votingPeriod),
        votes: Map.empty as Vote.votes,
        creator: Tezos.get_sender(),
        timelock: (None() as option<Timelock.t>)
    };
};

const isVotingPeriod = (p: t) : bool =>
    ((Tezos.get_now() >= p.startAt) && (Tezos.get_now() < p.endAt));

const _checkNotVotingPeriod = (p: t) : unit =>
    assert_with_error(!isVotingPeriod(p), Errors.votingPeriod);

const _checkIsVotingPeriod = (p: t) : unit =>
    assert_with_error(isVotingPeriod(p), Errors.notVotingPeriod);

const _checkNoVoteOngoing = (p_opt: option<t>) : unit =>
    match(p_opt, {
        Some: (p: t) => _checkNotVotingPeriod(p),
        None: () => unit
    });

const _checkVotingPeriodEnded = (p: t) : unit =>
    assert_with_error(Tezos.get_now() > p.endAt, Errors.votingPeriod);


#import "./config.jsligo" "Config"
#import "./lambda.jsligo" "Lambda"
#import "./metadata.jsligo" "Metadata"
#import "./outcome.jsligo" "Outcome"
#import "./proposal.jsligo" "Proposal"
#import "./timelock.jsligo" "Timelock"
#import "./token.jsligo" "Token"
#import "./vault.jsligo" "Vault"
#import "./vote.jsligo" "Vote"

export type outcomes = big_map<nat, Outcome.t>

export type t =
    // @layout:comb
    {
        metadata: Metadata.t,
        governanceToken: Token.t,
        config: Config.t,
        vault: Vault.t,
        proposal: option<Proposal.t>,
        outcomes: outcomes,
        nextOutcomeId: nat
    }

const createProposal = (p: Proposal.t, s: t) : t =>
    ({ ...s, proposal: Some(p) })

const updateConfig = (f: Lambda.parameterChange, s: t) : t =>
    ({ ...s, config: f() })

const updateVault = (v: Vault.t, s: t) : t =>
    ({ ...s, vault: v })

const updateVotes = (p: Proposal.t, v: Vote.t, s: t) : t => {
    const newVotes = Map.update(Tezos.get_sender(), Some(v), p.votes);
    const newProposal = { ...p, votes: newVotes };
    return { ...s, proposal: Some(newProposal) }
}

const updateOutcome = (k: nat, o: Outcome.t, s: t) : t =>
    ({ ...s, outcomes: Big_map.update(k, Some(o), s.outcomes) })

const addOutcome = (o: Outcome.t, s: t) : t => {
    let [proposal, status] = o;

    // If proposal is accepted, also create timelock
    if ((Accepted() as Outcome.state) == status) {
        const unlockAt = Tezos.get_now() + int(s.config.timelockDelay);
        proposal = ({ ...proposal, timelock: Some(Timelock.make(
            unlockAt,
            s.config.timelockPeriod))})
    }

    return { ...s,
        proposal: None() as option<Proposal.t>,
        outcomes: Big_map.update(
            s.nextOutcomeId,
            Some([proposal, status]),
            s.outcomes),
        nextOutcomeId: s.nextOutcomeId + (1 as nat)
    }
};


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

export type t =
    // @layout:comb
    {
        unlock_at: timestamp,
        // ^ timestamp for the unlock to happen

        relock_at: timestamp
        // ^ timestamp for the relock to happen
    };

const make = (unlock_at: timestamp, timelock_period: nat) : t => ({
   unlock_at: unlock_at,
   relock_at: unlock_at + int(timelock_period as nat)
});

const isLocked = (t : t) : bool =>
    ((Tezos.get_now() < t.unlock_at) || (Tezos.get_now() >= t.relock_at));

const _checkUnlocked = (t_opt : option<t>) : unit =>
    match(t_opt, {
        None: () => failwith(Errors.timelockNotFound),
        Some: (t: t) => assert_with_error(!isLocked(t), Errors.timelockLocked)
    });

const _checkLocked = (t_opt: option<t>) : unit =>
    match(t_opt, {
        None: () => failwith(Errors.timelockNotFound),
        Some: (t: t) => assert_with_error(isLocked(t), Errors.timelockUnlocked)
    });


#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "FA2"
#import "./errors.jsligo" "Errors"

export type t = address;
export type fa2TransferContract = contract<FA2.transfer>;

const getTransferEntrypoint = (addr: address) : fa2TransferContract => {
    const transferOption: option<fa2TransferContract> = Tezos.get_entrypoint_opt("%transfer", addr);
    match(transferOption, {
        None: () => failwith(Errors.receiverNotFound),
        Some: (c: fa2TransferContract) => c
    });
};

const transfer = (token_addr: t, from_: address, to_: address, amount_: nat) : operation => {
    const dest = getTransferEntrypoint(token_addr);
    const transfer_requests : FA2.transfer = list([
      {from_: from_, txs: list([{to_: to_, amount: amount_, token_id: 0 as nat}])}
    ]);

    return Tezos.transaction(transfer_requests, (0 as tez), dest)
};

const getTotalSupply = (token_addr: t) : option<nat> =>
    Tezos.call_view("total_supply", unit, token_addr)


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

export type owner = address;
export type amount_ = nat;
export type t = big_map<owner, amount_>;

const getForUser = (vault: t, owner: owner) : amount_ =>
    match(Big_map.find_opt(owner, vault), {
        Some: (tokens: nat) => tokens,
        None: () => 0 as nat
    });

const getForUserExn = (vault: t, owner: owner) : amount_ => {
    const amount_ = getForUser(vault, owner);
    if (amount_ == (0 as nat)) {
        return failwith(Errors.noLockedTokens)
    }

    return amount_
}

const updateForUser = (vault: t, owner: owner, amount_: nat) : t =>
    Big_map.update(owner, Some(amount_ as nat), vault)


export type choice = bool;
export type t = [choice, nat];
export type votes = map<address, t>;

//    [count (votes)] is the count of [votes].
//    Returns a triple of:
//        - total votes (for + against),
//        - sum of votes for,
//        - sum of votes against.
const count = (votes : votes) : [nat, nat, nat] => {
    const sum = (
        acc: [nat,nat],
        vote: [address, t]
    ): [nat, nat] => {
        const [for_, against] = acc;
        const [_, [choice, nb]] = vote;

        if (choice) {
            return [for_ + nb, against];
        }

        return [for_, against + nb];
    };

    const [for_, against] = Map.fold(sum, votes, [0 as nat, 0 as nat]);

    return [for_ + against, for_, against];
};


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "../helpers/token.jsligo" "Token_helper"
#import "../helpers/dao.jsligo" "DAO_helper"
#import "../../src/main.jsligo" "DAO"

// Boostrapping of the test environment,
// initTokAmount is the amount of token allocated to every
// bootstrapped accounts
const boot = (initTokAmount: nat, initDAOStorage : DAO.storage)
: [Token_helper.originated, DAO_helper.originated, address] => {
    // Originate the token contract and the contract under test
    const tok = Token_helper.originate(initTokAmount);
    // Override governance token with test token
    const initDAOStorage = { ...initDAOStorage, governanceToken: tok.addr };
    const dao = DAO_helper.originate(initDAOStorage);

    // Add the dao as operator for all the FA2 owner addresses
    //    TODO: ... in the real world, remove operator?
    List.iter((owner: address) => {
        Test.set_source(owner);
        Token_helper.add_operators(list([
                { owner: owner, operator: dao.addr, token_id: (0 as nat) }
            ]), tok.contr);
        }, tok.owners);

    // Set a token owner as sender in the Test framework
    const sender_ = List_helper.nth_exn(1)(tok.owners);
    Test.set_source(sender_);

    // Set the baker to 5th account
    const baker = Test.nth_bootstrap_account(5);
    Test.set_baker(baker);

    return [tok, dao, sender_];
};


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/dao.jsligo" "DAO_helper"
#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/suite.jsligo" "Suite_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "DAO"

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

// Boostrapping of the test environment
const initTokAmount = 33 as nat;
const bootstrap = (initDAOStorage : DAO.storage) : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, initDAOStorage);
const empty_nat_option = None() as option<nat>
const baseConfig = DAO_helper.baseConfig;
const baseStorage = DAO_helper.baseStorage;

// Successful cancel of current proposal
const testSuccessCurrentProposal = (() : unit => {
    // Add suffiscient start_delay
    const config = { ...baseConfig, startDelay: 86400 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, sender_] = bootstrap(daoStorage);
    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);
    DAO_helper.cancelSuccess(empty_nat_option, dao.contr);
    const daoStorage = Test.get_storage (dao.taddr);
    DAO_helper.assertProposalState(daoStorage.outcomes, 1 as nat, Canceled());
    Token_helper.assertBalanceAmount(
        tok.taddr,
        sender_,
        abs(initTokAmount - daoStorage.config.depositAmount)
    );
})();

// Succesful cancel of accepted proposal, before timelock is unlocked
const testSuccessAcceptedProposal = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat,
        votingPeriod: 1800 as nat,
        timelockDelay: 3000 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);
    DAO_helper.cancelSuccess(Some(1 as nat), dao.contr);
    const daoStorage = Test.get_storage (dao.taddr);
    DAO_helper.assertProposalState(daoStorage.outcomes, 1 as nat, Canceled());
})();

// Failing cancel because there is nothing to cancel
const testFailureNothingToCancel = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const r = DAO_helper.cancel(empty_nat_option, dao.contr);
    Assert.stringFailure(r, DAO.Errors.nothingToCancel);
})();

// Failing cancel because the outcome was not found
const testFailureOutcomeNotFound = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const r = DAO_helper.cancel(Some(23 as nat), dao.contr);
    Assert.stringFailure(r, DAO.Errors.outcomeNotFound);
})();

// Failing cancel proposal because not creator
const testFailureNotCreator = (() : unit => {
    const config = { ...baseConfig, startDelay: 1200 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const sender_ = List_helper.nth_exn (2)(tok.owners);
    Test.set_source (sender_);
    const r = DAO_helper.cancel(empty_nat_option, dao.contr);
    Assert.stringFailure(r, DAO.Errors.notCreator);
})();

// Failing cancel proposal because timelock is unlocked
const testFailureTimelockUnlocked = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 1800 as nat  };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);

    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const r = DAO_helper.cancel(Some(1 as nat), dao.contr);
    Assert.stringFailure(r, DAO.Errors.timelockUnlocked);
})();

// Failing cancel proposal because it was already executed
const testFailureAlreadyExecuted = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 1800 as nat  };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);
    DAO_helper.executeSuccess(1 as nat, DAO_helper.dummyPacked, dao.contr);

    const r = DAO_helper.cancel(Some(1 as nat), dao.contr);
    Assert.stringFailure(r, DAO.Errors.alreadyExecuted);
})();


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/dao.jsligo" "DAO_helper"
#import "./helpers/suite.jsligo" "Suite_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "DAO"

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

// Boostrapping of the test environment
const initTokAmount = 33 as nat;
const bootstrap = () : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => {
    const baseConfig = DAO_helper.baseConfig;
    const baseStorage = DAO_helper.baseStorage;
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 1800 as nat};
    const daoStorage = { ...baseStorage, config: config };
    Bootstrap.boot(initTokAmount, daoStorage);
};

// Successful end_vote with proposal accepted
const testSuccessPropAccepted = (() : unit => {
    const [tok, dao, _] = bootstrap();

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);
    const daoStorage = Test.get_storage (dao.taddr);
    assert (daoStorage.proposal == (None() as option<DAO.Proposal.t>));
    DAO_helper.assertProposalState(daoStorage.outcomes, 1 as nat, Accepted());
})();

// Successful end_vote with proposal rejected because quorum was not reached
const testSuccessPropRejectedQuorumNotReached = (() : unit => {
    const [tok, dao, _] = bootstrap();

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 5 as nat, true], [1, 5 as nat, true], [2, 5 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const daoStorage = Test.get_storage (dao.taddr);
    DAO_helper.assertProposalState(
        daoStorage.outcomes, 1 as nat,
        Rejected_(WithoutRefund())
    );
})();

// Successful end_vote with proposal rejected because super_majority was not reached
const testSuccessPropRejectedSuperMajNotReached = (() : unit => {
    const [tok, dao, _] = bootstrap();

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 15 as nat, true], [1, 15 as nat, true], [2, 15 as nat, false]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);
    const daoStorage = Test.get_storage (dao.taddr);
    DAO_helper.assertProposalState(
        daoStorage.outcomes, 1 as nat,
        Rejected_(WithRefund())
    );
})();

// Failing end_vote because proposal voting period ongoing
const testFailureVotingPeriod = (() : unit => {
    const [_, dao, _] = bootstrap();

    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const r = DAO_helper.endVote(dao.contr);
    Assert.stringFailure(r, DAO.Errors.votingPeriod);
})();

// TODO: test for total_supply_not_found error


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/dao.jsligo" "DAO_helper"
#import "./helpers/suite.jsligo" "Suite_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "DAO"

import Lambda = DAO.Lambda;

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

// Boostrapping of the test environment
const initTokAmount = 33 as nat;
const bootstrap = (initDAOStorage : DAO.storage) : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, initDAOStorage);
const baseConfig = DAO_helper.baseConfig;
const baseStorage = DAO_helper.baseStorage;

// Successful timelock execution of an operation list
const testSuccess = ((): unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 1800 as nat  };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(
        tok,
        dao,
        Some(DAO_helper.dummyHash),
        votes
    );

    DAO_helper.executeSuccess(1 as nat, DAO_helper.dummyPacked, dao.contr);
    DAO_helper.assertExecuted(dao.taddr, 1 as nat);
})();

// Successful execution of a parameter change
const testSuccessParameterChanged = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 1800 as nat  };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const baseConfig = DAO_helper.baseConfig;
    const packed = Bytes.pack (ParameterChange(
        () => ({ ...baseConfig, quorumThreshold: 51 as nat })
    ) as Lambda.t);
    const hash_ = Some(Crypto.sha256 (packed));
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    DAO_helper.executeSuccess(1 as nat, packed, dao.contr);
    DAO_helper.assertExecuted(dao.taddr, 1 as nat);
    const daoStorage = Test.get_storage (dao.taddr);

    // Assert that the config has been updated
    assert(daoStorage.config.quorumThreshold == (51 as nat));
})();

// Successful execution of an operation list
const testSuccessOperationList = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 1800 as nat  };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const owner2 = List_helper.nth_exn (2)(tok.owners);
    const owner2InitialBalance = Token_helper.get_balance_for(
        tok.taddr,
        owner2
    );

    // Pack an operation that will send 2 tokens from DAO to owner2
    const owner2AmountToReceive = 2 as nat;
    const opList = Token_helper.createTransferCallable(
        tok.addr, dao.addr, owner2, owner2AmountToReceive
    );
    const packed = Bytes.pack(OperationList(opList) as Lambda.t);

    const owner2AmountLocked = 25 as nat;
    const hash_ = Some(Crypto.sha256 (packed));
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    DAO_helper.executeSuccess(1 as nat, packed, dao.contr);
    DAO_helper.assertExecuted(dao.taddr, 1 as nat);

    const owner2_expected_balance : nat = abs(
        owner2InitialBalance
        - owner2AmountLocked
        + owner2AmountToReceive);

    Token_helper.assertBalanceAmount(
        tok.taddr,
        owner2,
        owner2_expected_balance
    );
})();

// Failing because no outcome
const testFailureNoOutcome = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const r = DAO_helper.execute(1 as nat, DAO_helper.dummyPacked, dao.contr);
    Assert.stringFailure(r, DAO.Errors.outcomeNotFound);
})();

// Failing because timelock delay not elapsed
const testFailureTimelockDelayNotElapsed = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 1800 as nat,
        timelockDelay: 1800 as nat};
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const r = DAO_helper.execute(1 as nat, DAO_helper.dummyPacked, dao.contr);
    Assert.stringFailure(r, DAO.Errors.timelockLocked);
})();

// Failing because timelock has been relocked
const testFailureTimelockRelocked = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 1800 as nat,
        timelockDelay: 10 as nat};

    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const r = DAO_helper.execute(1 as nat, DAO_helper.dummyPacked, dao.contr);
    Assert.stringFailure(r, DAO.Errors.timelockLocked);
})();

// Failing because the packed data is not matching expected type
const testFailureUnpackMismatch = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 1800 as nat };

    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const packed = Bytes.pack("");
    const hash_ = Some(Crypto.sha256(packed));
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const r = DAO_helper.execute(1 as nat, packed, dao.contr);
    Assert.stringFailure(r, DAO.Errors.unpackMismatch);
})();

// Failing because the hash doesn't match the packed bytes
const testFailureHashNotMatch = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 1800 as nat };

    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(0x01);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const r = DAO_helper.execute(1 as nat, DAO_helper.dummyPacked, dao.contr);
    Assert.stringFailure(r, DAO.Errors.hashNotMatch);
})();


// Assert contract call results in failwith with given string
const stringFailure = ([res,expected] : [test_exec_result, string]) : unit => {
  let expected_bis = Test.eval (expected) ;
  match (res, {
    Fail: (x: test_exec_error) => (
      match (x, {
        Rejected: (x:[michelson_code,address]) => assert (Test.michelson_equal (x[0], expected_bis)),
        Balance_too_low: (_: { contract_too_low : address , contract_balance : tez , spend_request : tez }) => Test.failwith ("contract failed for an unknown reason"),
        Other: (_:string) => Test.failwith ("contract failed for an unknown reason")
      })),
    Success: (_:nat) => Test.failwith ("bad price check")
  } );
} ;

// Assert contract result is successful
const txSuccess = (res: test_exec_result) : unit =>
  match (res, {
    Fail: (_: test_exec_error) => Test.failwith("Transaction should not fail"),
    Success: (_:nat) => unit
  } );


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

import Lambda = DAO.Lambda;
import Outcome = DAO.Outcome;

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

// Some dummy values intended to be used as placeholders
const dummyPacked = Bytes.pack (OperationList((() => list([]) as list<operation>)) as Lambda.t);
const dummyHash = Crypto.sha256 (dummyPacked);

const dummyProposal : DAO.Proposal.makeParams = {
    descriptionLink: "ipfs://QmbKq7QriWWU74NSq35sDSgUf24bYWTgpBq3Lea7A3d7jU",
    hash: Some(dummyHash)
};
const dummyGovernanceToken = "KT1VqarPDicMFn1ejmQqqshUkUXTCTXwmkCN" as address;

// Some default values
const emptyVault: DAO.Storage.Vault.t = Big_map.empty;
const emptyOutcomes: DAO.Storage.outcomes = Big_map.empty;

const baseConfig : DAO.Storage.Config.t = {
    depositAmount: 4 as nat,
    refundThreshold: 32 as nat,
    quorumThreshold: 67 as nat,
    superMajority: 80 as nat,
    startDelay: 360 as nat,
    votingPeriod: 1440 as nat,
    timelockDelay: 360 as nat,
    timelockPeriod: 720 as nat,
    burnAddress: "tz1burnburnburnburnburnburnburjAYjjX" as address
};

const baseStorage : DAO.storage = {
    metadata: Big_map.literal (list([
        ["", Bytes.pack("tezos-storage:contents")],
        ["contents", "" as bytes]
    ])),
    governanceToken: dummyGovernanceToken,
    vault: emptyVault,
    proposal: None() as option<DAO.Proposal.t>,
    config: baseConfig,
    nextOutcomeId: 1 as nat,
    outcomes: emptyOutcomes
};

// Originate a DAO contract with given init_storage storage
const originate = (init_storage: DAO.storage) : originated => {
    const [taddr, _, _] = Test.originate (DAO.main, init_storage, 0 as tez);
    const contr = Test.to_contract (taddr);
    const addr = Tezos.address (contr);
    return { addr: addr, taddr: taddr, contr: contr };
};

// Call entry point of DAO contr contract
const call = ([p, contr] : [DAO.parameter, contr]): test_exec_result =>
    Test.transfer_to_contract (contr, p, 0 as tez);

// Entry points call helpers
const cancel = ([outcome_key_opt, contr] : [option<nat>, contr]): test_exec_result =>
    call(Cancel(outcome_key_opt), contr);

const endVote = (contr: contr): test_exec_result => call(EndVote(), contr);

const execute = ([k, packed, contr] : [nat, bytes, contr]): test_exec_result =>
    call(Execute({ outcomeKey: k, packed: packed }), contr);

const lock = ([amount_, contr]: [nat, contr]): test_exec_result => call(Lock(amount_), contr);

const propose = ([proposal, contr] : [DAO.Proposal.makeParams, contr]): test_exec_result =>
    call(Propose(proposal), contr);

const release = ([amount_, contr]: [nat, contr]): test_exec_result =>
    call(Release(amount_), contr);

const vote = ([choice, contr]: [bool, contr]): test_exec_result => call(Vote(choice), contr);

// Asserter helper for successful entry point calls
const cancelSuccess = ([outcome_key_opt, contr] : [option<nat>, contr]): unit =>
    Assert.txSuccess(cancel(outcome_key_opt, contr));

const endVoteSuccess = (contr : contr): unit =>
    Assert.txSuccess(endVote(contr));

const executeSuccess = ([k, packed, contr] : [nat, bytes, contr]): unit =>
    Assert.txSuccess(execute(k, packed, contr));

const lockSuccess = ([amount_, contr]: [nat, contr]): unit =>
    Assert.txSuccess (lock(amount_, contr));

const proposeSuccess = ([proposal, contr] : [DAO.Proposal.makeParams, contr]): unit =>
    Assert.txSuccess(propose(proposal, contr));

const releaseSuccess = ([amount_, contr]: [nat, contr]): unit =>
    Assert.txSuccess(release(amount_, contr));

const voteSuccess = ([choice, contr]: [DAO.Vote.choice, contr]): unit =>
    Assert.txSuccess(vote(choice, contr));

// Batch call of lock entry point, WARNING: changes Test framework source
const batchLock = ([addr_lst, amount_, contr] : [list<address>, nat, contr]) : unit => {
    const lock = (addr: address) : unit => {
        Test.set_source (addr);
        lockSuccess(amount_, contr);
    };
    List.iter(lock, addr_lst);
};

// Batch call of vote entry point, WARNING: changes Test framework source
const batchVote = ([addr_lst, choice, contr] : [list<address>, DAO.Vote.choice, contr]) : unit => {
    const vote = (addr: address) : unit => {
        Test.set_source (addr);
        voteSuccess(choice, contr);
    };
    List.iter(vote, addr_lst);
};

// Assert DAO contract at [taddr] has [owner] [amount_] of tokens locked
const assertLocked = ([taddr, owner, amount_] : [taddr, DAO.Storage.Vault.owner,  nat]) : unit => {
    const s = Test.get_storage(taddr);
    match (Big_map.find_opt(owner, s.vault), {
        Some: (tokens: nat) => assert(tokens == amount_),
        None: () => Test.failwith("Big_map key should not be missing")
    });
};

// Assert DAO contract at [taddr] have registered [voter] [choice] with [amount_] votes
const assertVoted = ([taddr, voter, choice, amount_] : [taddr, address, bool, nat])
: unit => {
    const s = Test.get_storage (taddr);
    const p = Option.unopt(s.proposal);
    match (Map.find_opt(voter, p.votes), {
        Some: (vote: DAO.Vote.t) => assert(vote[0] == choice && vote[1] == amount_),
        None: () => Test.failwith("Map key should not be missing")
    });
};

// Assert DAO contract at [taddr] have an outcome occuring for [n] key in Executed state
const assertExecuted = ([taddr, n]: [taddr, nat]) : unit => {
    const s = Test.get_storage (taddr);
    match (Big_map.find_opt(n, s.outcomes), {
        None: () => Test.failwith("The outcome should exists"),
        Some: (o: Outcome.t) => {
            const [_, state] = o;
            assert(state == (Executed() as Outcome.state))
        }
    });
};

// Assert outcomes [bm] big map have an entry for key [k] and has given [s] state
const assertProposalState =
    ([bm, k, s]: [DAO.Storage.outcomes, nat, DAO.Outcome.state]) : unit =>
    match(Big_map.find_opt(k, bm), {
        Some: (outcome: DAO.Outcome.t) => {
            const [proposal, state] = outcome;
            // just checking timelock existence
            const _checkTimelock = proposal.timelock;
            // check that the proposal have been accepted
            assert(state == s)
        },
        None: () => Test.failwith("outcome not found")
    });


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

    loop(n, "");
};

// Log boxed lbl
//
// "+-----------+"
// "| My string |"
// "+-----------+"
const describe = (lbl : string) : unit => {
    const hr = "+" + repeat("-", String.length(lbl) + (2 as nat)) +  "+";
    Test.log(hr);
    Test.log("| " + lbl + " |");
    Test.log(hr);
};


#import "./token.jsligo" "Token_helper"
#import "./dao.jsligo" "DAO_helper"
#import "@ligo/fa/test/helpers/list.mligo" "List_helper"

// Creates a proposal on [dao] with [tok] as governance_token,
// using given [hash_] for the proposal lambda.
// The proposal creator is the first token owner registered in
// the given [tok] token contract owners list.
// Every token owner locks [amount_] of tokens in the DAO,
// and votes "yes" to the created proposal,
// eventually, the end_vote entry point is called.
// Can lead to either accepted or rejected proposal, according to
// the given [amount_] of tokens.
// Requires appropriate config of various periods and delays
const createAndVoteProposal = (
    [tok, dao, hash_, votes] : [Token_helper.originated,
    DAO_helper.originated, option<bytes>, list<[int, nat, bool]>]
) : unit => {
    // set up the sender for propose and end_vote entry points
    const sender_ = List_helper.nth_exn(1)(tok.owners);

    // impersonate token owners and call lock entry point
    const callLock = ([nthAccount, amount_, _] : [int, nat, bool]) : unit => {
        Test.set_source (List_helper.nth_exn(nthAccount)(tok.owners));
        DAO_helper.lockSuccess(amount_, dao.contr);
    };
    List.iter (callLock, votes);

    // create proposal
    Test.set_source (sender_);
    const proposal = { ...DAO_helper.dummyProposal, hash: hash_ };
    DAO_helper.proposeSuccess(proposal, dao.contr);

    // impersonate token owners and call vote entry point
    const callVote = ([nthAccount, _, choice] : [int, nat, bool]) : unit => {
        Test.set_source (List_helper.nth_exn(nthAccount)(tok.owners));
        DAO_helper.voteSuccess(choice, dao.contr);
    };
    List.iter (callVote, votes);

    Test.set_source (sender_);
    DAO_helper.endVoteSuccess(dao.contr);
}


#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "SingleAsset"
#import "@ligo/fa/test/fa2/single_asset.test.mligo" "SingleAsset_helper"
#import "./assert.jsligo" "Assert"
#import "../../src/main.jsligo" "DAO"

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

const originate = (tok_amount : nat) : originated => {
    const f = "../bootstrap/single_asset.mligo";
    const [init_storage, owners, ops] = SingleAsset_helper.get_initial_storage(
        tok_amount, tok_amount, tok_amount
    );
    const v_mich = Test.run(((x:SingleAsset.Storage.t) => x), init_storage);
    const [addr, _, _] = Test.originate_from_file(f, "main", list(["total_supply"]), v_mich, 0 as tez);
    const taddr : taddr = Test.cast_address (addr);
    const contr = Test.to_contract (taddr);
    return {
        addr: addr,
        taddr: taddr,
        owners: owners,
        ops: ops,
        contr: contr
    };
};

type single_asset_transfer_param = {
    contr: contr,
    source: address,
    from_: address,
    to: address,
    amount: nat
};

// Transfer token in [contr] between [from_] and [to_] addresses with [amount_] tokens,
//  WARNING: changes Test framework source
const transfer = ([contr, from_, to_, amount_] : [contr, address, address, nat])
: nat => {
    Test.set_source (from_);
    const transfer_requests : SingleAsset.transfer = list([
      {from_: from_, txs: list([{to_:to_, amount: amount_, token_id: 0 as nat}])}
    ]);
    Test.transfer_to_contract_exn (contr, (Transfer(transfer_requests)), 0 as tez);
};

// Batch add [operators] to [contr] contract
const add_operators = ([operators, contr] : [list<SingleAsset.operator>,
contract<SingleAsset.parameter>]) : unit => {
    const f = ([ys, x] : [list<SingleAsset.unit_update>, SingleAsset.operator])
    : list<SingleAsset.unit_update> => list([(Add_operator(x) as SingleAsset.unit_update), ...ys]);
    const add_operator = List.fold_left (f, (list([]) as list<SingleAsset.unit_update>), operators);
    let r = Test.transfer_to_contract(contr, (Update_operators(add_operator)), 0 as tez);
    Assert.txSuccess(r);
};

// assert for FA2 insuffiscient balance string failure
const assertInsBalanceFailure = (r : test_exec_result) : unit =>
    Assert.stringFailure(r, SingleAsset.Errors.ins_balance);

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

// get balance in [taddr] contract for [owner] address
const get_balance_for = ([taddr, owner] : [taddr, SingleAsset.Ledger.owner]) :
nat => {
    const s = Test.get_storage (taddr);
    match (Big_map.find_opt(owner, s.ledger), {
        Some: (amount_: nat) => amount_,
        None: () => 0 as nat
    });
};

// Create a lambda of type (list<operation>) that would call the "transfer"
// entrypoint of a FA2 contract residing at [addr], making a token transfer between
// [from_] and [to_] addresses with [amount_] tokens.
const createTransferCallable = ([addr, from_, to_, amount_] : [address, address, address, nat])
: DAO.Lambda.operationList => {
    return () : list<operation> => {
        const transferOpt: option<contract<SingleAsset.transfer>> =
            Tezos.get_entrypoint_opt("%transfer", addr);

        match (transferOpt, {
            Some: (c: contract<SingleAsset.transfer>) => {
                const transfer_requests: SingleAsset.transfer = list([
                  {from_: from_, txs: list([{to_: to_, amount: amount_, token_id: 0 as nat}]) as
                  list<SingleAsset.atomic_trans> }
                ]);
                const op = Tezos.transaction(transfer_requests, 0 as tez, c);
                list([op]);
            },
            None: () => failwith("TOKEN_CONTRACT_NOT_FOUND")
        });
    }
};


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

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

// Boostrapping of the test environment
const initTokAmount = 10 as nat;
const bootstrap = (initDAOStorage : DAO.storage) : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, initDAOStorage);
const baseConfig = DAO_helper.baseConfig;
const baseStorage = DAO_helper.baseStorage;

// Succesful lock
const testSuccess = (() : unit => {
    const [tok, dao, sender_] = bootstrap(baseStorage);

    const amount_ = 3 as nat;
    const r = DAO_helper.lock(amount_, dao.contr);
    Assert.txSuccess(r);

    DAO_helper.assertLocked(dao.taddr, sender_, amount_);
    Token_helper.assertBalanceAmount(
        tok.taddr,
        sender_,
        abs(initTokAmount - amount_));
})();

// Succesful lock before voting starts
const testSuccessBeforeVotingStarts = (() : unit => {
    // Add suffiscient start_delay
    const config = { ...baseConfig, startDelay: 86400 as nat };
    let daoStorage = { ...baseStorage, config: config };
    const [tok, dao, sender_] = bootstrap(daoStorage);
    daoStorage = Test.get_storage (dao.taddr);

    const amount_ = 3 as nat;
    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);
    DAO_helper.lockSuccess(amount_, dao.contr);

    DAO_helper.assertLocked(dao.taddr, sender_, amount_);
    Token_helper.assertBalanceAmount(
        tok.taddr,
        sender_,
        abs(initTokAmount - amount_ - daoStorage.config.depositAmount)
    );
})();

// Failing lock because sender has insuffiscient balance
const testFailureInsBalance = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);
    const r = DAO_helper.lock(30 as nat, dao.contr);
    Token_helper.assertInsBalanceFailure(r);
})();

// Failing lock because voting is underway
const testFailureVotingPeriod = (() : unit => {
    // Really short start_delay
    const config = { ...baseConfig, startDelay: 10 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [_, dao, _] = bootstrap(daoStorage);

    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);
    const r = DAO_helper.lock(3 as nat, dao.contr);

    Assert.stringFailure(r, DAO.Errors.votingPeriod);
})();


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

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

// Boostrapping of the test environment
const initTokAmount = 10 as nat;
const bootstrap = () : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, DAO_helper.baseStorage);

// Successful proposal creation
const testSuccess = (() : unit => {
    const [tok, dao, sender_] = bootstrap();

    const r = DAO_helper.propose(DAO_helper.dummyProposal, dao.contr);
    Assert.txSuccess(r);

    const daoStorage = Test.get_storage(dao.taddr);
    const proposal = Option.unopt(daoStorage.proposal);
    assert(proposal.creator == sender_);
    assert(proposal.descriptionLink ==
        "ipfs://QmbKq7QriWWU74NSq35sDSgUf24bYWTgpBq3Lea7A3d7jU");
    assert(proposal.hash == Some(DAO_helper.dummyHash));

    Token_helper.assertBalanceAmount(
        tok.taddr,
        dao.addr,
        daoStorage.config.depositAmount
    );

    Token_helper.assertBalanceAmount(
        tok.taddr,
        sender_,
        abs(initTokAmount - daoStorage.config.depositAmount)
    );
})();

// Failing proposal creation because there is already a proposal
const testFailureProposalExists = (() : unit => {
    const [_, dao, _] = bootstrap();

    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);
    const r = DAO_helper.propose(DAO_helper.dummyProposal, dao.contr);

    Assert.stringFailure(r, DAO.Errors.proposalAlreadyExists);
})();

// Failing because the proposing account doesn't have sufiscient balance for the deposit amount
const testFailureInsufiscientBalance = (() : unit => {
    const [tok, dao, sender_] = bootstrap();

    // Burn all the sender tokens
    const burn_addr = "tz1ZZZZZZZZZZZZZZZZZZZZZZZZZZZZNkiRg" as address;
    const _ = Token_helper.transfer(tok.contr, sender_, burn_addr, initTokAmount);
    const r = DAO_helper.propose(DAO_helper.dummyProposal, dao.contr);

    Token_helper.assertInsBalanceFailure(r);
})();


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

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

// Boostrapping of the test environment
const initTokAmount = 10 as nat;
const bootstrap = (initDAOStorage : DAO.storage) : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, initDAOStorage);
const baseConfig = DAO_helper.baseConfig;
const baseStorage = DAO_helper.baseStorage;

// Successful release
const testSuccess = (() : unit => {
    const [tok, dao, sender_] = bootstrap(baseStorage);

    DAO_helper.lockSuccess(3 as nat, dao.contr);
    DAO_helper.releaseSuccess(3 as nat, dao.contr);

    DAO_helper.assertLocked(dao.taddr, sender_, 0 as nat);
    Token_helper.assertBalanceAmount(
        tok.taddr,
        sender_,
        initTokAmount
    );
})();

// Failing release because no locked tokens
const testFailureNoLockedTokens = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const r = DAO_helper.release(3 as nat, dao.contr);
    Assert.stringFailure(r, DAO.Errors.noLockedTokens);
})();

// Failing release because insuffiscient balance
const testFailureInsBalance = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);
    DAO_helper.lockSuccess(2 as nat, dao.contr);
    const r = DAO_helper.release(3 as nat, dao.contr);
    Assert.stringFailure(r, DAO.Errors.notEnoughBalance);
})();

// Failing release because voting is underway
const testFailureVotingPeriod = (() : unit => {
    // Really short start_delay
    const config = { ...baseConfig, startDelay: 10 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [_, dao, _] = bootstrap(daoStorage);

    DAO_helper.lockSuccess(3 as nat, dao.contr);
    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const r = DAO_helper.release(3 as nat, dao.contr);

    Assert.stringFailure(r, DAO.Errors.votingPeriod);
})();


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

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

// Boostrapping of the test environment
const initTokAmount = 10 as nat;
const bootstrap = (initDAOStorage : DAO.storage) : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, initDAOStorage);
const baseConfig = DAO_helper.baseConfig;
const baseStorage = DAO_helper.baseStorage;

// Successful vote
const testSuccess = (() : unit => {
    // Really short start_delay
    const config = { ...baseConfig, startDelay: 10 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [_, dao, sender_] = bootstrap(daoStorage);

    const amount_ = 3 as nat;
    DAO_helper.lockSuccess(amount_, dao.contr);
    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const choice = true;
    DAO_helper.voteSuccess(choice, dao.contr);
    DAO_helper.assertVoted(dao.taddr, sender_, choice, amount_);
})();

// Failing vote because no proposal
const testFailureNoProposal = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const r = DAO_helper.vote(true, dao.contr);
    Assert.stringFailure(r, DAO.Errors.noProposal);
})();

// Failing vote because proposal is not in voting period
const testFailureNotVotingPeriod = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const amount_ = 3 as nat;
    DAO_helper.lockSuccess(amount_, dao.contr);
    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const r = DAO_helper.vote(true, dao.contr);
    Assert.stringFailure(r, DAO.Errors.notVotingPeriod);
})();

// Failing because no locked tokens in vault
const testFailureNoLockedTokens = (() : unit => {
    // Really short start_delay
    const config = { ...baseConfig, startDelay: 10 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [_, dao, _] = bootstrap(daoStorage);

    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const r = DAO_helper.vote(true, dao.contr);
    Assert.stringFailure(r, DAO.Errors.noLockedTokens);
})();


DAO-Jsligo

An exemple of multisig contract in CameLIGO

target_fa2

transfers

create_proposal

sign_proposal

proposal_counter

proposal_map

signers

threshold

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

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"


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

#import "errors.mligo" "Errors"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


type storage = Storage.t

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

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

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

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

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

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

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

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

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

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


type parameter = [@layout:comb] | Transfer of transfer | Balance_of of balance_of | Update_operators of update_operators
let main ((p,s):(parameter * storage)) = match p with
   Transfer         p -> transfer   p s
|  Balance_of       p -> balance_of p s
|  Update_operators p -> update_ops p s


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

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

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

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



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

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

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

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

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

type request = Parameter.Types.t * Storage.Types.t
type result = operation list * Storage.Types.t

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

(**
 * Proposal signature
 *)

 // LIGO INFO UNCURRIED FUNCTION DOESN'T WORK
let sign_proposal (proposal_number, storage : Parameter.Types.proposal_number * Storage.Types.t) : result =
    let proposal = Preamble.retrieve_a_proposal(proposal_number, storage) in

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

    let operations = FA2.perform_operations proposal in

    (operations, storage)

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

let main (action, storage : request) : result =
    match action with
    | Create_proposal(proposal_params) ->
        create_proposal (proposal_params, storage)
    | Sign_proposal(proposal_number) ->
        sign_proposal (proposal_number, storage)


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

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

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

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

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

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

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

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

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

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

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

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

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



    

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

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

    type proposal_number = nat

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


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


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

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

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

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

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

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


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

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


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

import Types = P.Types

export type func_main = (p: Main.Parameter.Types.t, s: Main.Storage.Types.t) =>  Main.result;
export type func_mainfa2 = (p: FA2.parameter, s: FA2.storage) =>  [list<operation>, FA2.storage];


const assert_error = ([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 _temp: unit = Test.log("here");
const x = Test.reset_state (7 as nat, list([30000000 as tez]) as list <tez>);
const alice: address = Test.nth_bootstrap_account(1);
const bob: address = Test.nth_bootstrap_account(2);
const charly: address = Test.nth_bootstrap_account(3);
const delta: address = Test.nth_bootstrap_account(4);
const echo: address = Test.nth_bootstrap_account(5);
const unknown = Test.nth_bootstrap_account(6);
const signers: set<address> = Set.add(
    alice,
    Set.add(
        bob,
        Set.add(
            charly,
            Set.add(
                delta,
                Set.add(
                    echo,
                    Set.empty as set<address>
                )
            )
        )
    )
);
const threshold: nat = 3 as nat;
const proposal_map: big_map<nat, Main.Storage.Types.proposal> = Big_map.empty;
const proposal_counter: nat = 0 as nat;
const metadata_initial: big_map<string, bytes> = Big_map.empty;
const c: unit = Test.log("here");
const storage: Main.Storage.Types.t = ({
    signers: signers,
    threshold: threshold,
    proposal_map: proposal_map,
    proposal_counter: proposal_counter,
    metadata: metadata_initial
});
const v: unit = Test.log("here");

const atomic: FA2.atomic_trans = {
        to_: bob,
        token_id: 1 as nat
    };
const b: unit = Test.log("here");
const transfer_from: FA2.transfer_from = {
    from_: alice,
    tx: list([atomic]) as list<FA2.atomic_trans>
};
//_ = Test.log("here");
const transfers: FA2.transfer = list([transfer_from]) as FA2.transfer;
//_ = Test.log("here");
const create_proposal_params: Main.Parameter.Types.proposal_params = {
    target_fa2: bob as address,
    transfers: transfers
};
//_ = Test.log("here");


const _test_signer_creates_proposal_works = (mainf: func_main): unit => {
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(alice);

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

const _test_unknown_creates_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_tx = Test.transfer_to_contract(contr, Create_proposal(create_proposal_params), 0 as tez);
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(taddr);
    assert(curr_storage == storage);
};



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

    const [taddr, _, _] = Test.originate(mainf, {
        ...storage, proposal_map: Big_map.literal(list([
        [1 as nat, init_proposal]
    ]))}
    , 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(bob);
    const _gas_used: nat = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);
    const curr_storage = Test.get_storage(taddr);
    const end_signed_proposal = match(Big_map.find_opt(1 as nat, curr_storage.proposal_map), {
        Some: (op: proposal) => op,
        None: () => failwith(Main.Conditions.Errors.no_proposal_exist)
    });
    const expected_signer: set<address> = Set.add(
        bob,
        Set.add(
            alice,
            Set.empty as set<address>
        )
    );
    assert(end_signed_proposal.approved_signers == expected_signer);
};


const _test_unknown_signs_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_tx = Test.transfer_to_contract(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(taddr);
    assert(curr_storage == storage);
};



const _test_unknown_signs_unknown_proposal_fails = (mainf : func_main): unit => {
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_sign_tx = Test.transfer_to_contract(contr, (Sign_proposal(2 as nat) as Types.t), 0 as tez);
    assert_error(fail_sign_tx, Main.Conditions.Errors.only_signer);
};


const _test_signer_signs_unknown_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(alice);
    const fail_sign_tx = Test.transfer_to_contract(contr, (Sign_proposal(2 as nat) as Types.t), 0 as tez);
    assert_error(fail_sign_tx, Main.Conditions.Errors.no_proposal_exist);
};



const _signer_creates_proposal_signers_sign_proposal_execute_works = ([mainf, mainfa2]: [
    func_main,
    func_mainfa2
    ]): unit => {
    Test.set_source(alice);
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    const addr: address = Tezos.address(contr);

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

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

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

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

    const [taddr_fa2, _, _] = Test.originate(mainfa2, storage_fa2, 0 as tez);
    const contr_fa2 = Test.to_contract(taddr_fa2);
    const addr_fa2 = Tezos.address(contr_fa2);
    const params: Main.Parameter.Types.proposal_params = {...create_proposal_params, target_fa2: addr_fa2};
    let _gas_used: nat = Test.transfer_to_contract_exn(contr, Create_proposal(params), 0 as mutez);



    Test.set_source(bob);
    _gas_used = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);
    Test.set_source(charly);
    _gas_used = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);

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

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

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


const _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works = ([mainf, mainfa2]: [
    func_main,
    func_mainfa2
    ]): unit => {
    Test.set_source(alice);
    const storage_init = {...storage, threshold: 1 as nat};
    const [taddr, _, _] = Test.originate(mainf, storage_init, 0 as tez);
    const contr = Test.to_contract(taddr);
    const addr: address = Tezos.address(contr);

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

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

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

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

    const [taddr_fa2, _, _] = Test.originate(mainfa2, storage_fa2, 0 as tez);
    const contr_fa2 = Test.to_contract(taddr_fa2);
    const addr_fa2 = Tezos.address(contr_fa2);
    const params: Main.Parameter.Types.proposal_params = {...create_proposal_params, target_fa2: addr_fa2};
    let _gas_used: nat = Test.transfer_to_contract_exn(contr, Create_proposal(params), 0 as mutez);



    Test.set_source(bob);
    _gas_used = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);

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

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

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

const test_1 = _test_signer_creates_proposal_works(Main.main);
const test_2 = _test_unknown_creates_proposal_fails(Main.main);
const test_3 = _test_signer_signs_proposal_works(Main.main);
const test_4 = _test_unknown_signs_proposal_fails(Main.main);
const test_5 = _test_unknown_signs_unknown_proposal_fails(Main.main);
const test_6 = _test_signer_signs_unknown_proposal_fails(Main.main);
const test_7 = _signer_creates_proposal_signers_sign_proposal_execute_works(Main.main, FA2.main);
const test_8 = _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works(Main.main, FA2.main);


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

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

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


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

const _ = mutation_tests();

Multisig-Cameligo

An exemple of multisig contract in JsLIGO

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

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

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

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



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

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

namespace Preamble {
    const prepare_new_proposal = ([params, storage]: [Parameter.Types.proposal_params, Storage.Types.t]): Storage.Types.proposal => {
        Conditions.only_signer(storage);
        Conditions.amount_must_be_zero_tez((Tezos.get_amount ())); 
        return Storage.Utils.create_proposal(params);
    };

    const retrieve_a_proposal = ([proposal_number, storage]: [nat, Storage.Types.t]): Storage.Types.proposal => {
        Conditions.only_signer(storage);
        const target_proposal: Storage.Types.proposal = Storage.Utils.retrieve_proposal(proposal_number, storage);
        Conditions.not_yet_signer(target_proposal);
        return target_proposal;
    };
};

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

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


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



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

    return [operations, final_storage];
};

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

const main = ([action, store]: [Parameter.Types.t, Storage.Types.t]): result => (match (action, {
        Create_proposal: (p: Parameter.Types.proposal_params) => create_proposal(p, store),
        Sign_proposal:   (p: nat) => sign_proposal(p, store)
    }));


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

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

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

#import "../fa2/fa2.mligo" "FA2"
export namespace Types {
    export type proposal_params = 
    //@ layout:comb
    {
        target_fa2: address,
        transfers: FA2.transfer
    };

    export type proposal_number = nat;

    export type t = ["Create_proposal", proposal_params] | ["Sign_proposal", proposal_number];
};


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



export namespace Types {
    export type proposal =
    // @layout:comb
    {
        approved_signers: set<address>,
        executed: bool,
        number_of_signer: nat,
        target_fa2: address,
        transfers: FA2.transfer,
        timestamp: timestamp
    };

    export type t =
    // @layout:comb
    {
        proposal_counter: nat,
        proposal_map: big_map<nat, proposal>,
        signers: set<address>,
        threshold: nat,
        metadata: big_map<string, bytes>
    };
};

export namespace Utils {
    // @inline
    const new_storage = (
        [signers, threshold]:
        [set<address>, nat]
    ): Types.t => ({
        proposal_counter: 0 as nat,
        proposal_map: Big_map.empty as big_map<nat, Types.proposal>,
        signers: signers,
        threshold: threshold,
        metadata: (Big_map.empty as big_map<string, bytes>)
    });


    // @inline
    const create_proposal = (params: Parameter.Types.proposal_params): Types.proposal => ({
            approved_signers: Set.literal(list([(Tezos.get_sender ())])),
            executed: false,
            number_of_signer: 1 as nat,
            target_fa2: params.target_fa2,
            timestamp: (Tezos.get_now ()),
            transfers: params.transfers
        });

    // @inline
    const register_proposal = ([proposal, storage]: [Types.proposal, Types.t]): Types.t => {
        const proposal_counter = storage.proposal_counter + (1 as nat);
        const proposal_map = Big_map.add(proposal_counter,
            proposal,
            storage.proposal_map
        );
        return {
            ...storage,
            proposal_map: proposal_map,
            proposal_counter: proposal_counter
        };
    };

    // @inline
    const retrieve_proposal = (
        [proposal_number, storage]:
        [nat, Types.t]
    ): Types.proposal =>
        (match(Big_map.find_opt(proposal_number, storage.proposal_map), {
            None: () => failwith(Errors.no_proposal_exist),
            Some: (proposal: Types.proposal) => proposal
        }));

    // @inline
    const add_signer_to_proposal = (
        [proposal, signer, threshold]:
        [Types.proposal, address, nat]
    ): Types.proposal => {
        const approved_signers: set<address> = Set.add(signer, proposal.approved_signers);
        const executed: bool = Set.cardinal(approved_signers) >= threshold || proposal.executed;
        return {
            ...proposal,
            approved_signers: approved_signers,
            number_of_signer: proposal.number_of_signer + (1 as nat),
            executed: executed
        };
    };

    // @inline
    const update_proposal = (
        [proposal_number, proposal, storage]:
        [Parameter.Types.proposal_number, Types.proposal, Types.t]
    ): Types.t => {
        const proposal_map = Big_map.update(proposal_number, Some(proposal), storage.proposal_map);
            return {
                ...storage,
                proposal_map: proposal_map
            }
        };
}


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

import Types = P.Types


export type func_main = (p: Main.Parameter.Types.t, s: Main.Storage.Types.t) =>  Main.result;
export type func_mainfa2 = (p: FA2.parameter, s: FA2.storage) =>  [list<operation>, FA2.storage];


const assert_error = ([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 _temp: unit = Test.log("here");
const x = Test.reset_state (7 as nat, list([30000000 as tez]) as list <tez>);
const alice: address = Test.nth_bootstrap_account(1);
const bob: address = Test.nth_bootstrap_account(2);
const charly: address = Test.nth_bootstrap_account(3);
const delta: address = Test.nth_bootstrap_account(4);
const echo: address = Test.nth_bootstrap_account(5);
const unknown = Test.nth_bootstrap_account(6);
const signers: set<address> = Set.add(
    alice,
    Set.add(
        bob,
        Set.add(
            charly,
            Set.add(
                delta,
                Set.add(
                    echo,
                    Set.empty as set<address>
                )
            )
        )
    )
);
const threshold: nat = 3 as nat;
const proposal_map: big_map<nat, Main.Storage.Types.proposal> = Big_map.empty;
const proposal_counter: nat = 0 as nat;
const metadata_initial: big_map<string, bytes> = Big_map.empty;
const c: unit = Test.log("here");
const storage: Main.Storage.Types.t = ({
    signers: signers,
    threshold: threshold,
    proposal_map: proposal_map,
    proposal_counter: proposal_counter,
    metadata: metadata_initial
});
const v: unit = Test.log("here");

const atomic: FA2.atomic_trans = {
        to_: bob,
        token_id: 1 as nat
    };
const b: unit = Test.log("here");
const transfer_from: FA2.transfer_from = {
    from_: alice,
    tx: list([atomic]) as list<FA2.atomic_trans>
};
//_ = Test.log("here");
const transfers: FA2.transfer = list([transfer_from]) as FA2.transfer;
//_ = Test.log("here");
const create_proposal_params: Main.Parameter.Types.proposal_params = {
    target_fa2: bob as address,
    transfers: transfers
};
//_ = Test.log("here");


const _test_signer_creates_proposal_works = (mainf: func_main): unit => {
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(alice);

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

const _test_unknown_creates_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_tx = Test.transfer_to_contract(contr, Create_proposal(create_proposal_params), 0 as tez);
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(taddr);
    assert(curr_storage == storage);
};



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

    const [taddr, _, _] = Test.originate(mainf, {
        ...storage, proposal_map: Big_map.literal(list([
        [1 as nat, init_proposal]
    ]))}
    , 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(bob);
    const _gas_used: nat = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);
    const curr_storage = Test.get_storage(taddr);
    const end_signed_proposal = match(Big_map.find_opt(1 as nat, curr_storage.proposal_map), {
        Some: (op: proposal) => op,
        None: () => failwith(Main.Conditions.Errors.no_proposal_exist)
    });
    const expected_signer: set<address> = Set.add(
        bob,
        Set.add(
            alice,
            Set.empty as set<address>
        )
    );
    assert(end_signed_proposal.approved_signers == expected_signer);
};


const _test_unknown_signs_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_tx = Test.transfer_to_contract(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(taddr);
    assert(curr_storage == storage);
};



const _test_unknown_signs_unknown_proposal_fails = (mainf : func_main): unit => {
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_sign_tx = Test.transfer_to_contract(contr, (Sign_proposal(2 as nat) as Types.t), 0 as tez);
    assert_error(fail_sign_tx, Main.Conditions.Errors.only_signer);
};


const _test_signer_signs_unknown_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(alice);
    const fail_sign_tx = Test.transfer_to_contract(contr, (Sign_proposal(2 as nat) as Types.t), 0 as tez);
    assert_error(fail_sign_tx, Main.Conditions.Errors.no_proposal_exist);
};



const _signer_creates_proposal_signers_sign_proposal_execute_works = ([mainf, mainfa2]: [
    func_main,
    func_mainfa2
    ]): unit => {
    Test.set_source(alice);
    const [taddr, _, _] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    const addr: address = Tezos.address(contr);

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

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

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

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

    const [taddr_fa2, _, _] = Test.originate(mainfa2, storage_fa2, 0 as tez);
    const contr_fa2 = Test.to_contract(taddr_fa2);
    const addr_fa2 = Tezos.address(contr_fa2);
    const params: Main.Parameter.Types.proposal_params = {...create_proposal_params, target_fa2: addr_fa2};
    let _gas_used: nat = Test.transfer_to_contract_exn(contr, Create_proposal(params), 0 as mutez);



    Test.set_source(bob);
    _gas_used = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);
    Test.set_source(charly);
    _gas_used = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);

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

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

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


const _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works = ([mainf, mainfa2]: [
    func_main,
    func_mainfa2
    ]): unit => {
    Test.set_source(alice);
    const storage_init = {...storage, threshold: 1 as nat};
    const [taddr, _, _] = Test.originate(mainf, storage_init, 0 as tez);
    const contr = Test.to_contract(taddr);
    const addr: address = Tezos.address(contr);

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

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

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

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

    const [taddr_fa2, _, _] = Test.originate(mainfa2, storage_fa2, 0 as tez);
    const contr_fa2 = Test.to_contract(taddr_fa2);
    const addr_fa2 = Tezos.address(contr_fa2);
    const params: Main.Parameter.Types.proposal_params = {...create_proposal_params, target_fa2: addr_fa2};
    let _gas_used: nat = Test.transfer_to_contract_exn(contr, Create_proposal(params), 0 as mutez);



    Test.set_source(bob);
    _gas_used = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);

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

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

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

const test_1 = _test_signer_creates_proposal_works(Main.main);
const test_2 = _test_unknown_creates_proposal_fails(Main.main);
const test_3 = _test_signer_signs_proposal_works(Main.main);
const test_4 = _test_unknown_signs_proposal_fails(Main.main);
const test_5 = _test_unknown_signs_unknown_proposal_fails(Main.main);
const test_6 = _test_signer_signs_unknown_proposal_fails(Main.main);
const test_7 = _signer_creates_proposal_signers_sign_proposal_execute_works(Main.main, FA2.main);
const test_8 = _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works(Main.main, FA2.main);


Multisig-Jsligo

Exemple of a NFT Factory contract in CameLIGO

token_metas

generateCollection

nothing

all_collections

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"


Packages

Most downloaded

Contracts

Featured contract templates

Marigold