LINE区块链应用开发：在LINE生态系统上构建去中心化应用

网络: 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 });
}