@qubic.ts/react 0.1.0

package/src/hooks/contract-hooks.test.tsx

@@ -0,0 +1,312 @@
+import { describe, expect, it } from "bun:test";
+import type { ContractDefinition } from "@qubic.ts/contracts";
+import type { QueryRawResult, SendTransactionResult } from "@qubic.ts/sdk";
+import { createSdk } from "@qubic.ts/sdk";
+import type { UseMutationResult, UseQueryResult } from "@tanstack/react-query";
+import { QueryClient } from "@tanstack/react-query";
+import React from "react";
+import TestRenderer, { act } from "react-test-renderer";
+import { QubicQueryProvider } from "../providers/query-provider.js";
+import { SdkProvider } from "../providers/sdk-provider.js";
+import { useContractMutation } from "./use-contract-mutation.js";
+import { useContractQuery } from "./use-contract-query.js";
+
+const demoContractsRegistry = [
+  {
+    name: "DEMO",
+    contractIndex: 7,
+    address: "A".repeat(60),
+    entries: [
+      {
+        kind: "function",
+        name: "Read",
+        inputType: 1,
+        inputTypeName: "uint64",
+        outputTypeName: "uint64",
+        outputSize: 8,
+      },
+      {
+        kind: "procedure",
+        name: "Write",
+        inputType: 2,
+        inputTypeName: "uint64",
+      },
+    ],
+  },
+] as const satisfies readonly ContractDefinition[];
+
+describe("contract hooks", () => {
+  it("useContractQuery caches results by key and avoids duplicate calls", async () => {
+    const queryClient = createTestQueryClient();
+    let queryCalls = 0;
+    let latestInput:
+      | Readonly<{
+          contractIndex: number | bigint;
+          inputType: number | bigint;
+          inputBytes?: Uint8Array;
+          expectedOutputSize?: number;
+        }>
+      | undefined;
+
+    const sdk = createMockSdk({
+      queryRaw: async (input) => {
+        queryCalls += 1;
+        latestInput = input;
+        return {
+          responseBytes: new Uint8Array([1, 2, 3, 4]),
+          responseBase64: "AQIDBA==",
+          attempts: 1,
+        };
+      },
+    });
+
+    let hookResult: UseQueryResult<QueryRawResult, Error> | undefined;
+    let renderer: TestRenderer.ReactTestRenderer | undefined;
+
+    function Consumer() {
+      hookResult = useContractQuery(
+        "DEMO",
+        "Read",
+        {
+          inputBytes: new Uint8Array([9]),
+          decodeOutput: false,
+        },
+        { staleTime: Number.POSITIVE_INFINITY },
+      );
+      return null;
+    }
+
+    await act(async () => {
+      renderer = TestRenderer.create(
+        <TestProviders sdk={sdk} queryClient={queryClient}>
+          <Consumer />
+        </TestProviders>,
+      );
+    });
+
+    await waitFor(() => hookResult?.isSuccess === true);
+    expect(queryCalls).toBe(1);
+    expect(latestInput).toEqual({
+      contractIndex: 7,
+      inputType: 1,
+      inputBytes: new Uint8Array([9]),
+      expectedOutputSize: 8,
+    });
+
+    await act(async () => {
+      renderer?.unmount();
+    });
+
+    hookResult = undefined;
+
+    await act(async () => {
+      renderer = TestRenderer.create(
+        <TestProviders sdk={sdk} queryClient={queryClient}>
+          <Consumer />
+        </TestProviders>,
+      );
+    });
+
+    await waitFor(() => hookResult?.isSuccess === true);
+    expect(queryCalls).toBe(1);
+  });
+
+  it("useContractMutation exposes success and error states", async () => {
+    const queryClient = createTestQueryClient();
+    let sendCalls = 0;
+    let latestInput:
+      | Readonly<{
+          fromSeed?: string;
+          toIdentity: string;
+          amount: bigint;
+          targetTick?: bigint | number;
+          inputType: number;
+          inputBytes: Uint8Array;
+        }>
+      | undefined;
+
+    const successSdk = createMockSdk({
+      send: async (input) => {
+        sendCalls += 1;
+        latestInput = input;
+        return {
+          txBytes: new Uint8Array([7, 8, 9]),
+          txId: "tx-success",
+          networkTxId: "network-success",
+          targetTick: 12n,
+          broadcast: {
+            peersBroadcasted: 1,
+            encodedTransaction: "BwgJ",
+            transactionId: "network-success",
+          },
+        };
+      },
+    });
+
+    let successResult: UseMutationResult<any, Error, any> | undefined;
+
+    function SuccessConsumer() {
+      successResult = useContractMutation("DEMO");
+      return null;
+    }
+
+    await act(async () => {
+      TestRenderer.create(
+        <TestProviders sdk={successSdk} queryClient={queryClient}>
+          <SuccessConsumer />
+        </TestProviders>,
+      );
+    });
+
+    await act(async () => {
+      await successResult?.mutateAsync({
+        name: "Write",
+        fromSeed: "a".repeat(55),
+        toIdentity: "B".repeat(60),
+        inputBytes: new Uint8Array([5]),
+        amount: 2n,
+        targetTick: 11n,
+      });
+    });
+
+    await waitFor(() => successResult?.isSuccess === true);
+    expect(sendCalls).toBe(1);
+    expect(latestInput).toEqual({
+      fromSeed: "a".repeat(55),
+      toIdentity: "B".repeat(60),
+      amount: 2n,
+      targetTick: 11n,
+      inputType: 2,
+      inputBytes: new Uint8Array([5]),
+    });
+    expect(successResult?.data?.txId).toBe("tx-success");
+
+    const errorClient = createTestQueryClient();
+    const errorSdk = createMockSdk({
+      send: async () => {
+        throw new Error("send failed");
+      },
+    });
+
+    let errorResult: UseMutationResult<any, Error, any> | undefined;
+
+    function ErrorConsumer() {
+      errorResult = useContractMutation("DEMO");
+      return null;
+    }
+
+    await act(async () => {
+      TestRenderer.create(
+        <TestProviders sdk={errorSdk} queryClient={errorClient}>
+          <ErrorConsumer />
+        </TestProviders>,
+      );
+    });
+
+    await act(async () => {
+      try {
+        await errorResult?.mutateAsync({
+          name: "Write",
+          fromSeed: "a".repeat(55),
+          toIdentity: "B".repeat(60),
+          inputBytes: new Uint8Array([1]),
+        });
+      } catch {
+        // Assertion is state-based below.
+      }
+    });
+
+    await waitFor(() => errorResult?.isError === true);
+    expect(errorResult?.error?.message).toBe("send failed");
+  });
+});
+
+function createTestQueryClient(): QueryClient {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+      mutations: {
+        retry: false,
+      },
+    },
+  });
+}
+
+function TestProviders(props: {
+  sdk: ReturnType<typeof createSdk>;
+  queryClient: QueryClient;
+  children: React.ReactNode;
+}) {
+  return (
+    <QubicQueryProvider client={props.queryClient}>
+      <SdkProvider sdk={props.sdk} contractsRegistry={demoContractsRegistry}>
+        {props.children}
+      </SdkProvider>
+    </QubicQueryProvider>
+  );
+}
+
+function createMockSdk(overrides: Readonly<{
+  queryRaw?: (input: {
+    contractIndex: number | bigint;
+    inputType: number | bigint;
+    inputBytes?: Uint8Array;
+    expectedOutputSize?: number;
+    retries?: number;
+    retryDelayMs?: number;
+    signal?: AbortSignal;
+  }) => Promise<QueryRawResult>;
+  send?: (input: {
+    fromSeed?: string;
+    fromVault?: string;
+    toIdentity: string;
+    amount: bigint;
+    targetTick?: bigint | number;
+    inputType: number;
+    inputBytes: Uint8Array;
+  }) => Promise<SendTransactionResult>;
+}>): ReturnType<typeof createSdk> {
+  return {
+    contracts: {
+      queryRaw:
+        overrides.queryRaw ??
+        (async () => ({
+          responseBytes: new Uint8Array(),
+          responseBase64: "",
+          attempts: 1,
+        })),
+    },
+    transactions: {
+      send:
+        overrides.send ??
+        (async () => ({
+          txBytes: new Uint8Array(),
+          txId: "tx-default",
+          networkTxId: "network-default",
+          targetTick: 0n,
+          broadcast: {
+            peersBroadcasted: 1,
+            encodedTransaction: "",
+            transactionId: "network-default",
+          },
+        })),
+    },
+  } as unknown as ReturnType<typeof createSdk>;
+}
+
+async function waitFor(predicate: () => boolean, timeoutMs = 3000): Promise<void> {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (predicate()) return;
+    await act(async () => {
+      await sleep(10);
+    });
+  }
+  throw new Error("Timed out waiting for condition");
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/hooks/read-hooks.test.tsx

