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

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

// 例：安全な引き出しパターン
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 });
}