eth-twc-sdk-react 0.1.0

package/test/hooks.sign.test.ts

@@ -0,0 +1,231 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, test } from "bun:test";
+import type { Hex } from "viem";
+
+import {
+  useSignBatchTransferWithCommit,
+  useSignCancelAuthorization,
+  useSignSingleTransfer,
+  useSignUniCommitTransfers,
+} from "../hooks/sign.ts";
+import { ADDR, ADDR_B, COMMIT } from "./fixtures.ts";
+import { createQueryWrapper, createTestQueryClient } from "./queryClient.tsx";
+import { resetSdkConfigAddress, setSdkConfigAddressZero } from "./sdkConfigState.ts";
+import {
+  stubClientsGetEip712DomainRejects,
+  stubClientsSignSuccess,
+  stubClientsSignTypedDataRejects,
+  stubPublicClient,
+  stubWalletClient,
+} from "./stubs.ts";
+import { resetWagmiState, wagmiState } from "./wagmiState.ts";
+
+describe("useSign*", () => {
+  beforeEach(() => {
+    resetWagmiState();
+    resetSdkConfigAddress();
+  });
+
+  test("未接続時は mutate が narrowWriteClients で失敗", async () => {
+    wagmiState.publicClient = stubPublicClient();
+    wagmiState.walletClient = stubWalletClient();
+    wagmiState.address = undefined;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSignSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      from: ADDR,
+      to: ADDR_B,
+      token: ADDR,
+      executor: ADDR_B,
+      value: 1n,
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(
+      /TWC: connect a wallet to send or sign/,
+    );
+  });
+
+  test("sdk_js: Signer と EIP-712 from が不一致なら署名前に失敗", async () => {
+    const { publicClient, walletClient } = stubClientsSignSuccess();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR_B as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSignSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      from: ADDR,
+      to: ADDR_B,
+      token: ADDR,
+      executor: ADDR_B,
+      value: 1n,
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(
+      /Signer account .* does not match EIP-712 message from/,
+    );
+  });
+
+  test("config ゼロアドレスでは assert が失敗", async () => {
+    setSdkConfigAddressZero();
+    const { publicClient: pc, walletClient } = stubClientsSignSuccess();
+    wagmiState.publicClient = stubPublicClient({
+      getEip712Domain: pc.getEip712Domain,
+      getCode: async () => "0x",
+    });
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSignSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      from: ADDR,
+      to: ADDR_B,
+      token: ADDR,
+      executor: ADDR_B,
+      value: 1n,
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(
+      /not deployed at/,
+    );
+  });
+
+  test("RPC: getEip712Domain が失敗したらエラーが伝播", async () => {
+    const { publicClient, walletClient } = stubClientsGetEip712DomainRejects();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSignSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      from: ADDR,
+      to: ADDR_B,
+      token: ADDR,
+      executor: ADDR_B,
+      value: 1n,
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/getEip712Domain failed/);
+  });
+
+  test("ウォレット: signTypedData が拒否されたらエラーが伝播", async () => {
+    const { publicClient, walletClient } = stubClientsSignTypedDataRejects();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSignSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      from: ADDR,
+      to: ADDR_B,
+      token: ADDR,
+      executor: ADDR_B,
+      value: 1n,
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/User rejected/);
+  });
+
+  test("成功時は Signed* が data に入る", async () => {
+    const { publicClient, walletClient, sig } = stubClientsSignSuccess();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSignSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      from: ADDR,
+      to: ADDR_B,
+      token: ADDR,
+      executor: ADDR_B,
+      value: 1n,
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.signature).toBe(sig);
+  });
+
+  test("useSignUniCommitTransfers: RPC 失敗を伝播", async () => {
+    const { publicClient, walletClient } = stubClientsGetEip712DomainRejects();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSignUniCommitTransfers(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      from: ADDR,
+      executor: ADDR_B,
+      details: [{ to: ADDR_B, token: ADDR, value: 1n }],
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/getEip712Domain failed/);
+  });
+
+  test("useSignBatchTransferWithCommit: RPC 失敗を伝播", async () => {
+    const { publicClient, walletClient } = stubClientsGetEip712DomainRejects();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSignBatchTransferWithCommit(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      from: ADDR,
+      executor: ADDR_B,
+      details: [
+        { to: ADDR_B, token: ADDR, value: 1n, commitment: COMMIT },
+      ],
+      batchCommitment: ("0x" + "aa".repeat(32)) as Hex,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/getEip712Domain failed/);
+  });
+
+  test("useSignCancelAuthorization: authorizer と接続アドレスが不一致なら失敗", async () => {
+    const { publicClient, walletClient } = stubClientsSignSuccess();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR_B as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSignCancelAuthorization(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      authorizer: ADDR,
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(
+      /Signer account .* does not match EIP-712 message authorizer/,
+    );
+  });
+});

