HTTP 402ベースの支払いプロトコルx402を理解しよう

GET /api/protected-resource HTTP/1.1
Host: example.com

HTTP/1.1 402 Payment Required
Content-Type: application/json

{
  "payment_required": true,
  "amount": "0.001",
  "currency": "ETH",
  "recipient": "0x1234...",
  "facilitator_url": "https://facilitator.example.com"
}

GET /api/protected-resource HTTP/1.1
Host: example.com
X-Payment-Proof: {"tx_hash": "0xabcd...", "signature": "..."}

POST /verify HTTP/1.1
Host: facilitator.example.com
Content-Type: application/json

{
  "payment_proof": {"tx_hash": "0xabcd...", "signature": "..."},
  "expected_amount": "0.001",
  "expected_recipient": "0x1234..."
}

POST /settle HTTP/1.1
Host: facilitator.example.com
Content-Type: application/json

{
  "payment_id": "payment_123",
  "confirmation": true
}

HTTP/1.1 200 OK
Content-Type: application/json

{
  "data": "Protected resource content"
}

const paymentInfo = {
  amount: '0.001', // ETH
  recipient: '0x1234567890abcdef...',
  network: 'base', // または 'ethereum', 'polygon' など
  currency: 'ETH'
};

import { createWalletClient, http } from 'viem';
import { base } from 'viem/chains';

const walletClient = createWalletClient({
  chain: base,
  transport: http()
});

// トランザクション作成
const hash = await walletClient.sendTransaction({
  to: paymentInfo.recipient,
  value: parseEther(paymentInfo.amount)
});

console.log('Transaction Hash:', hash);
// 例: 0xabcdef1234567890...

import { createPublicClient, http } from 'viem';
import { base } from 'viem/chains';

const publicClient = createPublicClient({
  chain: base,
  transport: http()
});

// トランザクション情報を取得
const transaction = await publicClient.getTransaction({
  hash: paymentProof.tx_hash
});

console.log('Transaction Details:', {
  from: transaction.from,
  to: transaction.to,
  value: transaction.value,
  blockNumber: transaction.blockNumber
});

function verifyPayment(transaction, expectedParams) {
  // 1. 受取人アドレスの確認
  if (transaction.to !== expectedParams.recipient) {
    return { valid: false, reason: 'Recipient mismatch' };
  }

  // 2. 支払い金額の確認
  const actualAmount = formatEther(transaction.value);
  if (actualAmount < expectedParams.amount) {
    return { valid: false, reason: 'Insufficient amount' };
  }

  // 3. トランザクションのステータス確認
  const receipt = await publicClient.getTransactionReceipt({
    hash: transaction.hash
  });

  if (receipt.status !== 'success') {
    return { valid: false, reason: 'Transaction failed' };
  }

  // 4. 十分な確認数があるか
  const currentBlock = await publicClient.getBlockNumber();
  const confirmations = currentBlock - receipt.blockNumber;

  if (confirmations < REQUIRED_CONFIRMATIONS) {
    return { valid: false, reason: 'Insufficient confirmations' };
  }

  // すべてのチェックが通過
  return { valid: true };
}

// データベースに決済記録を保存
async function settlePay(txHash: string, serverId: string) {
  // トランザクションハッシュが既に使用されていないか確認
  const existing = await db.settlements.findOne({ txHash });

  if (existing) {
    throw new Error('Transaction already settled');
  }

  // 新しい決済記録を作成
  await db.settlements.create({
    txHash,
    serverId,
    settledAt: new Date(),
    status: 'completed'
  });
}

try {
  const hash = await walletClient.sendTransaction({
    to: paymentInfo.recipient,
    value: parseEther(paymentInfo.amount)
  });
} catch (error) {
  if (error.message.includes('insufficient funds')) {
    // ユーザーに残高不足を通知
    console.error('Insufficient balance for gas fees');
  }
}

const receipt = await publicClient.getTransactionReceipt({
  hash: txHash
});

if (receipt.status === 'reverted') {
  // リバート理由を取得
  const reason = await publicClient.getTransactionRevertReason({
    hash: txHash
  });
  console.error('Transaction reverted:', reason);
}

async function waitForConfirmation(txHash: string, maxWaitTime: number = 60000) {
  const startTime = Date.now();

  while (Date.now() - startTime < maxWaitTime) {
    const receipt = await publicClient.getTransactionReceipt({
      hash: txHash
    });

    if (receipt && receipt.status === 'success') {
      return receipt;
    }

    // 2秒待機してから再試行
    await new Promise(resolve => setTimeout(resolve, 2000));
  }

  throw new Error('Transaction confirmation timeout');
}

import { encodeFunctionData, keccak256, toHex } from 'viem';

// EIP-712ドメイン定義
const domain = {
  name: 'USD Coin',
  version: '2',
  chainId: 8453, // Base
  verifyingContract: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' // USDC on Base
};

