LINE Blockchain & Web3 Development: Kaia Network, NFT & Smart Contracts Guide

Network: Kaia Mainnet (Chain ID: 8217)
Consensus: Istanbul BFT (based on PBFT)
Block Time: ~1 second
Finality: Immediate (single block)
TPS: 4,000+
EVM Compatible: Yes (Solidity smart contracts)
Token Standard: KIP-7 (fungible), KIP-17 (NFT), KIP-37 (multi-token)

Application Layer
├── LINE Mini Apps (LIFF + Web3)
├── DOSI NFT Marketplace
├── LINE BITMAX Exchange
└── Third-party dApps

Middleware Layer
├── Kaia SDK / caver.js
├── LINE Blockchain API
├── Oracle Services
└── Cross-chain Bridges

Consensus Layer
├── Istanbul BFT Consensus
├── Validator Committee (Governance Council)
└── Block Proposer Selection

Data Layer
├── State Trie (Account & Contract State)
├── Transaction Pool
└── Block Storage

# Install Kaia SDK
npm install @kaiachain/web3js-ext
npm install @kaiachain/ethers-ext

# Install additional tools
npm install ethers hardhat dotenv

// hardhat.config.ts
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import * as dotenv from "dotenv";

dotenv.config();

const config: HardhatUserConfig = {
  solidity: "0.8.24",
  networks: {
    kairos: {
      url: "https://public-en-kairos.node.kaia.io",
      chainId: 1001,
      accounts: [process.env.DEPLOYER_PRIVATE_KEY!],
      gasPrice: 250000000000,
    },
    kaia: {
      url: "https://public-en.node.kaia.io",
      chainId: 8217,
      accounts: [process.env.DEPLOYER_PRIVATE_KEY!],
      gasPrice: 250000000000,
    },
  },
};

export default config;

// contracts/LineRewardToken.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@kaiachain/contracts/KIP/token/KIP7/KIP7.sol";
import "@kaiachain/contracts/access/Ownable.sol";