@@ -0,0 +1,339 @@
+import { describe, expect, it } from "bun:test";
+import type {
+  LastProcessedTick,
+  LiveBalance,
+  QueryTransaction,
+  TickInfo,
+  TransactionsForIdentityRequest,
+  TransactionsForIdentityResponse,
+} from "@qubic.ts/sdk";
+import { createSdk } from "@qubic.ts/sdk";
+import type { InfiniteData, UseInfiniteQueryResult, UseQueryResult } from "@tanstack/react-query";
+import { QueryClient } from "@tanstack/react-query";
+import React from "react";
+import TestRenderer, { act } from "react-test-renderer";
+import { QubicQueryProvider } from "../providers/query-provider.js";
+import { SdkProvider } from "../providers/sdk-provider.js";
+import { queryKeys } from "../query/keys.js";
+import { useBalance } from "./use-balance.js";
+import { useLastProcessedTick } from "./use-last-processed-tick.js";
+import { useTickInfo } from "./use-tick-info.js";
+import { useTransactions } from "./use-transactions.js";
+
+describe("read hooks", () => {
+  it("useBalance caches by query key and reuses cached data on remount", async () => {
+    const queryClient = createTestQueryClient();
+    let balanceCalls = 0;
+    const sdk = createMockSdk({
+      balance: async (identity) => {
+        balanceCalls += 1;
+        return createBalance(identity, 100n);
+      },
+    });
+
+    let firstBalance: LiveBalance | undefined;
+    let secondBalance: LiveBalance | undefined;
+    let renderer: TestRenderer.ReactTestRenderer | undefined;
+
+    function Consumer() {
+      firstBalance = useBalance("ID1", { staleTime: Number.POSITIVE_INFINITY }).data;
+      secondBalance = useBalance("ID1", { staleTime: Number.POSITIVE_INFINITY }).data;
+      return null;
+    }
+
+    await act(async () => {
+      renderer = TestRenderer.create(
+        <TestProviders sdk={sdk} queryClient={queryClient}>
+          <Consumer />
+        </TestProviders>,
+      );
+    });
+
+    await waitFor(() => firstBalance !== undefined && secondBalance !== undefined);
+    expect(balanceCalls).toBe(1);
+
+    await act(async () => {
+      renderer?.unmount();
+    });
+
+    firstBalance = undefined;
+    secondBalance = undefined;
+
+    await act(async () => {
+      renderer = TestRenderer.create(
+        <TestProviders sdk={sdk} queryClient={queryClient}>
+          <Consumer />
+        </TestProviders>,
+      );
+    });
+
+    await waitFor(() => firstBalance !== undefined && secondBalance !== undefined);
+    expect(balanceCalls).toBe(1);
+  });
+
+  it("useTickInfo refetches on demand", async () => {
+    const queryClient = createTestQueryClient();
+    let tickCalls = 0;
+    const sdk = createMockSdk({
+      tickInfo: async () => {
+        tickCalls += 1;
+        return createTickInfo(BigInt(tickCalls));
+      },
+    });
+
+    let hookResult: UseQueryResult<TickInfo, Error> | undefined;
+
+    function Consumer() {
+      hookResult = useTickInfo({ staleTime: Number.POSITIVE_INFINITY });
+      return null;
+    }
+
+    await act(async () => {
+      TestRenderer.create(
+        <TestProviders sdk={sdk} queryClient={queryClient}>
+          <Consumer />
+        </TestProviders>,
+      );
+    });
+
+    await waitFor(() => hookResult?.isSuccess === true);
+    expect(hookResult?.data?.tick).toBe(1n);
+    expect(tickCalls).toBe(1);
+
+    await act(async () => {
+      await hookResult?.refetch();
+    });
+
+    await waitFor(() => hookResult?.data?.tick === 2n);
+    expect(tickCalls).toBe(2);
+    expect(hookResult?.data?.tick).toBe(2n);
+  });
+
+  it("useLastProcessedTick refetches when invalidated", async () => {
+    const queryClient = createTestQueryClient();
+    let processedTickCalls = 0;
+    const sdk = createMockSdk({
+      lastProcessedTick: async () => {
+        processedTickCalls += 1;
+        return createLastProcessedTick(BigInt(processedTickCalls));
+      },
+    });
+
+    let hookResult: UseQueryResult<LastProcessedTick, Error> | undefined;
+
+    function Consumer() {
+      hookResult = useLastProcessedTick({ staleTime: Number.POSITIVE_INFINITY });
+      return null;
+    }
+
+    await act(async () => {
+      TestRenderer.create(
+        <TestProviders sdk={sdk} queryClient={queryClient}>
+          <Consumer />
+        </TestProviders>,
+      );
+    });
+
+    await waitFor(() => hookResult?.isSuccess === true);
+    expect(hookResult?.data?.tickNumber).toBe(1n);
+    expect(processedTickCalls).toBe(1);
+
+    await act(async () => {
+      await queryClient.invalidateQueries({ queryKey: queryKeys.lastProcessedTick() });
+    });
+
+    await waitFor(() => hookResult?.data?.tickNumber === 2n);
+    expect(processedTickCalls).toBe(2);
+    expect(hookResult?.data?.tickNumber).toBe(2n);
+  });
+
+  it("useTransactions paginates and reuses cached pages", async () => {
+    const queryClient = createTestQueryClient();
+    const transactions = [createTransaction(1), createTransaction(2), createTransaction(3)];
+    let transactionCalls = 0;
+    const sdk = createMockSdk({
+      transactionsForIdentity: async (input) => {
+        transactionCalls += 1;
+        const offset = Number(input.pagination?.offset ?? 0n);
+        const size = Number(input.pagination?.size ?? 100n);
+        return createTransactionsResponse(transactions, offset, size);
+      },
+    });
+
+    let hookResult: UseInfiniteQueryResult<InfiniteData<TransactionsForIdentityResponse>, Error> | undefined;
+    let renderer: TestRenderer.ReactTestRenderer | undefined;
+
+    function Consumer() {
+      hookResult = useTransactions(
+        {
+          identity: "ID1",
+          pageSize: 2,
+          limit: 3,
+        },
+        { staleTime: Number.POSITIVE_INFINITY },
+      );
+      return null;
+    }
+
+    await act(async () => {
+      renderer = TestRenderer.create(
+        <TestProviders sdk={sdk} queryClient={queryClient}>
+          <Consumer />
+        </TestProviders>,
+      );
+    });
+
+    await waitFor(() => hookResult?.isSuccess === true);
+    expect(hookResult?.data?.pages[0]?.transactions.length).toBe(2);
+    expect(transactionCalls).toBe(1);
+
+    await act(async () => {
+      await hookResult?.fetchNextPage();
+    });
+
+    await waitFor(() => hookResult?.data?.pages.length === 2);
+    expect(hookResult?.data?.pages[1]?.transactions.length).toBe(1);
+    expect(transactionCalls).toBe(2);
+
+    await act(async () => {
+      renderer?.unmount();
+    });
+
+    hookResult = undefined;
+
+    await act(async () => {
+      renderer = TestRenderer.create(
+        <TestProviders sdk={sdk} queryClient={queryClient}>
+          <Consumer />
+        </TestProviders>,
+      );
+    });
+
+    await waitFor(() => hookResult?.isSuccess === true);
+    expect(transactionCalls).toBe(2);
+  });
+});
+
+function createTestQueryClient(): QueryClient {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  });
+}
+
+function TestProviders(props: {
+  sdk: ReturnType<typeof createSdk>;
+  queryClient: QueryClient;
+  children: React.ReactNode;
+}) {
+  return (
+    <QubicQueryProvider client={props.queryClient}>
+      <SdkProvider sdk={props.sdk}>{props.children}</SdkProvider>
+    </QubicQueryProvider>
+  );
+}
+
+function createMockSdk(overrides: Readonly<{
+  balance?: (identity: string) => Promise<LiveBalance>;
+  tickInfo?: () => Promise<TickInfo>;
+  lastProcessedTick?: () => Promise<LastProcessedTick>;
+  transactionsForIdentity?: (
+    input: TransactionsForIdentityRequest,
+  ) => Promise<TransactionsForIdentityResponse>;
+}>): ReturnType<typeof createSdk> {
+  return {
+    rpc: {
+      live: {
+        balance: overrides.balance ?? (async (identity) => createBalance(identity, 0n)),
+        tickInfo: overrides.tickInfo ?? (async () => createTickInfo(0n)),
+      },
+      query: {
+        getLastProcessedTick:
+          overrides.lastProcessedTick ?? (async () => createLastProcessedTick(0n)),
+        getTransactionsForIdentity:
+          overrides.transactionsForIdentity ??
+          (async () => createTransactionsResponse([], 0, 100)),
+      },
+    },
+  } as unknown as ReturnType<typeof createSdk>;
+}
+
+function createTickInfo(tick: bigint): TickInfo {
+  return {
+    tick,
+    duration: 5n,
+    epoch: 1n,
+    initialTick: 1n,
+  };
+}
+
+function createBalance(identity: string, balance: bigint): LiveBalance {
+  return {
+    id: identity,
+    balance,
+    validForTick: 1n,
+    latestIncomingTransferTick: 0n,
+    latestOutgoingTransferTick: 0n,
+    incomingAmount: 0n,
+    outgoingAmount: 0n,
+    numberOfIncomingTransfers: 0n,
+    numberOfOutgoingTransfers: 0n,
+  };
+}
+
+function createLastProcessedTick(tickNumber: bigint): LastProcessedTick {
+  return {
+    tickNumber,
+    epoch: 1n,
+    intervalInitialTick: 1n,
+  };
+}
+
+function createTransaction(index: number): QueryTransaction {
+  return {
+    hash: `hash-${index}`,
+    amount: BigInt(index),
+    source: `source-${index}`,
+    destination: `destination-${index}`,
+    tickNumber: BigInt(index),
+    timestamp: BigInt(index),
+    inputType: 0n,
+    inputSize: 0n,
+    inputData: "",
+    signature: `sig-${index}`,
+  };
+}
+
+function createTransactionsResponse(
+  allTransactions: readonly QueryTransaction[],
+  offset: number,
+  size: number,
+): TransactionsForIdentityResponse {
+  return {
+    validForTick: 1n,
+    hits: {
+      total: BigInt(allTransactions.length),
+      from: BigInt(offset),
+      size: BigInt(size),
+    },
+    transactions: allTransactions.slice(offset, offset + size),
+  };
+}
+
+async function waitFor(predicate: () => boolean, timeoutMs = 3000): Promise<void> {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (predicate()) return;
+    await act(async () => {
+      await sleep(10);
+    });
+  }
+  throw new Error("Timed out waiting for condition");
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}