[EIP5792] 複数のオンチェーン呼び出しをバッチ送信するWallet Call APIの仕組みを理解しよう！

type SendCallsParams = {
  version: string;           // 必須: 使用するプロトコルバージョン（例: "2.0.0"）
  id?: string;               // オプション: 呼び出しバッチの識別子
  from?: `0x${string}`;      // オプション: 送信元アドレス
  chainId: `0x${string}`;    // 必須: 16進数でエンコードされたチェーンID
  atomicRequired: boolean;   // 必須: アトミック実行が必要かどうか
  calls: {
    to?: `0x${string}`;      // オプション: 送信先アドレス
    data?: `0x${string}`;    // オプション: 呼び出しデータ
    value?: `0x${string}`;   // オプション: 送信するネイティブトークンの量
    capabilities?: Record<string, Capability>;  // オプション: 呼び出し固有のケーパビリティ
  }[];
  capabilities?: Record<string, Capability>;    // オプション: バッチ全体のケーパビリティ
};

type SendCallsResult = {
  id: string;                              // バッチの識別子
  capabilities?: Record<string, any>;      // ウォレットからのケーパビリティレスポンス
};

const params = {
  version: "2.0.0",
  chainId: "0x1", // Ethereum Mainnet
  atomicRequired: true,
  from: "0x1234567890abcdef1234567890abcdef12345678",
  calls: [
    {
      // 1. トークンのapprove
      to: "0xA0b86a33E6e7eF3d0b7e8e3d9e3e3e3e3e3e3e3e", // USDCコントラクト
      data: "0x095ea7b3000000000000000000000000def1c0ded9bec7f1a1670819833240f027b25eee0000000000000000000000000000000000000000000000000000000005f5e100", // approve(spender, amount)
    },
    {
      // 2. スワップの実行
      to: "0xDEF1C0ded9bec7F1a1670819833240f027b25EeE", // DEXルーターコントラクト
      data: "0x...", // swap関数のcalldata
      value: "0x0",
    }
  ]
};

const response = await provider.request({
  method: "wallet_sendCalls",
  params: [params]
});

console.log("Batch ID:", response.id);

type GetCallsParams = [string];

type GetCallsResult = {
  version: string;
  id: `0x${string}`;
  chainId: `0x${string}`;
  status: number;
  atomic: boolean;
  receipts?: {
    logs: {
      address: `0x${string}`;
      data: `0x${string}`;
      topics: `0x${string}`[];
    }[];
    status: `0x${string}`;
    blockHash: `0x${string}`;
    blockNumber: `0x${string}`;
    gasUsed: `0x${string}`;
    transactionHash: `0x${string}`;
  }[];
  capabilities?: Record<string, any>;
};

const status = await provider.request({
  method: "wallet_getCallsStatus",
  params: ["0xabc123..."]
});

console.log("Status:", status.status);
console.log("Atomic:", status.atomic);

if (status.receipts) {
  status.receipts.forEach((receipt, index) => {
    console.log(`Transaction ${index + 1}:`, receipt.transactionHash);
    console.log(`  Status: ${receipt.status === "0x1" ? "Success" : "Failed"}`);
    console.log(`  Gas Used: ${parseInt(receipt.gasUsed, 16)}`);
  });
}

type ShowCallsStatusParams = [string];

try {
  await provider.request({
    method: "wallet_showCallsStatus",
    params: ["0xabc123..."]
  });
  console.log("Wallet is showing the batch status to the user.");
} catch (error) {
  if (error.code === 5730) {
    console.log("Unknown batch ID");
  }
}

type GetCapabilitiesParams = [
  `0x${string}`,
  `0x${string}`[]
];

type GetCapabilitiesResult = Record<
  `0x${string}`,
  Record<string, any>
>;

const capabilities = await provider.request({
  method: "wallet_getCapabilities",
  params: [
    "0x1234567890abcdef1234567890abcdef12345678",
    ["0x1", "0x89"]
  ]
});

console.log("Ethereum capabilities:", capabilities["0x1"]);
console.log("Polygon capabilities:", capabilities["0x89"]);

if (capabilities["0x1"]?.atomic?.status === "supported") {
  console.log("Atomic batch execution is supported on Ethereum!");
}

type AtomicCapability = {
  status: 'supported' | 'ready' | 'unsupported';
};

const capabilities = await provider.request({
  method: "wallet_getCapabilities",
  params: [walletAddress, ["0x1"]]
});

const atomicStatus = capabilities["0x1"]?.atomic?.status;

