Art NFT Marketplace

Art NFT Marketplace Platform

Developed a comprehensive NFT marketplace for art trading on two major blockchain networks (Klaytn and Ethereum), featuring innovative royalty distribution systems and full-stack implementation.

---

Klaytn Chain Implementation

Royalty Distribution System

Implemented sophisticated on-chain royalty mechanism using Caver.java library.

// Royalty Distribution Logic
public class RoyaltyDistributor {
    private final Caver caver;
    private final String marketplaceContract;
    
    public void distributeSaleProceeds(
        String nftContract,
        BigInteger tokenId,
        BigInteger salePrice
    ) {
        // Fetch royalty info from NFT contract
        RoyaltyInfo royalty = getRoyaltyInfo(nftContract, tokenId, salePrice);
        
        // Calculate distributions
        BigInteger creatorAmount = salePrice
            .multiply(royalty.percentage)
            .divide(BigInteger.valueOf(10000));
        BigInteger platformFee = salePrice
            .multiply(PLATFORM_FEE_PERCENT)
            .divide(BigInteger.valueOf(10000));
        BigInteger sellerAmount = salePrice
            .subtract(creatorAmount)
            .subtract(platformFee);
        
        // Execute transfers
        transferKLAY(royalty.creator, creatorAmount);
        transferKLAY(platformAddress, platformFee);
        transferKLAY(seller, sellerAmount);
    }
}

Smart Contract Architecture

Developed ERC-721 compatible NFT contracts with royalty support:

• KIP-17 Standard: Klaytn's NFT standard implementation
• On-Chain Metadata: Artwork information stored on-chain for permanence
• Batch Minting: Gas-optimized batch minting for artists with collections

---

Ethereum Chain Implementation

Mandatory Royalty Enforcement

Designed a novel smart contract mechanism that enforces creator royalties at the protocol level.

// Mandatory Royalty NFT Market
contract ArtMarketplace {
    struct Sale {
        address seller;
        uint256 price;
        bool active;
    }
    
    mapping(address => mapping(uint256 => Sale)) public listings;
    mapping(address => uint256) public creatorRoyaltyPercent;
    
    function buyNFT(address nftContract, uint256 tokenId) 
        external 
        payable 
    {
        Sale memory sale = listings[nftContract][tokenId];
        require(sale.active, "Not for sale");
        require(msg.value >= sale.price, "Insufficient payment");
        
        // Calculate and enforce royalty
        address creator = IERC721(nftContract).getCreator(tokenId);
        uint256 royaltyAmount = (sale.price * creatorRoyaltyPercent[creator]) / 10000;
        uint256 platformFee = (sale.price * 250) / 10000; // 2.5%
        uint256 sellerProceeds = sale.price - royaltyAmount - platformFee;
        
        // Atomic transfers
        payable(creator).transfer(royaltyAmount);
        payable(platformAddress).transfer(platformFee);
        payable(sale.seller).transfer(sellerProceeds);
        
        // Transfer NFT
        IERC721(nftContract).safeTransferFrom(sale.seller, msg.sender, tokenId);
        
        delete listings[nftContract][tokenId];
    }
}

EIP-1559 Gas Optimization

Implemented advanced gas estimation and optimization strategies:

// Dynamic Gas Estimation with EIP-1559
async function estimateOptimalGas(transaction) {
    // Fetch current network conditions
    const latestBlock = await web3.eth.getBlock('latest');
    const baseFee = BigInt(latestBlock.baseFeePerGas);
    
    // Calculate priority fee based on network congestion
    const pendingBlock = await web3.eth.getBlock('pending');
    const congestionRatio = pendingBlock.transactions.length / latestBlock.gasLimit;
    
    let priorityFee;
    if (congestionRatio > 0.9) {
        priorityFee = web3.utils.toWei('3', 'gwei'); // High congestion
    } else if (congestionRatio > 0.5) {
        priorityFee = web3.utils.toWei('1.5', 'gwei'); // Medium
    } else {
        priorityFee = web3.utils.toWei('1', 'gwei'); // Low
    }
    
    // Calculate maxFeePerGas with buffer
    const maxFee = (baseFee * 2n) + BigInt(priorityFee);
    
    return {
        maxPriorityFeePerGas: priorityFee,
        maxFeePerGas: maxFee.toString(),
        gasLimit: await estimateGasLimit(transaction)
    };
}

