eth-twc-sdk-react 0.1.0

package/hooks/signatureTransfer.ts

@@ -0,0 +1,110 @@
+"use client";
+
+import { useMutation, type UseMutationOptions } from "@tanstack/react-query";
+import type { SignedBatchTransfer } from "eth-twc-sdk-js/signatureTransfer/batch";
+import type { SignedCancelAuthorization } from "eth-twc-sdk-js/signatureTransfer/cancelAuthorization";
+import type { SignedSingleTransfer } from "eth-twc-sdk-js/signatureTransfer/single";
+import type { SignedUnifiedTransfer } from "eth-twc-sdk-js/signatureTransfer/unified";
+import { sendTx as sendAuthorizedBatch } from "eth-twc-sdk-js/signatureTransfer/batch";
+import { sendTx as sendCancelAuthorization } from "eth-twc-sdk-js/signatureTransfer/cancelAuthorization";
+import { sendTx as sendAuthorizedSingle } from "eth-twc-sdk-js/signatureTransfer/single";
+import { sendTx as sendAuthorizedUnified } from "eth-twc-sdk-js/signatureTransfer/unified";
+import type { Hex } from "viem";
+import { useConnection, usePublicClient, useWalletClient } from "wagmi";
+
+import { narrowWriteClients } from "./clients.ts";
+
+export function useSendAuthorizedSingleTransfer(
+  options?: Omit<
+    UseMutationOptions<Hex, Error, SignedSingleTransfer>,
+    "mutationFn"
+  >,
+) {
+  const publicClient = usePublicClient();
+  const { data: walletClient } = useWalletClient();
+  const { address } = useConnection();
+
+  return useMutation({
+    ...options,
+    mutationFn: async (signed: SignedSingleTransfer) => {
+      const [pc, wc, addr] = narrowWriteClients(
+        publicClient,
+        walletClient,
+        address,
+      );
+      return sendAuthorizedSingle(pc, wc, addr, signed);
+    },
+  });
+}
+
+export function useSendAuthorizedUnifiedTransfer(
+  options?: Omit<
+    UseMutationOptions<Hex, Error, SignedUnifiedTransfer>,
+    "mutationFn"
+  >,
+) {
+  const publicClient = usePublicClient();
+  const { data: walletClient } = useWalletClient();
+  const { address } = useConnection();
+
+  return useMutation({
+    ...options,
+    mutationFn: async (signed: SignedUnifiedTransfer) => {
+      const [pc, wc, addr] = narrowWriteClients(
+        publicClient,
+        walletClient,
+        address,
+      );
+      return sendAuthorizedUnified(pc, wc, addr, signed);
+    },
+  });
+}
+
+export const useSendAuthorizedUniCommitTransfers =
+  useSendAuthorizedUnifiedTransfer;
+
+export function useSendAuthorizedBatchTransfer(
+  options?: Omit<
+    UseMutationOptions<Hex, Error, SignedBatchTransfer>,
+    "mutationFn"
+  >,
+) {
+  const publicClient = usePublicClient();
+  const { data: walletClient } = useWalletClient();
+  const { address } = useConnection();
+
+  return useMutation({
+    ...options,
+    mutationFn: async (signed: SignedBatchTransfer) => {
+      const [pc, wc, addr] = narrowWriteClients(
+        publicClient,
+        walletClient,
+        address,
+      );
+      return sendAuthorizedBatch(pc, wc, addr, signed);
+    },
+  });
+}
+
+export function useSendCancelAuthorization(
+  options?: Omit<
+    UseMutationOptions<Hex, Error, SignedCancelAuthorization>,
+    "mutationFn"
+  >,
+) {
+  const publicClient = usePublicClient();
+  const { data: walletClient } = useWalletClient();
+  const { address } = useConnection();
+
+  return useMutation({
+    ...options,
+    mutationFn: async (signed: SignedCancelAuthorization) => {
+      const [pc, wc, addr] = narrowWriteClients(
+        publicClient,
+        walletClient,
+        address,
+      );
+      return sendCancelAuthorization(pc, wc, addr, signed);
+    },
+  });
+}

package/hooks/verify.ts

