NFT zero to hero tutorial

use near_sdk::{
    near, AccountId, PanicOnDefault,
    collections::{LazyOption, LookupMap, UnorderedSet},
};
use near_sdk::json_types::U128;

#[near(serializers = [json, borsh])]
pub struct Token {
    pub token_id: String,
    pub owner_id: AccountId,
    pub metadata: TokenMetadata,
}

#[near(serializers = [json, borsh])]
pub struct TokenMetadata {
    pub title: Option<String>,
    pub description: Option<String>,
    pub media: Option<String>,
    pub media_hash: Option<String>,
}

#[near(contract_state)]
#[derive(PanicOnDefault)]
pub struct NftContract {
    pub owner_id: AccountId,
    pub tokens_per_owner: LookupMap<AccountId, UnorderedSet<String>>,
    pub tokens_by_id: LookupMap<String, Token>,
    pub token_metadata_by_id: LookupMap<String, TokenMetadata>,
}

#[near]
impl NftContract {
    #[init]
    pub fn new(owner_id: AccountId) -> Self {
        Self {
            owner_id,
            tokens_per_owner: LookupMap::new(b"o"),
            tokens_by_id: LookupMap::new(b"t"),
            token_metadata_by_id: LookupMap::new(b"m"),
        }
    }
    
    #[payable]
    pub fn nft_mint(
        &mut self,
        token_id: String,
        receiver_id: AccountId,
        metadata: TokenMetadata,
    ) -> Token {
        // Implementation in tutorial
        Token {
            token_id,
            owner_id: receiver_id,
            metadata,
        }
    }
}

#[tokio::test]
async fn test_nft_mint() -> Result<()> {
    let worker = near_workspaces::sandbox().await?;
    let contract = worker.dev_deploy(include_bytes!("../target/near/nft.wasm")).await?;
    
    // Initialize contract
    contract.call("new")
        .args_json(serde_json::json!({
            "owner_id": contract.id()
        }))
        .transact()
        .await?;
    
    // Mint an NFT
    let outcome = contract
        .call("nft_mint")
        .args_json(serde_json::json!({
            "token_id": "1",
            "receiver_id": contract.id(),
            "metadata": {
                "title": "Test NFT",
                "description": "A test NFT",
                "media": "https://example.com/nft.png"
            }
        }))
        .deposit(near_sdk::NearToken::from_millinear(10))
        .transact()
        .await?;
    
    assert!(outcome.is_success());
    
    // Query the NFT
    let token: Token = contract
        .view("nft_token")
        .args_json(serde_json::json!({"token_id": "1"}))
        .await?
        .json()?;
    
    assert_eq!(token.metadata.title, Some("Test NFT".to_string()));
    
    Ok(())
}

import { NearBindgen, near, call, view, UnorderedMap } from 'near-sdk-js';

@NearBindgen({})
class NftContract {
  constructor() {
    this.owner_id = '';
    this.tokensById = new UnorderedMap('t');
  }
  
  @call({ payableFunction: true })
  nft_mint({ token_id, receiver_id, metadata }) {
    const token = {
      token_id,
      owner_id: receiver_id,
      metadata
    };
    
    this.tokensById.set(token_id, token);
    return token;
  }
  
  @view({})
  nft_token({ token_id }) {
    return this.tokensById.get(token_id);
  }
}