Art NFT Marketplace

Art NFT Marketplace Platform

Klaytn Chain Implementation

Royalty Distribution System

java
// 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

• ▶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

solidity
// 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

javascript
// 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)
    };
}

• ▶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

java
// 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

• ▶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

sql
-- 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

• ▶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