// TransferWithAuthorizationの型定義
const types = {
  TransferWithAuthorization: [
    { name: 'from', type: 'address' },
    { name: 'to', type: 'address' },
    { name: 'value', type: 'uint256' },
    { name: 'validAfter', type: 'uint256' },
    { name: 'validBefore', type: 'uint256' },
    { name: 'nonce', type: 'bytes32' }
  ]
};

// クライアント側：署名を作成
async function createTransferAuthorization(
  from: string,
  to: string,
  value: bigint,
  validAfter: number,
  validBefore: number
) {
  // ランダムnonceを生成
  const nonce = keccak256(toHex(Date.now()));

  const message = {
    from,
    to,
    value,
    validAfter,
    validBefore,
    nonce
  };

  // EIP-712署名を作成
  const signature = await walletClient.signTypedData({
    domain,
    types,
    primaryType: 'TransferWithAuthorization',
    message
  });

  return { message, signature, nonce };
}

// サーバー側：署名を検証して実行
async function executeTransferWithAuthorization(
  message: any,
  signature: string
) {
  const usdcContract = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';

  // r, s, vに分解
  const r = signature.slice(0, 66);
  const s = '0x' + signature.slice(66, 130);
  const v = parseInt(signature.slice(130, 132), 16);

  // transferWithAuthorizationを呼び出し
  const data = encodeFunctionData({
    abi: usdcABI,
    functionName: 'transferWithAuthorization',
    args: [
      message.from,
      message.to,
      message.value,
      message.validAfter,
      message.validBefore,
      message.nonce,
      v,
      r,
      s
    ]
  });

  // Relayerがガス代を支払ってトランザクションを送信
  const txHash = await relayerClient.sendTransaction({
    to: usdcContract,
    data
  });

  return txHash;
}

// ユーザー側：Permitを作成
async function createPermit(
  owner: string,
  spender: string,
  value: bigint,
  deadline: number
) {
  const nonce = await tokenContract.read.nonces([owner]);

  const domain = {
    name: 'Dai Stablecoin',
    version: '1',
    chainId: 8453,
    verifyingContract: daiAddress
  };

  const types = {
    Permit: [
      { name: 'owner', type: 'address' },
      { name: 'spender', type: 'address' },
      { name: 'value', type: 'uint256' },
      { name: 'nonce', type: 'uint256' },
      { name: 'deadline', type: 'uint256' }
    ]
  };

  const message = { owner, spender, value, nonce, deadline };

  const signature = await walletClient.signTypedData({
    domain,
    types,
    primaryType: 'Permit',
    message
  });

  return { message, signature };
}

// サーバー側：Permitを実行して送金
async function executePermitAndTransfer(
  permit: any,
  signature: string
) {
  const { v, r, s } = splitSignature(signature);

  // 1. Permitで承認
  await tokenContract.write.permit([
    permit.owner,
    permit.spender,
    permit.value,
    permit.deadline,
    v,
    r,
    s
  ]);

  // 2. transferFromで送金
  await tokenContract.write.transferFrom([
    permit.owner,
    permit.spender,
    permit.value
  ]);
}

// AIエージェントの登録
async function registerAIAgent(
  agentMetadata: {
    name: string;
    description: string;
    capabilities: string[];
  }
) {
  const identityRegistry = '0x...'; // ERC-8004 Identity Registry

  // エージェントNFTをミント
  const txHash = await identityContract.write.registerAgent([
    agentMetadata.name,
    agentMetadata.description,
    JSON.stringify(agentMetadata.capabilities)
  ]);

  const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
  const agentId = receipt.logs[0].topics[1]; // NFT Token ID

  return agentId;
}

// x402サーバー側：エージェントの検証
async function verifyAgent(agentId: bigint) {
  // 1. Identity Registryでエージェントの存在を確認
  const owner = await identityContract.read.ownerOf([agentId]);

  if (!owner) {
    throw new Error('Invalid agent ID');
  }

  // 2. Reputation Registryで評価を取得
  const reputation = await reputationContract.read.getReputation([agentId]);

  if (reputation.score < MINIMUM_REPUTATION_SCORE) {
    throw new Error('Agent reputation too low');
  }

  // 3. 過去の取引履歴を確認
  const history = await reputationContract.read.getHistory([agentId]);

  return {
    agentId,
    owner,
    reputation: reputation.score,
    totalTransactions: history.length,
    verified: true
  };
}

// タスク完了後の評価記録
async function recordTaskCompletion(
  agentId: bigint,
  taskId: string,
  success: boolean
) {
  // Validation Registryにタスク完了を記録
  await validationContract.write.recordCompletion([
    agentId,
    taskId,
    success,
    Date.now()
  ]);

  // Reputation Registryを更新
  const scoreChange = success ? 1 : -2;
  await reputationContract.write.updateReputation([agentId, scoreChange]);
}

interface IERC1363 {
  function transferAndCall(address to, uint256 value) external returns (bool);
  function transferAndCall(address to, uint256 value, bytes memory data) external returns (bool);
  function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
  function transferFromAndCall(address from, address to, uint256 value, bytes memory data) external returns (bool);
  function approveAndCall(address spender, uint256 value) external returns (bool);
  function approveAndCall(address spender, uint256 value, bytes memory data) external returns (bool);
}

