# 스타일러스를 이용한 NFT 만들기 ## 1. 시작하기 NFT를 구축하고 배포하려면 몇가지 필요하다. 기본적인 환경설정이 되어 있다는 가정하에 진행한다. ## 2. NFT 만들기 ```rust git clone https://github.com/OffchainLabs/stylus-workshop-nft.git cd stylus-workshop-nft ``` 위 파일은 다음과 같은 구성으로 되어있다. `src/` 디렉토리에서 다음 소스 파일을 볼 수 있다. 각각 목적이 있으며, 각 파일 내에 관련 문서가 있다. | 파일 | 정보 | | :--------------------------------- | :------------------------------- | | [`erc721.rs`](erc721.rs) | [ERC-721 표준][erc721]을 구현. | | [`main.rs`](src/main.rs) | 진입점을 정의. | | [`utils.rs`](src/utils.rs) | 온체인 png 생성을 위한 유틸리티. | | [`print_art.rs`](src/print_art.rs) | 콘솔에 NFT를 인쇄 👀 | | [`art.rs`](art.rs) | **NFT를 그릴 수 있는 곳 😄** | ### art.rs 중요 코드 generate_nft fn 을 통해서 아래와 같은 이미지가 그려진다. ```rust pub fn generate_nft(address: Address, token_id: U256) -> Image<32, 32> { let mut hasher = FnvHasher::new(); hasher.update(token_id.as_le_slice()); hasher.update(address.as_slice()); let mut rng = Rng::with_seed(hasher.output()); let bg_color = Color::from_hex(0xe3066e); let fg_color = Color { red: rng.u8(..), green: rng.u8(..), blue: rng.u8(..), }; let mut image = Image::new(bg_color); image.draw_gradient(Color::from_hex(0xff0000), Color::from_hex(0x0000ff)); image.draw_line(Cell::new(4, 4), Cell::new(4, 6), fg_color); image.draw_line(Cell::new(10, 4), Cell::new(10, 6), fg_color); image.draw_ellipse(Cell::new(7, 9), 3, 3, [false, false, true, true], fg_color); image } ``` ### 이미지 print ```rust cargo test print_art -- --nocapture ``` 위 명령어를 치면 아래와 같이 png 파일이 draw 된다. ![alt text](https://github.com/Ludium-Official/road-to-bangkok/raw/main/%EC%95%84%EB%B9%84%ED%8A%B8%EB%9F%BC%20%EB%94%A5%EB%8B%A4%EC%9D%B4%EB%B8%8C/Stylus/image.png) ### 배포 아래 명령어를 통해 배포를 확인한다. ```rust cargo stylus check cargo stylus check --private-key <프라이빗 키> ``` ### ERC-721.rs 코드 분석 ```rust //! ERC-721 표준의 구현 //! (https://github.com/OffchainLabs/stylus-workshop-nft/ 구현을 기반으로 함) //! //! [`Erc721`] 타입은 모든 표준 메서드를 제공하며, //! 다른 계약 타입에 의해 상속되도록 설계되었다. //! //! [`Erc721Params`] 트레이트를 통해 [`Erc721`]의 동작을 구성할 수 있으며, //! 이를 통해 이름, 심볼, 토큰 URI를 지정할 수 있다. //! //! 이 코드는 감사되지 않았으며 프로덕션 사용에 적합하지 않음을 유의하자. use alloc::{string::String, vec, vec::Vec}; use alloy_primitives::{Address, U256}; use alloy_sol_types::{sol, SolError}; use core::{borrow::BorrowMut, marker::PhantomData}; use stylus_sdk::{ abi::Bytes, evm, msg, prelude::* }; pub trait Erc721Params { /// 변경 불가능한 NFT 이름. const NAME: &'static str; /// 변경 불가능한 NFT 심볼. const SYMBOL: &'static str; } sol_storage! { /// Erc721은 모든 ERC-721 메서드를 구현한다. pub struct Erc721 { /// 토큰 ID에서 소유자 매핑 mapping(uint256 => address) owners; /// 사용자에서 잔액 매핑 mapping(address => uint256) balance; /// 토큰 ID에서 승인된 사용자 매핑 mapping(uint256 => address) approved; /// 사용자에서 운영자 매핑 (운영자는 소유자의 모든 NFT를 관리할 수 있음) mapping(address => mapping(address => bool)) approved_for_all; /// 총 발행량 uint256 total_supply; /// [`Erc721Params`]를 허용하는 데 사용됨 PhantomData phantom; } } // 이벤트 및 Solidity 오류 타입 선언 sol! { event Transfer(address indexed from, address indexed to, uint256 indexed token_id); event Approval(address indexed owner, address indexed approved, uint256 indexed token_id); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); // 토큰 ID가 발행되지 않았거나 소각됨 error InvalidTokenId(uint256 token_id); // 지정된 주소가 지정된 토큰 ID의 소유자가 아님 error NotOwner(address from, uint256 token_id, address real_owner); // 지정된 주소가 지정된 토큰 ID를 사용할 수 있는 권한이 없음 error NotApproved(address owner, address spender, uint256 token_id); // 토큰 ID를 제로 주소로 전송하려고 시도함 error TransferToZero(uint256 token_id); // 수신자 주소가 지정된 토큰 ID의 수신을 거부함 error ReceiverRefused(address receiver, uint256 token_id, bytes4 returned); } /// 메서드가 실패할 수 있는 경우를 나타낸다. pub enum Erc721Error { InvalidTokenId(InvalidTokenId), NotOwner(NotOwner), NotApproved(NotApproved), TransferToZero(TransferToZero), ReceiverRefused(ReceiverRefused), ExternalCall(stylus_sdk::call::Error), } /// 곧 이 작업을 정리하기 위해 `#[derive(SolidityError)]`을 제공할 예정이다. impl From for Erc721Error { fn from(err: stylus_sdk::call::Error) -> Self { Self::ExternalCall(err) } } /// 곧 이 작업을 정리하기 위해 `#[derive(SolidityError)]`을 제공할 예정이다. impl From for Vec { fn from(val: Erc721Error) -> Self { match val { Erc721Error::InvalidTokenId(err) => err.encode(), Erc721Error::NotOwner(err) => err.encode(), Erc721Error::NotApproved(err) => err.encode(), Erc721Error::TransferToZero(err) => err.encode(), Erc721Error::ReceiverRefused(err) => err.encode(), Erc721Error::ExternalCall(err) => err.into(), } } } // 이 메서드들은 외부 메서드에서 사용되는 도우미 역할을 한다. // 여기서 "pub"으로 표시된 메서드는 erc721 모듈 외부에서 사용 가능 (즉, lib.rs에서 호출 가능)하다. impl Erc721 { /// msg::sender()가 주어진 토큰을 사용할 권한이 있는지 확인 fn require_authorized_to_spend(&self, from: Address, token_id: U256) -> Result<(), Erc721Error> { let owner = self.owner_of(token_id)?; if from != owner { return Err(Erc721Error::NotOwner(NotOwner { from, token_id, real_owner: owner, })); } if msg::sender() == owner { return Ok(()); } if self.approved_for_all.getter(owner).get(msg::sender()) { return Ok(()); } if msg::sender() == self.approved.get(token_id) { return Ok(()); } Err(Erc721Error::NotApproved(NotApproved { owner, spender: msg::sender(), token_id, })) } /// `token_id`를 `from`에서 `to`로 전송한다. /// 이 함수는 `from`이 토큰의 소유자인지 확인하지만, `to`가 제로 주소가 아닌지 확인하지 않는다. 이 함수는 소각에 사용할 수 있다. pub fn transfer(&mut self, token_id: U256, from: Address, to: Address) -> Result<(), Erc721Error> { let mut owner = self.owners.setter(token_id); let previous_owner = owner.get(); if previous_owner != from { return Err(Erc721Error::NotOwner(NotOwner { from, token_id, real_owner: previous_owner, })); } owner.set(to); // 현재로서는 스토리지를 다루는 것이 번거로울 수 있지만, 이는 곧 출시될 Stylus SDK 버전에서 변경될 예정이다. let mut from_balance = self.balance.setter(from); let balance = from_balance.get() - U256::from(1); from_balance.set(balance); let mut to_balance = self.balance.setter(to); let balance = to_balance.get() + U256::from(1); to_balance.set(balance); self.approved.delete(token_id); evm::log(Transfer { from, to, token_id }); Ok(()) } /// `to` 주소가 계약인 경우 `onERC721Received`를 호출한다. /// 그렇지 않으면 아무 것도 하지 않는다. fn call_receiver( storage: &mut S, token_id: U256, from: Address, to: Address, data: Vec, ) -> Result<(), Erc721Error> { if to.has_code() { let receiver = IERC721TokenReceiver::new(to); let received = receiver .on_erc_721_received(&mut *storage, msg::sender(), from, token_id, data)? .0; if u32::from_be_bytes(received) != ERC721_TOKEN_RECEIVER_ID { return Err(Erc721Error::ReceiverRefused(ReceiverRefused { receiver: receiver.address, token_id, returned: received, })); } } Ok(()) } /// 전송 및 `onERC721Received` 호출 pub fn safe_transfer>( storage: &mut S, token_id: U256, from: Address, to: Address, data: Vec, ) -> Result<(), Erc721Error> { storage.borrow_mut().transfer(token_id, from, to)?; Self::call_receiver(storage, token_id, from, to, data) } /// 새로운 토큰을 발행하고 `to`로 전송한다. pub fn mint(&mut self, to: Address) -> Result<(), Erc721Error> { let new_token_id = self.total_supply.get(); self.total_supply.set(new_token_id + U256::from(1u8)); self.transfer(new_token_id, Address::default(), to)?; Ok(()) } /// 새로운 토큰을 발행하고 이를 안전하게 `to`로 전송한다. pub fn safe_mint>( storage: &mut S, to: Address, data: Vec, ) -> Result<(), Erc721Error> { let this = storage.borrow_mut(); let new_token_id = this.total_supply.get(); this.total_supply.set(new_token_id + U256::from(1u8)); Self::safe_transfer(storage, new_token_id, Address::default(), to, data)?; Ok(()) } /// `from`에서 `token_id` 토큰을 소각한다. pub fn burn(&mut self, from: Address, token_id: U256) -> Result<(), Erc721Error> { self.transfer(token_id, from, Address::default())?; Ok(()) } } sol_interface! { /// `IERC721TokenReceiver`를 구현하는 다른 계약의 `onERC721Received` 메서드 호출을 허용한다. interface IERC721TokenReceiver { function onERC721Received(address operator, address from, uint256 token_id, bytes data) external returns(bytes4); } } /// `IERC721TokenReceiver`를 구현하는 계약에서 반환되는 `onERC721Received`의 선택자. const ERC721_TOKEN_RECEIVER_ID: u32 = 0x150b7a02; // 이 메서드들은 다른 계약에 대해 외부적으로 작용한다. #[external] impl Erc721 { /// 변경 불가능한 NFT 이름. pub fn name() -> Result { Ok(T::NAME.into()) } /// 변경 불가능한 NFT 심볼. pub fn symbol() -> Result { Ok(T::SYMBOL.into()) } /// NFT가 주어진 표준을 지원하는지 여부. pub fn supports_interface(interface: [u8; 4]) -> Result { if interface == [0xff; 4] { // ERC165 표준에서 특별히 처리됨 return Ok(false); } const IERC165: u32 = 0x01ffc9a7; const IERC721: u32 = 0x80ac58cd; const _IERC721_ENUMERABLE: u32 = 0x780e9d63; // TODO: 표준 구현 Ok(matches!(u32::from_be_bytes(interface), IERC165 | IERC721)) } /// 계정이 소유한 NFT 수를 가져온다. pub fn balance_of(&self, owner: Address) -> Result { Ok(self.balance.get(owner)) } /// NFT의 소유자를 가져옵니다, 존재할 경우. pub fn owner_of(&self, token_id: U256) -> Result { let owner = self.owners.get(token_id); if owner.is_zero() { return Err(Erc721Error::InvalidTokenId(InvalidTokenId { token_id })); } Ok(owner) } /// `to` 주소가 NFT를 받을 수 있는지 확인한 후 NFT를 전송한다. pub fn safe_transfer_from>( storage: &mut S, from: Address, to: Address, token_id: U256, ) -> Result<(), Erc721Error> { Self::safe_transfer_from_with_data(storage, from, to, token_id, Bytes(vec![])) } /// [`safe_transfer_from`]과 동일하지만, 수신자에게 추가 데이터를 포함한다. /// /// 참고: Rust는 동일한 이름의 메서드를 여러 개 허용하지 않기 때문에, /// `#[selector]` 매크로 속성을 사용하여 Solidity 오버로딩을 시뮬레이트한다. #[selector(name = "safeTransferFrom")] pub fn safe_transfer_from_with_data>( storage: &mut S, from: Address, to: Address, token_id: U256, data: Bytes, ) -> Result<(), Erc721Error> { if to.is_zero() { return Err(Erc721Error::TransferToZero(TransferToZero { token_id })); } storage .borrow_mut() .require_authorized_to_spend(from, token_id)?; Self::safe_transfer(storage, token_id, from, to, data.0) } /// NFT를 전송한다. pub fn transfer_from(&mut self, from: Address, to: Address, token_id: U256) -> Result<(), Erc721Error> { if to.is_zero() { return Err(Erc721Error::TransferToZero(TransferToZero { token_id })); } self.require_authorized_to_spend(from, token_id)?; self.transfer(token_id, from, to)?; Ok(()) } /// 계정에 사용자의 NFT를 관리할 수 있는 권한을 부여한다. pub fn approve(&mut self, approved: Address, token_id: U256) -> Result<(), Erc721Error> { let owner = self.owner_of(token_id)?; // 권한 요구 if msg::sender() != owner && !self.approved_for_all.getter(owner).get(msg::sender()) { return Err(Erc721Error::NotApproved(NotApproved { owner, spender: msg::sender(), token_id, })); } self.approved.insert(token_id, approved); evm::log(Approval { approved, owner, token_id, }); Ok(()) } /// 계정에 사용자의 모든 NFT를 관리할 수 있는 권한을 부여한다. pub fn set_approval_for_all(&mut self, operator: Address, approved: bool) -> Result<(), Erc721Error> { let owner = msg::sender(); self.approved_for_all .setter(owner) .insert(operator, approved); evm::log(ApprovalForAll { owner, operator, approved, }); Ok(()) } /// NFT를 관리하는 계정을 가져오거나 관리되지 않는 경우 0을 반환한다. pub fn get_approved(&mut self, token_id: U256) -> Result { Ok(self.approved.get(token_id)) } /// 계정이 사용자의 모든 NFT를 관리할 수 있는 권한을 부여받았는지 여부를 결정한다. pub fn is_approved_for_all(&mut self, owner: Address, operator: Address) -> Result { Ok(self.approved_for_all.getter(owner).get(operator)) } } ```

Stylus ERC-721