Feat/nft example

crates/loam-cli/examples/soroban/calculator/Cargo.toml

@@ -15,5 +15,5 @@ loam-sdk = { workspace = true, features = ["loam-soroban-sdk"] }
 loam-subcontract-core = { workspace = true }
 
 
-[dev_dependencies]
+[dev-dependencies]
 loam-sdk = { workspace = true, features = ["soroban-sdk-testutils"] }

crates/loam-cli/examples/soroban/core/Cargo.toml

@@ -17,7 +17,7 @@ loam-subcontract-core = { workspace = true }
 loam-soroban-sdk = { workspace = true }
 
 
-[dev_dependencies]
+[dev-dependencies]
 loam-sdk = { workspace = true, features = ["soroban-sdk-testutils"] }
 
 [package.metadata.loam]

crates/loam-cli/examples/soroban/ft/Cargo.toml

@@ -16,7 +16,7 @@ loam-subcontract-core = { workspace = true }
 loam-subcontract-ft = { workspace = true }
 
 
-[dev_dependencies]
+[dev-dependencies]
 loam-sdk = { workspace = true, features = ["soroban-sdk-testutils"] }
 
 [package.metadata.loam]

crates/loam-cli/examples/soroban/ft/src/ft.rs

@@ -48,7 +48,7 @@ impl Default for MyFungibleToken {
 }
 
 impl IsInitable for MyFungibleToken {
-    fn ft_init(&mut self, admin: Address, name: Bytes, symbol: Bytes, decimals: u32) {
+    fn ft_init(&self, admin: Address, name: Bytes, symbol: Bytes, decimals: u32) {
         Contract::admin_get().unwrap().require_auth();
         MyFungibleToken::set_lazy(MyFungibleToken::new(admin, name, symbol, decimals));
     }

crates/loam-cli/examples/soroban/nft/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "example-nft"
+version = "0.0.0"
+authors = ["Stellar Development Foundation <[email protected]>"]
+license = "Apache-2.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+doctest = false
+
+[dependencies]
+loam-sdk = { workspace = true, features = ["loam-soroban-sdk"] }
+loam-subcontract-core = { workspace = true }
+
+
+[dev-dependencies]
+loam-sdk = { workspace = true, features = ["soroban-sdk-testutils"] }
+
+[package.metadata.loam]
+contract = true

crates/loam-cli/examples/soroban/nft/src/lib.rs

@@ -0,0 +1,27 @@
+#![no_std]
+use loam_sdk::derive_contract;
+use loam_subcontract_core::{admin::Admin, Core};
+
+pub mod nft;
+pub mod subcontract;
+
+use nft::MyNonFungibleToken;
+use subcontract::{Initable, NonFungible};
+use crate::subcontract::Metadata;
+
+#[derive_contract(
+    Core(Admin),
+    NonFungible(MyNonFungibleToken),
+    Initable(MyNonFungibleToken)
+)]
+pub struct Contract;
+
+impl Contract {
+    pub(crate) fn require_auth() {
+        Contract::admin_get()
+            .expect("No admin! Call 'admin_set' first.")
+            .require_auth();
+    }
+}
+
+mod test;

crates/loam-cli/examples/soroban/nft/src/nft.rs