interface IERC1363Receiver {
  function onTransferReceived(
    address operator,
    address from,
    uint256 value,
    bytes memory data
  ) external returns (bytes4);
}

interface IERC1363Spender {
  function onApprovalReceived(
    address owner,
    uint256 value,
    bytes memory data
  ) external returns (bytes4);
}

// 受取側の実装例
contract PayableReceiver is IERC1363Receiver {
  function onTransferReceived(
    address operator,
    address from,
    uint256 value,
    bytes memory data
  ) external override returns (bytes4) {
    // 処理を実行
    // ...

    // 成功を示すセレクターを返す
    return IERC1363Receiver.onTransferReceived.selector;
  }
}

// x402サーバー側：ERC-1363レシーバーを実装
contract X402APIServer is IERC1363Receiver {
  // transferAndCallを受け取った時の処理
  function onTransferReceived(
    address operator,
    address from,
    uint256 value,
    bytes calldata data
  ) external override returns (bytes4) {
    // dataにAPIパラメータがエンコードされている
    (string memory apiEndpoint, bytes memory params) = abi.decode(
      data,
      (string, bytes)
    );

    // 支払い金額を検証
    require(value >= getAPIPrice(apiEndpoint), 'Insufficient payment');

    // API処理を実行
    bytes memory result = executeAPI(apiEndpoint, params);

    // 成功を返す
    return IERC1363Receiver.onTransferReceived.selector;
  }

  function executeAPI(
    string memory endpoint,
    bytes memory params
  ) internal returns (bytes memory) {
    // API処理の実装
    if (keccak256(bytes(endpoint)) == keccak256('generate-image')) {
      return generateImage(params);
    }
    // ...
  }
}

// クライアント側：transferAndCallで支払いとAPI呼び出しを同時実行
const erc1363Token = '0x...'; // ERC-1363対応トークン
const x402Server = '0x...';

// APIパラメータをエンコード
const apiParams = encodeFunctionData({
  abi: apiABI,
  functionName: 'encodeParams',
  args: ['generate-image', { prompt: '猫の画像', style: 'realistic' }]
});

// 1トランザクションで支払い+API呼び出し
const txHash = await walletClient.writeContract({
  address: erc1363Token,
  abi: erc1363ABI,
  functionName: 'transferAndCall',
  args: [
    x402Server,
    parseUnits('0.1', 6), // 0.1 USDC
    apiParams
  ]
});

User (署名のみ) → Trusted Forwarder → Relayer (ガス代支払い) → Target Contract

abstract contract ERC2771Context {
  address private immutable _trustedForwarder;

  constructor(address trustedForwarder) {
    _trustedForwarder = trustedForwarder;
  }

  function isTrustedForwarder(address forwarder) public view returns (bool) {
    return forwarder == _trustedForwarder;
  }

  function _msgSender() internal view virtual override returns (address sender) {
    if (isTrustedForwarder(msg.sender) && msg.data.length >= 20) {
      // msg.dataの末尾20バイトが実際の送信者アドレス
      assembly {
        sender := shr(96, calldataload(sub(calldatasize(), 20)))
      }
    } else {
      sender = msg.sender;
    }
  }
}

[オリジナルのcalldata] + [実際の送信者アドレス（20バイト）]

contract MinimalForwarder {
  mapping(address => uint256) private _nonces;

  function getNonce(address from) public view returns (uint256) {
    return _nonces[from];
  }

  function verify(
    ForwardRequest calldata req,
    bytes calldata signature
  ) public view returns (bool) {
    address signer = _recoverSigner(req, signature);
    return _nonces[req.from] == req.nonce && signer == req.from;
  }

  function execute(
    ForwardRequest calldata req,
    bytes calldata signature
  ) public payable returns (bool, bytes memory) {
    require(verify(req, signature), 'Invalid signature');

    _nonces[req.from]++;

    // ターゲットコントラクトを呼び出し
    (bool success, bytes memory returndata) = req.to.call{
      gas: req.gas,
      value: req.value
    }(abi.encodePacked(req.data, req.from));

    return (success, returndata);
  }
}

// クライアント側：メタトランザクションを作成
async function createMetaTransaction(
  from: string,
  to: string,
  data: string
) {
  const forwarder = '0x...'; // Trusted Forwarder
  const nonce = await forwarderContract.read.getNonce([from]);

  const message = {
    from,
    to,
    value: 0n,
    gas: 1000000n,
    nonce,
    data
  };

  // EIP-712署名を作成
  const signature = await walletClient.signTypedData({
    domain: {
      name: 'MinimalForwarder',
      version: '0.0.1',
      chainId: 8453,
      verifyingContract: forwarder
    },
    types: {
      ForwardRequest: [
        { name: 'from', type: 'address' },
        { name: 'to', type: 'address' },
        { name: 'value', type: 'uint256' },
        { name: 'gas', type: 'uint256' },
        { name: 'nonce', type: 'uint256' },
        { name: 'data', type: 'bytes' }
      ]
    },
    primaryType: 'ForwardRequest',
    message
  });

  return { message, signature };
}

