#include "imports/stdlib.fc"; #include "op-codes.fc"; global int storage::merkle_root; global int storage::merkle_depth; global cell storage::nft_item_code; global slice storage::owner; global cell storage::content; global cell storage::royalty; global int storage::last_index; global cell storage::api_data; global slice storage::second_owner; const int node_dict_key_len = 32; const int error::not_owner = 100; const int error::bad_proof = 101; const int error::index_too_high = 102; const int error::tree_full = 103; const int error::malformed_updates = 104; const int op::claim = "op::claim"c; const int op::update = "op::update"c; const int op::update_api_data = "op::update_api_data"c; const int op::proxy_send = "op::proxy_send"c; const int op::change_owner = 3; const int op::change_secondary_owner = 6; const int op::update_content = 4; const int op::return_balance = 5; const int item_init_value = 50000000; const int workchain = 0; () load_data() impure { slice ds = get_data().begin_parse(); storage::merkle_root = ds~load_uint(256); storage::merkle_depth = ds~load_uint(8); storage::owner = ds~load_msg_addr(); storage::content = ds~load_ref(); storage::nft_item_code = ds~load_ref(); storage::royalty = ds~load_ref(); storage::last_index = ds~load_uint(128); storage::api_data = ds~load_ref(); storage::second_owner = ds~load_msg_addr(); ds.end_parse(); } () save_data() impure { set_data(begin_cell() .store_uint(storage::merkle_root, 256) .store_uint(storage::merkle_depth, 8) .store_slice(storage::owner) .store_ref(storage::content) .store_ref(storage::nft_item_code) .store_ref(storage::royalty) .store_uint(storage::last_index, 128) .store_ref(storage::api_data) .store_slice(storage::second_owner) .end_cell()); } int hash_nodes(int a, int b) { return begin_cell().store_uint(a, 256).store_uint(b, 256).end_cell().cell_hash(); } int get_node(cell p, int i) { (slice v, int ok) = p.udict_get?(node_dict_key_len, i); throw_unless(error::bad_proof, ok); return v.preload_uint(256); } (cell, ()) set_node(cell p, int i, int v) { p~udict_set_builder(node_dict_key_len, i, begin_cell().store_uint(v, 256)); return (p, ()); } int check_proof(int root, cell proof, int leaf, int leaf_index, int depth) { int i = 0; int cur = leaf; while (i < depth) { int is_right = (leaf_index >> i) & 1; if (is_right) { cur = hash_nodes(proof.get_node(i), cur); } else { cur = hash_nodes(cur, proof.get_node(i)); } i += 1; } return cur == root; } cell calculate_nft_item_state_init(int item_index, cell nft_item_code) { cell data = begin_cell().store_uint(item_index, 64).store_slice(my_address()).end_cell(); return begin_cell().store_uint(0, 2).store_dict(nft_item_code).store_dict(data).store_uint(0, 1).end_cell(); } slice calculate_nft_item_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(); } () deploy_nft_item(int item_index, cell nft_message) impure { cell state_init = calculate_nft_item_state_init(item_index, storage::nft_item_code); slice nft_address = calculate_nft_item_address(state_init); var msg = begin_cell() .store_uint(0x18, 6) .store_slice(nft_address) .store_coins(0) .store_uint(4 + 2 + 1, 1 + 4 + 4 + 64 + 32 + 1 + 1 + 1) .store_ref(state_init) .store_ref(nft_message); send_raw_message(msg.end_cell(), 64); ;; transfer all income value to nft } () claim(int nft_index, cell nft_data, cell proof) impure { throw_if(error::index_too_high, nft_index > storage::last_index); throw_unless(error::bad_proof, check_proof(storage::merkle_root, proof, nft_data.cell_hash(), nft_index, storage::merkle_depth)); deploy_nft_item(nft_index, nft_data); } () update(cell updates, int new_last_index, cell hashes) impure { throw_if(error::tree_full, storage::last_index >= ((1 << storage::merkle_depth) - 1)); throw_unless(error::malformed_updates, new_last_index > storage::last_index); int cur_left = (storage::last_index + 1) + (1 << storage::merkle_depth); int i = storage::merkle_depth; int last_node_hash = -1; cell verification_hashes = hashes; int zero_hash = 0; while (i > 0) { (slice v, int ok) = updates.udict_get?(node_dict_key_len, i); if (ok) { int node_index = v~load_uint(128); int leaf_node_index = node_index << (storage::merkle_depth - i); throw_unless(error::malformed_updates, leaf_node_index == cur_left); ;; does this verify that node_index belongs to depth cur_left = leaf_node_index + (1 << (storage::merkle_depth - i)); int new_hash = v~load_uint(256); last_node_hash = node_index >> 1; hashes~set_node(last_node_hash, hash_nodes(hashes.get_node(node_index - 1), new_hash)); verification_hashes~set_node(last_node_hash, hash_nodes(verification_hashes.get_node(node_index - 1), zero_hash)); } elseif (last_node_hash != -1) { int new_last_node_hash = last_node_hash >> 1; hashes~set_node(new_last_node_hash, hash_nodes(hashes.get_node(last_node_hash - 1), hashes.get_node(last_node_hash))); verification_hashes~set_node(new_last_node_hash, hash_nodes(verification_hashes.get_node(last_node_hash - 1), verification_hashes.get_node(last_node_hash))); last_node_hash = new_last_node_hash; } zero_hash = hash_nodes(zero_hash, zero_hash); i -= 1; } if ((storage::last_index == 0) & (zero_hash == storage::merkle_root)) { ;; special case for update empty collection (slice v, int ok) = updates.udict_get?(node_dict_key_len, 0); if (ok) { int node_index = v~load_uint(128); int new_hash = v~load_uint(256); storage::merkle_root = new_hash; } else { throw(error::malformed_updates); } storage::last_index = new_last_index; save_data(); } else { throw_unless(error::malformed_updates, cur_left == (1 << (storage::merkle_depth + 1))); throw_unless(error::malformed_updates, verification_hashes.get_node(1) == storage::merkle_root); storage::merkle_root = hashes.get_node(1); storage::last_index = new_last_index; save_data(); } } () send_royalty_params(slice to_address, int query_id, slice data) impure inline { var msg = begin_cell() .store_uint(0x10, 6) ;; nobounce - int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 011000 .store_slice(to_address) .store_coins(0) .store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1) .store_uint(op::report_royalty_params(), 32) .store_uint(query_id, 64) .store_slice(data); send_raw_message(msg.end_cell(), 64); ;; carry all the remaining value of the inbound message } () 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); if (flags & 1) { return (); } slice sender_address = cs~load_msg_addr(); load_data(); int op = in_msg_body~load_uint(32); int query_id = in_msg_body~load_uint(64); if (op == op::claim) { slice proof_data = in_msg_body~load_ref().begin_parse(); claim(proof_data~load_uint(128), proof_data~load_ref(), proof_data~load_ref()); return (); } if (op == op::update) { throw_unless(error::not_owner, equal_slices(sender_address, storage::owner) | equal_slices(sender_address, storage::second_owner)); slice update_data = in_msg_body~load_ref().begin_parse(); update(update_data~load_ref(), update_data~load_uint(128), update_data~load_ref()); return (); } if (op == op::get_royalty_params()) { send_royalty_params(sender_address, query_id, storage::royalty.begin_parse()); return (); } if (op == op::change_owner) { ;; change owner throw_unless(error::not_owner, equal_slices(sender_address, storage::owner)); storage::owner = in_msg_body~load_msg_addr(); storage::second_owner = storage::owner; save_data(); return (); } if (op == op::change_secondary_owner) { ;; change owner throw_unless(error::not_owner, equal_slices(sender_address, storage::owner) | equal_slices(sender_address, storage::second_owner)); storage::second_owner = in_msg_body~load_msg_addr(); save_data(); return (); } if (op == op::update_content) { ;; update content throw_unless(error::not_owner, equal_slices(sender_address, storage::owner) | equal_slices(sender_address, storage::second_owner)); storage::content = in_msg_body~load_ref(); storage::royalty = in_msg_body~load_ref(); save_data(); return (); } if (op == op::return_balance) { ;; return collection balance throw_unless(error::not_owner, equal_slices(sender_address, storage::owner)); var msg = begin_cell() .store_uint(0x18, 6) .store_slice(sender_address) .store_coins(0) .store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1) .store_uint(op, 32) .store_uint(query_id, 64); raw_reserve(50000000, 0); ;; 0.05 TON send_raw_message(msg.end_cell(), 128); ;; return all non reserve balance return (); } if (op == op::update_api_data) { ;; update content throw_unless(error::not_owner, equal_slices(sender_address, storage::owner) | equal_slices(sender_address, storage::second_owner)); storage::api_data = in_msg_body~load_ref(); save_data(); return (); } if (op == op::proxy_send) { slice to = in_msg_body~load_msg_addr(); cell body = in_msg_body~load_ref(); var msg = begin_cell() .store_uint(0x18, 6) .store_slice(to) .store_coins(0) .store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1) .store_uint(op, 32) .store_uint(query_id, 64) .store_slice(sender_address) .store_ref(body); send_raw_message(msg.end_cell(), 64); ;; proxy all input coins return (); } throw(0xffff); } (int, cell, slice) get_collection_data() method_id { load_data(); slice cs = storage::content.begin_parse(); return (-1, cs~load_ref(), storage::owner); } slice get_nft_address_by_index(int index) method_id { load_data(); cell state_init = calculate_nft_item_state_init(index, storage::nft_item_code); return calculate_nft_item_address(state_init); } (int, int, slice) royalty_params() method_id { load_data(); slice rs = storage::royalty.begin_parse(); return (rs~load_uint(16), rs~load_uint(16), rs~load_msg_addr()); } cell get_nft_content(int index, cell individual_nft_content) method_id { load_data(); slice cs = storage::content.begin_parse(); cs~load_ref(); slice common_content = cs~load_ref().begin_parse(); return (begin_cell() .store_uint(1, 8) ;; offchain tag .store_slice(common_content) .store_ref(individual_nft_content) .end_cell()); } int get_merkle_root() method_id { load_data(); return storage::merkle_root; } int get_last_index() method_id { load_data(); return storage::last_index; } (int, cell) get_nft_api_info() method_id { load_data(); slice cs = storage::api_data.begin_parse(); int version = cs~load_uint(8); cell link = cs~load_ref(); return (version, link); } (slice) get_second_owner_address() method_id { load_data(); return (storage::second_owner); }

Contracts/3Nk7oN3n/mevE3kwX3oboU307efvW4FsMc8HvbpDy58=

Verified Sources