Merge pull request #37 from AhaLabs/feat/oz

feat!: use OZ FT contract

Author: chadoh

Cargo.lock

@@ -4,9 +4,19 @@ members = [
   "contracts/*",
 ]
 
+[workspace.package]
+authors = ["AhaLabs"]
+edition = "2021"
+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" }
 
 [profile.release]
 opt-level = "z"

Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "fungible-token-interface-example"
+edition.workspace = true
+license.workspace = true
+repository = "https://github.com/OpenZeppelin/stellar-contracts"
+publish = false
+version.workspace = true
+
+[lib]
+crate-type = ["cdylib"]
+doctest = false
+
+[dependencies]
+soroban-sdk = { workspace = true }
+stellar-pausable = { workspace = true }
+stellar-pausable-macros = { workspace = true }
+stellar-fungible = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }

contracts/fungible-token-interface/Cargo.toml

@@ -0,0 +1,146 @@
+//! Fungible Pausable Example Contract.
+//!
+//! This contract replicates the functionality of the contract in
+//! "examples/fungible-pausable", offering the same features. The key difference
+//! lies in how SEP-41 compliance is achieved. The contract in "contract.rs"
+//! accomplishes this by implementing
+//! [`stellar_fungible::fungible::FungibleToken`] and
+//! [`stellar_fungible::burnable::FungibleBurnable`], whereas this
+//! version directly implements [`soroban_sdk::token::TokenInterface`].
+//!
+//! Ultimately, it is up to the user to choose their preferred approach to
+//! creating a SEP-41 token. We suggest the approach in
+//! "examples/fungible-pausable" for better organization of the code,
+//! consistency and ease of inspection/debugging.
+
+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_pausable::{self as pausable, Pausable};
+use stellar_pausable_macros::when_not_paused;
+
+pub const OWNER: Symbol = symbol_short!("OWNER");
+
+#[contract]
+pub struct ExampleContract;
+
+#[contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
+#[repr(u32)]
+pub enum ExampleContractError {
+    Unauthorized = 1,
+}
+
+#[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);
+        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)
+    }
+}
+
+#[contractimpl]
+impl Pausable for ExampleContract {
+    fn paused(e: &Env) -> bool {
+        pausable::paused(e)
+    }
+
+    fn pause(e: &Env, caller: Address) {
+        // 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");
+        if owner != caller {
+            panic_with_error!(e, ExampleContractError::Unauthorized);
+        }
+
+        pausable::pause(e, &caller);
+    }
+
+    fn unpause(e: &Env, caller: Address) {
+        // 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");
+        if owner != caller {
+            panic_with_error!(e, ExampleContractError::Unauthorized);
+        }
+
+        pausable::unpause(e, &caller);
+    }
+}
+
+#[contractimpl]
+impl TokenInterface for ExampleContract {
+    fn balance(e: Env, account: Address) -> i128 {
+        fungible::balance(&e, &account)
+    }
+
+    fn allowance(e: Env, owner: Address, spender: Address) -> i128 {
+        fungible::allowance(&e, &owner, &spender)
+    }
+
+    #[when_not_paused]
+    fn transfer(e: Env, from: Address, to: Address, amount: i128) {
+        fungible::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);
+    }
+
+    fn approve(e: Env, owner: Address, spender: Address, amount: i128, live_until_ledger: u32) {
+        fungible::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)
+    }
+
+    #[when_not_paused]
+    fn burn_from(e: Env, spender: Address, from: Address, amount: i128) {
+        fungible::burnable::burn_from(&e, &spender, &from, amount)
+    }
+
+    fn decimals(e: Env) -> u32 {
+        fungible::metadata::decimals(&e)
+    }
+
+    fn name(e: Env) -> String {
+        fungible::metadata::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);
+    }
+}

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

@@ -0,0 +1,5 @@
+#![no_std]
+#![allow(dead_code)]
+
+mod contract;
+mod test;

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