@@ -0,0 +1,67 @@
+"use client";
+
+import {
+  useQuery,
+  type UseQueryOptions,
+  type UseQueryResult,
+} from "@tanstack/react-query";
+import {
+  getTransferWithCommitmentSentEventLogs,
+  verify,
+} from "eth-twc-sdk-js/verify";
+import type { Hex, Log } from "viem";
+import { usePublicClient } from "wagmi";
+
+/** Args for `verify` — same shape as the third argument to `eth-twc-sdk-js/verify`. */
+export type VerifyTransferArgs = Parameters<typeof verify>[2];
+
+export function useVerifyTransfer(
+  txHash: Hex | undefined,
+  args: VerifyTransferArgs | undefined,
+  options?: Omit<UseQueryOptions<null, Error, null>, "queryKey" | "queryFn">,
+): UseQueryResult<null, Error> {
+  const publicClient = usePublicClient();
+  const { enabled: enabledOption, ...queryOptions } = options ?? {};
+
+  return useQuery({
+    ...queryOptions,
+    queryKey: [
+      "twc",
+      "verify",
+      txHash ?? null,
+      args?.from ?? null,
+      args?.token ?? null,
+      args?.to ?? null,
+      args != null ? args.value.toString() : null,
+      args?.commitment ?? null,
+    ],
+    queryFn: async () => {
+      if (!publicClient) throw new Error("TWC: public client is not available");
+      if (!txHash) throw new Error("TWC: tx hash is required");
+      if (!args) throw new Error("TWC: verify args are required");
+      await verify(publicClient, txHash, args);
+      return null;
+    },
+    enabled:
+      Boolean(publicClient && txHash && args) && (enabledOption ?? true),
+  });
+}
+
+export function useTransferWithCommitmentSentLogs(
+  txHash: Hex | undefined,
+  options?: Omit<UseQueryOptions<Log[], Error, Log[]>, "queryKey" | "queryFn">,
+): UseQueryResult<Log[], Error> {
+  const publicClient = usePublicClient();
+  const { enabled: enabledOption, ...queryOptions } = options ?? {};
+
+  return useQuery({
+    ...queryOptions,
+    queryKey: ["twc", "transferWithCommitmentSent", txHash ?? null],
+    queryFn: async () => {
+      if (!publicClient) throw new Error("TWC: public client is not available");
+      if (!txHash) throw new Error("TWC: tx hash is required");
+      return getTransferWithCommitmentSentEventLogs(publicClient, txHash);
+    },
+    enabled: Boolean(publicClient && txHash) && (enabledOption ?? true),
+  });
+}

package/index.ts

@@ -0,0 +1 @@
+export * from "./hooks/index.ts";

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "eth-twc-sdk-react",
+  "version": "0.1.0",
+  "module": "index.ts",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "scripts": {
+    "test": "bun test --preload ./test/preload.ts --concurrency 1 ./test/",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p test/tsconfig.json"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.59.0",
+    "react": "^18 || ^19",
+    "typescript": "^5",
+    "viem": "^2.0.0",
+    "wagmi": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "eth-twc-sdk-js": "^0.1.0"
+  },
+  "devDependencies": {
+    "@tanstack/react-query": "^5.99.0",
+    "@testing-library/react": "^16.3.0",
+    "@types/bun": "latest",
+    "@types/react": "^19",
+    "happy-dom": "^20.0.10",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "typescript": "^5",
+    "viem": "2.x",
+    "wagmi": "^3.6.1"
+  }
+}

package/test/clients.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { mainnet } from "viem/chains";
+import type { Hex, PublicClient, WalletClient } from "viem";
+
+import { narrowWriteClients } from "../hooks/clients.ts";
+
+describe("narrowWriteClients", () => {
+  const pc = { chain: mainnet } as unknown as PublicClient;
+  const wc = { chain: mainnet } as unknown as WalletClient;
+  const addr = "0x1111111111111111111111111111111111111111" as Hex;
+
+  test("public client が無いときは TWC: public client", () => {
+    expect(() =>
+      narrowWriteClients(undefined, wc, addr),
+    ).toThrow(/TWC: public client is not available/);
+  });
+
+  test("wallet client が無いときは TWC: wallet client", () => {
+    expect(() => narrowWriteClients(pc, undefined, addr)).toThrow(
+      /TWC: wallet client is not available/,
+    );
+  });
+
+  test("address が無いときは connect a wallet", () => {
+    expect(() => narrowWriteClients(pc, wc, undefined)).toThrow(
+      /TWC: connect a wallet to send or sign/,
+    );
+  });
+
+  test("揃っているときはタプルを返す", () => {
+    expect(narrowWriteClients(pc, wc, addr)).toEqual([pc, wc, addr]);
+  });
+});

