feat: Add NFT contract (#82)

* Add nft example contract

* Fixup references for deployed contracts to use {}

* Update hello world to use Stellar vs Soroban, add constructor for NFT

* Update all OZ references

* Update fungible token example

* Update package-lock

Author: pselle

Cargo.lock

@@ -1,8 +1,6 @@
 [workspace]
+members = ["contracts/*"]
 resolver = "2"
-members = [
-  "contracts/*",
-]
 
 [workspace.package]
 authors = ["AhaLabs"]
@@ -11,24 +9,42 @@ license = "Apache-2.0"
 repository = "https://github.com/AhaLabs/scaffold-stellar"
 version = "0.0.1"
 
-[workspace.dependencies]
-soroban-sdk = { version = "22.0.7" }
-soroban-token-sdk = { version = "22.0.1" }
-stellar-pausable = { git = "https://github.com/OpenZeppelin/stellar-contracts", tag = "v0.2.0" }
-stellar-pausable-macros = { git = "https://github.com/OpenZeppelin/stellar-contracts", tag = "v0.2.0" }
-stellar-fungible = { git = "https://github.com/OpenZeppelin/stellar-contracts", tag = "v0.2.0" }
+[workspace.dependencies.soroban-sdk]
+version = "22.0.7"
+
+[workspace.dependencies.soroban-token-sdk]
+version = "22.0.1"
+
+[workspace.dependencies.stellar-default-impl-macro]
+git = "https://github.com/OpenZeppelin/stellar-contracts"
+tag = "v0.3.0"
+
+[workspace.dependencies.stellar-fungible]
+git = "https://github.com/OpenZeppelin/stellar-contracts"
+tag = "v0.3.0"
+
+[workspace.dependencies.stellar-non-fungible]
+git = "https://github.com/OpenZeppelin/stellar-contracts"
+tag = "v0.3.0"
+
+[workspace.dependencies.stellar-pausable]
+git = "https://github.com/OpenZeppelin/stellar-contracts"
+tag = "v0.3.0"
+
+[workspace.dependencies.stellar-pausable-macros]
+git = "https://github.com/OpenZeppelin/stellar-contracts"
+tag = "v0.3.0"
 
 [profile.release]
 opt-level = "z"
-overflow-checks = true
-debug = 0
-strip = "symbols"
+debug = false
+lto = true
 debug-assertions = false
-panic = "abort"
 codegen-units = 1
-lto = true
+panic = "abort"
+overflow-checks = true
+strip = true
 
-# For more information about this profile see https://soroban.stellar.org/docs/basic-tutorials/logging#cargotoml-profile
 [profile.release-with-logs]
-inherits = "release"
 debug-assertions = true
+inherits = "release"

Cargo.toml

@@ -2,7 +2,7 @@
 name = "fungible-token-interface-example"
 edition.workspace = true
 license.workspace = true
-repository = "https://github.com/OpenZeppelin/stellar-contracts"
+repository.workspace = true
 publish = false
 version.workspace = true
 

contracts/fungible-token-interface/Cargo.toml

@@ -17,7 +17,7 @@ use soroban_sdk::{
     contract, contracterror, contractimpl, panic_with_error, symbol_short, token::TokenInterface,
     Address, Env, String, Symbol,
 };
-use stellar_fungible::{self as fungible, mintable::FungibleMintable};
+use stellar_fungible::Base;
 use stellar_pausable::{self as pausable, Pausable};
 use stellar_pausable_macros::when_not_paused;
 
@@ -36,20 +36,26 @@ pub enum ExampleContractError {
 #[contractimpl]
 impl ExampleContract {
     pub fn __constructor(e: &Env, owner: Address, initial_supply: i128) {
-        fungible::metadata::set_metadata(
-            e,
-            18,
-            String::from_str(e, "My Token"),
-            String::from_str(e, "TKN"),
-        );
-        fungible::mintable::mint(e, &owner, initial_supply);
+        Base::set_metadata(e, 18, String::from_str(e, "My Token"), String::from_str(e, "TKN"));
+        Base::mint(e, &owner, initial_supply);
         e.storage().instance().set(&OWNER, &owner);
     }
 
     /// `TokenInterface` doesn't require implementing `total_supply()` because
     /// of the need for backwards compatibility with Stellar classic assets.
     pub fn total_supply(e: &Env) -> i128 {
-        fungible::total_supply(e)
+        Base::total_supply(e)
+    }
+
+    #[when_not_paused]
+    pub fn mint(e: &Env, account: Address, amount: i128) {
+        // When `ownable` module is available,
+        // the following checks should be equivalent to:
+        // `ownable::only_owner(&e);`
+        let owner: Address = e.storage().instance().get(&OWNER).expect("owner should be set");
+        owner.require_auth();
+
+        Base::mint(e, &account, amount);
     }
 }
 
@@ -63,84 +69,72 @@ impl Pausable for ExampleContract {
         // When `ownable` module is available,
         // the following checks should be equivalent to:
         // `ownable::only_owner(&e);`
+        caller.require_auth();
         let owner: Address = e.storage().instance().get(&OWNER).expect("owner should be set");
         if owner != caller {
             panic_with_error!(e, ExampleContractError::Unauthorized);
         }
 
-        pausable::pause(e, &caller);
+        pausable::pause(e);
     }
 
     fn unpause(e: &Env, caller: Address) {
         // When `ownable` module is available,
         // the following checks should be equivalent to:
         // `ownable::only_owner(&e);`
+        caller.require_auth();
         let owner: Address = e.storage().instance().get(&OWNER).expect("owner should be set");
         if owner != caller {
             panic_with_error!(e, ExampleContractError::Unauthorized);
         }
 
-        pausable::unpause(e, &caller);
+        pausable::unpause(e);
     }
 }
 
 #[contractimpl]
 impl TokenInterface for ExampleContract {
     fn balance(e: Env, account: Address) -> i128 {
-        fungible::balance(&e, &account)
+        Base::balance(&e, &account)
     }
 
     fn allowance(e: Env, owner: Address, spender: Address) -> i128 {
-        fungible::allowance(&e, &owner, &spender)
+        Base::allowance(&e, &owner, &spender)
     }
 
     #[when_not_paused]
     fn transfer(e: Env, from: Address, to: Address, amount: i128) {
-        fungible::transfer(&e, &from, &to, amount);
+        Base::transfer(&e, &from, &to, amount);
     }
 
     #[when_not_paused]
     fn transfer_from(e: Env, spender: Address, from: Address, to: Address, amount: i128) {
-        fungible::transfer_from(&e, &spender, &from, &to, amount);
+        Base::transfer_from(&e, &spender, &from, &to, amount);
     }
 
     fn approve(e: Env, owner: Address, spender: Address, amount: i128, live_until_ledger: u32) {
-        fungible::approve(&e, &owner, &spender, amount, live_until_ledger);
+        Base::approve(&e, &owner, &spender, amount, live_until_ledger);
     }
 
     #[when_not_paused]
     fn burn(e: Env, from: Address, amount: i128) {
-        fungible::burnable::burn(&e, &from, amount)
+        Base::burn(&e, &from, amount)
     }
 
     #[when_not_paused]
     fn burn_from(e: Env, spender: Address, from: Address, amount: i128) {
-        fungible::burnable::burn_from(&e, &spender, &from, amount)
+        Base::burn_from(&e, &spender, &from, amount)
     }
 
     fn decimals(e: Env) -> u32 {
-        fungible::metadata::decimals(&e)
+        Base::decimals(&e)
     }
 
     fn name(e: Env) -> String {
-        fungible::metadata::name(&e)
+        Base::name(&e)
     }
 
     fn symbol(e: Env) -> String {
-        fungible::metadata::symbol(&e)
-    }
-}
-
-#[contractimpl]
-impl FungibleMintable for ExampleContract {
-    #[when_not_paused]
-    fn mint(e: &Env, account: Address, amount: i128) {
-        // When `ownable` module is available,
-        // the following checks should be equivalent to:
-        // `ownable::only_owner(&e);`
-        let owner: Address = e.storage().instance().get(&OWNER).expect("owner should be set");
-        owner.require_auth();
-
-        fungible::mintable::mint(e, &account, amount);
+        Base::symbol(&e)
     }
 }

contracts/fungible-token-interface/src/contract.rs

@@ -39,7 +39,7 @@ fn transfer_works() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #100)")]
+#[should_panic(expected = "Error(Contract, #1000)")]
 fn transfer_fails_when_paused() {
     let e = Env::default();
     let owner = Address::generate(&e);
@@ -67,7 +67,7 @@ fn transfer_from_works() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #100)")]
+#[should_panic(expected = "Error(Contract, #1000)")]
 fn transfer_from_fails_when_paused() {
     let e = Env::default();
     let owner = Address::generate(&e);
@@ -93,7 +93,7 @@ fn mint_works() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #100)")]
+#[should_panic(expected = "Error(Contract, #1000)")]
 fn mint_fails_when_paused() {
     let e = Env::default();
     let owner = Address::generate(&e);
@@ -117,7 +117,7 @@ fn burn_works() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #100)")]
+#[should_panic(expected = "Error(Contract, #1000)")]
 fn burn_fails_when_paused() {
     let e = Env::default();
     let owner = Address::generate(&e);

contracts/fungible-token-interface/src/test.rs

@@ -1,5 +1,5 @@
 [package]
-name = "soroban-hello-world-contract"
+name = "stellar-hello-world-contract"
 description = "A simple hello world contract"
 edition.workspace = true
 license.workspace = true

contracts/hello_world/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "nft-enumerable-example"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+publish = false
+version.workspace = true
+
+[lib]
+crate-type = ["cdylib"]
+doctest = false
+
+[dependencies]
+soroban-sdk = { workspace = true }
+stellar-non-fungible = { workspace = true }
+stellar-default-impl-macro = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }