Feature: ERC721 NFT Contract

Scarb.lock

@@ -82,6 +82,14 @@ version = "0.1.0"
 name = "erc20"
 version = "0.1.0"
 
+[[package]]
+name = "erc721"
+version = "0.1.0"
+dependencies = [
+ "openzeppelin",
+ "snforge_std",
+]
+
 [[package]]
 name = "errors"
 version = "0.1.0"

listings/applications/erc721/.gitignore

@@ -0,0 +1 @@
+target

listings/applications/erc721/Scarb.toml

@@ -0,0 +1,17 @@
+[package]
+name = "erc721"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+starknet.workspace = true
+openzeppelin.workspace = true
+
+[dev-dependencies]
+assert_macros.workspace = true
+snforge_std.workspace = true
+
+[scripts]
+test.workspace = true
+
+[[target.starknet-contract]]

listings/applications/erc721/src/erc721.cairo

@@ -0,0 +1,208 @@
+#[starknet::contract]
+pub mod ERC721 {
+    use core::num::traits::Zero;
+    use starknet::get_caller_address;
+    use starknet::ContractAddress;
+    use starknet::storage::{Map, StorageMapReadAccess, StorageMapWriteAccess};
+    use openzeppelin_introspection::interface::{ISRC5Dispatcher, ISRC5DispatcherTrait};
+    use erc721::interfaces::{
+        IERC721, IERC721ReceiverDispatcher, IERC721ReceiverDispatcherTrait, IERC721_RECEIVER_ID,
+        IERC721Mintable, IERC721Burnable,
+    };
+
+    #[storage]
+    pub struct Storage {
+        pub owners: Map<u256, ContractAddress>,
+        pub balances: Map<ContractAddress, u256>,
+        pub approvals: Map<u256, ContractAddress>,
+        pub operator_approvals: Map<(ContractAddress, ContractAddress), bool>,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        Transfer: Transfer,
+        Approval: Approval,
+        ApprovalForAll: ApprovalForAll,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct Transfer {
+        pub from: ContractAddress,
+        pub to: ContractAddress,
+        pub token_id: u256
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct Approval {
+        pub owner: ContractAddress,
+        pub approved: ContractAddress,
+        pub token_id: u256
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct ApprovalForAll {
+        pub owner: ContractAddress,
+        pub operator: ContractAddress,
+        pub approved: bool
+    }
+
+    pub mod Errors {
+        pub const INVALID_TOKEN_ID: felt252 = 'ERC721: invalid token ID';
+        pub const INVALID_ACCOUNT: felt252 = 'ERC721: invalid account';
+        pub const INVALID_OPERATOR: felt252 = 'ERC721: invalid operator';
+        pub const UNAUTHORIZED: felt252 = 'ERC721: unauthorized caller';
+        pub const INVALID_RECEIVER: felt252 = 'ERC721: invalid receiver';
+        pub const INVALID_SENDER: felt252 = 'ERC721: invalid sender';
+        pub const SAFE_TRANSFER_FAILED: felt252 = 'ERC721: safe transfer failed';
+        pub const ALREADY_MINTED: felt252 = 'ERC721: token already minted';
+    }
+
+    #[abi(embed_v0)]
+    impl ERC721 of IERC721<ContractState> {
+        fn owner_of(self: @ContractState, token_id: u256) -> ContractAddress {
+            self._require_owned(token_id)
+        }
+
+        fn balance_of(self: @ContractState, owner: ContractAddress) -> u256 {
+            assert(!owner.is_zero(), Errors::INVALID_ACCOUNT);
+            self.balances.read(owner)
+        }
+
+        fn set_approval_for_all(
+            ref self: ContractState, operator: ContractAddress, approved: bool
+        ) {
+            assert(!operator.is_zero(), Errors::INVALID_OPERATOR);
+            let owner = get_caller_address();
+            self.operator_approvals.write((owner, operator), approved);
+            self.emit(ApprovalForAll { owner, operator, approved });
+        }
+
+        fn approve(ref self: ContractState, approved: ContractAddress, token_id: u256) {
+            let owner = self._require_owned(token_id);
+            let caller = get_caller_address();
+            assert(
+                caller == owner || self.is_approved_for_all(owner, caller), Errors::UNAUTHORIZED
+            );
+
+            self.approvals.write(token_id, approved);
+            self.emit(Approval { owner, approved, token_id });
+        }
+
+        fn get_approved(self: @ContractState, token_id: u256) -> ContractAddress {
+            self._require_owned(token_id);
+            self.approvals.read(token_id)
+        }
+
+        fn transfer_from(
+            ref self: ContractState, from: ContractAddress, to: ContractAddress, token_id: u256
+        ) {
+            let previous_owner = self._require_owned(token_id);
+            assert(from == previous_owner, Errors::INVALID_SENDER);
+            assert(!to.is_zero(), Errors::INVALID_RECEIVER);
+            assert(
+                self._is_approved_or_owner(from, get_caller_address(), token_id),
+                Errors::UNAUTHORIZED
+            );
+
+            self.balances.write(from, self.balances.read(from) - 1);
+            self.balances.write(to, self.balances.read(to) + 1);
+            self.owners.write(token_id, to);
+            self.approvals.write(token_id, Zero::zero());
+
+            self.emit(Transfer { from, to, token_id });
+        }
+
+        fn safe_transfer_from(
+            ref self: ContractState,
+            from: ContractAddress,
+            to: ContractAddress,
+            token_id: u256,
+            data: Span<felt252>
+        ) {
+            Self::transfer_from(ref self, from, to, token_id);
+            assert(
+                self._check_on_erc721_received(from, to, token_id, data),
+                Errors::SAFE_TRANSFER_FAILED
+            );
+        }
+
+        fn is_approved_for_all(
+            self: @ContractState, owner: ContractAddress, operator: ContractAddress
+        ) -> bool {
+            self.operator_approvals.read((owner, operator))
+        }
+    }
+
+    #[abi(embed_v0)]
+    pub impl ERC721Burnable of IERC721Burnable<ContractState> {
+        fn burn(ref self: ContractState, token_id: u256) {
+            self._burn(token_id)
+        }
+    }
+
+    #[abi(embed_v0)]
+    pub impl ERC721Mintable of IERC721Mintable<ContractState> {
+        fn mint(ref self: ContractState, to: ContractAddress, token_id: u256) {
+            self._mint(to, token_id)
+        }
+    }
+
+    #[generate_trait]
+    pub impl InternalImpl of InternalTrait {
+        fn _mint(ref self: ContractState, to: ContractAddress, token_id: u256) {
+            assert(!to.is_zero(), Errors::INVALID_RECEIVER);
+            assert(self.owners.read(token_id).is_zero(), Errors::ALREADY_MINTED);
+
+            self.balances.write(to, self.balances.read(to) + 1);
+            self.owners.write(token_id, to);
+
+            self.emit(Transfer { from: Zero::zero(), to, token_id });
+        }
+
+        fn _burn(ref self: ContractState, token_id: u256) {
+            let owner = self._require_owned(token_id);
+
+            self.balances.write(owner, self.balances.read(owner) - 1);
+
+            self.owners.write(token_id, Zero::zero());
+            self.approvals.write(token_id, Zero::zero());
+
+            self.emit(Transfer { from: owner, to: Zero::zero(), token_id });
+        }
+
+        fn _require_owned(self: @ContractState, token_id: u256) -> ContractAddress {
+            let owner = self.owners.read(token_id);
+            assert(!owner.is_zero(), Errors::INVALID_TOKEN_ID);
+            owner
+        }
+
+        fn _is_approved_or_owner(
+            self: @ContractState, owner: ContractAddress, spender: ContractAddress, token_id: u256
+        ) -> bool {
+            !spender.is_zero()
+                && (owner == spender
+                    || self.is_approved_for_all(owner, spender)
+                    || spender == self.get_approved(token_id))
+        }
+
+        fn _check_on_erc721_received(
+            self: @ContractState,
+            from: ContractAddress,
+            to: ContractAddress,
+            token_id: u256,
+            data: Span<felt252>
+        ) -> bool {
+            let src5_dispatcher = ISRC5Dispatcher { contract_address: to };
+
+            if src5_dispatcher.supports_interface(IERC721_RECEIVER_ID) {
+                IERC721ReceiverDispatcher { contract_address: to }
+                    .on_erc721_received(
+                        get_caller_address(), from, token_id, data
+                    ) == IERC721_RECEIVER_ID
+            } else {
+                src5_dispatcher.supports_interface(openzeppelin_account::interface::ISRC6_ID)
+            }
+        }
+    }
+}

listings/applications/erc721/src/interfaces.cairo

@@ -0,0 +1,74 @@
+use starknet::ContractAddress;
+
+// [!region interface]
+#[starknet::interface]
+pub trait IERC721<TContractState> {
+    fn balance_of(self: @TContractState, owner: ContractAddress) -> u256;
+    fn owner_of(self: @TContractState, token_id: u256) -> ContractAddress;
+    // The function `safe_transfer_from(address _from, address _to, uint256 _tokenId)`
+    // is not included because the same behavior can be achieved by calling
+    // `safe_transfer_from(from, to, tokenId, data)` with an empty `data`
+    // parameter. This approach reduces redundancy in the contract's interface.
+    fn safe_transfer_from(
+        ref self: TContractState,
+        from: ContractAddress,
+        to: ContractAddress,
+        token_id: u256,
+        data: Span<felt252>
+    );
+    fn transfer_from(
+        ref self: TContractState, from: ContractAddress, to: ContractAddress, token_id: u256
+    );
+    fn approve(ref self: TContractState, approved: ContractAddress, token_id: u256);
+    fn set_approval_for_all(ref self: TContractState, operator: ContractAddress, approved: bool);
+    fn get_approved(self: @TContractState, token_id: u256) -> ContractAddress;
+    fn is_approved_for_all(
+        self: @TContractState, owner: ContractAddress, operator: ContractAddress
+    ) -> bool;
+}
+
+#[starknet::interface]
+pub trait IERC721Mintable<TContractState> {
+    fn mint(ref self: TContractState, to: ContractAddress, token_id: u256);
+}
+
+#[starknet::interface]
+pub trait IERC721Burnable<TContractState> {
+    fn burn(ref self: TContractState, token_id: u256);
+}
+
+pub const IERC721_RECEIVER_ID: felt252 =
+    0x3a0dff5f70d80458ad14ae37bb182a728e3c8cdda0402a5daa86620bdf910bc;
+
+#[starknet::interface]
+pub trait IERC721Receiver<TContractState> {
+    fn on_erc721_received(
+        self: @TContractState,
+        operator: ContractAddress,
+        from: ContractAddress,
+        token_id: u256,
+        data: Span<felt252>
+    ) -> felt252;
+}
+
+// The `IERC721Metadata` and `IERC721Enumerable` interfaces are included here
+// as optional extensions to the ERC721 standard. While they provide additional
+// functionality (such as token metadata and enumeration), they are not
+// implemented in this example. Including these interfaces demonstrates how they
+// can be integrated and serves as a starting point for developers who wish to
+// extend the functionality.
+#[starknet::interface]
+pub trait IERC721Metadata<TContractState> {
+    fn name(self: @TContractState) -> ByteArray;
+    fn symbol(self: @TContractState) -> ByteArray;
+    fn token_uri(self: @TContractState, token_id: u256) -> ByteArray;
+}
+
+#[starknet::interface]
+pub trait IERC721Enumerable<TContractState> {
+    fn total_supply(self: @TContractState) -> u256;
+    fn token_by_index(self: @TContractState, index: u256) -> u256;
+    fn token_of_owner_by_index(self: @TContractState, owner: ContractAddress, index: u256) -> u256;
+}
+// [!endregion interface]
+

listings/applications/erc721/src/lib.cairo

@@ -0,0 +1,6 @@
+pub mod erc721;
+pub mod interfaces;
+mod mocks;
+
+#[cfg(test)]
+mod tests;

listings/applications/erc721/src/mocks.cairo

@@ -0,0 +1,7 @@
+pub mod account;
+pub mod receiver;
+pub mod non_receiver;
+
+pub use account::AccountMock;
+pub use non_receiver::NonReceiverMock;
+pub use receiver::ERC721ReceiverMock;

listings/applications/erc721/src/mocks/account.cairo

@@ -0,0 +1,46 @@
+//! Copied with modifications from OpenZeppelin's repo
+//! https://github.com/OpenZeppelin/cairo-contracts/blob/6e60ba9310fa7953f045d0c30b343b0ffc168c14/packages/test_common/src/mocks/account.cairo
+
+#[starknet::contract(account)]
+pub mod AccountMock {
+    use openzeppelin_account::AccountComponent;
+    use openzeppelin_introspection::src5::SRC5Component;
+
+    component!(path: AccountComponent, storage: account, event: AccountEvent);
+    component!(path: SRC5Component, storage: src5, event: SRC5Event);
+
+    // Account
+    #[abi(embed_v0)]
+    impl SRC6Impl = AccountComponent::SRC6Impl<ContractState>;
+    #[abi(embed_v0)]
+    impl DeclarerImpl = AccountComponent::DeclarerImpl<ContractState>;
+    #[abi(embed_v0)]
+    impl DeployableImpl = AccountComponent::DeployableImpl<ContractState>;
+    impl AccountInternalImpl = AccountComponent::InternalImpl<ContractState>;
+
+    // SCR5
+    #[abi(embed_v0)]
+    impl SRC5Impl = SRC5Component::SRC5Impl<ContractState>;
+
+    #[storage]
+    pub struct Storage {
+        #[substorage(v0)]
+        pub account: AccountComponent::Storage,
+        #[substorage(v0)]
+        pub src5: SRC5Component::Storage
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        AccountEvent: AccountComponent::Event,
+        #[flat]
+        SRC5Event: SRC5Component::Event
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, public_key: felt252) {
+        self.account.initializer(public_key);
+    }
+}

listings/applications/erc721/src/mocks/non_receiver.cairo

@@ -0,0 +1,10 @@
+#[starknet::contract]
+pub mod NonReceiverMock {
+    #[storage]
+    pub struct Storage {}
+
+    #[external(v0)]
+    fn nope(self: @ContractState) -> bool {
+        false
+    }
+}