package/test/fixtures.ts

@@ -0,0 +1,11 @@
+/**
+ * sdk_js の単体テストと同じ定数（config モックと整合）。
+ */
+export {
+  ADDR,
+  ADDR_B,
+  COMMIT,
+  SALT_ZERO,
+  TEST_VERIFIER_CONTRACT,
+  testDomain,
+} from "../../sdk_js/test/unit/fixtures.ts";

package/test/hooks.configInfo.test.ts

@@ -0,0 +1,94 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type { Chain, PublicClient } from "viem";
+import { mainnet } from "viem/chains";
+
+import {
+  useIsSupportedChain,
+  useIsTransferWithCommitmentDeployed,
+} from "../hooks/configInfo.ts";
+import { EIP712_DOMAIN_NAME } from "../hooks/sdkConfig.ts";
+import { TEST_VERIFIER_CONTRACT } from "./fixtures.ts";
+import { createQueryWrapper, createTestQueryClient } from "./queryClient.tsx";
+import { resetSdkConfigAddress, sdkConfigState } from "./sdkConfigState.ts";
+import { resetWagmiState, wagmiState } from "./wagmiState.ts";
+import { stubPublicClient } from "./stubs.ts";
+
+describe("sdkConfig 再エクスポート", () => {
+  beforeEach(() => {
+    resetSdkConfigAddress();
+  });
+
+  test("transferWithCommitmentAddress はモック config と一致", () => {
+    expect(sdkConfigState.transferWithCommitmentAddress).toBe(
+      TEST_VERIFIER_CONTRACT,
+    );
+  });
+
+  test("EIP712_DOMAIN_NAME がコントラクトと一致", () => {
+    expect(EIP712_DOMAIN_NAME).toBe("TransferWithCommitment");
+  });
+});
+
+describe("useIsTransferWithCommitmentDeployed", () => {
+  beforeEach(() => {
+    resetWagmiState();
+  });
+
+  test("public client が無いときは false", () => {
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useIsTransferWithCommitmentDeployed(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    expect(result.current).toBe(false);
+  });
+
+  test("getCode が空なら false", async () => {
+    const qc = createTestQueryClient();
+    wagmiState.publicClient = stubPublicClient({
+      getCode: mock(() => Promise.resolve("0x")) as unknown as PublicClient["getCode"],
+    });
+    const { result } = renderHook(() => useIsTransferWithCommitmentDeployed(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    await waitFor(() => expect(result.current).toBe(false));
+  });
+
+  test("getCode が非空なら true", async () => {
+    const qc = createTestQueryClient();
+    wagmiState.publicClient = stubPublicClient({
+      chain: mainnet,
+      getCode: mock(() =>
+        Promise.resolve("0x6000"),
+      ) as unknown as PublicClient["getCode"],
+    });
+    const { result } = renderHook(() => useIsTransferWithCommitmentDeployed(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    await waitFor(() => expect(result.current).toBe(true));
+  });
+
+  test("未知名義の chain でも getCode が成功すれば評価される", async () => {
+    const qc = createTestQueryClient();
+    wagmiState.publicClient = stubPublicClient({
+      chain: { id: 999_999, name: "Unknown" } as unknown as Chain,
+      getCode: mock(() =>
+        Promise.resolve("0x6000"),
+      ) as unknown as PublicClient["getCode"],
+    });
+    const { result } = renderHook(() => useIsTransferWithCommitmentDeployed(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    await waitFor(() => expect(result.current).toBe(true));
+  });
+});
+
+describe("useIsSupportedChain（非推奨エイリアス）", () => {
+  beforeEach(() => {
+    resetWagmiState();
+  });
+
+  test("useIsTransferWithCommitmentDeployed と同じ参照", () => {
+    expect(useIsSupportedChain).toBe(useIsTransferWithCommitmentDeployed);
+  });
+});

package/test/hooks.selfTransfer.test.ts

@@ -0,0 +1,173 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, test } from "bun:test";
+import type { Hex } from "viem";
+import { mainnet } from "viem/chains";
+
+import { useSelfBatchTransfer, useSelfTransfer, useSelfUnifiedTransfer } from "../hooks/selfTransfer.ts";
+import { ADDR, ADDR_B, COMMIT } from "./fixtures.ts";
+import { createQueryWrapper, createTestQueryClient } from "./queryClient.tsx";
+import { resetSdkConfigAddress, setSdkConfigAddressZero } from "./sdkConfigState.ts";
+import {
+  stubClientsSelfTransferSimulateRpcError,
+  stubClientsSelfTransferSuccess,
+  stubPublicClient,
+  stubWalletClient,
+} from "./stubs.ts";
+import { resetWagmiState, wagmiState } from "./wagmiState.ts";
+
+describe("useSelfTransfer / useSelfUnifiedTransfer / useSelfBatchTransfer", () => {
+  beforeEach(() => {
+    resetWagmiState();
+    resetSdkConfigAddress();
+  });
+
+  test("未接続（address なし）は mutate が narrowWriteClients で失敗", async () => {
+    wagmiState.publicClient = stubPublicClient();
+    wagmiState.walletClient = stubWalletClient();
+    wagmiState.address = undefined;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSelfTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      token: ADDR,
+      to: 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: transferWithCommitmentAddress がゼロのとき assert が失敗", async () => {
+    setSdkConfigAddressZero();
+    const { publicClient: pc, walletClient } = stubClientsSelfTransferSuccess();
+    wagmiState.publicClient = stubPublicClient({
+      simulateContract: pc.simulateContract,
+      getCode: async () => "0x",
+    });
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSelfTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      token: ADDR,
+      to: 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: simulateContract が拒否されると mutation error にメッセージが伝播", async () => {
+    const { publicClient, walletClient } = stubClientsSelfTransferSimulateRpcError();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSelfTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      token: ADDR,
+      to: ADDR_B,
+      value: 1n,
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/RPC: eth_call failed/);
+  });
+
+  test("PublicClient と WalletClient の chain.id が異なれば chain mismatch", async () => {
+    const { publicClient, walletClient } = stubClientsSelfTransferSuccess();
+    wagmiState.publicClient = {
+      ...publicClient,
+      chain: mainnet,
+    } as typeof publicClient;
+    wagmiState.walletClient = {
+      ...walletClient,
+      chain: { id: 137, name: "Polygon" },
+    } as typeof walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSelfTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      token: ADDR,
+      to: ADDR_B,
+      value: 1n,
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/chain mismatch/);
+  });
+
+  test("成功時は write の戻り tx ハッシュが data になる", async () => {
+    const { publicClient, walletClient } = stubClientsSelfTransferSuccess();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSelfTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      token: ADDR,
+      to: ADDR_B,
+      value: 1n,
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toMatch(/^0x[a-fA-F0-9]+$/);
+  });
+
+  test("useSelfUnifiedTransfer も同様に RPC 失敗を伝播", async () => {
+    const { publicClient, walletClient } = stubClientsSelfTransferSimulateRpcError();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSelfUnifiedTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      details: [{ to: ADDR_B, token: ADDR, value: 1n }],
+      commitment: COMMIT,
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/RPC: eth_call failed/);
+  });
+
+  test("useSelfBatchTransfer も同様に RPC 失敗を伝播", async () => {
+    const { publicClient, walletClient } = stubClientsSelfTransferSimulateRpcError();
+    wagmiState.publicClient = publicClient;
+    wagmiState.walletClient = walletClient;
+    wagmiState.address = ADDR as Hex;
+
+    const qc = createTestQueryClient();
+    const { result } = renderHook(() => useSelfBatchTransfer(), {
+      wrapper: createQueryWrapper(qc),
+    });
+    result.current.mutate({
+      details: [
+        { to: ADDR_B, token: ADDR, value: 1n, commitment: COMMIT },
+      ],
+    });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error?.message).toMatch(/RPC: eth_call failed/);
+  });
+});