rootchain_std/

rrc721.rs

use crate::traits::RRC721;
use alloc::format;
use alloc::string::String;
use rootchain_core::types::Address;

pub struct BaseRRC721 {
    name: String,
    symbol: String,
}

impl BaseRRC721 {
    pub fn new(name: &str, symbol: &str) -> Self {
        Self {
            name: String::from(name),
            symbol: String::from(symbol),
        }
    }

    fn get_owner(&self, token_id: u64) -> Option<Address> {
        let key = format!("tokens/{}", token_id);
        let mut addr = [0u8; 32];
        unsafe {
            if crate::state_get(key.as_ptr(), key.len(), addr.as_mut_ptr(), 32) == 0 {
                Some(Address(addr))
            } else {
                None
            }
        }
    }

    fn set_owner(&mut self, token_id: u64, owner: Address) {
        let key = format!("tokens/{}", token_id);
        unsafe {
            crate::state_set(key.as_ptr(), key.len(), owner.0.as_ptr(), 32);
        }
    }

    fn get_balance(&self, owner: Address) -> u64 {
        let key = format!("balances/{}", hex::encode(owner.0));
        let mut buf = [0u8; 8];
        unsafe {
            if crate::state_get(key.as_ptr(), key.len(), buf.as_mut_ptr(), 8) == 0 {
                u64::from_le_bytes(buf)
            } else {
                0
            }
        }
    }

    fn set_balance(&mut self, owner: Address, balance: u64) {
        let key = format!("balances/{}", hex::encode(owner.0));
        let buf = balance.to_le_bytes();
        unsafe {
            crate::state_set(key.as_ptr(), key.len(), buf.as_ptr(), 8);
        }
    }

    fn is_approved_or_owner(&self, spender: Address, token_id: u64) -> bool {
        let owner = self.get_owner(token_id);
        if owner.is_none() {
            return false;
        }
        let owner = owner.unwrap();
        if owner == spender {
            return true;
        }
        self.get_approved(token_id) == spender
    }
}

impl RRC721 for BaseRRC721 {
    fn name(&self) -> &str {
        &self.name
    }

    fn symbol(&self) -> &str {
        &self.symbol
    }

    fn balance_of(&self, owner: Address) -> u64 {
        self.get_balance(owner)
    }

    fn owner_of(&self, token_id: u64) -> Address {
        self.get_owner(token_id).unwrap_or(Address([0; 32]))
    }

    fn safe_transfer_from(
        &mut self,
        from: Address,
        to: Address,
        token_id: u64,
    ) -> Result<(), crate::error::Error> {
        if self.get_owner(token_id) != Some(from) {
            return Err(crate::error::Error::Internal(100)); // Not owner
        }

        if !self.is_approved_or_owner(from, token_id) {
            return Err(crate::error::Error::Internal(101)); // Not authorized
        }

        // Update balances
        let from_balance = self.get_balance(from);
        self.set_balance(from, from_balance.saturating_sub(1));

        let to_balance = self.get_balance(to);
        self.set_balance(to, to_balance.saturating_add(1));

        // Update owner
        self.set_owner(token_id, to);

        // Clear approval
        let approve_key = format!("approvals/{}", token_id);
        unsafe {
            crate::state_set(
                approve_key.as_ptr(),
                approve_key.len(),
                [0u8; 32].as_ptr(),
                32,
            );
        }

        Ok(())
    }

    fn approve(&mut self, to: Address, token_id: u64) -> Result<(), crate::error::Error> {
        let owner = self.get_owner(token_id);
        let mut caller = [0u8; 32];
        unsafe { crate::get_caller(caller.as_mut_ptr()) };
        if owner != Some(Address(caller)) {
            return Err(crate::error::Error::Internal(100)); // Not owner
        }

        let key = format!("approvals/{}", token_id);
        unsafe {
            crate::state_set(key.as_ptr(), key.len(), to.0.as_ptr(), 32);
        }
        Ok(())
    }

    fn get_approved(&self, token_id: u64) -> Address {
        let key = format!("approvals/{}", token_id);
        let mut addr = [0u8; 32];
        unsafe {
            if crate::state_get(key.as_ptr(), key.len(), addr.as_mut_ptr(), 32) == 0 {
                Address(addr)
            } else {
                Address([0; 32])
            }
        }
    }

    fn token_uri(&self, token_id: u64) -> String {
        let key = format!("uri/{}", token_id);
        let mut buf = [0u8; 256];
        unsafe {
            let len = crate::state_get(key.as_ptr(), key.len(), buf.as_mut_ptr(), 256);
            if len >= 0 {
                String::from_utf8_lossy(&buf[..len as usize]).into()
            } else {
                String::new()
            }
        }
    }

    fn get_attribute(&self, token_id: u64, key: &str) -> String {
        let storage_key = format!("attr/{}/{}", token_id, key);
        let mut buf = [0u8; 128];
        unsafe {
            let len = crate::state_get(
                storage_key.as_ptr(),
                storage_key.len(),
                buf.as_mut_ptr(),
                128,
            );
            if len >= 0 {
                String::from_utf8_lossy(&buf[..len as usize]).into()
            } else {
                String::new()
            }
        }
    }
}

impl BaseRRC721 {
    pub fn set_token_uri(&mut self, token_id: u64, uri: &str) {
        let key = format!("uri/{}", token_id);
        unsafe {
            crate::state_set(key.as_ptr(), key.len(), uri.as_ptr(), uri.len());
        }
    }

    pub fn set_attribute(&mut self, token_id: u64, key: &str, value: &str) {
        let storage_key = format!("attr/{}/{}", token_id, key);
        unsafe {
            crate::state_set(
                storage_key.as_ptr(),
                storage_key.len(),
                value.as_ptr(),
                value.len(),
            );
        }
    }

    pub fn mint(&mut self, to: Address, token_id: u64) -> Result<(), crate::error::Error> {
        if self.get_owner(token_id).is_some() {
            return Err(crate::error::Error::Internal(102)); // Already minted
        }

        self.set_owner(token_id, to);
        let balance = self.get_balance(to);
        self.set_balance(to, balance.saturating_add(1));
        Ok(())
    }
}