@@ -0,0 +1,116 @@
+use loam_sdk::{
+    soroban_sdk::{self, contracttype, env, Address, Bytes, Lazy, Map, Vec},
+    IntoKey,
+};
+
+use crate::{subcontract::{IsInitable, IsNonFungible, Metadata}, Contract};
+
+#[contracttype]
+#[derive(IntoKey)]
+pub struct MyNonFungibleToken {
+    name: Bytes,
+    total_count: u128,
+    owners_to_nft_ids: Map<Address, Map<u128, ()>>, // the owner's collection
+    nft_ids_to_owners: Map<u128, Address>,
+    nft_ids_to_metadata: Map<u128, Metadata>,
+}
+
+impl MyNonFungibleToken {
+    #[must_use]
+    pub fn new(name: Bytes) -> Self {
+        MyNonFungibleToken {
+            name,
+            total_count: 0,
+            owners_to_nft_ids: Map::new(env()),
+            nft_ids_to_owners: Map::new(env()),
+            nft_ids_to_metadata: Map::new(env()),
+        }
+    }
+}
+
+impl Default for MyNonFungibleToken {
+    fn default() -> Self {
+        MyNonFungibleToken::new(Bytes::new(env()))
+    }
+}
+
+impl IsInitable for MyNonFungibleToken {
+    fn nft_init(&self, name: Bytes) {
+        Contract::require_auth();
+        MyNonFungibleToken::set_lazy(MyNonFungibleToken::new(name));
+    }
+}
+
+impl IsNonFungible for MyNonFungibleToken {
+    fn mint(&mut self, owner: Address, metadata: Metadata) -> u128 {
+        Contract::require_auth();
+
+        let current_count = self.total_count;
+        let new_id = current_count + 1;
+
+        //todo: check that the metadata is unique
+        self.nft_ids_to_metadata.set(new_id, metadata);
+        self.nft_ids_to_owners.set(new_id, owner.clone());
+
+        let mut owner_collection = self
+            .owners_to_nft_ids
+            .get(owner.clone())
+            .unwrap_or_else(|| Map::new(env()));
+        owner_collection.set(new_id, ());
+        self.owners_to_nft_ids.set(owner, owner_collection);
+
+        self.total_count = new_id;
+
+        new_id
+    }
+
+    fn transfer(&mut self, id: u128, current_owner: Address, new_owner: Address) {
+        current_owner.require_auth();
+        let owner_id = self.nft_ids_to_owners.get(id).expect("NFT does not exist");
+        assert!(
+            owner_id == current_owner,
+            "You are not the owner of this NFT"
+        );
+
+        // update the nft_ids_to_owners map with the new owner
+        self.nft_ids_to_owners.remove(id);
+        self.nft_ids_to_owners.set(id, new_owner.clone());
+
+        // remove the NFT id from the current owner's collection
+        let mut current_owner_collection = self
+            .owners_to_nft_ids
+            .get(current_owner.clone())
+            .expect("Owner does not have a collection of NFTs");
+        current_owner_collection.remove(id);
+
+        self.owners_to_nft_ids
+            .set(current_owner, current_owner_collection);
+
+        // add the NFT id to the new owner's collection
+        let mut new_owner_collection = self
+            .owners_to_nft_ids
+            .get(new_owner.clone())
+            .unwrap_or_else(|| Map::new(env()));
+        new_owner_collection.set(id, ());
+        self.owners_to_nft_ids.set(new_owner, new_owner_collection);
+    }
+
+    fn get_nft(&self, id: u128) -> Option<Metadata> {
+        self.nft_ids_to_metadata.get(id)
+    }
+
+    fn get_owner(&self, id: u128) -> Option<Address> {
+        self.nft_ids_to_owners.get(id)
+    }
+
+    fn get_total_count(&self) -> u128 {
+        self.total_count
+    }
+
+    fn get_collection_by_owner(&self, owner: Address) -> Vec<u128> {
+        self.owners_to_nft_ids
+            .get(owner)
+            .unwrap_or(Map::new(env()))
+            .keys()
+    }
+}

crates/loam-cli/examples/soroban/nft/src/subcontract.rs

@@ -0,0 +1,47 @@
+use loam_sdk::{
+    soroban_sdk::{self, contracttype, Lazy, String},
+    subcontract,
+};
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
+pub struct Metadata {
+    pub(crate) name: String,
+    pub(crate) description: String,
+    pub(crate) url: String,
+}
+
+#[subcontract]
+pub trait IsNonFungible {
+    /// Mint a new NFT with the given owner and metadata
+    fn mint(&mut self, owner: loam_sdk::soroban_sdk::Address, metadata: Metadata) -> u128;
+
+    /// Transfer the NFT with the given ID from current_owner to new_owner
+    fn transfer(
+        &mut self,
+        id: u128,
+        current_owner: loam_sdk::soroban_sdk::Address,
+        new_owner: loam_sdk::soroban_sdk::Address,
+    );
+
+    /// Get the NFT with the given ID
+    fn get_nft(&self, id: u128) -> Option<Metadata>;
+
+    /// Find the owner of the NFT with the given ID
+    fn get_owner(&self, id: u128) -> Option<loam_sdk::soroban_sdk::Address>;
+
+    /// Get the total count of NFTs
+    fn get_total_count(&self) -> u128;
+
+    /// Get all of the NFTs owned by the given address
+    fn get_collection_by_owner(
+        &self,
+        owner: loam_sdk::soroban_sdk::Address,
+    ) -> loam_sdk::soroban_sdk::Vec<u128>;
+}
+
+#[subcontract]
+pub trait IsInitable {
+    /// Initialize the NFT contract with the given admin and name
+    fn nft_init(&self, name: loam_sdk::soroban_sdk::Bytes);
+}