インテントベース取引の台頭 — UniswapX・CowSwap・1inch Fusion

インテントベース取引とは

インテント（Intent）ベース取引は、DeFiにおける新しいトランザクション実行パラダイムです。ユーザーが「何を達成したいか」（インテント）を宣言し、専門的な第三者（ソルバー/フィラー/リゾルバー）が最適な方法で実行するモデルです。

従来のトランザクション vs インテント

[従来のトランザクションモデル]
ユーザーが「どのように」実行するかを指定:
  1. Uniswap V3のETH/USDCプールを選択
  2. 手数料ティア0.3%のプールを指定
  3. スリッページ許容0.5%を設定
  4. ガス価格を設定
  5. トランザクションを署名・送信
  6. メモリプールに公開
  7. MEVにさらされる
  → ユーザーの知識・経験に依存、最適とは限らない

[インテントベースモデル]
ユーザーが「何を」達成したいかを宣言:
  「1 ETH を最低 3,000 USDC で交換したい」
  → 署名してオフチェーンに送信
  → 複数のソルバーが競争して最良の実行を提供
  → MEVから保護される
  → ユーザーは結果のみを確認

インテントの定義

インテントの技術的構造

// インテントの基本構造（概念）
interface Intent {
  // 何を売るか
  sellToken: string;      // トークンアドレス
  sellAmount: bigint;     // 売却量

  // 何を得たいか
  buyToken: string;       // トークンアドレス
  minBuyAmount: bigint;   // 最低受取量（スリッページ保護）

  // 制約条件
  deadline: number;       // 有効期限（UNIX timestamp）
  sender: string;         // 送信者アドレス
  receiver: string;       // 受取者アドレス（異なるアドレスも可）

  // オプション
  partialFillAllowed: boolean;  // 部分約定を許可するか
  exclusiveFiller?: string;     // 特定ソルバーへの独占実行期間

  // 署名
  signature: string;      // EIP-712署名
}

UniswapX

UniswapXは、Uniswap Labsが2023年7月に発表したインテントベースの取引プロトコルです。オフチェーンオーダーとオンチェーン決済を組み合わせ、MEV保護と最良レートを両立します。

UniswapXのアーキテクチャ

[UniswapX フロー]

1. ユーザーがインテント（Signed Order）を作成
   │ 「1 ETH を最低 3,000 USDC で売りたい」
   │ EIP-712署名（ガス代不要）
   ↓
2. オフチェーンのオーダーAPIに送信
   │ Uniswap Orderbook Server
   ↓
3. フィラー（Filler）がオーダーを取得
   │ 複数のフィラーが競争
   │ ├── Filler A: 3,005 USDC を提示
   │ ├── Filler B: 3,008 USDC を提示 ← 最良
   │ └── Filler C: 3,003 USDC を提示
   ↓
4. 最良のフィラーがオンチェーンで実行
   │ UniswapX Reactor コントラクト
   │ ├── ユーザーの1 ETH をエスクロー
   │ ├── フィラーから3,008 USDC を受取
   │ └── アトミックに交換
   ↓
5. ユーザーが3,008 USDC を受取

Dutch Auction（ダッチオークション）メカニズム

UniswapXの特徴的な仕組みがダッチオークション（逆オークション） です。

[Dutch Auction の価格推移]

価格
  ↑
  │  3,050 ──────┐
  │              │ 開始価格（ユーザーに有利）
  │              ↓
  │  3,030 ─────────┐
  │                  │  時間とともに価格が下がる
  │  3,010 ─────────────┐
  │                      │  ← フィラーがここで約定
  │  3,000 ─────────────────── 最低保証価格
  │
  └──────────────────────────→ 時間

効果:
  - 開始時はユーザーに非常に有利な条件
  - 時間とともに条件が緩和
  - フィラーは利益が出る最も早いタイミングで約定
  - 結果的に競争的な価格で約定

