fix: Replace example OZ contract for fungible, update library dependencies

Cargo.toml

@@ -10,10 +10,11 @@ repository = "https://github.com/theahaco/scaffold-stellar"
 version = "0.0.1"
 
 [workspace.dependencies.soroban-sdk]
-version = "22.0.8"
+version = "23.0.2"
 
-[workspace.dependencies.soroban-token-sdk]
-version = "22.0.8"
+[workspace.dependencies.stellar-access]
+git = "https://github.com/OpenZeppelin/stellar-contracts"
+tag = "v0.5.0"
 
 [workspace.dependencies.stellar-default-impl-macro]
 git = "https://github.com/OpenZeppelin/stellar-contracts"
@@ -23,6 +24,10 @@ tag = "v0.3.0"
 git = "https://github.com/OpenZeppelin/stellar-contracts"
 tag = "v0.3.0"
 
+[workspace.dependencies.stellar-macros]
+git = "https://github.com/OpenZeppelin/stellar-contracts"
+tag = "v0.5.0"
+
 [workspace.dependencies.stellar-non-fungible]
 git = "https://github.com/OpenZeppelin/stellar-contracts"
 tag = "v0.3.0"
@@ -35,6 +40,10 @@ tag = "v0.3.0"
 git = "https://github.com/OpenZeppelin/stellar-contracts"
 tag = "v0.3.0"
 
+[workspace.dependencies.stellar-tokens]
+git = "https://github.com/OpenZeppelin/stellar-contracts"
+tag = "v0.5.0"
+
 [profile.release]
 opt-level = "z"
 debug = false

contracts/fungible-token-interface/Cargo.toml → contracts/fungible-allowlist/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "fungible-token-interface-example"
+name = "fungible-allowlist-example"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true
@@ -12,9 +12,9 @@ doctest = false
 
 [dependencies]
 soroban-sdk = { workspace = true }
-stellar-pausable = { workspace = true }
-stellar-pausable-macros = { workspace = true }
-stellar-fungible = { workspace = true }
+stellar-access = { workspace = true }
+stellar-macros = { workspace = true }
+stellar-tokens = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }

contracts/fungible-allowlist/src/contract.rs

@@ -0,0 +1,71 @@
+//! Fungible AllowList Example Contract.
+
+//! This contract showcases how to integrate the AllowList extension with a
+//! SEP-41-compliant fungible token. It includes essential features such as
+//! controlled token transfers by an admin who can allow or disallow specific
+//! accounts.
+
+use soroban_sdk::{contract, contractimpl, symbol_short, Address, Env, String};
+use stellar_access::access_control::{self as access_control, AccessControl};
+use stellar_macros::{default_impl, only_role};
+use stellar_tokens::fungible::{
+    allowlist::{AllowList, FungibleAllowList},
+    burnable::FungibleBurnable,
+    Base, FungibleToken,
+};
+
+#[contract]
+pub struct ExampleContract;
+
+#[contractimpl]
+impl ExampleContract {
+    pub fn __constructor(e: &Env, admin: Address, manager: Address, initial_supply: i128) {
+        Base::set_metadata(
+            e,
+            18,
+            String::from_str(e, "AllowList Token"),
+            String::from_str(e, "ALT"),
+        );
+
+        access_control::set_admin(e, &admin);
+
+        // create a role "manager" and grant it to `manager`
+        access_control::grant_role_no_auth(e, &admin, &manager, &symbol_short!("manager"));
+
+        // Allow the admin to transfer tokens
+        AllowList::allow_user(e, &admin);
+
+        // Mint initial supply to the admin
+        Base::mint(e, &admin, initial_supply);
+    }
+}
+
+#[default_impl]
+#[contractimpl]
+impl FungibleToken for ExampleContract {
+    type ContractType = AllowList;
+}
+#[contractimpl]
+impl FungibleAllowList for ExampleContract {
+    fn allowed(e: &Env, account: Address) -> bool {
+        AllowList::allowed(e, &account)
+    }
+
+    #[only_role(operator, "manager")]
+    fn allow_user(e: &Env, user: Address, operator: Address) {
+        AllowList::allow_user(e, &user)
+    }
+
+    #[only_role(operator, "manager")]
+    fn disallow_user(e: &Env, user: Address, operator: Address) {
+        AllowList::disallow_user(e, &user)
+    }
+}
+
+#[default_impl]
+#[contractimpl]
+impl AccessControl for ExampleContract {}
+
+#[default_impl]
+#[contractimpl]
+impl FungibleBurnable for ExampleContract {}

contracts/fungible-token-interface/src/lib.rs → contracts/fungible-allowlist/src/lib.rs

@@ -2,4 +2,6 @@
 #![allow(dead_code)]
 
 mod contract;
+
+#[cfg(test)]
 mod test;

contracts/fungible-allowlist/src/test.rs

