admin_nft.fc

;;
;;  TON SBT-Editable Item Smart Contract
;;
#pragma version >=0.4.0;

#include "imports/stdlib.fc";
#include "imports/messages.fc";
#include "utils/constants.fc";
#include "utils/params.fc";
#include "utils/flags.fc";
#include "utils/op-codes.fc";

int min_tons_for_storage() asm "50000000 PUSHINT"; ;; 0.05 TON
;;
;;  Storage
;;
;;  uint64 index
;;  MsgAddressInt collection_address
;;  MsgAddressInt owner_address
;;  cell content
;;  MsgAddressInt authority_address
;;  MsgAddressInt editor_address
;;  uint64 revoked_at

(int, int, slice, slice, cell, slice, int) load_data() inline {
    slice ds = get_data().begin_parse();
    var (index, collection_address) = (ds~load_uint(64), ds~load_msg_addr());
    if (ds.slice_bits() > 0) {
      return (-1, index, collection_address, ds~load_msg_addr(), ds~load_ref(), ds~load_msg_addr(), ds~load_uint(64));
    } else {  
      return (0, index, collection_address, null(), null(), null(), null()); ;; nft not initialized yet
    }
}

() store_data(int index, slice collection_address, slice owner_address, cell content, slice authority_address, int revoked_at) impure {
    set_data(
        begin_cell()
            .store_uint(index, 64)
            .store_slice(collection_address)
            .store_slice(owner_address)
            .store_ref(content)
            .store_slice(authority_address)
            .store_uint(revoked_at, 64)
            .end_cell()
    );
}

() send_msg(int flag, slice to_address, int amount, int op, int query_id, builder payload, int send_mode) impure inline {

    var msg = begin_cell()
        .store_uint(flag, 6)
        .store_slice(to_address)
        .store_coins(amount)
        .store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1)
        .store_uint(op, 32)
        .store_uint(query_id, 64);

    if (~ builder_null?(payload)) {
        msg = msg.store_builder(payload);
    }

    send_raw_message(msg.end_cell(), send_mode);
}