// リレイヤー側：メタトランザクションを実行
async function executeMetaTransaction(
  request: any,
  signature: string
) {
  const forwarder = '0x...';

  // リレイヤーがガス代を支払ってトランザクションを送信
  const txHash = await relayerClient.writeContract({
    address: forwarder,
    abi: forwarderABI,
    functionName: 'execute',
    args: [request, signature]
  });

  return txHash;
}

// x402サーバー側：ERC-2771に対応
contract X402Server is ERC2771Context {
  constructor(address trustedForwarder)
    ERC2771Context(trustedForwarder)
  {}

  function processAPI(bytes calldata params) external {
    // _msgSender()は実際の送信者（クライアント）を返す
    address actualSender = _msgSender();

    // API処理を実行
    // ...
  }
}

struct UserOperation {
  address sender;                 // スマートアカウントのアドレス
  uint256 nonce;                  // リプレイ攻撃防止用
  bytes initCode;                 // アカウント作成コード（初回のみ）
  bytes callData;                 // 実行する関数呼び出し
  uint256 callGasLimit;           // 実行用のガス上限
  uint256 verificationGasLimit;   // 署名検証用のガス上限
  uint256 preVerificationGas;     // Bundler補償用のガス
  uint256 maxFeePerGas;           // ガス単価の上限
  uint256 maxPriorityFeePerGas;   // 優先手数料の上限
  bytes paymasterAndData;         // Paymaster情報
  bytes signature;                // ユーザー署名
}

// pm_getPaymasterStubData: スタブデータ取得
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "pm_getPaymasterStubData",
  "params": [{
    "sender": "0x...",
    "nonce": "0x1",
    "callData": "0x...",
    "callGasLimit": "0x100000",
    "verificationGasLimit": "0x100000",
    "preVerificationGas": "0x5000",
    "maxFeePerGas": "0x3b9aca00",
    "maxPriorityFeePerGas": "0x3b9aca00"
  }, "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789"] // EntryPoint address
}

// レスポンス
{
  "result": {
    "paymasterAndData": "0x...",
    "preVerificationGas": "0x6000", // 調整された値
    "verificationGasLimit": "0x120000", // 調整された値
    "callGasLimit": "0x110000" // 調整された値
  }
}

// pm_getPaymasterData: 最終データ取得
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "pm_getPaymasterData",
  "params": [{
    // 署名済みUserOperation全体
    "sender": "0x...",
    ...
    "signature": "0x..."
  }, "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789"]
}

interface IPaymaster {
  function validatePaymasterUserOp(
    UserOperation calldata userOp,
    bytes32 userOpHash,
    uint256 maxCost
  ) external returns (bytes memory context, uint256 validationData);

  function postOp(
    PostOpMode mode,
    bytes calldata context,
    uint256 actualGasCost
  ) external;
}

enum PostOpMode {
  opSucceeded,  // 成功
  opReverted,   // リバート
  postOpReverted // postOp自体がリバート
}

// クライアント側：PaymasterサービスでUserOperationを作成
async function createSponsoredUserOp(
  sender: string,
  callData: string
) {
  const paymasterUrl = 'https://paymaster.example.com/rpc';

  // Step 1: Paymaster stub dataを取得
  const stubData = await fetch(paymasterUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'pm_getPaymasterStubData',
      params: [{
        sender,
        nonce: '0x1',
        callData,
        callGasLimit: '0x100000',
        verificationGasLimit: '0x100000',
        preVerificationGas: '0x5000',
        maxFeePerGas: '0x3b9aca00',
        maxPriorityFeePerGas: '0x3b9aca00'
      }]
    })
  });

  const { result: paymasterData } = await stubData.json();

  // Step 2: UserOperationを作成して署名
  const userOp = {
    sender,
    nonce: '0x1',
    callData,
    callGasLimit: '0x100000',
    verificationGasLimit: '0x100000',
    preVerificationGas: '0x5000',
    maxFeePerGas: '0x3b9aca00',
    maxPriorityFeePerGas: '0x3b9aca00',
    ...paymasterData,
    signature: '0x' // 後で署名
  };

  // 署名を追加
  userOp.signature = await signUserOp(userOp);

  // Step 3: Bundlerに送信
  const txHash = await fetch(bundlerUrl, {
    method: 'POST',
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'eth_sendUserOperation',
      params: [userOp, entryPointAddress]
    })
  });

  return txHash;
}

// Paymaster側：ガス代スポンサーシップを実装
contract X402Paymaster is IPaymaster {
  mapping(address => uint256) public credits;

  // クレジット購入
  function purchaseCredits() external payable {
    credits[msg.sender] += msg.value;
  }

  // ガス代を負担するか判定
  function validatePaymasterUserOp(
    UserOperation calldata userOp,
    bytes32 userOpHash,
    uint256 maxCost
  ) external override returns (bytes memory context, uint256 validationData) {
    address sender = userOp.sender;

    // クレジット残高を確認
    require(credits[sender] >= maxCost, 'Insufficient credits');

    // クレジットを消費
    credits[sender] -= maxCost;

    return ('', 0);
  }

  // ガス代精算
  function postOp(
    PostOpMode mode,
    bytes calldata context,
    uint256 actualGasCost
  ) external override {
    // 実際のガス代を記録
    // 必要に応じて払い戻し処理
  }
}

