update entrypoints and remove main

src/main.mligo

@@ -10,7 +10,8 @@ type store = NFT_FA2.Storage.t
 type ext = NFT_FA2.extension
 type ext_storage = ext store
 
-let generateCollection(param, store : Parameter.generate_collection_param * Storage.t) : return = 
+[@entry]
+let generateCollection (param : Parameter.generate_collection_param) (store : storage) : return = 
  // create new collection
  let token_ids = param.token_ids in
  let sender = Tezos.get_sender () in
@@ -39,8 +40,7 @@ let generateCollection(param, store : Parameter.generate_collection_param * Stor
 
  let initial_delegate : key_hash option = (None: key_hash option) in
  let initial_amount : tez = 1tez in
- let create_my_contract = [%create_contract_of_file "generic_fa2/compiled/fa2_nft.tz"] in
- let originate : operation * address = create_my_contract initial_delegate initial_amount initial_storage in
+ let originate : operation * address = [%create_contract_of_file "generic_fa2/compiled/fa2_nft.tz"] 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
@@ -51,7 +51,4 @@ let generateCollection(param, store : Parameter.generate_collection_param * Stor
  ([originate.0], { store with all_collections=new_all_collections; owned_collections=new_owned_collections})
 
 [@entry]
-let main (ep : parameter) (store : storage) : return =
- match ep with 
- | GenerateCollection(p) -> generateCollection(p, store)
- | Nothing -> (([] : operation list), store)
+let nothing (_ : unit) (s : storage) : return = (([] : operation list), s)

src/marketplace/main.mligo

@@ -4,10 +4,12 @@
 #import "../generic_fa2/core/instance/NFT.mligo" "NFT_FA2"
 
 type storage = Storage.t
-type parameter = Parameter.t
+type parameter_sell = Parameter.sell_proposal_param
+type parameter_buy = Parameter.buy_param
 type return = operation list * storage
 
-let create_sell_proposal(param, store : Parameter.sell_proposal_param * Storage.t) : return = 
+[@entry]
+let create_sell_proposal(param : parameter_sell) (store : storage) : 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
@@ -27,8 +29,8 @@ let create_sell_proposal(param, store : Parameter.sell_proposal_param * Storage.
 
  (([] : 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 =
+[@entry]
+let accept_proposal(param : parameter_buy) (store : storage) : 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)
@@ -60,12 +62,6 @@ let accept_proposal(param, store : Parameter.buy_param * Storage.t) : return =
 
  ([op; op2;], { store with sell_proposals=new_proposals; active_proposals=new_active_proposals })
 
-[@entry]
-let main (ep : parameter) (store : storage) : return =
- match ep with 
- | Sell p -> create_sell_proposal(p, store)
- | Buy p -> accept_proposal(p, store)
-
 [@view] let get_proposal (p : nat) (s : storage) : Storage.sell_proposal = 
  match Big_map.find_opt p s.sell_proposals with 
  | None -> (failwith("") : Storage.sell_proposal)

src/marketplace/parameter.mligo

@@ -7,6 +7,4 @@ type sell_proposal_param = {
 
 type buy_param = {
  proposal_id : nat
-}
-
-type t = Sell of sell_proposal_param | Buy of buy_param
+}

src/parameter.mligo

@@ -6,4 +6,4 @@ type generate_collection_param = {
  token_metas : NFT_FA2.NFT.TokenMetadata.t
 }
 
-type t = GenerateCollection of generate_collection_param | Nothing of unit
+type t = generate_collection_param

test/test.mligo

@@ -1,8 +1,11 @@
 
 #import "../src/main.mligo" "Factory"
+#import "../src/storage.mligo" "Storage"
+#import "../src/parameter.mligo" "Parameter"
+#import "../src/generic_fa2/core/instance/NFT.mligo" "NFT_FA2"
 
-type fa2_storage = Factory.NFT_FA2.Storage.t
-type ext = Factory.NFT_FA2.extension
+type fa2_storage = NFT_FA2.Storage.t
+type ext = NFT_FA2.extension
 type ext_fa2_storage = ext fa2_storage
 
 let assert_string_failure (res : test_exec_result) (expected : string) : unit =
@@ -22,31 +25,30 @@ let test =
  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);
+ let init_storage : Storage.t = { 
+ all_collections=(Big_map.empty : (Storage.collectionContract, Storage.collectionOwner) big_map);
+ owned_collections=(Big_map.empty : (Storage.collectionOwner, 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 orig = Test.originate_from_file "../src/main.mligo" init_storage 0tez in
+ let addr = orig.addr 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
+ (1n, ({token_id=1n;token_info=token_info_1;} : NFT_FA2.NFT.TokenMetadata.data));
+ ] : 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
+ let gencol_args : Parameter.generate_collection_param = {name="alice_collection_1"; token_ids=token_ids; token_metas=token_metadata} in
+ let _ = Test.transfer_exn addr (GenerateCollection gencol_args : Factory parameter_of) 1000000mutez in
 
  // verify FA2 has been created
  let s : Factory.storage = Test.get_storage addr in
@@ -94,7 +96,7 @@ let test =
  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
+ let _x = Test.to_contract addr in
 
  // Retrieve address of collection 1
  let s_before : Factory.storage = Test.get_storage addr in
@@ -132,7 +134,7 @@ let test =
  //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 x = Test.to_contract addr in
 
  //let () = Test.log("alice generates a collection 2") in
  let () = Test.set_source alice in

test/test_marketplace.mligo

@@ -28,22 +28,21 @@ let test =
  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 orig = Test.originate_from_file "../src/main.mligo" init_storage 0tez in
+ let addr = orig.addr 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 orig = Test.originate_from_file "../src/marketplace/main.mligo" marketplace_init_storage 0tez in
+ let marketplace_taddr = orig.addr 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[
@@ -56,7 +55,7 @@ let test =
  // 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
+ let _ = Test.transfer_exn addr (GenerateCollection gencol_args : Factory parameter_of) 1000000mutez in
 
  // verify FA2 has been created
  let s : Factory.storage = Test.get_storage addr in
@@ -82,8 +81,7 @@ let test =
 
  // 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 marketplace_addr = Test.to_address marketplace_taddr 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
@@ -95,14 +93,14 @@ let test =
  price=1tez;
  } in
  let () = Test.set_source alice in
- let _ = Test.transfer_to_contract_exn marketplace_contract (Sell(sell_args)) 0mutez in
+ let _ = Test.transfer_exn marketplace_taddr (Create_sell_proposal sell_args : Marketplace parameter_of) 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 _ = Test.transfer_exn marketplace_taddr (Accept_proposal buy_args : Marketplace parameter_of) 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