@@ -0,0 +1,129 @@
+#![cfg(test)]
+
+extern crate std;
+
+use soroban_sdk::{testutils::Address as _, Address, Env, String};
+
+use crate::contract::{ExampleContract, ExampleContractClient};
+
+fn create_client<'a>(e: &Env, owner: &Address, initial_supply: i128) -> ExampleContractClient<'a> {
+    let address = e.register(ExampleContract, (owner, initial_supply));
+    ExampleContractClient::new(e, &address)
+}
+
+#[test]
+fn initial_state() {
+    let e = Env::default();
+    let owner = Address::generate(&e);
+    let client = create_client(&e, &owner, 1000);
+
+    assert_eq!(client.total_supply(), 1000);
+    assert_eq!(client.balance(&owner), 1000);
+    assert_eq!(client.symbol(), String::from_str(&e, "TKN"));
+    assert_eq!(client.name(), String::from_str(&e, "My Token"));
+    assert_eq!(client.decimals(), 18);
+    assert!(!client.paused());
+}
+
+#[test]
+fn transfer_works() {
+    let e = Env::default();
+    let owner = Address::generate(&e);
+    let recipient = Address::generate(&e);
+    let client = create_client(&e, &owner, 1000);
+
+    e.mock_all_auths();
+    client.transfer(&owner, &recipient, &100);
+    assert_eq!(client.balance(&owner), 900);
+    assert_eq!(client.balance(&recipient), 100);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #100)")]
+fn transfer_fails_when_paused() {
+    let e = Env::default();
+    let owner = Address::generate(&e);
+    let recipient = Address::generate(&e);
+    let client = create_client(&e, &owner, 1000);
+
+    e.mock_all_auths();
+    client.pause(&owner);
+    client.transfer(&owner, &recipient, &100);
+}
+
+#[test]
+fn transfer_from_works() {
+    let e = Env::default();
+    let owner = Address::generate(&e);
+    let spender = Address::generate(&e);
+    let recipient = Address::generate(&e);
+    let client = create_client(&e, &owner, 1000);
+
+    e.mock_all_auths();
+    client.approve(&owner, &spender, &200, &100);
+    client.transfer_from(&spender, &owner, &recipient, &200);
+    assert_eq!(client.balance(&owner), 800);
+    assert_eq!(client.balance(&recipient), 200);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #100)")]
+fn transfer_from_fails_when_paused() {
+    let e = Env::default();
+    let owner = Address::generate(&e);
+    let spender = Address::generate(&e);
+    let recipient = Address::generate(&e);
+    let client = create_client(&e, &owner, 1000);
+
+    e.mock_all_auths();
+    client.pause(&owner);
+    client.transfer_from(&spender, &owner, &recipient, &200);
+}
+
+#[test]
+fn mint_works() {
+    let e = Env::default();
+    let owner = Address::generate(&e);
+    let client = create_client(&e, &owner, 1000);
+
+    e.mock_all_auths();
+    client.mint(&owner, &500);
+    assert_eq!(client.total_supply(), 1500);
+    assert_eq!(client.balance(&owner), 1500);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #100)")]
+fn mint_fails_when_paused() {
+    let e = Env::default();
+    let owner = Address::generate(&e);
+    let client = create_client(&e, &owner, 1000);
+
+    e.mock_all_auths();
+    client.pause(&owner);
+    client.mint(&owner, &500);
+}
+
+#[test]
+fn burn_works() {
+    let e = Env::default();
+    let owner = Address::generate(&e);
+    let client = create_client(&e, &owner, 1000);
+
+    e.mock_all_auths();
+    client.burn(&owner, &200);
+    assert_eq!(client.total_supply(), 800);
+    assert_eq!(client.balance(&owner), 800);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #100)")]
+fn burn_fails_when_paused() {
+    let e = Env::default();
+    let owner = Address::generate(&e);
+    let client = create_client(&e, &owner, 1000);
+
+    e.mock_all_auths();
+    client.pause(&owner);
+    client.burn(&owner, &200);
+}

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

@@ -1,9 +1,11 @@
 [package]
 name = "soroban-hello-world-contract"
-version = "0.0.0"
-edition = "2021"
+description = "A simple hello world contract"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
 publish = false
-repository = "https://github.com/stellar/soroban-examples/tree/65d25d24028f71b2c2acb93e09791fcbe4b97142/hello_world"
+version.workspace = true
 
 [lib]
 crate-type = ["cdylib"]