contract LineRewardToken is KIP7, Ownable {
    uint256 public constant MAX_SUPPLY = 1_000_000 * 10**18;

    constructor()
        KIP7("LINE Reward Token", "LRT")
        Ownable(msg.sender)
    {
        _mint(msg.sender, MAX_SUPPLY);
    }

    function reward(address to, uint256 amount) external onlyOwner {
        _transfer(msg.sender, to, amount);
    }

    function supportsInterface(bytes4 interfaceId)
        public view virtual override returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

// lib/blockchain.ts
import { ethers } from "ethers";
import { Web3 } from "@kaiachain/web3js-ext";

const KAIA_RPC = "https://public-en.node.kaia.io";
const CONTRACT_ADDRESS = process.env.NEXT_PUBLIC_CONTRACT_ADDRESS!;

export function getProvider() {
  return new ethers.JsonRpcProvider(KAIA_RPC);
}

export async function connectWallet() {
  if (typeof window === "undefined") return null;

  // Check if LINE BITMAX Wallet is available
  const provider = (window as any).kaia;
  if (!provider) {
    throw new Error("Kaia wallet not found. Please install LINE BITMAX Wallet.");
  }

  const accounts = await provider.request({
    method: "eth_requestAccounts",
  });

  return accounts[0];
}

export async function getTokenBalance(address: string): Promise<string> {
  const provider = getProvider();
  const abi = ["function balanceOf(address) view returns (uint256)"];
  const contract = new ethers.Contract(CONTRACT_ADDRESS, abi, provider);
  const balance = await contract.balanceOf(address);
  return ethers.formatEther(balance);
}

// components/BlockchainWallet.tsx
"use client";

import { useState, useEffect } from "react";
import { connectWallet, getTokenBalance } from "@/lib/blockchain";
import { useLiff } from "@/components/LiffProvider";

export function BlockchainWallet() {
  const { profile } = useLiff();
  const [address, setAddress] = useState<string | null>(null);
  const [balance, setBalance] = useState<string>("0");

  async function handleConnect() {
    try {
      const wallet = await connectWallet();
      setAddress(wallet);
      if (wallet) {
        const bal = await getTokenBalance(wallet);
        setBalance(bal);
      }
    } catch (error) {
      console.error("Wallet connection failed:", error);
    }
  }

  return (
    <div className="p-4 rounded-lg border">
      <h3 className="font-bold text-lg">
        Welcome, {profile?.displayName}
      </h3>
      {address ? (
        <div className="mt-2 space-y-2">
          <p className="text-sm text-gray-500">
            Wallet: {address.slice(0, 6)}...{address.slice(-4)}
          </p>
          <p className="text-xl font-bold">{balance} LRT</p>
        </div>
      ) : (
        <button onClick={handleConnect} className="btn-primary mt-2">
          Connect Wallet
        </button>
      )}
    </div>
  );
}

// contracts/LineNFTCollection.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@kaiachain/contracts/KIP/token/KIP17/KIP17.sol";
import "@kaiachain/contracts/KIP/token/KIP17/extensions/KIP17URIStorage.sol";
import "@kaiachain/contracts/access/Ownable.sol";
import "@kaiachain/contracts/utils/Counters.sol";

contract LineNFTCollection is KIP17, KIP17URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIdCounter;

    uint256 public mintPrice = 5 ether; // 5 KAIA
    uint256 public maxSupply = 10000;
    string private _baseTokenURI;

    constructor(string memory baseURI)
        KIP17("LINE Digital Collectible", "LDC")
        Ownable(msg.sender)
    {
        _baseTokenURI = baseURI;
    }

    function mint(address to) external payable {
        require(msg.value >= mintPrice, "Insufficient payment");
        require(_tokenIdCounter.current() < maxSupply, "Max supply reached");

        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        _safeMint(to, tokenId);
    }

    function tokenURI(uint256 tokenId)
        public view override(KIP17, KIP17URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public view override(KIP17, KIP17URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

// lib/nft.ts
import { ethers } from "ethers";

const NFT_ABI = [
  "function mint(address to) external payable",
  "function totalSupply() view returns (uint256)",
  "function tokenURI(uint256) view returns (string)",
  "function balanceOf(address) view returns (uint256)",
];

export async function mintNFT(contractAddress: string) {
  const provider = (window as any).kaia;
  if (!provider) throw new Error("Wallet not connected");

  const web3Provider = new ethers.BrowserProvider(provider);
  const signer = await web3Provider.getSigner();
  const contract = new ethers.Contract(contractAddress, NFT_ABI, signer);

  const tx = await contract.mint(await signer.getAddress(), {
    value: ethers.parseEther("5"),
  });

  const receipt = await tx.wait();
  return receipt;
}

// services/rewards.ts
import { ethers } from "ethers";

interface RewardConfig {
  contractAddress: string;
  privateKey: string;
  rpcUrl: string;
}

export class RewardService {
  private contract: ethers.Contract;
  private wallet: ethers.Wallet;

  constructor(config: RewardConfig) {
    const provider = new ethers.JsonRpcProvider(config.rpcUrl);
    this.wallet = new ethers.Wallet(config.privateKey, provider);

    const abi = [
      "function reward(address to, uint256 amount) external",
      "function balanceOf(address) view returns (uint256)",
    ];

    this.contract = new ethers.Contract(
      config.contractAddress,
      abi,
      this.wallet
    );
  }

  async distributeReward(
    userAddress: string,
    amount: number
  ): Promise<string> {
    const tx = await this.contract.reward(
      userAddress,
      ethers.parseEther(amount.toString())
    );
    const receipt = await tx.wait();
    return receipt.hash;
  }

  async getBalance(address: string): Promise<string> {
    const balance = await this.contract.balanceOf(address);
    return ethers.formatEther(balance);
  }
}

// Example: Secure withdrawal pattern
contract SecureVault {
    mapping(address => uint256) private balances;
    bool private locked;

    modifier noReentrant() {
        require(!locked, "No reentrancy");
        locked = true;
        _;
        locked = false;
    }

    function withdraw(uint256 amount) external noReentrant {
        require(balances[msg.sender] >= amount, "Insufficient balance");

        // Update state BEFORE external call (checks-effects-interactions)
        balances[msg.sender] -= amount;

        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}

// Never expose private keys in client-side code
// Use server-side signing for admin operations

// BAD: Private key in frontend
// const wallet = new ethers.Wallet(PRIVATE_KEY);

// GOOD: Server-side API route for privileged operations
// app/api/blockchain/reward/route.ts
import { NextResponse } from "next/server";
import { RewardService } from "@/services/rewards";

export async function POST(request: Request) {
  const { userAddress, amount } = await request.json();

  // Validate the request (check auth, rate limits, etc.)
  const service = new RewardService({
    contractAddress: process.env.CONTRACT_ADDRESS!,
    privateKey: process.env.ADMIN_PRIVATE_KEY!, // Server-side only
    rpcUrl: process.env.KAIA_RPC_URL!,
  });

  const txHash = await service.distributeReward(userAddress, amount);
  return NextResponse.json({ success: true, txHash });
}