struct Subscription {
  address subscriber;    // 支払う人
  address provider;      // 受け取る人
  address token;         // 支払うトークン（ERC20）
  uint256 amount;        // 1回あたりの支払い額
  uint256 interval;      // 支払い間隔（秒単位）
  uint256 lastPayment;   // 最後の支払い時刻
  uint256 startTime;     // サブスク開始時刻
  bool active;           // アクティブかどうか
}

contract SubscriptionManager {
  mapping(bytes32 => Subscription) public subscriptions;

  event SubscriptionCreated(bytes32 indexed subId, address indexed subscriber, address indexed provider);
  event PaymentExecuted(bytes32 indexed subId, uint256 amount, uint256 timestamp);
  event SubscriptionCancelled(bytes32 indexed subId);

  function subscribe(
    address provider,
    address token,
    uint256 amount,
    uint256 interval
  ) external returns (bytes32) {
    bytes32 subId = keccak256(
      abi.encodePacked(msg.sender, provider, token, block.timestamp)
    );

    subscriptions[subId] = Subscription({
      subscriber: msg.sender,
      provider: provider,
      token: token,
      amount: amount,
      interval: interval,
      lastPayment: block.timestamp,
      startTime: block.timestamp,
      active: true
    });

    emit SubscriptionCreated(subId, msg.sender, provider);
    return subId;
  }

  function executePayment(bytes32 subId) external {
    Subscription storage sub = subscriptions[subId];

    require(sub.active, 'Subscription not active');
    require(
      block.timestamp >= sub.lastPayment + sub.interval,
      'Too early'
    );

    // トークン送金
    IERC20(sub.token).transferFrom(
      sub.subscriber,
      sub.provider,
      sub.amount
    );

    sub.lastPayment = block.timestamp;
    emit PaymentExecuted(subId, sub.amount, block.timestamp);
  }

  function cancel(bytes32 subId) external {
    Subscription storage sub = subscriptions[subId];
    require(sub.subscriber == msg.sender, 'Not subscriber');

    sub.active = false;
    emit SubscriptionCancelled(subId);
  }

  // サブスク情報を取得
  function getSubscription(bytes32 subId) external view returns (Subscription memory) {
    return subscriptions[subId];
  }

  // 次の支払い期日を取得
  function getNextPaymentDue(bytes32 subId) external view returns (uint256) {
    Subscription memory sub = subscriptions[subId];
    return sub.lastPayment + sub.interval;
  }
}

function executePaymentWithReward(bytes32 subId) external {
  Subscription storage sub = subscriptions[subId];

  // 通常の支払い処理
  IERC20(sub.token).transferFrom(sub.subscriber, sub.provider, sub.amount);

  // 実行者に報酬を支払う
  uint256 reward = sub.amount / 100; // 1%の報酬
  IERC20(sub.token).transferFrom(sub.subscriber, msg.sender, reward);

  sub.lastPayment = block.timestamp;
}

// サブスクリプション契約
contract X402Subscription {
  struct Subscription {
    address subscriber;
    address provider;
    uint256 amount;
    uint256 interval; // 支払い間隔（秒）
    uint256 lastPayment;
    bool active;
  }

  mapping(bytes32 => Subscription) public subscriptions;

  // サブスクリプション作成
  function subscribe(
    address provider,
    uint256 amount,
    uint256 interval
  ) external {
    bytes32 subId = keccak256(
      abi.encodePacked(msg.sender, provider, block.timestamp)
    );

    subscriptions[subId] = Subscription({
      subscriber: msg.sender,
      provider: provider,
      amount: amount,
      interval: interval,
      lastPayment: block.timestamp,
      active: true
    });
  }

  // 定期支払い実行
  function executePayment(bytes32 subId) external {
    Subscription storage sub = subscriptions[subId];

    require(sub.active, 'Subscription not active');
    require(
      block.timestamp >= sub.lastPayment + sub.interval,
      'Too early'
    );

    // トークン送金
    IERC20(usdcToken).transferFrom(sub.subscriber, sub.provider, sub.amount);

    sub.lastPayment = block.timestamp;
  }

  // キャンセル
  function cancel(bytes32 subId) external {
    require(subscriptions[subId].subscriber == msg.sender, 'Not subscriber');
    subscriptions[subId].active = false;
  }
}