package/test/hooks.signatureTransfer.test.ts

@@ -0,0 +1,198 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, test } from "bun:test";
+import type { SignedSingleTransfer } from "eth-twc-sdk-js/signatureTransfer/single";
+import type { Hex } from "viem";
+
+import {
+  useSendAuthorizedBatchTransfer,
+  useSendAuthorizedSingleTransfer,
+  useSendAuthorizedUnifiedTransfer,
+  useSendCancelAuthorization,
+} from "../hooks/signatureTransfer.ts";
+import { ADDR, ADDR_B, COMMIT, testDomain } from "./fixtures.ts";
+import { createQueryWrapper, createTestQueryClient } from "./queryClient.tsx";
+import { resetSdkConfigAddress, setSdkConfigAddressZero } from "./sdkConfigState.ts";
+import {
+  minimalSignedBatch,
+  minimalSignedCancel,
+  minimalSignedSingleTransfer,
+  minimalSignedUni,
+  stubClientsSignatureSendSimulateFails,
+  stubClientsSignatureSendSuccess,
+  stubPublicClient,
+  stubWalletClient,
+} from "./stubs.ts";
+import { resetWagmiState, wagmiState } from "./wagmiState.ts";
+
+describe("useSendAuthorized* / useSendCancelAuthorization", () => {
+  beforeEach(() => {
+    resetWagmiState();
+    resetSdkConfigAddress();
+  });
+
+  test("未接続時は mutate が失敗", async () => {
+    wagmiState.publicClient = stubPublicClient();
+    wagmiState.walletClient = stubWalletClient();
+    wagmiState.address = undefined;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSendAuthorizedSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate(minimalSignedSingleTransfer());
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(
+      /TWC: connect a wallet to send or sign/,
+    );
+  });
+
+  test("sdk_js: config ゼロでは assert が失敗", async () => {
+    setSdkConfigAddressZero();
+    const { publicClient: pc, walletClient } = stubClientsSignatureSendSuccess();
+    wagmiState.publicClient = stubPublicClient({
+      simulateContract: pc.simulateContract,
+      getCode: async () => "0x",
+    });
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSendAuthorizedSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate(minimalSignedSingleTransfer());
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(
+      /not deployed at/,
+    );
+  });
+
+  test("RPC: simulate が revert 相当で失敗すると伝播", async () => {
+    const { publicClient, walletClient } = stubClientsSignatureSendSimulateFails();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSendAuthorizedSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate(minimalSignedSingleTransfer());
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/RPC: execution reverted/);
+  });
+
+  test("sdk_js: domain の verifyingContract が config と不一致なら失敗", async () => {
+    const { publicClient, walletClient } = stubClientsSignatureSendSuccess();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const base = minimalSignedSingleTransfer();
+    const wrong: typeof base = {
+      ...base,
+      domain: {
+        ...base.domain,
+        verifyingContract: ADDR_B,
+      },
+    };
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSendAuthorizedSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate(wrong);
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(
+      /verifyingContract .* does not match transferWithCommitmentAddress/,
+    );
+  });
+
+  test("成功時は tx ハッシュが data", async () => {
+    const { publicClient, walletClient } = stubClientsSignatureSendSuccess();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSendAuthorizedSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate(minimalSignedSingleTransfer());
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toMatch(/^0x/);
+  });
+
+  test("useSendAuthorizedUnifiedTransfer が RPC 失敗を伝播", async () => {
+    const { publicClient, walletClient } = stubClientsSignatureSendSimulateFails();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSendAuthorizedUnifiedTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate(minimalSignedUni());
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/RPC: execution reverted/);
+  });
+
+  test("useSendAuthorizedBatchTransfer が RPC 失敗を伝播", async () => {
+    const { publicClient, walletClient } = stubClientsSignatureSendSimulateFails();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSendAuthorizedBatchTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate(minimalSignedBatch());
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/RPC: execution reverted/);
+  });
+
+  test("useSendCancelAuthorization が RPC 失敗を伝播", async () => {
+    const { publicClient, walletClient } = stubClientsSignatureSendSimulateFails();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSendCancelAuthorization(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate(minimalSignedCancel());
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/RPC: execution reverted/);
+  });
+
+  test("domain chainId がクライアントと不一致なら失敗", async () => {
+    const { publicClient, walletClient } = stubClientsSignatureSendSuccess();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const d = testDomain(undefined, 2);
+    const wrongSigned = {
+      ...minimalSignedSingleTransfer(),
+      domain: {
+        name: d.name,
+        version: d.version,
+        chainId: d.chainId,
+        verifyingContract: d.verifyingContract,
+      },
+    };
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSendAuthorizedSingleTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate(wrongSigned as SignedSingleTransfer);
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(
+      /domain\.chainId .* does not match client chain id/,
+    );
+  });
+});