@@ -0,0 +1,154 @@
+extern crate std;
+
+use soroban_sdk::{testutils::Address as _, Address, Env};
+
+use crate::contract::{ExampleContract, ExampleContractClient};
+
+fn create_client<'a>(
+    e: &Env,
+    admin: &Address,
+    manager: &Address,
+    initial_supply: &i128,
+) -> ExampleContractClient<'a> {
+    let address = e.register(ExampleContract, (admin, manager, initial_supply));
+    ExampleContractClient::new(e, &address)
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #113)")]
+fn cannot_transfer_before_allow() {
+    let e = Env::default();
+    let admin = Address::generate(&e);
+    let manager = Address::generate(&e);
+    let user1 = Address::generate(&e);
+    let user2 = Address::generate(&e);
+    let initial_supply = 1_000_000;
+    let client = create_client(&e, &admin, &manager, &initial_supply);
+    let transfer_amount = 1000;
+
+    // Verify initial state - admin is allowed, others are not
+    assert!(client.allowed(&admin));
+    assert!(!client.allowed(&user1));
+    assert!(!client.allowed(&user2));
+
+    // Admin can't transfer to user1 initially (user1 not allowed)
+    e.mock_all_auths();
+    client.transfer(&admin, &user1, &transfer_amount);
+}
+
+#[test]
+fn transfer_to_allowed_account_works() {
+    let e = Env::default();
+    let admin = Address::generate(&e);
+    let manager = Address::generate(&e);
+    let user1 = Address::generate(&e);
+    let user2 = Address::generate(&e);
+    let initial_supply = 1_000_000;
+    let client = create_client(&e, &admin, &manager, &initial_supply);
+    let transfer_amount = 1000;
+
+    e.mock_all_auths();
+
+    // Verify initial state - admin is allowed, others are not
+    assert!(client.allowed(&admin));
+    assert!(!client.allowed(&user1));
+    assert!(!client.allowed(&user2));
+
+    // Allow user1
+    client.allow_user(&user1, &manager);
+    assert!(client.allowed(&user1));
+
+    // Now admin can transfer to user1
+    client.transfer(&admin, &user1, &transfer_amount);
+    assert_eq!(client.balance(&user1), transfer_amount);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #113)")]
+fn cannot_transfer_after_disallow() {
+    let e = Env::default();
+    let admin = Address::generate(&e);
+    let manager = Address::generate(&e);
+    let user1 = Address::generate(&e);
+    let user2 = Address::generate(&e);
+    let initial_supply = 1_000_000;
+    let client = create_client(&e, &admin, &manager, &initial_supply);
+    let transfer_amount = 1000;
+
+    e.mock_all_auths();
+
+    // Verify initial state - admin is allowed, others are not
+    assert!(client.allowed(&admin));
+    assert!(!client.allowed(&user1));
+    assert!(!client.allowed(&user2));
+
+    // Allow user1
+    client.allow_user(&user1, &manager);
+    assert!(client.allowed(&user1));
+
+    // Now admin can transfer to user1
+    client.transfer(&admin, &user1, &transfer_amount);
+    assert_eq!(client.balance(&user1), transfer_amount);
+
+    // Disallow user1
+    client.disallow_user(&user1, &manager);
+    assert!(!client.allowed(&user1));
+
+    // Admin can't transfer to user1 after disallowing
+    client.transfer(&admin, &user1, &100);
+}
+
+#[test]
+fn allowlist_transfer_from_override_works() {
+    let e = Env::default();
+    let admin = Address::generate(&e);
+    let manager = Address::generate(&e);
+    let user1 = Address::generate(&e);
+    let user2 = Address::generate(&e);
+    let initial_supply = 1_000_000;
+    let client = create_client(&e, &admin, &manager, &initial_supply);
+    let transfer_amount = 1000;
+
+    e.mock_all_auths();
+
+    // Verify initial state - admin is allowed, others are not
+    assert!(client.allowed(&admin));
+    assert!(!client.allowed(&user1));
+    assert!(!client.allowed(&user2));
+
+    // Allow user2
+    client.allow_user(&user2, &manager);
+    assert!(client.allowed(&user2));
+
+    // Now admin can transfer to user1
+    client.approve(&admin, &user1, &transfer_amount, &1000);
+    client.transfer_from(&user1, &admin, &user2, &transfer_amount);
+    assert_eq!(client.balance(&user2), transfer_amount);
+}
+
+#[test]
+fn allowlist_approve_override_works() {
+    let e = Env::default();
+    let admin = Address::generate(&e);
+    let manager = Address::generate(&e);
+    let user1 = Address::generate(&e);
+    let user2 = Address::generate(&e);
+    let initial_supply = 1_000_000;
+    let client = create_client(&e, &admin, &manager, &initial_supply);
+    let transfer_amount = 1000;
+
+    e.mock_all_auths();
+
+    // Verify initial state - admin is allowed, others are not
+    assert!(client.allowed(&admin));
+    assert!(!client.allowed(&user1));
+    assert!(!client.allowed(&user2));
+
+    // Allow user1
+    client.allow_user(&user1, &manager);
+    assert!(client.allowed(&user1));
+
+    // Approve user2 to transfer from user1
+    client.approve(&user1, &user2, &transfer_amount, &1000);
+    assert_eq!(client.allowance(&user1, &user2), transfer_amount);
+}