{
  "name": "AI Agent #123",
  "description": "GPT-4ベースの画像生成エージェント",
  "image": "ipfs://QmXxx.../avatar.png",
  "intelligence": {
    "modelType": "gpt-4",
    "modelUri": "ipfs://QmYyyy.../model.enc",
    "encryption": "AES-256-GCM",
    "decryptionKey": "encrypted_with_owner_pubkey",
    "capabilities": [
      "image-generation",
      "text-to-image",
      "style-transfer"
    ],
    "personality": {
      "tone": "professional",
      "language": "en",
      "customization": "ipfs://QmZzzz.../personality.json"
    },
    "trainingData": {
      "dataset": "private-dataset-v1",
      "fineTuneUri": "ipfs://QmWwww.../finetune.enc",
      "version": "1.2.3"
    }
  },
  "performance": {
    "accuracy": 0.95,
    "speed": "fast",
    "costPerRequest": "0.01 USDC"
  }
}

interface IERC7857 {
  // iNFTをミント
  function mintAgent(
    address to,
    string memory modelUri,
    bytes memory encryptedKey,
    string memory metadata
  ) external returns (uint256 tokenId);

  // モデルURIを取得
  function getModelUri(uint256 tokenId) external view returns (string memory);

  // 暗号化された復号鍵を取得
  function getEncryptedKey(uint256 tokenId) external view returns (bytes memory);

  // オーナーのみ：復号鍵を更新（譲渡時）
  function updateEncryptedKey(uint256 tokenId, bytes memory newEncryptedKey) external;
}

contract IntelligentNFT is ERC721, IERC7857 {
  struct AgentData {
    string modelUri;          // 暗号化モデルのURI
    bytes encryptedKey;       // 復号鍵（オーナーの公開鍵で暗号化）
    string metadata;          // メタデータURI
    uint256 createdAt;        // 作成日時
  }

  mapping(uint256 => AgentData) private _agents;
  uint256 private _tokenIdCounter;

  function mintAgent(
    address to,
    string memory modelUri,
    bytes memory encryptedKey,
    string memory metadata
  ) external override returns (uint256) {
    uint256 tokenId = _tokenIdCounter++;

    _agents[tokenId] = AgentData({
      modelUri: modelUri,
      encryptedKey: encryptedKey,
      metadata: metadata,
      createdAt: block.timestamp
    });

    _safeMint(to, tokenId);
    return tokenId;
  }

  function getModelUri(uint256 tokenId) external view override returns (string memory) {
    require(_exists(tokenId), 'Token does not exist');
    return _agents[tokenId].modelUri;
  }

  function getEncryptedKey(uint256 tokenId) external view override returns (bytes memory) {
    require(ownerOf(tokenId) == msg.sender, 'Not owner');
    return _agents[tokenId].encryptedKey;
  }

  function updateEncryptedKey(uint256 tokenId, bytes memory newEncryptedKey) external override {
    require(ownerOf(tokenId) == msg.sender, 'Not owner');
    _agents[tokenId].encryptedKey = newEncryptedKey;
  }
}

// AIエージェントNFTをミント
async function mintIntelligentNFT(
  agentMetadata: {
    name: string;
    modelUri: string; // 暗号化されたAIモデルのURI
    capabilities: string[];
  }
) {
  const nftContract = '0x...'; // ERC-7857コントラクト

  const txHash = await walletClient.writeContract({
    address: nftContract,
    abi: erc7857ABI,
    functionName: 'mintAgent',
    args: [
      agentMetadata.name,
      agentMetadata.modelUri,
      JSON.stringify(agentMetadata.capabilities)
    ]
  });

  return txHash;
}

ERC-721 NFT → Token Bound Account (TBA) → 資産（ETH, ERC20, NFT等）

function account(
  address implementation,
  uint256 chainId,
  address tokenContract,
  uint256 tokenId,
  uint256 salt
) public view returns (address) {
  bytes32 hash = keccak256(
    abi.encodePacked(
      bytes1(0xff),
      address(this),
      salt,
      keccak256(
        abi.encodePacked(
          implementation,
          chainId,
          tokenContract,
          tokenId
        )
      )
    )
  );

  return address(uint160(uint256(hash)));
}

contract ERC6551Registry {
  event AccountCreated(
    address account,
    address implementation,
    uint256 chainId,
    address tokenContract,
    uint256 tokenId,
    uint256 salt
  );

  function createAccount(
    address implementation,
    uint256 chainId,
    address tokenContract,
    uint256 tokenId,
    uint256 salt,
    bytes calldata initData
  ) external returns (address) {
    bytes memory code = _creationCode(implementation, chainId, tokenContract, tokenId, salt);

    address _account = Create2.computeAddress(
      bytes32(salt),
      keccak256(code)
    );

    if (_account.code.length != 0) {
      return _account;
    }

    _account = Create2.deploy(0, bytes32(salt), code);

    if (initData.length != 0) {
      (bool success, ) = _account.call(initData);
      require(success, 'Initialization failed');
    }

    emit AccountCreated(_account, implementation, chainId, tokenContract, tokenId, salt);

    return _account;
  }

  function account(
    address implementation,
    uint256 chainId,
    address tokenContract,
    uint256 tokenId,
    uint256 salt
  ) external view returns (address) {
    bytes32 bytecodeHash = keccak256(
      _creationCode(implementation, chainId, tokenContract, tokenId, salt)
    );

    return Create2.computeAddress(bytes32(salt), bytecodeHash);
  }
}

