LINE區塊鏈與Web3開發：Kaia網路、NFT與智慧合約指南

網路: Kaia Mainnet (Chain ID: 8217)
共識: Istanbul BFT (基於PBFT)
出塊時間: 約1秒
最終性: 即時 (單區塊)
TPS: 4,000+
EVM相容: 是 (Solidity智慧合約)
代幣標準: KIP-7 (同質化), KIP-17 (NFT), KIP-37 (多代幣)

應用層
├── LINE迷你應用程式 (LIFF + Web3)
├── DOSI NFT市集
├── LINE BITMAX交易所
└── 第三方dApps

中介層
├── Kaia SDK / caver.js
├── LINE Blockchain API
├── 預言機服務
└── 跨鏈橋

共識層
├── Istanbul BFT共識
├── 驗證者委員會 (治理委員會)
└── 區塊提議者選擇

資料層
├── 狀態樹 (帳戶與合約狀態)
├── 交易池
└── 區塊儲存

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

# 安裝其他工具
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);
    }
}

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

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;

  // 檢查LINE BITMAX錢包是否可用
  const provider = (window as any).kaia;
  if (!provider) {
    throw new Error("未找到Kaia錢包。請安裝LINE BITMAX錢包。");
  }

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

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

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

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

    uint256 public mintPrice = 5 ether; // 5 KAIA
    uint256 public maxSupply = 10000;

    constructor()
        KIP17("LINE Digital Collectible", "LDC")
        Ownable(msg.sender)
    {}

    function mint(address to) external payable {
        require(msg.value >= mintPrice, "支付金額不足");
        require(_tokenIdCounter.current() < maxSupply, "已達最大供應量");

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

// 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("錢包未連接");

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

// 範例：安全提款模式
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, "餘額不足");

        // 在外部呼叫之前更新狀態 (checks-effects-interactions)
        balances[msg.sender] -= amount;

        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "轉帳失敗");
    }
}

// 絕不要在用戶端程式碼中暴露私鑰
// 管理員操作請使用伺服器端簽章

// 好的做法：用於特權操作的伺服器端API路由
// 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();

  // 驗證請求（檢查身分驗證、速率限制等）
  const service = new RewardService({
    contractAddress: process.env.CONTRACT_ADDRESS!,
    privateKey: process.env.ADMIN_PRIVATE_KEY!, // 僅伺服器端
    rpcUrl: process.env.KAIA_RPC_URL!,
  });

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