blockchain_program.fc

;; Storage
;;
;; int32 seqno
;; int256 public_key
;; slice dapp_owner
;; int64 next_collection_index
;; cell collections_dict

#pragma version >=0.4.0;
#include "imports/stdlib.fc";
#include "imports/messages.fc";
#include "imports/test-libs/message_helpers.fc";
#include "imports/utils.func";
#include "utils/op-codes.fc";
#include "utils/constants.fc";
#include "utils/params.fc";

(slice, int, cell) load_data() inline_ref {

    slice cs = get_data().begin_parse();

    return (
      cs~load_msg_addr(), ;; slice dapp_owner
      cs~load_uint(64), ;; int64 next_collection_index
      (cs.slice_bits() > 0 ? cs~load_dict() : new_dict()) ;; cell collections_dict
    );
}

() save_data(slice dapp_owner, int next_collection_index, cell collections_dict) impure inline {
    set_data(
      begin_cell()
        .store_slice(dapp_owner) ;; slice dapp_owner
        .store_uint(next_collection_index, 64) ;; int256 public_key
        .store_dict(collections_dict) ;; cell collections_dict
      .end_cell()
    );
}

slice calculate_collection_address(cell state_init) {
  return begin_cell().store_uint(4, 3)
                     .store_int(workchain, 8)
                     .store_uint(cell_hash(state_init), 256)
                     .end_cell()
                     .begin_parse();
}


() change_owner(slice new_owner_addr) impure {

  (slice dapp_owner, int next_collection_index, cell collections_dict) = load_data();

  force_chain(new_owner_addr);

  save_data(new_owner_addr, next_collection_index, collections_dict);
}

() withdraw_funds(int my_balance, int withdraw_amount) impure {

  throw_unless(407, my_balance + MIN_TONS_FOR_STORAGE > withdraw_amount);

  (slice dapp_owner,  _, _) = load_data();

  messages::send_empty(withdraw_amount, dapp_owner, NORMAL + 1);
}


() edit_code(cell new_code) impure {

  set_code(new_code);

  cont old_code = get_c3();
  set_c3(new_code.begin_parse().bless());

  throw(0);
}

(slice) return_collection_addr_by_id (int collection_id) inline_ref {

  (_, _, cell collections_dict) = load_data();

  (slice value, int f) = udict_get?(collections_dict, 256, collection_id);

  throw_unless(666, f);

  return value;

}

() deploy_collection (cell collection_code, cell collection_data) impure {

  (slice dapp_owner, int next_collection_index, cell collections_dict) = load_data();

  cell state_init = (generate_init_state_with_data_no_library(collection_code, collection_data)).end_cell();
  
  slice collection_addr = calculate_collection_address(state_init);

  messages::send_with_stateinit(50000000, collection_addr, state_init, (begin_cell().end_cell()), NORMAL);

  cell new_collections_dict = collections_dict.udict_set(256, next_collection_index, collection_addr);

  next_collection_index += 1;

  save_data(dapp_owner, next_collection_index, new_collections_dict);

}

() deploy_item (int collection_id, int query_id, int item_index, int amount, cell nft_content) impure {
  
  slice collection_address = return_collection_addr_by_id(collection_id);

  slice in_msg_body = begin_cell()
                    .store_uint(op::deploy_nft_item, 32)
                    .store_uint(query_id, 64)
                    .store_uint(item_index, 64)
                    .store_coins(amount)
                    .store_ref(nft_content)
                  .end_cell().begin_parse();

  cell msg_body = begin_cell().store_slice(in_msg_body).end_cell();

  messages::send_via_proxy(ZERO_AMOUNT, collection_address, msg_body, CARRY_REMAINING_GAS);

}

() batch_nft_deploy (int collection_id, int query_id, cell deploy_list) impure {

  slice collection_address = return_collection_addr_by_id(collection_id);

  slice in_msg_body = begin_cell()
                    .store_uint(op::batch_nft_deploy, 32)
                    .store_uint(query_id, 64)
                    .store_ref(deploy_list)
                  .end_cell().begin_parse();

  cell msg_body = begin_cell().store_slice(in_msg_body).end_cell();

  messages::send_via_proxy(ZERO_AMOUNT, collection_address, msg_body, CARRY_REMAINING_GAS);

}

() edit_collection_content (int collection_id, int query_id, cell new_content, cell royalty_params) impure {

  slice collection_address = return_collection_addr_by_id(collection_id);

  slice in_msg_body = begin_cell()
                    .store_uint(op::edit_collection_content, 32)
                    .store_uint(query_id, 64)
                    .store_ref(new_content)
                    .store_ref(royalty_params)
                  .end_cell().begin_parse();

  cell msg_body = begin_cell().store_slice(in_msg_body).end_cell();
  
  messages::send_via_proxy(ZERO_AMOUNT, collection_address, msg_body, CARRY_REMAINING_GAS);  

}

() change_collection_owner (int collection_id, int query_id, slice new_owner_addr) impure {

  slice collection_address = return_collection_addr_by_id(collection_id);

  slice in_msg_body = begin_cell()
                    .store_uint(op::change_collection_owner, 32)
                    .store_uint(query_id, 64)
                    .store_slice(new_owner_addr)
                  .end_cell().begin_parse();

  cell msg_body = begin_cell().store_slice(in_msg_body).end_cell();
  
  messages::send_via_proxy(ZERO_AMOUNT, collection_address, msg_body, CARRY_REMAINING_GAS);

}