UniswapX のコード例

// UniswapX Signed Order の構造
struct ExclusiveDutchOrder {
    OrderInfo info;           // 基本情報
    address exclusiveFiller;  // 独占フィラー（初期期間）
    uint256 exclusivityOverrideBps;  // 独占期間後の追加手数料
    DutchInput input;         // 売却するトークン・量
    DutchOutput[] outputs;    // 受取るトークン・量（時間減衰）
}

struct DutchOutput {
    address token;
    uint256 startAmount;  // 開始時の受取量（最大）
    uint256 endAmount;    // 終了時の受取量（最小）
    address recipient;    // 受取アドレス
}

// フィラーがオーダーを実行
function execute(SignedOrder calldata order, bytes calldata fillerData)
    external
{
    // 1. オーダーの署名を検証
    // 2. 現在のダッチオークション価格を計算
    // 3. ユーザーのトークンをエスクロー
    // 4. フィラーからトークンを受取
    // 5. ユーザーに送金
}

Cross-Chain Intents

UniswapXはクロスチェーンインテントもサポートしています。

[クロスチェーンインテント]

ユーザー: Ethereum上の1 ETH を Arbitrum上の3,000 USDC に交換したい

フロー:
  1. ユーザーがEthereum上でインテントに署名
  2. フィラーがArbitrum上で3,000 USDCをユーザーに送金
  3. Ethereum上のReactorがユーザーの1 ETHをフィラーに送金
  4. クロスチェーンの検証（決済レイヤー）

メリット:
  - ユーザーはブリッジを意識しない
  - フィラーが最適なルートを選択
  - 従来のブリッジよりも高速・低コスト

CowSwap（CoW Protocol）

CowSwap（カウスワップ）は、バッチオークション方式でMEVを根本的に排除するDEXアグリゲーターです。「Coincidence of Wants（欲求の一致）」を活用した独自のメカニズムが特徴です。

バッチオークションの仕組み

[CowSwap バッチオークション]

フェーズ1: 注文収集（約30秒）
  ├── ユーザーA: 1 ETH → USDC
  ├── ユーザーB: 3,000 USDC → ETH
  ├── ユーザーC: 0.5 ETH → USDC
  └── ユーザーD: 2 WBTC → ETH

フェーズ2: ソルバー競争
  ├── ソルバーX: 解を提出（最適マッチング + DEXルーティング）
  ├── ソルバーY: 解を提出
  └── ソルバーZ: 解を提出

フェーズ3: 最良の解を選択・実行
  最良の解:
  ├── ユーザーA ↔ ユーザーB: 直接マッチング（CoW）
  │   → DEXを介さない → ガス代・手数料が最小
  ├── ユーザーC: Uniswapで実行
  └── ユーザーD: CurveでWBTC→ETH

Coincidence of Wants（CoW）

[通常のDEX取引]
ユーザーA: 1 ETH → USDC → Uniswapで実行（手数料0.3%）
ユーザーB: 3000 USDC → ETH → Uniswapで実行（手数料0.3%）
  合計手数料: 約$18（0.3% × 2回）

[CoW（欲求の一致）]
ユーザーA: 1 ETH → USDC ─┐
                          ├→ 直接交換（DEX不要）
ユーザーB: 3000 USDC → ETH ┘
  合計手数料: ほぼ$0（ソルバー手数料のみ）

CowSwap の技術的特徴

CowSwap ソルバーの仕組み

# CowSwap ソルバーの基本ロジック（概念実装）

