Ver3.0 ๐จ ํ์ด์ฌ๊ณผ web3.py๋ก NFT ์๋ ๋ฐํ ์์คํ ๊ตฌ์ถํ๊ธฐ

๐จ ํ์ด์ฌ๊ณผ web3.py๋ก NFT ์๋ ๋ฐํ ์์คํ ๊ตฌ์ถํ๊ธฐ
๋ธ๋ก์ฒด์ธ ์ธ์์์ ๋๋ง์ NFT ๋ฐํ ์์คํ ๋ง๋ค๊ธฐ ๐
์์ฆ NFT ์์ฅ ์ง์ง ํซํ์ฃ ? ๐ฅ
๊ทผ๋ฐ NFT๋ฅผ ํ๋ํ๋ ์๋์ผ๋ก ๋ฐํํ๋ ๊ฑด ๋๋ฌด ๋นํจ์จ์ ์ด์์์ ใ
ใ
ใ
ํนํ ๋๋์ผ๋ก NFT ์ปฌ๋ ์
์ ๋ง๋ค์ด์ผ ํ ๋๋ ์๋ํ๊ฐ ํ์์ธ๋ฐ์!
์ค๋์ ํ์ด์ฌ๊ณผ web3.py ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํ์ฉํด์ NFT๋ฅผ ์๋์ผ๋ก ๋ฐํํ๋ ์์คํ
์ ๊ตฌ์ถํ๋ ๋ฐฉ๋ฒ์ ์๋ ค๋๋ฆด๊ฒ์.
์ฝ๋ฉ ์ด๋ณด์๋ ๋ฐ๋ผํ ์ ์๊ฒ ์ต๋ํ ์ฝ๊ฒ ์ค๋ช
ํ ๊ฒ์ ๐ช
๐ฏ NFT ์๋ ๋ฐํ ์์คํ ์ด ํ์ํ ์ด์
NFT ํ๋ก์ ํธ๋ฅผ ์งํํ๋ค ๋ณด๋ฉด ์๋ฐฑ, ์์ฒ ๊ฐ์ NFT๋ฅผ ๋ฐํํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์.
์๋ฅผ ๋ค์ด 10,000๊ฐ์ ํ๋กํ ์ฌ์ง NFT ์ปฌ๋ ์
์ ๋ง๋ ๋ค๊ณ ์๊ฐํด๋ณด์ธ์ ๐ฑ
ํ๋ํ๋ ์๋์ผ๋ก ๋ฐํํ๋ฉด ์๊ฐ๋ ์ค๋ ๊ฑธ๋ฆฌ๊ณ , ์ค์ํ ๊ฐ๋ฅ์ฑ๋ ๋์ฃ .
๊ฒ๋ค๊ฐ ๊ฐ์ค๋น๋ ๋งค๋ฒ ์ ๊ฒฝ ์จ์ผ ํ๊ณ ... ์ง์ง ์คํธ๋ ์ค ์ฅ๋ ์๋์์ ใ
ใ
โจ ์๋ํ ์์คํ
์ ์ฅ์
โข ๋๋์ NFT๋ฅผ ๋น ๋ฅด๊ฒ ๋ฐํ ๊ฐ๋ฅ โก
โข ๋ฉํ๋ฐ์ดํฐ ๊ด๋ฆฌ๊ฐ ์ฒด๊ณ์ ์ด๊ณ ์ ํํจ ๐
โข ๊ฐ์ค๋น ์ต์ ํ๋ก ๋น์ฉ ์ ๊ฐ ๐ฐ
โข ์ค์ ๋ฐฉ์ง ๋ฐ ์ผ๊ด์ฑ ์ ์ง ๐ฏ
โข ๋ฐํ ๊ณผ์ ์ถ์ ๋ฐ ๋ก๊น
๊ฐ๋ฅ ๐
๐ ๏ธ ํ์ํ ๋๊ตฌ์ ํ๊ฒฝ ์ค์
๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํ๊ธฐ ์ ์ ํ์ํ ๊ฒ๋ค์ ์ค๋นํด๋ณผ๊น์?
์๊ฐ๋ณด๋ค ๊ฐ๋จํด์! ๊ธฐ๋ณธ์ ์ธ ํ์ด์ฌ ์ง์๋ง ์์ผ๋ฉด ์ถฉ๋ถํฉ๋๋ค ๐
๐ฆ 1๋จ๊ณ: ํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น
๋จผ์ ํ์ด์ฌ ํ๊ฒฝ์ด ์ค์น๋์ด ์์ด์ผ ํด์. Python 3.8 ์ด์ ๋ฒ์ ์ ๊ถ์ฅํฉ๋๋ค!
๊ทธ๋ฆฌ๊ณ ๋ค์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ์ค์นํด์ฃผ์ธ์:
pip install web3
pip install python-dotenv
pip install pillow
pip install requests
๐ก Tip: ๊ฐ์ํ๊ฒฝ(venv)์ ์ฌ์ฉํ๋ฉด ํ๋ก์ ํธ๋ณ๋ก ํจํค์ง๋ฅผ ๋
๋ฆฝ์ ์ผ๋ก ๊ด๋ฆฌํ ์ ์์ด์!
python -m venv nft_env ๋ช
๋ น์ด๋ก ๊ฐ์ํ๊ฒฝ์ ๋ง๋ค๊ณ ํ์ฑํํ ํ ํจํค์ง๋ฅผ ์ค์นํ๋ ๊ฑธ ์ถ์ฒํด์ ใ
ใ
๐ 2๋จ๊ณ: ๋ธ๋ก์ฒด์ธ ๋คํธ์ํฌ ์ ํ
NFT๋ฅผ ๋ฐํํ ๋ธ๋ก์ฒด์ธ ๋คํธ์ํฌ๋ฅผ ์ ํํด์ผ ํด์.
๋ํ์ ์ผ๋ก ์ด๋๋ฆฌ์, ํด๋ฆฌ๊ณค, ํด๋ ์ดํผ ๋ฑ์ด ์๋๋ฐ์.
์ด๋ณด์๋ผ๋ฉด ํ
์คํธ๋ท์์ ๋จผ์ ์ฐ์ตํ๋ ๊ฑธ ๊ฐ๋ ฅ ์ถ์ฒํฉ๋๋ค! ๐
์ค์ ๋์ด ๋ค์ด๊ฐ์ง ์์ผ๋๊น ๋ง์ ํธํ๊ฒ ํ
์คํธํ ์ ์๊ฑฐ๋ ์ ใ
ใ
ใ
๐ ์ฃผ์ ํ
์คํธ๋ท
โข Goerli: ์ด๋๋ฆฌ์ ํ
์คํธ๋ท (๊ฐ์ฅ ์์ ์ )
โข Mumbai: ํด๋ฆฌ๊ณค ํ
์คํธ๋ท (๋น ๋ฅด๊ณ ์ ๋ ด)
โข Baobab: ํด๋ ์ดํผ ํ
์คํธ๋ท (๊ตญ๋ด ์นํ์ )
ํ
์คํธ๋ท ํ ํฐ์ Faucet์์ ๋ฌด๋ฃ๋ก ๋ฐ์ ์ ์์ด์! ๐ธ
๐ 3๋จ๊ณ: ์ง๊ฐ๊ณผ API ํค ์ค๋น
NFT๋ฅผ ๋ฐํํ๋ ค๋ฉด ์ง๊ฐ ์ฃผ์์ ๊ฐ์ธํค๊ฐ ํ์ํด์.
MetaMask ๊ฐ์ ์ง๊ฐ์ ๋ง๋ค๊ณ , ๊ฐ์ธํค๋ฅผ ์์ ํ๊ฒ ๋ณด๊ดํ์ธ์! ๐
๊ทธ๋ฆฌ๊ณ Infura๋ Alchemy ๊ฐ์ ๋
ธ๋ ์๋น์ค์ API ํค๋ ํ์ํฉ๋๋ค.
์ด ์๋น์ค๋ค์ ๋ธ๋ก์ฒด์ธ ๋คํธ์ํฌ์ ์ ์ํ ์ ์๊ฒ ํด์ฃผ๋ ์ค๊ฐ์ ์ญํ ์ ํด์.
โ ๏ธ ๋ณด์ ์ฃผ์์ฌํญ
๊ฐ์ธํค๋ ์ ๋๋ก ์ฝ๋์ ์ง์ ์
๋ ฅํ์ง ๋ง์ธ์!
.env ํ์ผ์ ๋ง๋ค์ด์ ํ๊ฒฝ๋ณ์๋ก ๊ด๋ฆฌํ๊ณ , ์ด ํ์ผ์ .gitignore์ ์ถ๊ฐํด์ Git์ ์ฌ๋ผ๊ฐ์ง ์๋๋ก ํด์ผ ํด์.
๊ฐ์ธํค๊ฐ ์ ์ถ๋๋ฉด ์ง๊ฐ์ ๋ชจ๋ ์์ฐ์ ์์ ์ ์์ต๋๋ค ๐ฑ
๐ ์ค๋งํธ ์ปจํธ๋ํธ ์ดํดํ๊ธฐ
NFT๋ฅผ ๋ฐํํ๋ ค๋ฉด ๋จผ์ ์ค๋งํธ ์ปจํธ๋ํธ๊ฐ ํ์ํด์.
์ค๋งํธ ์ปจํธ๋ํธ๋ ๋ธ๋ก์ฒด์ธ ์์์ ์คํ๋๋ ํ๋ก๊ทธ๋จ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋ผ์! ๐ค
NFT๋ ๋ณดํต ERC-721 ๋๋ ERC-1155 ํ์ค์ ๋ฐ๋ฅด๋๋ฐ์,
ERC-721์ ๊ฐ ํ ํฐ์ด ๊ณ ์ ํ ๊ฒฝ์ฐ(์: ๋์งํธ ์ํธ), ERC-1155๋ ๊ฐ์ ์ข
๋ฅ์ ํ ํฐ์ ์ฌ๋ฌ ๊ฐ ๋ฐํํ ๋ ์ฌ์ฉํด์.
์ง์ ์ค๋งํธ ์ปจํธ๋ํธ๋ฅผ ์์ฑํ ์๋ ์์ง๋ง, OpenZeppelin ๊ฐ์ ๊ฒ์ฆ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ ํจ์ฌ ์์ ํด์! ๐ก๏ธ
๋ณด์ ์ทจ์ฝ์ ์ด ์๊ณ , ํ์ค์ ์ ํํ๊ฒ ๋ฐ๋ฅด๋๊น์.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract MyNFT is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(uint256 => string) private _tokenURIs;
constructor() ERC721("MyNFT", "MNFT") {}
function mintNFT(address recipient, string memory tokenURI)
public onlyOwner
returns (uint256)
{
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(recipient, newItemId);
_setTokenURI(newItemId, tokenURI);
return newItemId;
}
function _setTokenURI(uint256 tokenId, string memory tokenURI) internal {
_tokenURIs[tokenId] = tokenURI;
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
return _tokenURIs[tokenId];
}
}
์ด ์ปจํธ๋ํธ๋ฅผ Remix IDE๋ Hardhat์ ์ฌ์ฉํด์ ๋ฐฐํฌํ๋ฉด ๋ผ์.
๋ฐฐํฌํ๊ณ ๋๋ฉด ์ปจํธ๋ํธ ์ฃผ์๋ฅผ ๋ฐ๊ฒ ๋๋๋ฐ, ์ด๊ฒ ๋์ค์ ํ์ด์ฌ ์ฝ๋์์ ์ฌ์ฉํ ์ฃผ์์์! ๐
๐ Python๊ณผ web3.py๋ก NFT ๋ฐํํ๊ธฐ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ํ์ด์ฌ ์ฝ๋๋ฅผ ์์ฑํด๋ณผ๊น์? ๐
web3.py๋ ์ด๋๋ฆฌ์ ๋ธ๋ก์ฒด์ธ๊ณผ ์ํธ์์ฉํ ์ ์๊ฒ ํด์ฃผ๋ ํ์ด์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์.
์ง์ง ๊ฐ๋ ฅํ๊ณ ์ฌ์ฉํ๊ธฐ๋ ํธํด์ ใ
ใ
ใ
๐ง Step 1: ํ๊ฒฝ ์ค์ ํ์ผ ๋ง๋ค๊ธฐ
๋จผ์ .env ํ์ผ์ ๋ง๋ค์ด์ ๋ฏผ๊ฐํ ์ ๋ณด๋ค์ ์ ์ฅํด์:
INFURA_URL=https://goerli.infura.io/v3/YOUR_PROJECT_ID
PRIVATE_KEY=your_private_key_here
CONTRACT_ADDRESS=0x1234567890abcdef...
WALLET_ADDRESS=0xabcdef1234567890...
๐ป Step 2: ๊ธฐ๋ณธ ์ฐ๊ฒฐ ์ค์
์ด์ ํ์ด์ฌ ์ฝ๋๋ก ๋ธ๋ก์ฒด์ธ์ ์ฐ๊ฒฐํด๋ด ์๋ค!
from web3 import Web3
from dotenv import load_dotenv
import os
import json
# ํ๊ฒฝ๋ณ์ ๋ก๋
load_dotenv()
# Web3 ์ธ์คํด์ค ์์ฑ
w3 = Web3(Web3.HTTPProvider(os.getenv('INFURA_URL')))
# ์ฐ๊ฒฐ ํ์ธ
if w3.is_connected():
print("โ
๋ธ๋ก์ฒด์ธ ์ฐ๊ฒฐ ์ฑ๊ณต!")
print(f"ํ์ฌ ๋ธ๋ก ๋ฒํธ: {w3.eth.block_number}")
else:
print("โ ์ฐ๊ฒฐ ์คํจ")
exit()
# ๊ณ์ ์ค์
private_key = os.getenv('PRIVATE_KEY')
wallet_address = os.getenv('WALLET_ADDRESS')
contract_address = os.getenv('CONTRACT_ADDRESS')
# ๊ณ์ ์์ก ํ์ธ
balance = w3.eth.get_balance(wallet_address)
print(f"๐ฐ ์ง๊ฐ ์์ก: {w3.from_wei(balance, 'ether')} ETH")
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ธ๋ก์ฒด์ธ์ ์ ๋๋ก ์ฐ๊ฒฐ๋๋์ง ํ์ธํ ์ ์์ด์! ๐
์ฐ๊ฒฐ์ด ์ ๋๋ฉด API ํค๋ ๋คํธ์ํฌ ์ค์ ์ ๋ค์ ํ์ธํด๋ณด์ธ์.
๐ Step 3: ์ปจํธ๋ํธ ABI ๋ก๋
์ค๋งํธ ์ปจํธ๋ํธ์ ์ํธ์์ฉํ๋ ค๋ฉด ABI(Application Binary Interface)๊ฐ ํ์ํด์.
ABI๋ ์ปจํธ๋ํธ์ ํจ์๋ค์ ์ด๋ป๊ฒ ํธ์ถํ๋์ง ์๋ ค์ฃผ๋ ์ผ์ข
์ ์ค๋ช
์์์ ๐
# ABI ํ์ผ ๋ก๋ (์ปจํธ๋ํธ ์ปดํ์ผ ์ ์์ฑ๋จ)
with open('contract_abi.json', 'r') as f:
contract_abi = json.load(f)
# ์ปจํธ๋ํธ ์ธ์คํด์ค ์์ฑ
contract = w3.eth.contract(
address=Web3.to_checksum_address(contract_address),
abi=contract_abi
)
print("๐ ์ปจํธ๋ํธ ๋ก๋ ์๋ฃ!")
print(f"์ปจํธ๋ํธ ์ฃผ์: {contract_address}")
๐ก ABI๋ ์ด๋์ ๊ตฌํ๋์?
Remix์์ ์ปจํธ๋ํธ๋ฅผ ์ปดํ์ผํ๋ฉด ABI๋ฅผ ๋ณต์ฌํ ์ ์์ด์.
๋๋ Hardhat/Truffle๋ก ๋ฐฐํฌํ๋ค๋ฉด artifacts ํด๋์์ ์ฐพ์ ์ ์์ต๋๋ค!
Etherscan์์ ๊ฒ์ฆ๋ ์ปจํธ๋ํธ์ ABI๋ ๋ค์ด๋ก๋ ๊ฐ๋ฅํด์ ๐
๐จ Step 4: ๋ฉํ๋ฐ์ดํฐ ์ค๋น
NFT์ ๋ฉํ๋ฐ์ดํฐ๋ ๋ณดํต JSON ํ์์ผ๋ก ์์ฑํด์.
์ด๋ฏธ์ง, ์ด๋ฆ, ์ค๋ช
, ์์ฑ ๋ฑ์ ์ ๋ณด๊ฐ ๋ค์ด๊ฐ์ฃ ! ๐ผ๏ธ
{
"name": "Cool NFT #1",
"description": "์ด๊ฒ์ ๋ฉ์ง NFT์
๋๋ค!",
"image": "ipfs://QmXxxx.../image.png",
"attributes": [
{
"trait_type": "๋ฐฐ๊ฒฝ",
"value": "ํ๋์"
},
{
"trait_type": "ํฌ๊ท๋",
"value": "๋ ์ด"
}
]
}
๋ฉํ๋ฐ์ดํฐ๋ IPFS(InterPlanetary File System)์ ์
๋ก๋ํ๋ ๊ฒ ์ผ๋ฐ์ ์ด์์.
IPFS๋ ๋ถ์ฐ ํ์ผ ์ ์ฅ ์์คํ
์ผ๋ก, ๋ฐ์ดํฐ๊ฐ ์๊ตฌ์ ์ผ๋ก ๋ณด์กด๋ผ์! ๐
Pinata๋ NFT.Storage ๊ฐ์ ์๋น์ค๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๊ฒ IPFS์ ์
๋ก๋ํ ์ ์์ด์.
import requests
def upload_to_ipfs(file_path):
"""ํ์ผ์ IPFS์ ์
๋ก๋ํ๊ณ CID ๋ฐํ"""
pinata_api_key = os.getenv('PINATA_API_KEY')
pinata_secret = os.getenv('PINATA_SECRET')
url = "https://api.pinata.cloud/pinning/pinFileToIPFS"
headers = {
'pinata_api_key': pinata_api_key,
'pinata_secret_api_key': pinata_secret
}
with open(file_path, 'rb') as f:
files = {'file': f}
response = requests.post(url, files=files, headers=headers)
if response.status_code == 200:
ipfs_hash = response.json()['IpfsHash']
print(f"โ
IPFS ์
๋ก๋ ์ฑ๊ณต: {ipfs_hash}")
return f"ipfs://{ipfs_hash}"
else:
print(f"โ ์
๋ก๋ ์คํจ: {response.text}")
return None
def create_metadata(name, description, image_uri, attributes):
"""๋ฉํ๋ฐ์ดํฐ JSON ์์ฑ"""
metadata = {
"name": name,
"description": description,
"image": image_uri,
"attributes": attributes
}
# ๋ฉํ๋ฐ์ดํฐ๋ฅผ ํ์ผ๋ก ์ ์ฅ
metadata_file = f"metadata_{name}.json"
with open(metadata_file, 'w', encoding='utf-8') as f:
json.dump(metadata, f, ensure_ascii=False, indent=2)
# IPFS์ ์
๋ก๋
metadata_uri = upload_to_ipfs(metadata_file)
return metadata_uri
๐ Step 5: NFT ๋ฐํ ํจ์ ์์ฑ
๋๋์ด NFT๋ฅผ ๋ฐํํ๋ ํต์ฌ ํจ์๋ฅผ ๋ง๋ค ์ฐจ๋ก์์! ๐
์ด ํจ์๋ ํธ๋์ญ์
์ ์์ฑํ๊ณ , ์๋ช
ํ๊ณ , ๋ธ๋ก์ฒด์ธ์ ์ ์กํ๋ ๋ชจ๋ ๊ณผ์ ์ ์ฒ๋ฆฌํด์.
def mint_nft(recipient_address, token_uri):
"""NFT๋ฅผ ๋ฐํํ๋ ํจ์"""
try:
# nonce ๊ฐ์ ธ์ค๊ธฐ (ํธ๋์ญ์
์์ ๋ฒํธ)
nonce = w3.eth.get_transaction_count(wallet_address)
# ๊ฐ์ค ๊ฐ๊ฒฉ ๊ฐ์ ธ์ค๊ธฐ
gas_price = w3.eth.gas_price
# ํธ๋์ญ์
๋น๋
transaction = contract.functions.mintNFT(
Web3.to_checksum_address(recipient_address),
token_uri
).build_transaction({
'from': wallet_address,
'nonce': nonce,
'gas': 300000, # ๊ฐ์ค ๋ฆฌ๋ฏธํธ
'gasPrice': gas_price
})
# ํธ๋์ญ์
์๋ช
signed_txn = w3.eth.account.sign_transaction(
transaction,
private_key=private_key
)
# ํธ๋์ญ์
์ ์ก
tx_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)
print(f"โณ ํธ๋์ญ์
์ ์ก๋จ: {tx_hash.hex()}")
print("๋ธ๋ก์ ํฌํจ๋ ๋๊น์ง ๋๊ธฐ ์ค...")
# ํธ๋์ญ์
์์์ฆ ๋๊ธฐ
tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
if tx_receipt['status'] == 1:
print(f"โ
NFT ๋ฐํ ์ฑ๊ณต!")
print(f"ํธ๋์ญ์
ํด์: {tx_hash.hex()}")
print(f"๊ฐ์ค ์ฌ์ฉ๋: {tx_receipt['gasUsed']}")
return tx_hash.hex()
else:
print("โ ํธ๋์ญ์
์คํจ")
return None
except Exception as e:
print(f"โ ์ค๋ฅ ๋ฐ์: {str(e)}")
return None
์ด ํจ์ ํ๋๋ก NFT ๋ฐํ์ด ๋๋์! ์ง์ง ๊ฐ๋จํ์ฃ ? ใ
ใ
ใ
๋ฌผ๋ก ์ค์ ๋ก๋ ์๋ฌ ์ฒ๋ฆฌ๋ ๊ฐ์ค๋น ์ต์ ํ ๊ฐ์ ๋ถ๋ถ์ ๋ ์ ๊ฒฝ ์จ์ผ ํด์.
๐ ๋๋ NFT ์๋ ๋ฐํ ์์คํ
์ด์ ์ฌ๋ฌ ๊ฐ์ NFT๋ฅผ ์๋์ผ๋ก ๋ฐํํ๋ ์์คํ
์ ๋ง๋ค์ด๋ณผ๊ฒ์! ๐ญ
CSV ํ์ผ์ด๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ ๋ณด๋ฅผ ์ฝ์ด์์ ๋ฐฐ์น๋ก ์ฒ๋ฆฌํ๋ ๋ฐฉ์์ด์์.
import csv
import time
from datetime import datetime
class NFTBatchMinter:
def __init__(self, contract, w3, wallet_address, private_key):
self.contract = contract
self.w3 = w3
self.wallet_address = wallet_address
self.private_key = private_key
self.success_count = 0
self.fail_count = 0
self.log_file = f"mint_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
def log(self, message):
"""๋ก๊ทธ ๊ธฐ๋ก"""
timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
log_message = f"[{timestamp}] {message}"
print(log_message)
with open(self.log_file, 'a', encoding='utf-8') as f:
f.write(log_message + '\n')
def mint_from_csv(self, csv_file):
"""CSV ํ์ผ์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด NFT ๋ฐํ"""
self.log(f"๐ CSV ํ์ผ ๋ก๋: {csv_file}")
with open(csv_file, 'r', encoding='utf-8') as f:
reader = csv.DictReader(f)
nft_data = list(reader)
total = len(nft_data)
self.log(f"๐ ์ด {total}๊ฐ์ NFT๋ฅผ ๋ฐํํฉ๋๋ค.")
for idx, row in enumerate(nft_data, 1):
self.log(f"\n{'='*50}")
self.log(f"๐จ [{idx}/{total}] NFT ๋ฐํ ์์")
try:
# ์ด๋ฏธ์ง ์
๋ก๋
image_uri = upload_to_ipfs(row['image_path'])
if not image_uri:
raise Exception("์ด๋ฏธ์ง ์
๋ก๋ ์คํจ")
# ์์ฑ ํ์ฑ
attributes = []
if 'attributes' in row:
attr_list = row['attributes'].split(';')
for attr in attr_list:
trait, value = attr.split(':')
attributes.append({
"trait_type": trait.strip(),
"value": value.strip()
})
# ๋ฉํ๋ฐ์ดํฐ ์์ฑ ๋ฐ ์
๋ก๋
metadata_uri = create_metadata(
name=row['name'],
description=row['description'],
image_uri=image_uri,
attributes=attributes
)
if not metadata_uri:
raise Exception("๋ฉํ๋ฐ์ดํฐ ์
๋ก๋ ์คํจ")
# NFT ๋ฐํ
tx_hash = mint_nft(row['recipient'], metadata_uri)
if tx_hash:
self.success_count += 1
self.log(f"โ
์ฑ๊ณต! TX: {tx_hash}")
else:
raise Exception("๋ฏผํ
์คํจ")
# ๊ฐ์ค๋น ์ ์ฝ์ ์ํ ๋๊ธฐ ์๊ฐ
if idx < total:
wait_time = 15 # 15์ด ๋๊ธฐ
self.log(f"โณ {wait_time}์ด ๋๊ธฐ ์ค...")
time.sleep(wait_time)
except Exception as e:
self.fail_count += 1
self.log(f"โ ์คํจ: {str(e)}")
continue
# ์ต์ข
๊ฒฐ๊ณผ
self.log(f"\n{'='*50}")
self.log(f"๐ ๋ฐํ ์๋ฃ!")
self.log(f"โ
์ฑ๊ณต: {self.success_count}๊ฐ")
self.log(f"โ ์คํจ: {self.fail_count}๊ฐ")
self.log(f"๐ ๋ก๊ทธ ํ์ผ: {self.log_file}")
# ์ฌ์ฉ ์์
if __name__ == "__main__":
minter = NFTBatchMinter(contract, w3, wallet_address, private_key)
minter.mint_from_csv('nft_data.csv')
CSV ํ์ผ์ ์ด๋ฐ ํ์์ผ๋ก ์์ฑํ๋ฉด ๋ผ์:
name,description,image_path,recipient,attributes
"Cool NFT #1","์ฒซ ๋ฒ์งธ NFT","./images/nft1.png","0xABC...","๋ฐฐ๊ฒฝ:ํ๋์;ํฌ๊ท๋:๋ ์ด"
"Cool NFT #2","๋ ๋ฒ์งธ NFT","./images/nft2.png","0xDEF...","๋ฐฐ๊ฒฝ:๋นจ๊ฐ์;ํฌ๊ท๋:์ปค๋จผ"
"Cool NFT #3","์ธ ๋ฒ์งธ NFT","./images/nft3.png","0xGHI...","๋ฐฐ๊ฒฝ:์ด๋ก์;ํฌ๊ท๋:์ํฝ"
โ ๏ธ ๊ฐ์ค๋น ์ฃผ์!
๋๋์ผ๋ก NFT๋ฅผ ๋ฐํํ ๋๋ ๊ฐ์ค๋น๊ฐ ์์ฒญ ๋ง์ด ๋์ฌ ์ ์์ด์! ๐ธ
๋คํธ์ํฌ๊ฐ ํผ์กํ์ง ์์ ์๊ฐ๋๋ฅผ ์ ํํ๊ณ , ๊ฐ์ค ๊ฐ๊ฒฉ์ ๋ชจ๋ํฐ๋งํ๋ฉด์ ๋ฐํํ๋ ๊ฒ ์ข์์.
๋ํ ๋ฐฐ์น ๋ฏผํ
(ํ ๋ฒ์ ์ฌ๋ฌ ๊ฐ ๋ฐํ) ๊ธฐ๋ฅ์ ์ปจํธ๋ํธ์ ๊ตฌํํ๋ฉด ๊ฐ์ค๋น๋ฅผ ํฌ๊ฒ ์ ์ฝํ ์ ์์ต๋๋ค! ๐ฏ
โก ์ฑ๋ฅ ์ต์ ํ ํ
NFT ๋ฐํ ์์คํ ์ ๋ ํจ์จ์ ์ผ๋ก ๋ง๋ค ์ ์๋ ๋ฐฉ๋ฒ๋ค์ ์๋ ค๋๋ฆด๊ฒ์! ๐
๐ฏ ์ต์ ํ ์ ๋ต
1. ๋ฐฐ์น ๋ฏผํ
๊ตฌํ
ํ ๋ฒ์ ํธ๋์ญ์
์ผ๋ก ์ฌ๋ฌ NFT๋ฅผ ๋ฐํํ๋ฉด ๊ฐ์ค๋น๋ฅผ ์ต๋ 70%๊น์ง ์ ์ฝํ ์ ์์ด์!
2. ๊ฐ์ค ๊ฐ๊ฒฉ ๋ชจ๋ํฐ๋ง
w3.eth.gas_price๋ก ํ์ฌ ๊ฐ์ค ๊ฐ๊ฒฉ์ ํ์ธํ๊ณ , ๋๋ฌด ๋์ผ๋ฉด ๋๊ธฐํ๋ ๋ก์ง์ ์ถ๊ฐํ์ธ์.
3. ๋
ผ์ค(Nonce) ๊ด๋ฆฌ
์ฌ๋ฌ ํธ๋์ญ์
์ ๋์์ ๋ณด๋ผ ๋๋ ๋
ผ์ค๋ฅผ ์๋์ผ๋ก ๊ด๋ฆฌํด์ผ ํด์. ๊ทธ๋์ผ ํธ๋์ญ์
์ด ๊ผฌ์ด์ง ์์์!
4. ๋ฉํฐ์ค๋ ๋ฉ
IPFS ์
๋ก๋ ๊ฐ์ I/O ์์
์ ๋ฉํฐ์ค๋ ๋ฉ์ผ๋ก ๋ณ๋ ฌ ์ฒ๋ฆฌํ๋ฉด ์๊ฐ์ ํฌ๊ฒ ๋จ์ถํ ์ ์์ด์.
5. ์ฌ์๋ ๋ก์ง
๋คํธ์ํฌ ์ค๋ฅ๋ ์ผ์์ ์ธ ๋ฌธ์ ๋ก ์คํจํ ๊ฒฝ์ฐ ์๋์ผ๋ก ์ฌ์๋ํ๋ ๋ก์ง์ ์ถ๊ฐํ์ธ์! ๐ช
def wait_for_low_gas(max_gwei=50, check_interval=60):
"""๊ฐ์ค ๊ฐ๊ฒฉ์ด ๋ฎ์์ง ๋๊น์ง ๋๊ธฐ"""
while True:
gas_price = w3.eth.gas_price
gas_gwei = w3.from_wei(gas_price, 'gwei')
print(f"โฝ ํ์ฌ ๊ฐ์ค ๊ฐ๊ฒฉ: {gas_gwei:.2f} Gwei")
if gas_gwei <= max_gwei:
print(f"โ
๊ฐ์ค ๊ฐ๊ฒฉ์ด ์ ์ ์์ค์
๋๋ค!")
return gas_price
else:
print(f"โณ ๊ฐ์ค ๊ฐ๊ฒฉ์ด ๋๋ฌด ๋์ต๋๋ค. {check_interval}์ด ํ ์ฌํ์ธ...")
time.sleep(check_interval)
# ์ฌ์ฉ ์์
optimal_gas_price = wait_for_low_gas(max_gwei=30)
print(f"๋ฐํ์ ์์ํฉ๋๋ค! (๊ฐ์ค ๊ฐ๊ฒฉ: {w3.from_wei(optimal_gas_price, 'gwei')} Gwei)")
๐ก๏ธ ๋ณด์ ๊ณ ๋ ค์ฌํญ
NFT ๋ฐํ ์์คํ
์ ์ด์ํ ๋๋ ๋ณด์์ด ์ ๋ง ์ค์ํด์! ๐
ํ ๋ฒ ์ค์ํ๋ฉด ํฐ ์์ค๋ก ์ด์ด์ง ์ ์์ผ๋๊น์ ใ
ใ
๐ ํ์ ๋ณด์ ์ฒดํฌ๋ฆฌ์คํธ
โ
๊ฐ์ธํค ๊ด๋ฆฌ
โข ์ ๋ ์ฝ๋์ ํ๋์ฝ๋ฉํ์ง ๋ง ๊ฒ
โข ํ๊ฒฝ๋ณ์๋ ์ํธํ๋ ํค ์ ์ฅ์ ์ฌ์ฉ
โข ํ๋ก๋์
ํ๊ฒฝ์์๋ AWS KMS, HashiCorp Vault ๊ฐ์ ์ ๋ฌธ ์๋ฃจ์
๊ณ ๋ ค
โ
๊ถํ ๊ด๋ฆฌ
โข ์ค๋งํธ ์ปจํธ๋ํธ์ onlyOwner ๊ฐ์ ์ ๊ทผ ์ ์ด ๊ตฌํ
โข ๋ฐํ ๊ถํ์ ๊ฐ์ง ์ฃผ์๋ฅผ ํ์ดํธ๋ฆฌ์คํธ๋ก ๊ด๋ฆฌ
โ
ํธ๋์ญ์
๊ฒ์ฆ
โข ๋ฐํ ์ ์ ์์ ์ ์ฃผ์๊ฐ ์ ํจํ์ง ํ์ธ
โข ๋ฉํ๋ฐ์ดํฐ URI๊ฐ ์ฌ๋ฐ๋ฅธ์ง ๊ฒ์ฆ
โข ์ค๋ณต ๋ฐํ ๋ฐฉ์ง ๋ก์ง ๊ตฌํ
โ
์๋ฌ ์ฒ๋ฆฌ
โข ๋ชจ๋ ์์ธ ์ํฉ์ ๋ํ ์ฒ๋ฆฌ ๋ก์ง ์์ฑ
โข ์คํจํ ํธ๋์ญ์
๋ก๊ทธ ์ ์ฅ ๋ฐ ์๋ฆผ
โข ์๋ ๋กค๋ฐฑ ๋ฉ์ปค๋์ฆ ๊ตฌํ
def safe_mint_nft(recipient, token_uri, max_retries=3):
"""์ฌ์๋ ๋ก์ง์ด ํฌํจ๋ ์์ ํ NFT ๋ฐํ"""
# ์ฃผ์ ๊ฒ์ฆ
if not w3.is_address(recipient):
raise ValueError(f"์ ํจํ์ง ์์ ์ฃผ์: {recipient}")
# URI ๊ฒ์ฆ
if not token_uri.startswith(('ipfs://', 'https://')):
raise ValueError(f"์ ํจํ์ง ์์ URI: {token_uri}")
for attempt in range(max_retries):
try:
print(f"๐ ์๋ {attempt + 1}/{max_retries}")
# ์์ก ํ์ธ
balance = w3.eth.get_balance(wallet_address)
if balance < w3.to_wei(0.01, 'ether'):
raise Exception("์์ก ๋ถ์กฑ! ์ต์ 0.01 ETH ํ์")
# ๊ฐ์ค ์ถ์
estimated_gas = contract.functions.mintNFT(
Web3.to_checksum_address(recipient),
token_uri
).estimate_gas({'from': wallet_address})
print(f"โฝ ์์ ๊ฐ์ค: {estimated_gas}")
# ์ค์ ๋ฐํ
tx_hash = mint_nft(recipient, token_uri)
if tx_hash:
return tx_hash
except Exception as e:
print(f"โ ์ค๋ฅ: {str(e)}")
if attempt < max_retries - 1:
wait_time = (attempt + 1) * 10
print(f"โณ {wait_time}์ด ํ ์ฌ์๋...")
time.sleep(wait_time)
else:
print("โ ์ต๋ ์ฌ์๋ ํ์ ์ด๊ณผ")
raise
return None
๐ ๋ชจ๋ํฐ๋ง๊ณผ ๋ก๊น
๋๋ ๋ฐํ ์์คํ
์ ์ด์ํ๋ ค๋ฉด ์ค์๊ฐ ๋ชจ๋ํฐ๋ง์ด ํ์์์! ๐
๋ญ๊ฐ ๋ฌธ์ ๊ฐ ์๊ฒผ์ ๋ ๋น ๋ฅด๊ฒ ๋์ํ ์ ์๊ฑฐ๋ ์.
import logging
from logging.handlers import RotatingFileHandler
class NFTLogger:
def __init__(self, log_dir='logs'):
os.makedirs(log_dir, exist_ok=True)
# ๋ก๊ฑฐ ์ค์
self.logger = logging.getLogger('NFTMinter')
self.logger.setLevel(logging.DEBUG)
# ํ์ผ ํธ๋ค๋ฌ (์๋ ๋กํ
์ด์
)
file_handler = RotatingFileHandler(
f'{log_dir}/nft_minter.log',
maxBytes=10*1024*1024, # 10MB
backupCount=5
)
file_handler.setLevel(logging.DEBUG)
# ์ฝ์ ํธ๋ค๋ฌ
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
# ํฌ๋งท ์ค์
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
self.logger.addHandler(file_handler)
self.logger.addHandler(console_handler)
def info(self, message):
self.logger.info(message)
def error(self, message):
self.logger.error(message)
def warning(self, message):
self.logger.warning(message)
def debug(self, message):
self.logger.debug(message)
# ์ฌ์ฉ ์์
logger = NFTLogger()
logger.info("โ
NFT ๋ฐํ ์์คํ
์์")
logger.error("โ ํธ๋์ญ์
์คํจ: ๊ฐ์ค ๋ถ์กฑ")
๐จ ์ค์ ํ๋ก์ ํธ: ์ ๋๋ ์ดํฐ๋ธ NFT ์ปฌ๋ ์
์ด์ ๋ฐฐ์ด ๋ด์ฉ์ ์ข
ํฉํด์ ์ค์ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ณผ๊น์? ๐
์ ๋๋ ์ดํฐ๋ธ ์ํธ NFT ์ปฌ๋ ์
์ ์๋์ผ๋ก ์์ฑํ๊ณ ๋ฐํํ๋ ์์คํ
์ด์์!
์์ฆ ์ ํํ๋ ํ๋กํ ์ฌ์ง NFT์ฒ๋ผ, ์ฌ๋ฌ ๋ ์ด์ด๋ฅผ ์กฐํฉํด์ ๊ณ ์ ํ ์ด๋ฏธ์ง๋ฅผ ๋ง๋๋ ๊ฑฐ์ฃ ๐จ
from PIL import Image
import random
import os
class GenerativeNFTCreator:
def __init__(self, layers_dir, output_dir):
self.layers_dir = layers_dir
self.output_dir = output_dir
os.makedirs(output_dir, exist_ok=True)
# ๋ ์ด์ด ๋ก๋
self.layers = {
'background': self.load_layer_images('background'),
'body': self.load_layer_images('body'),
'eyes': self.load_layer_images('eyes'),
'mouth': self.load_layer_images('mouth'),
'accessory': self.load_layer_images('accessory')
}
def load_layer_images(self, layer_name):
"""ํน์ ๋ ์ด์ด์ ๋ชจ๋ ์ด๋ฏธ์ง ๋ก๋"""
layer_path = os.path.join(self.layers_dir, layer_name)
images = {}
for filename in os.listdir(layer_path):
if filename.endswith('.png'):
name = filename.replace('.png', '')
images[name] = os.path.join(layer_path, filename)
return images
def generate_nft(self, token_id):
"""NFT ์ด๋ฏธ์ง ์์ฑ"""
# ๊ฐ ๋ ์ด์ด์์ ๋๋ค ์ ํ
selected = {}
attributes = []
for layer_name, layer_images in self.layers.items():
choice = random.choice(list(layer_images.keys()))
selected[layer_name] = layer_images[choice]
attributes.append({
"trait_type": layer_name.capitalize(),
"value": choice
})
# ์ด๋ฏธ์ง ํฉ์ฑ
base = Image.open(selected['background']).convert('RGBA')
for layer in ['body', 'eyes', 'mouth', 'accessory']:
layer_img = Image.open(selected[layer]).convert('RGBA')
base = Image.alpha_composite(base, layer_img)
# ์ ์ฅ
output_path = os.path.join(self.output_dir, f'nft_{token_id}.png')
base.save(output_path, 'PNG')
return output_path, attributes
def generate_collection(self, count):
"""์ปฌ๋ ์
์์ฑ"""
collection_data = []
for i in range(1, count + 1):
print(f"๐จ NFT #{i} ์์ฑ ์ค...")
image_path, attributes = self.generate_nft(i)
collection_data.append({
'token_id': i,
'name': f'Awesome NFT #{i}',
'description': f'์ ๋๋ ์ดํฐ๋ธ NFT ์ปฌ๋ ์
์ {i}๋ฒ์งธ ์ํ',
'image_path': image_path,
'attributes': attributes
})
return collection_data
# ์ฌ์ฉ ์์
creator = GenerativeNFTCreator(
layers_dir='./layers',
output_dir='./generated_nfts'
)
# 100๊ฐ์ NFT ์์ฑ
collection = creator.generate_collection(100)
print(f"โ
{len(collection)}๊ฐ์ NFT ์ด๋ฏธ์ง ์์ฑ ์๋ฃ!")
์ด๋ ๊ฒ ์์ฑ๋ ์ด๋ฏธ์ง๋ค์ ์์์ ๋ง๋ ๋ฐฐ์น ๋ฏผํ
์์คํ
๊ณผ ์ฐ๊ฒฐํ๋ฉด ์์ ์๋ํ๊ฐ ๊ฐ๋ฅํด์! ๐
์ง์ง ๋ฉ์ง์ง ์๋์? ใ
ใ
ใ
๐ ์ฌ๋ฅ๋ท์์ NFT ๊ฐ๋ฐ ์ฌ๋ฅ ๊ณต์ ํ๊ธฐ
์ฌ๊ธฐ๊น์ง ๋ฐ๋ผ์ค๋๋ผ ์๊ณ ๋ง์ผ์
จ์ด์! ๐
์ด์ ์ฌ๋ฌ๋ถ๋ NFT ์๋ ๋ฐํ ์์คํ
์ ๊ตฌ์ถํ ์ ์๋ ๋ฅ๋ ฅ์ ๊ฐ์ถ์
จ์ด์!
ํน์ ์ด๋ฐ ๊ธฐ์ ์ ๋ ๋ฐฐ์ฐ๊ณ ์ถ๊ฑฐ๋, ๋ฐ๋๋ก ๋ค๋ฅธ ์ฌ๋๋ค์๊ฒ ๊ฐ๋ฅด์ณ์ฃผ๊ณ ์ถ๋ค๋ฉด
์ฌ๋ฅ๋ท(https://www.jaenung.net)์ ํ์ฉํด๋ณด๋ ๊ฑด ์ด๋จ๊น์? ๐ก
์ฌ๋ฅ๋ท์์๋ ๋ธ๋ก์ฒด์ธ ๊ฐ๋ฐ, NFT ํ๋ก์ ํธ ์ปจ์คํ
, ์ค๋งํธ ์ปจํธ๋ํธ ์์ฑ ๋ฑ
๋ค์ํ Web3 ๊ด๋ จ ์ฌ๋ฅ์ ๊ฑฐ๋ํ ์ ์์ด์!
์ฌ๋ฌ๋ถ์ด ๋ฐฐ์ด ์ง์์ ๋ค๋ฅธ ์ฌ๋๋ค๊ณผ ๋๋๋ฉด์ ์์ต๋ ์ฐฝ์ถํ ์ ์๊ณ ,
๋ฐ๋๋ก ๋ ๊ณ ๊ธ ๊ธฐ์ ์ด ํ์ํ ๋๋ ์ ๋ฌธ๊ฐ์ ๋์์ ๋ฐ์ ์๋ ์์ฃ ๐
๐ผ ์ฌ๋ฅ๋ท์์ ๊ฑฐ๋ ๊ฐ๋ฅํ NFT ๊ด๋ จ ์ฌ๋ฅ
โข NFT ์ค๋งํธ ์ปจํธ๋ํธ ๊ฐ๋ฐ ๋ฐ ๋ฐฐํฌ ๐ง
โข ์ ๋๋ ์ดํฐ๋ธ ์ํธ ์ปฌ๋ ์
์ ์ ๐จ
โข NFT ๋ง์ผํ๋ ์ด์ค ๊ตฌ์ถ ๐ช
โข ๋ฉํ๋ฐ์ดํฐ ์ต์ ํ ๋ฐ IPFS ์ค์ ๐
โข ๊ฐ์ค๋น ์ต์ ํ ์ปจ์คํ
โฝ
โข NFT ํ๋ก์ ํธ ๊ธฐํ ๋ฐ ๋ง์ผํ
์ ๋ต ๐
โข ๋ธ๋ก์ฒด์ธ ๊ต์ก ๋ฐ ๋ฉํ ๋ง ๐จโ๐ซ
๐ ์ถ๊ฐ ํ์ต ๋ฆฌ์์ค
NFT ๊ฐ๋ฐ์ ๋ ๊น์ด ๊ณต๋ถํ๊ณ ์ถ๋ค๋ฉด ์ด๋ฐ ๊ฒ๋ค์ ์ฐธ๊ณ ํด๋ณด์ธ์! ๐
๐ ์ถ์ฒ ํ์ต ์๋ฃ
๊ณต์ ๋ฌธ์
โข web3.py ๊ณต์ ๋ฌธ์: ๊ฐ์ฅ ์ ํํ๊ณ ์ต์ ์ ๋ณด
โข OpenZeppelin ๋ฌธ์: ์์ ํ ์ค๋งํธ ์ปจํธ๋ํธ ์์ฑ๋ฒ
โข Ethereum.org: ์ด๋๋ฆฌ์ ๊ธฐ์ด๋ถํฐ ๊ณ ๊ธ๊น์ง
์ปค๋ฎค๋ํฐ
โข Stack Overflow: ๋งํ ๋ ์ง๋ฌธํ๊ธฐ ์ข์ ๊ณณ
โข Reddit r/ethdev: ๊ฐ๋ฐ์๋ค์ ํ ๋ก
โข Discord ์๋ฒ๋ค: ์ค์๊ฐ ์ํต ๊ฐ๋ฅ
์ค์ต ํ๋ซํผ
โข Remix IDE: ๋ธ๋ผ์ฐ์ ์์ ๋ฐ๋ก ์ปจํธ๋ํธ ์์ฑ
โข Hardhat: ํ๋กํ์
๋ํ ๊ฐ๋ฐ ํ๊ฒฝ
โข Tenderly: ํธ๋์ญ์
๋๋ฒ๊น
๋๊ตฌ
๐ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์... ์ฌ๊ธฐ๊น์ง ์ ๋ง ๊ธด ์ฌ์ ์ด์๋ค์! ๐
ํ์ด์ฌ๊ณผ web3.py๋ฅผ ์ฌ์ฉํด์ NFT ์๋ ๋ฐํ ์์คํ
์ ๊ตฌ์ถํ๋ ๋ฐฉ๋ฒ์ ์์๋ดค์ด์.
์ฒ์์๋ ๋ณต์กํด ๋ณด์ผ ์ ์์ง๋ง, ํ๋์ฉ ๋ฐ๋ผํ๋ค ๋ณด๋ฉด ์๊ฐ๋ณด๋ค ์ด๋ ต์ง ์์์!
์ค์ํ ๊ฑด ๊พธ์คํ ์ค์ตํ๊ณ , ์คํจ๋ฅผ ๋๋ ค์ํ์ง ์๋ ๊ฒ์ด์์ ๐ช
ํ
์คํธ๋ท์์ ์ถฉ๋ถํ ์ฐ์ตํ ํ์ ๋ฉ์ธ๋ท์ผ๋ก ๋์ด๊ฐ๊ณ ,
๋ณด์์ ํญ์ ์ ๊ฒฝ ์ฐ๋ฉด์ ๊ฐ๋ฐํ๋ ์ต๊ด์ ๋ค์ด์ธ์!
๊ทธ๋ฆฌ๊ณ ํผ์ ํ๊ธฐ ํ๋ค ๋๋ ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์ ํ์ฉํด์
๋ค๋ฅธ ๊ฐ๋ฐ์๋ค๊ณผ ํ์
ํ๊ฑฐ๋ ๋์์ ๋ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์์ ๐ค
๐ฏ ํต์ฌ ์์ฝ
โ
web3.py๋ก ๋ธ๋ก์ฒด์ธ๊ณผ ์ฐ๊ฒฐํ๊ณ ์ค๋งํธ ์ปจํธ๋ํธ ํธ์ถ
โ
IPFS์ ์ด๋ฏธ์ง์ ๋ฉํ๋ฐ์ดํฐ ์
๋ก๋
โ
ํธ๋์ญ์
์์ฑ, ์๋ช
, ์ ์ก์ ์ ์ฒด ํ๋ก์ธ์ค
โ
๋๋ ๋ฐํ์ ์ํ ๋ฐฐ์น ์์คํ
๊ตฌ์ถ
โ
๊ฐ์ค๋น ์ต์ ํ์ ์๋ฌ ์ฒ๋ฆฌ
โ
๋ณด์ ๊ณ ๋ ค์ฌํญ๊ณผ ๋ชจ๋ํฐ๋ง
โ
์ ๋๋ ์ดํฐ๋ธ NFT ์ปฌ๋ ์
์๋ ์์ฑ
์ด์ ์ฌ๋ฌ๋ถ๋ NFT ๊ฐ๋ฐ์๊ฐ ๋ ์ค๋น๊ฐ ๋์์ด์! ๐
Happy Coding! ์ฆ๊ฑฐ์ด NFT ๊ฐ๋ฐ ๋์ธ์! ๐โจ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.