() recv_internal(int my_balance, int msg_value, cell in_msg_full, slice in_msg_body) impure {
    if (in_msg_body.slice_empty?()) { 
        return ();
    }

    slice cs = in_msg_full.begin_parse();
    int flags = cs~load_uint(4);

    slice sender_address = cs~load_msg_addr();

    cs~load_msg_addr(); 
    cs~load_coins(); 
    cs~skip_bits(1); 
    cs~load_coins();
    
    int fwd_fee = muldiv(cs~load_coins(), 3, 2);
    
    (int init?, int index, slice collection_address, slice owner_address, cell content, slice authority_address, int revoked_at) = load_data();

    if (~ init?) {
        throw_unless(405, equal_slices(collection_address, sender_address));

        slice owner_address = in_msg_body~load_msg_addr();
       ;; cell content_dict = in_msg_body~load_dict();
        slice authority_address = in_msg_body~load_msg_addr();

      ;;  cell content = begin_cell().store_uint(0, 8).store_dict(content_dict).end_cell();

        cell content = begin_cell().store_uint(0, 8).store_dict(new_dict()).end_cell();

        store_data(index, collection_address, owner_address, content, authority_address, 0); 

        return ();
    }

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

    if (flags & 1) { ;; route all prove_ownership bounced messages to owner
        ;; first op was 0xffffffff, because of bounced, now we need to read real one
        op = in_msg_body~load_uint(32);

        if (op == op::ownership_proof) {
            send_msg(flag::regular(), owner_address, ZERO_AMOUNT, op::ownership_proof_bounced, query_id, null(), CARRY_REMAINING_GAS);
        }
        return ();
    }

    if (op == op::request_owner) {
        slice dest = in_msg_body~load_msg_addr();
        cell body = in_msg_body~load_ref();
        int with_content = in_msg_body~load_uint(1);

        var msg = begin_cell()
                .store_uint(index, 256)
                .store_slice(sender_address)
                .store_slice(owner_address)
                .store_ref(body)
                .store_uint(revoked_at, 64)
                .store_uint(with_content, 1);

        if (with_content != 0) {
            msg = msg.store_ref(content);
        }

        send_msg(flag::regular() | flag::bounce(), dest, ZERO_AMOUNT, op::owner_info, query_id, msg, CARRY_REMAINING_GAS);
        return ();
    }
    if (op == op::prove_ownership) {
        throw_unless(401, equal_slices(owner_address, sender_address));

        slice dest = in_msg_body~load_msg_addr();
        cell body = in_msg_body~load_ref();
        int with_content = in_msg_body~load_uint(1);

        var msg = begin_cell()
                .store_uint(index, 256)
                .store_slice(owner_address)
                .store_ref(body)
                .store_uint(revoked_at, 64)
                .store_uint(with_content, 1);

        if (with_content != 0) {
            msg = msg.store_ref(content);
        }

        send_msg(flag::regular() | flag::bounce(), dest, ZERO_AMOUNT, op::ownership_proof, query_id, msg, CARRY_REMAINING_GAS);
        return ();
    }
    if (op == op::get_static_data) {
        var msg = begin_cell().store_uint(index, 256).store_slice(collection_address);

        send_msg(flag::regular(), sender_address, ZERO_AMOUNT, op::report_static_data, query_id, msg, CARRY_REMAINING_GAS);
        return ();
    }
    if (op == op::destroy) {
        throw_unless(401, equal_slices(owner_address, sender_address));

        send_msg(flag::regular(), sender_address, ZERO_AMOUNT, op::excesses, query_id, null(), CARRY_ALL_BALANCE);

        owner_address = null_addr();
        authority_address = null_addr();
        
        store_data(index, collection_address, owner_address, content, authority_address, revoked_at);
        return ();
    }
    if (op == op::revoke) {
        throw_unless(401, equal_slices(authority_address, sender_address));
        throw_unless(403, revoked_at == 0);

        revoked_at = now();
        store_data(index, collection_address, owner_address, content, authority_address, revoked_at);
        return ();
    }
    if (op == op::take_excess) {
        throw_unless(401, equal_slices(owner_address, sender_address));

        raw_reserve(min_tons_for_storage(), 0);

        send_msg(flag::regular(), sender_address, ZERO_AMOUNT, op::excesses, query_id, null(), CARRY_ALL_BALANCE);
        return ();
    }
    if (op == op::edit_content) { ;; owner can change content and dns records
        throw_unless(410, equal_slices(sender_address, owner_address));
        store_data(index, collection_address, owner_address, in_msg_body~load_ref(), authority_address, revoked_at);
        return ();
    }
    if (op == op::change_record) { 
        throw_unless(411, equal_slices(sender_address, owner_address));
        int key = in_msg_body~load_uint(256);
        int has_value = in_msg_body.slice_refs() > 0;

        slice cs = content.begin_parse();
        throw_unless(412, cs~load_uint(8) == 0); ;; data onchain tag
        cell keyvalue_map = cs~load_dict();

        if (has_value) {
            cell value = in_msg_body~load_ref();

            keyvalue_map~udict_set_ref(256, key, value);
        } else {
            keyvalue_map~udict_delete?(256, key);
        }

        content = begin_cell().store_uint(0, 8).store_dict(keyvalue_map).end_cell();

        store_data(index, collection_address, owner_address, content, authority_address, revoked_at);
        return ();
    }
 
    if (op == op::transfer) {

        throw(413);

    }
    throw(0xffff);
}

;;
;;  GET Methods
;;

(int, int, slice, slice, cell, slice, int) get_nft_data() method_id {
    (int init?, int index, slice collection_address, slice owner_address, cell content, slice authority_address, int revoked_at) = load_data();
    return (init?, index, collection_address, owner_address, content, authority_address, revoked_at);
}

slice get_authority_address() method_id {
    (_, _, _, _, _, slice authority_address, _) = load_data();
    return authority_address;
}

int get_revoked_time() method_id {
    (_, _, _, _, _, _, int revoked_at) = load_data();
    return revoked_at;
}