class CowSolver:
    """CowSwap バッチオークション ソルバー"""

    def solve_batch(self, orders: list[Order]) -> Solution:
        """バッチ内の注文を最適にマッチングする"""

        solution = Solution()

        # Step 1: CoW（P2Pマッチング）を探索
        cow_matches = self.find_coincidence_of_wants(orders)
        solution.add_cow_trades(cow_matches)

        # Step 2: 残りの注文を外部流動性でルーティング
        remaining = [o for o in orders if o not in cow_matches]
        for order in remaining:
            best_route = self.find_best_route(order)
            solution.add_amm_trade(order, best_route)

        # Step 3: Uniform Clearing Price（統一清算価格）を計算
        solution.compute_clearing_prices()

        # Step 4: ソリューションの品質スコアを計算
        # スコア = ユーザーの余剰（surplus）の合計
        solution.score = sum(
            self.calculate_surplus(order, solution.clearing_price)
            for order in orders
        )

        return solution

    def find_coincidence_of_wants(self, orders: list) -> list:
        """注文間のCoW（直接マッチング）を探索"""
        matches = []
        buy_orders = [o for o in orders if o.side == "buy"]
        sell_orders = [o for o in orders if o.side == "sell"]

        for buy in buy_orders:
            for sell in sell_orders:
                if (buy.buy_token == sell.sell_token and
                    buy.sell_token == sell.buy_token):
                    # マッチング可能
                    match_amount = min(buy.buy_amount, sell.sell_amount)
                    if match_amount > 0:
                        matches.append(CoWMatch(buy, sell, match_amount))

        return matches

    def find_best_route(self, order: Order) -> Route:
        """DEX/AMMの最適ルーティング"""
        routes = []

        # 複数DEXの価格を取得
        for dex in self.dex_sources:
            quote = dex.get_quote(
                order.sell_token,
                order.buy_token,
                order.sell_amount
            )
            if quote.buy_amount >= order.min_buy_amount:
                routes.append(Route(dex=dex, quote=quote))

        # スプリットルーティングも検討
        split_routes = self.optimize_split(order, self.dex_sources)
        routes.extend(split_routes)

        return max(routes, key=lambda r: r.quote.buy_amount)

CowSwap Hooks

CowSwap Hooksは、取引の前後に任意のオンチェーンアクションを実行できる機能です。

[Hooks の使用例]

Pre-Hook（取引前）:
  ├── Aaveからの借り入れ → スワップに使用
  ├── NFTの売却 → 得た資金でトークン購入
  └── ステーキング解除 → トークンをスワップ

Post-Hook（取引後）:
  ├── 受け取ったトークンを自動ステーキング
  ├── レンディングプロトコルに自動供給
  └── 別のウォレットに自動送金

例: 「stETHをアンステーク → ETHを受取 → USDCにスワップ → Aaveに供給」
    → すべて1つのインテントで完結

1inch Fusion

1inch Fusion（ワンインチ・フュージョン）は、1inch Networkのインテントベース取引モード です。リゾルバー（Resolver） のネットワークがユーザーの注文を実行します。

1inch Fusion のアーキテクチャ

[1inch Fusion フロー]

1. ユーザーがFusion注文を作成（ガスレス、署名のみ）
   │
2. 1inch Fusion APIに送信
   │
3. リゾルバーネットワークが受信
   │ ├── Resolver A（独占期間: 0-12秒）
   │ │   → 独占的に実行可能（最良条件が求められる）
   │ │
   │ ├── Resolver B（12-24秒）
   │ │   → 次の優先リゾルバー
   │ │
   │ └── 公開オークション（24秒以降）
   │     → すべてのリゾルバーが参加可能
   │
4. リゾルバーがオンチェーンで実行
   │ ├── 自己資金で即座に決済
   │ └── または DEXルーティングで実行
   │
5. ユーザーがトークンを受取

リゾルバーのインセンティブ構造

1inch Fusion API の利用例

// 1inch Fusion 注文の作成（概念コード）
import { FusionSDK, FusionOrder } from "@1inch/fusion-sdk";

const sdk = new FusionSDK({
  url: "https://fusion.1inch.io",
  network: 1, // Ethereum mainnet
});

