Native NFT Support

use tako_sdk::nft::*;
 
let collection_id = nft_create_collection(
    "My Collection",           // name
    "MYC",                     // symbol
    "https://example.com/",    // base_uri
    500,                       // royalty_bps (5%)
    Some(10000),               // max_supply (optional)
)?;

nft_update_collection(
    &collection_id,
    Some("New Name"),
    Some("https://new-uri.com/"),
)?;

nft_transfer_collection_ownership(&collection_id, &new_owner)?;

nft_set_minting_paused(&collection_id, true)?;  // Pause
nft_set_minting_paused(&collection_id, false)?; // Resume

let exists = nft_collection_exists(&collection_id)?;

let token_id = nft_mint(
    &collection_id,
    &recipient,
    "ipfs://Qm.../metadata.json",
)?;

let recipients = vec![
    (address1, "ipfs://Qm.../1.json"),
    (address2, "ipfs://Qm.../2.json"),
    (address3, "ipfs://Qm.../3.json"),
];
 
let token_ids = nft_batch_mint(&collection_id, &recipients)?;

nft_transfer(&collection_id, token_id, &to_address)?;

let transfers = vec![
    (token_id_1, address_1),
    (token_id_2, address_2),
    (token_id_3, address_3),
];
 
nft_batch_transfer(&collection_id, &transfers)?;

nft_burn(&collection_id, token_id)?;

let token_ids = vec![1, 2, 3, 4, 5];
nft_batch_burn(&collection_id, &token_ids)?;

nft_approve(&collection_id, token_id, &operator)?;

let approved = nft_get_approved(&collection_id, token_id)?;

nft_set_approval_for_all(&collection_id, &operator, true)?;

let is_approved = nft_is_approved_for_all(&collection_id, &owner, &operator)?;

nft_revoke(&collection_id, token_id)?;

nft_freeze(&collection_id, token_id)?;

nft_thaw(&collection_id, token_id)?;

let frozen = nft_is_frozen(&collection_id, token_id)?;

let token_ids = vec![1, 2, 3];
nft_batch_freeze(&collection_id, &token_ids)?;
nft_batch_thaw(&collection_id, &token_ids)?;

nft_set_token_uri(&collection_id, token_id, "ipfs://Qm.../new.json")?;

nft_update_attribute(&collection_id, token_id, "rarity", "legendary")?;

nft_remove_attribute(&collection_id, token_id, "temporary_buff")?;

let exists = nft_exists(&collection_id, token_id)?;

let owner = nft_owner_of(&collection_id, token_id)?;

let balance = nft_balance_of(&collection_id, &owner)?;

let uri = nft_token_uri(&collection_id, token_id)?;

let supply = nft_get_total_supply(&collection_id)?;

let count = nft_get_mint_count(&collection_id)?;

use tako_sdk::*;
use tako_sdk::nft::*;
 
#[no_mangle]
pub extern "C" fn create_collection() {
    let caller = get_tx_sender();
 
    // Create collection
    let collection = nft_create_collection(
        "TOS Punks",
        "PUNK",
        "https://api.tospunks.com/metadata/",
        500,  // 5% royalty
        Some(10000),  // Max 10k NFTs
    ).expect("Failed to create collection");
 
    // Store collection ID
    storage_write(b"collection", &collection);
 
    log(&format!("Collection created: {:?}", collection));
}
 
#[no_mangle]
pub extern "C" fn mint_nft() {
    let caller = get_tx_sender();
    let collection = storage_read_hash(b"collection").unwrap();
 
    // Mint to caller
    let token_id = nft_mint(
        &collection,
        &caller,
        "ipfs://QmXxx.../1.json",
    ).expect("Failed to mint");
 
    log(&format!("Minted token #{}", token_id));
}
 
#[no_mangle]
pub extern "C" fn batch_mint() {
    let collection = storage_read_hash(b"collection").unwrap();
 
    // Prepare batch
    let recipients: Vec<(Address, &str)> = vec![
        (addr1, "ipfs://Qm.../1.json"),
        (addr2, "ipfs://Qm.../2.json"),
        (addr3, "ipfs://Qm.../3.json"),
    ];
 
    let token_ids = nft_batch_mint(&collection, &recipients)
        .expect("Batch mint failed");
 
    log(&format!("Minted {} NFTs", token_ids.len()));
}