Gas Optimization Results:

• Average transaction cost reduced by 25% compared to legacy pricing
• 95% success rate during network congestion
• Dynamic adjustment based on real-time network conditions

---

Backend System Architecture

Wallet Management Service

Implemented secure wallet generation and key management:

// Secure Wallet Service
public class WalletService {
    private final KeyManagementService kms;
    
    public Wallet createWallet(String userId) {
        // Generate new key pair
        ECKeyPair keyPair = Keys.createEcKeyPair();
        String address = Keys.getAddress(keyPair.getPublicKey());
        
        // Encrypt private key
        String encryptedPrivateKey = kms.encrypt(
            keyPair.getPrivateKey().toString(16),
            userId
        );
        
        // Store in database
        walletRepository.save(new WalletEntity(
            userId,
            address,
            encryptedPrivateKey
        ));
        
        return new Wallet(address, keyPair);
    }
    
    public Transaction signTransaction(
        String userId,
        RawTransaction rawTx
    ) {
        String encryptedKey = walletRepository.getPrivateKey(userId);
        String privateKey = kms.decrypt(encryptedKey, userId);
        
        Credentials credentials = Credentials.create(privateKey);
        byte[] signedTx = TransactionEncoder.signMessage(rawTx, credentials);
        
        return new Transaction(Numeric.toHexString(signedTx));
    }
}

NFT Marketplace API

Designed RESTful API server supporting all marketplace operations:

• Minting: POST /api/nft/mint
• Listing: POST /api/marketplace/list
• Buying: POST /api/marketplace/buy
• Transfers: POST /api/nft/transfer
• Metadata: GET /api/nft/{contract}/{tokenId}

Database Design

PostgreSQL schema for marketplace data:

-- NFT Metadata Table
CREATE TABLE nft_metadata (
    id SERIAL PRIMARY KEY,
    contract_address VARCHAR(42) NOT NULL,
    token_id NUMERIC NOT NULL,
    name VARCHAR(255),
    description TEXT,
    image_uri TEXT,
    creator_address VARCHAR(42),
    royalty_percent INTEGER DEFAULT 1000, -- 10%
    created_at TIMESTAMP DEFAULT NOW(),
    UNIQUE(contract_address, token_id)
);

-- Marketplace Listings
CREATE TABLE marketplace_listings (
    id SERIAL PRIMARY KEY,
    contract_address VARCHAR(42) NOT NULL,
    token_id NUMERIC NOT NULL,
    seller_address VARCHAR(42) NOT NULL,
    price NUMERIC NOT NULL,
    status VARCHAR(20) DEFAULT 'active',
    listed_at TIMESTAMP DEFAULT NOW(),
    sold_at TIMESTAMP
);

-- Transaction History
CREATE TABLE transaction_history (
    id SERIAL PRIMARY KEY,
    tx_hash VARCHAR(66) UNIQUE,
    contract_address VARCHAR(42),
    token_id NUMERIC,
    from_address VARCHAR(42),
    to_address VARCHAR(42),
    price NUMERIC,
    royalty_paid NUMERIC,
    platform_fee NUMERIC,
    tx_type VARCHAR(20), -- 'mint', 'sale', 'transfer'
    block_number BIGINT,
    timestamp TIMESTAMP
);

---

Frontend Development

Built full-featured marketplace UI with React:

• Artist Portal: Upload artwork, set royalties, mint NFTs
• Gallery View: Browse collections with filters
• Auction System: Timed auctions with bid tracking
• Wallet Integration: MetaMask and Kaikas wallet support
• Real-time Updates: WebSocket for live price changes

---

Technical Achievements