// Fusion注文の作成
async function createFusionOrder() {
  const order = await sdk.createOrder({
    fromTokenAddress: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
    toTokenAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",   // USDC
    amount: "1000000000000000000", // 1 ETH
    walletAddress: "0x...",
    // Fusion固有のパラメータ
    preset: "fast", // "fast" | "medium" | "slow"
  });

  // 注文に署名
  const signedOrder = await order.sign(wallet);

  // 送信
  const result = await sdk.submitOrder(signedOrder);
  console.log("Order hash:", result.orderHash);

  return result;
}

// 注文ステータスの確認
async function checkOrderStatus(orderHash: string) {
  const status = await sdk.getOrderStatus(orderHash);
  // status: "pending" | "filled" | "partially_filled" | "expired" | "cancelled"
  console.log(`Status: ${status.status}`);
  console.log(`Fill amount: ${status.filledAmount}`);
  return status;
}

1inch Fusion+ (クロスチェーン)

1inch Fusion+はクロスチェーン版のFusionで、チェーン間のスワップをインテントベースで実行します。

[Fusion+ クロスチェーンフロー]

1. ユーザー: Ethereum上のETHをArbitrum上のUSDCに交換したい
2. 署名してFusion+に送信

3. リゾルバーの実行:
   a. Arbitrum上でユーザーにUSDCを送金（先払い）
   b. Ethereum上のエスクローからETHを受取
   c. クロスチェーン検証（ハッシュロック等）

4. ユーザー: Arbitrum上でUSDCを受取

メリット:
  - ブリッジを意識しない
  - ガスレス
  - MEV保護

Across Protocol — クロスチェーンインテント

Across Protocolは、クロスチェーンに特化したインテントベースプロトコルです。UMAオラクルを活用した楽観的検証が特徴です。

Acrossの技術的仕組み

[Across Protocol フロー]

1. ユーザーがソースチェーンでデポジット
   │ Ethereum: 1,000 USDC をSpokePoolにデポジット
   │ + インテント: 「Arbitrumで999 USDCを受け取りたい」
   ↓
2. リレイヤーが検知・実行
   │ Arbitrum: リレイヤーが自己資金で999 USDCをユーザーに送金
   │ （数秒〜数分で完了）
   ↓
3. 決済（UMAオラクル）
   │ HubPool (Ethereum) で決済
   │ ├── バンドル提案: リレイヤーの請求をまとめて提出
   │ ├── チャレンジ期間: 2時間（不正がないか検証）
   │ └── 承認: リレイヤーにソースチェーンの資金を返済
   ↓
4. リバランス
   │ HubPoolが各チェーンのSpokePool間で流動性をリバランス

Across vs 他のインテントプロトコル

ソルバー/フィラーの役割とビジネス

ソルバーエコシステム

インテントベース取引において、ソルバー（フィラー/リゾルバー）は市場の効率性を担保する重要な役割を果たします。

[ソルバーの収益モデル]

収益源:
├── スプレッド（ユーザーの最低受取量との差額）
├── ガス最適化（効率的なルーティングによるガス節約）
├── バッチ処理の効率化
└── クロスチェーンのレート差

コスト:
├── ガス代（オンチェーン実行）
├── 在庫リスク（自己資金で先払い）
├── インフラコスト（ノード、API、サーバー）
└── 開発・運用コスト

ソルバーとして参入する方法

アルゴリズムトレーダーとしてのソルバー参入

# ソルバー参入のためのフレームワーク（概念コード）

