Update fungible token example

Author: pselle

Cargo.lock

@@ -21,7 +21,7 @@ tag = "v0.3.0"
 
 [workspace.dependencies.stellar-fungible]
 git = "https://github.com/OpenZeppelin/stellar-contracts"
-tag = "v0.2.0"
+tag = "v0.3.0"
 
 [workspace.dependencies.stellar-non-fungible]
 git = "https://github.com/OpenZeppelin/stellar-contracts"

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);