switch (atomicStatus) {
  case "supported":
    console.log("アトミック実行がサポートされています");
    break;
  case "ready":
    console.log("アップグレードでアトミック実行が可能になります");
    break;
  case "unsupported":
    console.log("アトミック実行はサポートされていません");
    break;
  default:
    console.log("atomicケーパビリティが不明です");
}

async function swapTokens(provider, userAddress, tokenAddress, spenderAddress, amount, swapData) {
  const capabilities = await provider.request({
    method: "wallet_getCapabilities",
    params: [userAddress, ["0x1"]]
  });

  const supportsAtomic = capabilities["0x1"]?.atomic?.status === "supported";
  console.log("Atomic support:", supportsAtomic);

  // 2. バッチリクエストを構築
  const sendCallsParams = {
    version: "2.0.0",
    chainId: "0x1",
    atomicRequired: supportsAtomic, // アトミックがサポートされている場合のみtrue
    from: userAddress,
    calls: [
      {
        // approve呼び出し
        to: tokenAddress,
        data: encodeApprove(spenderAddress, amount),
      },
      {
        // swap呼び出し
        to: spenderAddress,
        data: swapData,
      }
    ]
  };

  // 3. バッチを送信
  const { id: batchId } = await provider.request({
    method: "wallet_sendCalls",
    params: [sendCallsParams]
  });

  console.log("Batch submitted:", batchId);

  // 4. ステータスをポーリング
  let status;
  do {
    await sleep(2000); // 2秒待機
    status = await provider.request({
      method: "wallet_getCallsStatus",
      params: [batchId]
    });
    console.log("Current status:", status.status);
  } while (status.status === 100); // 100 = pending

  // 5. 結果を処理
  if (status.status === 200) {
    console.log("Swap completed successfully!");
    console.log("Atomic execution:", status.atomic);
    if (status.receipts) {
      console.log("Transaction hashes:", status.receipts.map(r => r.transactionHash));
    }
    return { success: true, receipts: status.receipts };
  } else if (status.status === 400) {
    console.log("Batch was not submitted");
    return { success: false, error: "Not submitted" };
  } else if (status.status === 500) {
    console.log("Batch completely reverted");
    return { success: false, error: "Reverted" };
  } else if (status.status === 600) {
    console.log("Partial revert occurred");
    return { success: false, error: "Partial revert", receipts: status.receipts };
  }
}

// ヘルパー関数
function encodeApprove(spender, amount) {
  // ERC20 approve(address,uint256) のエンコード
  const functionSelector = "0x095ea7b3";
  const encodedSpender = spender.slice(2).padStart(64, "0");
  const encodedAmount = amount.toString(16).padStart(64, "0");
  return functionSelector + encodedSpender + encodedAmount;
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function executeWithFallback(provider, userAddress, calls) {
  const capabilities = await provider.request({
    method: "wallet_getCapabilities",
    params: [userAddress, ["0x1"]]
  });

  const atomicStatus = capabilities["0x1"]?.atomic?.status;

  if (atomicStatus === "supported") {
    // アトミック実行を使用
    return await executeAtomic(provider, userAddress, calls);
  } else if (atomicStatus === "ready") {
    // ユーザーにアップグレードを提案
    const userWantsUpgrade = await promptUserForUpgrade();
    if (userWantsUpgrade) {
      try {
        return await executeAtomic(provider, userAddress, calls);
      } catch (error) {
        if (error.code === 5750) {
          // ユーザーがアップグレードを拒否した場合
          console.log("User rejected upgrade, falling back to sequential");
          return await executeSequential(provider, userAddress, calls);
        }
        throw error;
      }
    } else {
      return await executeSequential(provider, userAddress, calls);
    }
  } else {
    // アトミック実行非対応 - 順次実行
    return await executeSequential(provider, userAddress, calls);
  }
}

async function executeAtomic(provider, userAddress, calls) {
  const { id } = await provider.request({
    method: "wallet_sendCalls",
    params: [{
      version: "2.0.0",
      chainId: "0x1",
      atomicRequired: true,
      from: userAddress,
      calls
    }]
  });
  return await waitForCompletion(provider, id);
}

async function executeSequential(provider, userAddress, calls) {
  const { id } = await provider.request({
    method: "wallet_sendCalls",
    params: [{
      version: "2.0.0",
      chainId: "0x1",
      atomicRequired: false,
      from: userAddress,
      calls
    }]
  });
  return await waitForCompletion(provider, id);
}

async function waitForCompletion(provider, batchId) {
  let status;
  do {
    await sleep(2000);
    status = await provider.request({
      method: "wallet_getCallsStatus",
      params: [batchId]
    });
  } while (status.status === 100);
  return status;
}

async function promptUserForUpgrade() {
  return confirm("スマートアカウントにアップグレードしてアトミック実行を有効にしますか？");
}