class IntentSolver:
    """インテントベース取引のソルバー基本フレームワーク"""

    def __init__(self, config: dict):
        self.chains = self.initialize_chains(config["rpc_urls"])
        self.dex_sources = self.initialize_dexes(config["dexes"])
        self.inventory = Inventory(config["initial_capital"])

    async def listen_for_intents(self, protocol: str):
        """インテントを監視"""
        if protocol == "cowswap":
            async for batch in self.cow_api.stream_batches():
                solution = await self.solve_cow_batch(batch)
                if solution.is_profitable():
                    await self.submit_solution(solution)

        elif protocol == "uniswapx":
            async for order in self.uniswapx_api.stream_orders():
                if await self.can_fill_profitably(order):
                    await self.fill_order(order)

    async def can_fill_profitably(self, order) -> bool:
        """注文を利益を出して実行可能か判断"""
        # 1. 最良の実行ルートを探索
        best_route = await self.find_best_route(
            order.sell_token,
            order.buy_token,
            order.sell_amount
        )

        # 2. コストを計算
        execution_cost = (
            best_route.gas_cost +
            best_route.slippage_cost +
            self.inventory.opportunity_cost(order.sell_amount)
        )

        # 3. 利益を計算
        current_dutch_price = order.get_current_price()  # ダッチオークション現在価格
        revenue = order.sell_amount - current_dutch_price

        profit = revenue - execution_cost

        return profit > self.min_profit_threshold

    async def find_best_route(self, sell_token, buy_token, amount):
        """複数ソースから最適ルートを検索"""
        routes = []

        # オンチェーンDEX
        for dex in self.dex_sources:
            quote = await dex.get_quote(sell_token, buy_token, amount)
            routes.append(quote)

        # 自己在庫
        if self.inventory.has_sufficient(buy_token, amount):
            routes.append(InventoryRoute(
                cost=self.inventory.get_cost(buy_token, amount),
                speed="instant"
            ))

        # スプリットルート
        split = await self.optimize_split_route(
            sell_token, buy_token, amount, self.dex_sources
        )
        routes.append(split)

        return min(routes, key=lambda r: r.total_cost)

インテントがMEVを解決する仕組み

なぜインテントはMEVに強いのか

[従来のDEX取引]
ユーザーTX → メモリプール（公開） → サーチャーがフロントラン
                 ↑ ここがMEVの攻撃面

[インテントベース取引]
ユーザー署名 → オフチェーンAPI → ソルバーが実行
                 ↑ メモリプールに公開されない → MEV不可

具体的なMEV保護メカニズム:
1. オフチェーン注文: メモリプールに公開されない
2. ソルバー競争: 最良レートが保証される
3. バッチ処理: 注文の順序に意味がない（CowSwap）
4. ダッチオークション: 時間経過で条件が変化
5. Surplus sharing: MEV利益がユーザーに還元

MEV保護の効果（定量比較）

今後の展望

ERC-7521: インテントの標準化

インテントの標準規格としてERC-7521の議論が進んでいます。

[ERC-7521 の目標]

現状の課題:
├── UniswapX、CowSwap、1inch Fusionが独自フォーマット
├── ソルバーが各プロトコルに個別対応が必要
└── 流動性と注文フローが分断

ERC-7521 の提案:
├── 統一されたインテントフォーマット
├── プロトコル間の相互運用性
├── ソルバーが1つの実装で複数プロトコルに対応
└── 注文フローの統合 → より良い価格発見

インテントベース取引の進化ロードマップ

アルゴリズムトレーダーへの示唆

1. ソルバーとしての参入機会 — 技術力があればソルバーとして収益を得られる
2. MEV戦略の変化 — 従来のサンドイッチ攻撃は衰退、ソルバー競争に移行
3. クロスチェーン戦略 — インテントベースのクロスチェーン取引が新たなアービトラージ機会を創出
4. インフラ投資 — 複数プロトコルのAPIに対応したソルバーインフラが競争優位
5. 資本効率 — 自己資金でフィリングを行うため、資本管理スキルが重要

インテントベース取引は、DeFiの取引体験を根本から変革するパラダイムです。ユーザーにとってはMEV保護と最良レートを、ソルバーにとっては新たなビジネス機会を提供します。アルゴリズムトレーダーにとっては、従来のMEV戦略からソルバーへのピボットという戦略転換が重要なテーマとなるでしょう。