Implement Asset

Author: LaGodxy

contracts/assetsup/src/asset.rs

@@ -0,0 +1,29 @@
+use soroban_sdk::{contracttype, Address, BytesN, String};
+
+use crate::types::{AssetStatus, AssetType};
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum DataKey {
+    Asset(BytesN<32>),
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Asset {
+    pub id: BytesN<32>,
+    pub name: String,
+    pub asset_type: AssetType,
+    pub category: String,
+    pub branch_id: u64,
+    pub department_id: u64,
+    pub status: AssetStatus,
+    pub purchase_date: u64,
+    pub purchase_cost: i128,
+    pub current_value: i128,
+    pub warranty_expiry: u64,
+    pub stellar_token_id: BytesN<32>,
+    pub owner: Address,
+}
+
+// Note: Contract methods implemented in lib.rs

contracts/assetsup/src/errors.rs

@@ -0,0 +1,8 @@
+use soroban_sdk::contracterror;
+
+#[contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum ContractError {
+    AssetAlreadyExists = 1,
+    AssetNotFound = 2,
+}

contracts/assetsup/src/lib.rs

@@ -1,5 +1,9 @@
 #![no_std]
-use soroban_sdk::{Address, Env, contract, contractimpl, contracttype};
+use soroban_sdk::{Address, Env, contract, contractimpl, contracttype, BytesN};
+
+pub(crate) mod types;
+pub(crate) mod errors;
+pub(crate) mod asset;
 
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -24,6 +28,33 @@ impl AssetUpContract {
     pub fn get_admin(env: Env) -> Address {
         env.storage().persistent().get(&DataKey::Admin).unwrap()
     }
+
+    // Asset functions
+    pub fn register_asset(env: Env, asset: asset::Asset) -> Result<(), errors::ContractError> {
+        // Access control
+        asset.owner.require_auth();
+
+        if asset.name.len() == 0 {
+            panic!("Name cannot be empty");
+        }
+
+        let key = asset::DataKey::Asset(asset.id.clone());
+        let store = env.storage().persistent();
+        if store.has(&key) {
+            return Err(errors::ContractError::AssetAlreadyExists);
+        }
+        store.set(&key, &asset);
+        Ok(())
+    }
+
+    pub fn get_asset(env: Env, asset_id: BytesN<32>) -> Result<asset::Asset, errors::ContractError> {
+        let key = asset::DataKey::Asset(asset_id);
+        let store = env.storage().persistent();
+        match store.get::<_, asset::Asset>(&key) {
+            Some(a) => Ok(a),
+            None => Err(errors::ContractError::AssetNotFound),
+        }
+    }
 }
 
 mod tests;

contracts/assetsup/src/tests/asset.rs

@@ -0,0 +1,100 @@
+#![cfg(test)]
+
+extern crate std;
+
+use soroban_sdk::{testutils::Address as _, Address, BytesN, Env, String};
+
+use crate::{asset::Asset, types::{AssetStatus, AssetType}, errors::ContractError};
+
+use super::initialize::setup_test_environment;
+
+fn make_bytes32(env: &Env, seed: u32) -> BytesN<32> {
+    let mut arr = [0u8; 32];
+    // Simple deterministic fill
+    for i in 0..32 {
+        arr[i] = ((seed as usize + i) % 256) as u8;
+    }
+    BytesN::from_array(env, &arr)
+}
+
+#[test]
+fn test_register_and_get_asset_success() {
+    let (env, client, _admin) = setup_test_environment();
+    let owner = Address::generate(&env);
+
+    let id = make_bytes32(&env, 1);
+    let token = make_bytes32(&env, 2);
+
+    let name = String::from_str(&env, "Laptop A");
+    let category = String::from_str(&env, "Electronics");
+
+    let asset = Asset {
+        id: id.clone(),
+        name: name.clone(),
+        asset_type: AssetType::IT,
+        category: category.clone(),
+        branch_id: 10,
+        department_id: 20,
+        status: AssetStatus::Active,
+        purchase_date: 1_725_000_000,
+        purchase_cost: 120_000,
+        current_value: 100_000,
+        warranty_expiry: 1_800_000_000,
+        stellar_token_id: token.clone(),
+        owner: owner.clone(),
+    };
+
+    let res = client.try_register_asset(&asset);
+    assert!(res.is_ok());
+
+    let got = client.try_get_asset(&id).unwrap().unwrap();
+
+    assert_eq!(got.id, id);
+    assert_eq!(got.name, name);
+    assert_eq!(got.asset_type, AssetType::IT);
+    assert_eq!(got.category, category);
+    assert_eq!(got.branch_id, 10);
+    assert_eq!(got.department_id, 20);
+    assert_eq!(got.status, AssetStatus::Active);
+    assert_eq!(got.purchase_date, 1_725_000_000);
+    assert_eq!(got.purchase_cost, 120_000);
+    assert_eq!(got.current_value, 100_000);
+    assert_eq!(got.warranty_expiry, 1_800_000_000);
+    assert_eq!(got.stellar_token_id, token);
+    assert_eq!(got.owner, owner);
+}
+
+#[test]
+#[should_panic]
+fn test_register_asset_duplicate() {
+    let (env, client, _admin) = setup_test_environment();
+    let owner = Address::generate(&env);
+
+    let id = make_bytes32(&env, 3);
+    let token = make_bytes32(&env, 4);
+
+    let name = String::from_str(&env, "Office Chair");
+    let category = String::from_str(&env, "Furniture");
+
+    let asset = Asset {
+        id: id.clone(),
+        name: name.clone(),
+        asset_type: AssetType::Furniture,
+        category: category.clone(),
+        branch_id: 1,
+        department_id: 2,
+        status: AssetStatus::Active,
+        purchase_date: 1_700_000_000,
+        purchase_cost: 15_000,
+        current_value: 12_000,
+        warranty_expiry: 1_750_000_000,
+        stellar_token_id: token.clone(),
+        owner: owner.clone(),
+    };
+
+    // First registration should succeed
+    client.register_asset(&asset);
+
+    // Second registration with same ID should panic (Err propagated)
+    client.register_asset(&asset);
+}

contracts/assetsup/src/tests/initialize.rs

@@ -28,7 +28,7 @@ fn test_initialize() {
 }
 
 #[test]
-#[should_panic()]
+#[should_panic]
 fn test_initialize_panic() {
     let (_env, client, admin) = setup_test_environment();
     client.initialize(&admin);

contracts/assetsup/src/tests/mod.rs

@@ -1 +1,2 @@
 mod initialize;
+mod asset;

contracts/assetsup/src/types.rs

@@ -0,0 +1,22 @@
+#![allow(clippy::upper_case_acronyms)]
+use soroban_sdk::{contracttype};
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum AssetType {
+    IT,
+    Furniture,
+    Vehicle,
+    RealEstate,
+    Machinery,
+    Other,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum AssetStatus {
+    Active,
+    Maintenance,
+    Retired,
+    Disposed,
+}