package/test/hooks.verify.test.ts

@@ -0,0 +1,230 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { transferWithCommitmentAbi } from "eth-twc-sdk-js/abi";
+import { transferWithCommitmentAddress } from "eth-twc-sdk-js/config";
+import { encodeAbiParameters, encodeEventTopics } from "viem";
+import { mainnet } from "viem/chains";
+import type { Chain, Hex, PublicClient } from "viem";
+
+import {
+  useTransferWithCommitmentSentLogs,
+  useVerifyTransfer,
+} from "../hooks/verify.ts";
+import { ADDR, COMMIT } from "./fixtures.ts";
+import { createQueryWrapper, createTestQueryClient } from "./queryClient.tsx";
+import { resetSdkConfigAddress, setSdkConfigAddressZero } from "./sdkConfigState.ts";
+import { stubPublicClient } from "./stubs.ts";
+import { resetWagmiState, wagmiState } from "./wagmiState.ts";
+
+const TX = ("0x" + "ab".repeat(32)) as Hex;
+
+const validVerifyArgs = {
+  from: ADDR,
+  token: ADDR,
+  to: ADDR,
+  value: 1n,
+  commitment: COMMIT,
+};
+
+describe("useVerifyTransfer", () => {
+  beforeEach(() => {
+    resetWagmiState();
+    resetSdkConfigAddress();
+  });
+
+  test("txHash / args が無いときはクエリが enabled にならず fetch しない", async () => {
+    wagmiState.publicClient = stubPublicClient();
+    const qc = createTestQueryClient();
+    const { result } = renderHook(
+      () => useVerifyTransfer(undefined, validVerifyArgs),
+      { wrapper: createQueryWrapper(qc) },
+    );
+    expect(result.current.fetchStatus).toBe("idle");
+    expect(result.current.status).toBe("pending");
+  });
+
+  test("sdk_js: verify の arktype 失敗は query error", async () => {
+    wagmiState.publicClient = stubPublicClient();
+    const qc = createTestQueryClient();
+    const { result } = renderHook(
+      () =>
+        useVerifyTransfer(TX, {
+          ...validVerifyArgs,
+          from: "0xbad" as Hex,
+        }),
+      { wrapper: createQueryWrapper(qc) },
+    );
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error).toBeDefined();
+  });
+
+  test("sdk_js: config ゼロでは verify が失敗して query error", async () => {
+    setSdkConfigAddressZero();
+    wagmiState.publicClient = stubPublicClient({
+      getCode: async () => "0x",
+    }) as unknown as PublicClient;
+    const qc = createTestQueryClient();
+    const { result } = renderHook(
+      () => useVerifyTransfer(TX, validVerifyArgs),
+      { wrapper: createQueryWrapper(qc) },
+    );
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(String(result.current.error?.message)).toMatch(
+      /not deployed at/,
+    );
+  });
+
+  test("RPC: getTransactionReceipt が失敗したら query error に伝播", async () => {
+    const getTransactionReceipt = mock(() =>
+      Promise.reject(new Error("RPC: receipt timeout")),
+    );
+    wagmiState.publicClient = stubPublicClient({
+      getTransactionReceipt,
+    }) as unknown as PublicClient;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(
+      () => useVerifyTransfer(TX, validVerifyArgs),
+      { wrapper: createQueryWrapper(qc) },
+    );
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/RPC: receipt timeout/);
+  });
+
+  test("レシートに該当ログが無いとき sdk_js のメッセージが伝播", async () => {
+    const getTransactionReceipt = mock(() =>
+      Promise.resolve({
+        logs: [],
+      }),
+    ) as unknown as PublicClient["getTransactionReceipt"];
+    wagmiState.publicClient = stubPublicClient({
+      getTransactionReceipt,
+    }) as unknown as PublicClient;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(
+      () => useVerifyTransfer(TX, validVerifyArgs),
+      { wrapper: createQueryWrapper(qc) },
+    );
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(
+      /TransferWithCommitmentSent event not found/,
+    );
+  });
+
+  test("例外的な chain id でも TWC デプロイ済みなら verify はレシートまで進む", async () => {
+    const getTransactionReceipt = mock(() =>
+      Promise.resolve({
+        logs: [],
+      }),
+    ) as unknown as PublicClient["getTransactionReceipt"];
+    wagmiState.publicClient = stubPublicClient({
+      chain: { id: 999_998, name: "CustomTest" } as unknown as Chain,
+      getTransactionReceipt,
+    }) as unknown as PublicClient;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(
+      () => useVerifyTransfer(TX, validVerifyArgs),
+      { wrapper: createQueryWrapper(qc) },
+    );
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(
+      /TransferWithCommitmentSent event not found/,
+    );
+  });
+
+  test("成功時は TanStack Query 用に null を data として返す", async () => {
+    const getTransactionReceipt = mock(() =>
+      Promise.resolve({
+        logs: [
+          {
+            address: transferWithCommitmentAddress,
+            topics: encodeEventTopics({
+              abi: transferWithCommitmentAbi,
+              eventName: "TransferWithCommitmentSent",
+              args: {
+                from: validVerifyArgs.from,
+                to: validVerifyArgs.to,
+                token: validVerifyArgs.token,
+              },
+            }),
+            data: encodeAbiParameters(
+              [{ type: "uint256" }, { type: "bytes32" }],
+              [validVerifyArgs.value, validVerifyArgs.commitment],
+            ),
+          },
+        ],
+      }),
+    ) as unknown as PublicClient["getTransactionReceipt"];
+    wagmiState.publicClient = stubPublicClient({
+      getTransactionReceipt,
+    }) as unknown as PublicClient;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(
+      () => useVerifyTransfer(TX, validVerifyArgs),
+      { wrapper: createQueryWrapper(qc) },
+    );
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toBeNull();
+  });
+});
+
+describe("useTransferWithCommitmentSentLogs", () => {
+  beforeEach(() => {
+    resetWagmiState();
+    resetSdkConfigAddress();
+  });
+
+  test("config ゼロでは assert が失敗", async () => {
+    setSdkConfigAddressZero();
+    wagmiState.publicClient = stubPublicClient({
+      getCode: async () => "0x",
+    }) as unknown as PublicClient;
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useTransferWithCommitmentSentLogs(TX), {
+      wrapper: createQueryWrapper(qc),
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(String(result.current.error?.message)).toMatch(
+      /not deployed at/,
+    );
+  });
+
+  test("RPC 失敗を query error に伝播", async () => {
+    const getTransactionReceipt = mock(() =>
+      Promise.reject(new Error("RPC: not found")),
+    );
+    wagmiState.publicClient = stubPublicClient({
+      getTransactionReceipt,
+    }) as unknown as PublicClient;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useTransferWithCommitmentSentLogs(TX), {
+      wrapper: createQueryWrapper(qc),
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/RPC: not found/);
+  });
+
+  test("成功時はログ配列が data（空でも例外にしない）", async () => {
+    const getTransactionReceipt = mock(() =>
+      Promise.resolve({
+        logs: [],
+      }),
+    ) as unknown as PublicClient["getTransactionReceipt"];
+    wagmiState.publicClient = stubPublicClient({
+      chain: mainnet,
+      getTransactionReceipt,
+    }) as unknown as PublicClient;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useTransferWithCommitmentSentLogs(TX), {
+      wrapper: createQueryWrapper(qc),
+    });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(Array.isArray(result.current.data)).toBe(true);
+    expect(result.current.data).toEqual([]);
+  });
+});