contract TokenBoundAccount {
  function execute(
    address to,
    uint256 value,
    bytes calldata data,
    uint8 operation
  ) external payable returns (bytes memory) {
    require(_isValidSigner(msg.sender), 'Invalid signer');

    if (operation == 0) {
      // Call
      (bool success, bytes memory result) = to.call{value: value}(data);
      require(success, 'Call failed');
      return result;
    } else if (operation == 1) {
      // DelegateCall
      (bool success, bytes memory result) = to.delegatecall(data);
      require(success, 'Delegatecall failed');
      return result;
    }

    revert('Invalid operation');
  }

  function _isValidSigner(address signer) internal view returns (bool) {
    // NFTのオーナーを取得
    (uint256 chainId, address tokenContract, uint256 tokenId) = _token();

    if (chainId != block.chainid) return false;

    return IERC721(tokenContract).ownerOf(tokenId) == signer;
  }

  function _token() internal view returns (uint256, address, uint256) {
    bytes memory footer = new bytes(0x60);

    assembly {
      extcodecopy(address(), add(footer, 0x20), 0x4d, 0x60)
    }

    return abi.decode(footer, (uint256, address, uint256));
  }
}

// Token Bound Accountを作成
async function createTokenBoundAccount(
  nftContract: string,
  tokenId: bigint
) {
  const registryAddress = '0x...'; // ERC-6551 Registry

  const txHash = await walletClient.writeContract({
    address: registryAddress,
    abi: erc6551RegistryABI,
    functionName: 'createAccount',
    args: [
      implementationAddress, // TBA実装コントラクト
      8453n, // chainId (Base)
      nftContract,
      tokenId,
      0n, // salt
      '0x' // initData
    ]
  });

  // TBAアドレスを計算
  const tbaAddress = await registryContract.read.account([
    implementationAddress,
    8453n,
    nftContract,
    tokenId,
    0n
  ]);

  return tbaAddress;
}

// AIエージェントNFT + TBAでx402決済
class AIAgentWithWallet {
  private nftId: bigint;
  private tbaAddress: string;

  async payAndExecuteAPI(apiUrl: string, params: any) {
    // Step 1: APIに価格を問い合わせ
    const response = await fetch(apiUrl, {
      method: 'POST',
      body: JSON.stringify(params)
    });

    if (response.status === 402) {
      const paymentInfo = await response.json();

      // Step 2: Token Bound Accountから支払い
      const txHash = await publicClient.writeContract({
        address: this.tbaAddress,
        abi: tbaABI,
        functionName: 'execute',
        args: [
          usdcAddress,
          0n,
          encodeFunctionData({
            abi: erc20ABI,
            functionName: 'transfer',
            args: [paymentInfo.recipient, parseUnits(paymentInfo.amount, 6)]
          }),
          0 // call operation
        ],
        account: this.getNFTOwner() // NFTオーナーが署名
      });

      // Step 3: 支払い証明を提出してAPI実行
      const apiResponse = await fetch(apiUrl, {
        method: 'POST',
        headers: {
          'X-Payment-Hash': txHash,
          'X-Agent-NFT': this.nftId.toString()
        },
        body: JSON.stringify(params)
      });

      return await apiResponse.json();
    }
  }
}

interface IERC7579Account {
  function installModule(
    uint256 moduleTypeId,
    address module,
    bytes calldata initData
  ) external;

  function uninstallModule(
    uint256 moduleTypeId,
    address module,
    bytes calldata deInitData
  ) external;

  function isModuleInstalled(
    uint256 moduleTypeId,
    address module,
    bytes calldata additionalContext
  ) external view returns (bool);

  function execute(
    address target,
    uint256 value,
    bytes calldata data
  ) external;

  function executeBatch(
    address[] calldata targets,
    uint256[] calldata values,
    bytes[] calldata datas
  ) external;
}

interface IModule {
  function onInstall(bytes calldata data) external;
  function onUninstall(bytes calldata data) external;
  function isModuleType(uint256 typeId) external view returns (bool);
  function isInitialized(address smartAccount) external view returns (bool);
}

contract ECDSAValidator is IValidator {
  mapping(address => address) public owners;

  function onInstall(bytes calldata data) external override {
    address owner = abi.decode(data, (address));
    owners[msg.sender] = owner;
  }

  function onUninstall(bytes calldata data) external override {
    delete owners[msg.sender];
  }

  function validateUserOp(
    UserOperation calldata userOp,
    bytes32 userOpHash
  ) external view override returns (uint256 validationData) {
    address owner = owners[msg.sender];
    bytes32 hash = userOpHash.toEthSignedMessageHash();
    address recovered = hash.recover(userOp.signature);

    if (recovered == owner) {
      return 0; // 成功
    }

    return 1; // 失敗
  }

  function isModuleType(uint256 typeId) external pure override returns (bool) {
    return typeId == 1; // Validator type
  }
}