() edit_item_content (slice item_address, int query_id, cell content) impure {

  slice in_msg_body = begin_cell()
                    .store_uint(op::edit_content, 32)
                    .store_uint(query_id, 64)
                    .store_dict(content)
                  .end_cell().begin_parse();

  cell msg_body = begin_cell().store_slice(in_msg_body).end_cell();
  
  messages::send_via_proxy(ZERO_AMOUNT, item_address, msg_body, CARRY_REMAINING_GAS);

}

() destroy_sbt_item (slice item_address, int query_id) impure {

  slice in_msg_body = begin_cell()
                    .store_uint(op::destroy, 32)
                    .store_uint(query_id, 64)
                  .end_cell().begin_parse();

  cell msg_body = begin_cell().store_slice(in_msg_body).end_cell();

  messages::send_via_proxy(ZERO_AMOUNT, item_address, msg_body, CARRY_REMAINING_GAS);

}

() revoke_sbt_item (slice item_address, int query_id) impure {

  slice in_msg_body = begin_cell()
                  .store_uint(op::revoke, 32)
                  .store_uint(query_id, 64)
                .end_cell().begin_parse();

  cell msg_body = begin_cell().store_slice(in_msg_body).end_cell();

  messages::send_via_proxy(ZERO_AMOUNT, item_address, msg_body, CARRY_REMAINING_GAS);

}

() transfer_item (slice item_address, int query_id, slice new_owner_address, slice resp_address, int fwd_amount) impure {

  slice in_msg_body = begin_cell()
                  .store_uint(op::transfer, 32)
                  .store_uint(query_id, 64)
                  .store_slice(new_owner_address)
                  .store_slice(resp_address)
                  .store_uint(0, 1)
                  .store_coins(fwd_amount)
                .end_cell().begin_parse();

  cell msg_body = begin_cell().store_slice(in_msg_body).end_cell();

  messages::send_via_proxy(ZERO_AMOUNT, item_address, msg_body, CARRY_REMAINING_GAS);

}

() recv_internal(int balance, int msg_value, cell in_msg_full, slice in_msg_body) impure {

  slice cs = in_msg_full.begin_parse();

  int flags = cs~load_uint(4);
  slice sender_address = cs~load_msg_addr();

  if (flags & 1) { 
    return (); 
  } 

  if (in_msg_body.slice_empty?()) { 
    return (); 
  }

  (slice dapp_owner, int next_collection_index, cell collections_dict) = load_data();

  int op = in_msg_body~load_uint(32);
  int query_id = in_msg_body~load_uint(64);

    if (op == op::mint_notification) {  ;; nft has just been initialized

      return ();
    }

    if (op == op::edit_notification) {

      return ();
    }

    if (op == op::excesses) {

      return ();
    }

    throw_unless(405, equal_slices(dapp_owner, sender_address));

      ;; Deploy Collection

    if (op == op::deploy_collection) {

      deploy_collection(in_msg_body~load_ref(), in_msg_body~load_ref());  
      
      return ();

    }

    if (op == op::deploy_nft_item) {

      int collection_id = in_msg_body~load_uint(64);

      deploy_item(collection_id, query_id, in_msg_body~load_uint(64), MIN_DEPLOY_AMOUNT, in_msg_body~load_ref());

      return ();

    }

    if (op == op::batch_nft_deploy) {

      int collection_id = in_msg_body~load_uint(64);

      batch_nft_deploy(collection_id, query_id, in_msg_body~load_ref());

      return ();

    }

    if (op == op::change_collection_owner) {

      int collection_id = in_msg_body~load_uint(64);

      change_collection_owner(collection_id, query_id, in_msg_body~load_msg_addr());

      return ();

    }

    if (op == op::edit_collection_content) {

      int collection_id = in_msg_body~load_uint(64);

      edit_collection_content(collection_id, query_id, in_msg_body~load_ref(), in_msg_body~load_ref());

      return ();

    }

    if (op == op::edit_item_content) {

      edit_item_content(in_msg_body~load_msg_addr(), query_id, in_msg_body~load_ref());

      return ();

    }

    if (op == op::destroy_sbt_item) {

      destroy_sbt_item(in_msg_body~load_msg_addr(), query_id);

      return ();

    }

    if (op == op::transfer_item) { ;; transfer order nft to freelancer

      transfer_item(in_msg_body~load_msg_addr(), query_id, in_msg_body~load_msg_addr(), in_msg_body~load_msg_addr(), in_msg_body~load_coins());

      return ();
    }

    if (op == op::change_owner) {

      change_owner(cs~load_msg_addr());

      return ();
    }

    if (op == op::withdraw_funds) {

      withdraw_funds(balance, cs~load_coins());

      return ();
    }

    if (op == op::edit_dapp_code) {  ;; edit dapp code

      edit_code(cs~load_ref());

      return ();
    }

    throw(0xffffff);

}

;; Getters

(slice, int, cell) get_dapp_data() method_id {
  (slice dapp_owner, int next_collection_index, cell collections_dict) = load_data();
  return (
    dapp_owner,
    next_collection_index,
    collections_dict
  );
}