contract ScheduledExecutor is IExecutor {
  struct ScheduledTask {
    address target;
    uint256 value;
    bytes data;
    uint256 executeAfter;
    bool executed;
  }

  mapping(address => ScheduledTask[]) public tasks;

  function scheduleTask(
    address target,
    uint256 value,
    bytes calldata data,
    uint256 delay
  ) external {
    tasks[msg.sender].push(ScheduledTask({
      target: target,
      value: value,
      data: data,
      executeAfter: block.timestamp + delay,
      executed: false
    }));
  }

  function executeScheduledTask(uint256 taskId) external {
    ScheduledTask storage task = tasks[msg.sender][taskId];

    require(!task.executed, 'Already executed');
    require(block.timestamp >= task.executeAfter, 'Too early');

    task.executed = true;

    IERC7579Account(msg.sender).execute(task.target, task.value, task.data);
  }

  function isModuleType(uint256 typeId) external pure override returns (bool) {
    return typeId == 2; // Executor type
  }
}

// スマートアカウントに複数のモジュールをインストール
smartAccount.installModule(1, ecdsaValidator, abi.encode(ownerAddress));
smartAccount.installModule(1, passkeyValidator, abi.encode(passkeyData));
smartAccount.installModule(2, scheduledExecutor, '');
smartAccount.installModule(2, x402PaymentExecutor, '');
smartAccount.installModule(3, erc1271Fallback, '');

// x402決済モジュール
contract X402PaymentModule is IExecutor {
  function executeX402Payment(
    address apiServer,
    uint256 amount,
    bytes calldata apiParams
  ) external returns (bytes memory) {
    // USDCを送金
    IERC20(usdcToken).transfer(apiServer, amount);

    // APIを呼び出し
    (bool success, bytes memory result) = apiServer.call(apiParams);
    require(success, 'API call failed');

    return result;
  }

  // ERC-7579のExecutorインターフェースを実装
  function onInstall(bytes calldata data) external override {}
  function onUninstall(bytes calldata data) external override {}
  function isModuleType(uint256 typeId) external pure override returns (bool) {
    return typeId == 2; // Executor module
  }
}

// モジュールをインストール
async function installX402Module(
  smartAccountAddress: string,
  moduleAddress: string
) {
  const txHash = await walletClient.writeContract({
    address: smartAccountAddress,
    abi: erc7579ABI,
    functionName: 'installModule',
    args: [
      2n, // Executor module type
      moduleAddress,
      '0x' // init data
    ]
  });

  return txHash;
}

interface IERC5169 {
  event ScriptUpdate(string[] newScriptURI);

  function scriptURI() external view returns (string[] memory);
  function setScriptURI(string[] memory newScriptURI) external;
}

// 複数のスクリプトURIを返せる
[
  "ipfs://QmXxxx.../script.js",           // IPFS
  "https://example.com/token-script.js", // HTTP/HTTPS
  "ar://abcd1234.../app.html"            // Arweave
]

contract X402APIToken is ERC20, IERC5169 {
  string[] private _scriptURIs;

  event ScriptUpdate(string[] newScriptURI);

  constructor() ERC20('X402 API Credit', 'X402') {
    _scriptURIs = new string[](2);
    _scriptURIs[0] = 'ipfs://QmXxxx.../x402-ui.html';
    _scriptURIs[1] = 'ipfs://QmYyyy.../x402-script.js';
  }

  function scriptURI() external view override returns (string[] memory) {
    return _scriptURIs;
  }

  function setScriptURI(string[] memory newScriptURI) external override onlyOwner {
    _scriptURIs = newScriptURI;
    emit ScriptUpdate(newScriptURI);
  }
}

// ウォレット側：scriptURIを取得してスクリプトを読み込む
async function loadTokenScript(tokenAddress: string) {
  // Step 1: scriptURIを取得
  const scriptURIs = await publicClient.readContract({
    address: tokenAddress,
    abi: erc5169ABI,
    functionName: 'scriptURI'
  });

  if (!scriptURIs || scriptURIs.length === 0) {
    console.log('No scripts available for this token');
    return;
  }

  // Step 2: IPFSからスクリプトを取得
  const response = await fetch(scriptURIs[0]);
  const scriptContent = await response.text();

  // Step 3: セキュリティ検証
  const isSecure = await verifyScriptSecurity(scriptContent, scriptURIs[0]);

  if (!isSecure) {
    console.error('Script security verification failed');
    return;
  }

  // Step 4: サンドボックス内で実行
  const iframe = document.createElement('iframe');
  iframe.sandbox = 'allow-scripts allow-same-origin';
  iframe.srcdoc = scriptContent;
  document.body.appendChild(iframe);
}

// セキュリティ検証
async function verifyScriptSecurity(
  content: string,
  uri: string
): Promise<boolean> {
  // IPFS URIの場合、ハッシュを検証
  if (uri.startsWith('ipfs://')) {
    const expectedHash = uri.replace('ipfs://', '').split('/')[0];
    const actualHash = await calculateHash(content);

    return expectedHash === actualHash;
  }

  // HTTPS URIの場合、署名を検証（EIP-3668準拠）
  // ...

  return true;
}