@unifold/headless-react 0.1.70-beta.1

package/dist/index.mjs

@@ -0,0 +1,402 @@
+// src/index.ts
+import { UnifoldProvider, useUnifold as useUnifold8 } from "@unifold/react-provider";
+
+// src/use-unifold-client.ts
+import { useMemo } from "react";
+import { createUnifoldClient } from "@unifold/core";
+import { useUnifold } from "@unifold/react-provider";
+function useUnifoldClient() {
+  const { publishableKey } = useUnifold();
+  return useMemo(
+    () => publishableKey ? createUnifoldClient({ publishableKey }) : null,
+    [publishableKey]
+  );
+}
+
+// src/use-deposit.ts
+import { useCallback, useEffect, useMemo as useMemo2, useRef, useState, useSyncExternalStore } from "react";
+import {
+  DepositSession,
+  DepositSessionEventType
+} from "@unifold/core";
+import { useUnifold as useUnifold2 } from "@unifold/react-provider";
+var IDLE_SNAPSHOT = {
+  status: "idle",
+  addresses: [],
+  executions: [],
+  latestExecution: null,
+  isCheckingDeposit: false,
+  error: null
+};
+function useDeposit(options) {
+  const { publishableKey } = useUnifold2();
+  const {
+    externalUserId,
+    destination,
+    confirmationMode = "auto",
+    method,
+    autoStart = true
+  } = options;
+  const callbacksRef = useRef(options);
+  useEffect(() => {
+    callbacksRef.current = options;
+  });
+  const [session, setSession] = useState(null);
+  const sessionKey = [
+    publishableKey,
+    externalUserId ?? "",
+    destination.chainType,
+    destination.chainId,
+    destination.tokenAddress,
+    destination.recipientAddress,
+    JSON.stringify(destination.contractCalls ?? null),
+    confirmationMode,
+    method ?? ""
+  ].join("|");
+  useEffect(() => {
+    if (!publishableKey || !externalUserId) {
+      setSession(null);
+      return;
+    }
+    const nextSession = new DepositSession({
+      publishableKey,
+      externalUserId,
+      destination,
+      confirmationMode,
+      method
+    });
+    let previousStatus = nextSession.getSnapshot().status;
+    const offEvents = nextSession.on("*", (event) => {
+      const callbacks = callbacksRef.current;
+      callbacks.onEvent?.(event);
+      switch (event.type) {
+        case DepositSessionEventType.ADDRESSES_CREATED:
+          callbacks.onAddressesReady?.(event.data.object.addresses);
+          break;
+        case DepositSessionEventType.EXECUTION_DETECTED:
+          callbacks.onExecutionDetected?.(event.data.object);
+          break;
+        case DepositSessionEventType.EXECUTION_UPDATED:
+          callbacks.onExecutionUpdated?.(event.data.object);
+          break;
+        case DepositSessionEventType.EXECUTION_SUCCEEDED:
+          callbacks.onSuccess?.(event.data.object);
+          break;
+        case DepositSessionEventType.EXECUTION_FAILED:
+          callbacks.onError?.({
+            code: "DEPOSIT_FAILED",
+            message: "Deposit failed",
+            fatal: false,
+            cause: event.data.object
+          });
+          break;
+        case DepositSessionEventType.SESSION_ERRORED:
+          callbacks.onError?.({
+            code: event.data.object.code,
+            message: event.data.object.message,
+            fatal: event.data.object.fatal
+          });
+          break;
+      }
+    });
+    const offStatus = nextSession.subscribe(() => {
+      const status = nextSession.getSnapshot().status;
+      if (status !== previousStatus) {
+        previousStatus = status;
+        callbacksRef.current.onStatusChange?.(status);
+      }
+    });
+    setSession(nextSession);
+    if (autoStart) {
+      void nextSession.start();
+    }
+    return () => {
+      offEvents();
+      offStatus();
+      nextSession.destroy();
+    };
+  }, [sessionKey, autoStart]);
+  const subscribe = useCallback(
+    (listener) => session ? session.subscribe(listener) : () => {
+    },
+    [session]
+  );
+  const getSnapshot = useCallback(
+    () => session ? session.getSnapshot() : IDLE_SNAPSHOT,
+    [session]
+  );
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, () => IDLE_SNAPSHOT);
+  const getAddress = useCallback(
+    (query) => snapshot.addresses.find((a) => a.chainType === query.chainType),
+    [snapshot.addresses]
+  );
+  const controls = useMemo2(
+    () => ({
+      start: () => session?.start() ?? Promise.resolve(),
+      confirmFundsSent: () => session?.confirmFundsSent(),
+      stop: () => session?.stop(),
+      restart: async () => {
+        if (!session) return;
+        session.stop();
+        await session.start();
+      }
+    }),
+    [session]
+  );
+  return {
+    status: snapshot.status,
+    addresses: snapshot.addresses,
+    getAddress,
+    executions: snapshot.executions,
+    latestExecution: snapshot.latestExecution,
+    isCheckingDeposit: snapshot.isCheckingDeposit,
+    error: snapshot.error,
+    ...controls,
+    session
+  };
+}
+
+// src/use-deposit-addresses.ts
+import { useQuery } from "@tanstack/react-query";
+import {
+  createDepositAddress,
+  mapWalletToDepositAddress
+} from "@unifold/core";
+import { useUnifold as useUnifold3 } from "@unifold/react-provider";
+function useDepositAddresses(options) {
+  const { publishableKey } = useUnifold3();
+  const { externalUserId, destination, actionType, enabled = true } = options;
+  return useQuery({
+    // Key parity with @unifold/ui-react's useDepositAddress — do not reorder.
+    queryKey: [
+      "unifold",
+      "depositAddress",
+      externalUserId,
+      destination?.recipientAddress ?? null,
+      destination?.chainType ?? null,
+      destination?.chainId ?? null,
+      destination?.tokenAddress ?? null,
+      actionType ?? null,
+      destination?.contractCalls ?? null,
+      publishableKey
+    ],
+    queryFn: () => createDepositAddress(
+      {
+        external_user_id: externalUserId,
+        recipient_address: destination?.recipientAddress,
+        destination_chain_type: destination?.chainType,
+        destination_chain_id: destination?.chainId,
+        destination_token_address: destination?.tokenAddress,
+        action_type: actionType,
+        contract_calls: destination?.contractCalls
+      },
+      publishableKey
+    ),
+    select: (response) => response.data.map(mapWalletToDepositAddress),
+    enabled: enabled && !!externalUserId && !!publishableKey,
+    staleTime: 1e3 * 60 * 60,
+    // 1 hour — wallets don't change once created
+    gcTime: 1e3 * 60 * 60 * 24,
+    refetchOnMount: false,
+    refetchOnWindowFocus: false,
+    retry: 3,
+    retryDelay: (attempt) => Math.min(1e3 * 2 ** attempt, 1e4)
+  });
+}
+
+// src/use-supported-deposit-tokens.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+import {
+  getSupportedDepositTokens
+} from "@unifold/core";
+import { useUnifold as useUnifold4 } from "@unifold/react-provider";
+function useSupportedDepositTokens(options = {}) {
+  const { publishableKey } = useUnifold4();
+  const { destination, productType, enabled = true } = options;
+  const apiOptions = destination || productType ? {
+    ...destination ? {
+      destination_token_address: destination.tokenAddress,
+      destination_chain_id: destination.chainId,
+      destination_chain_type: destination.chainType
+    } : {},
+    ...productType ? { product_type: productType } : {}
+  } : void 0;
+  return useQuery2({
+    // Key parity with @unifold/ui-react's useSupportedDepositTokens.
+    queryKey: [
+      "unifold",
+      "supportedDepositTokens",
+      publishableKey,
+      destination?.tokenAddress ?? null,
+      destination?.chainId ?? null,
+      destination?.chainType ?? null,
+      productType ?? null
+    ],
+    queryFn: () => getSupportedDepositTokens(publishableKey, apiOptions),
+    select: (response) => response.data,
+    enabled: enabled && !!publishableKey,
+    staleTime: 1e3 * 60 * 5,
+    gcTime: 1e3 * 60 * 30,
+    refetchOnMount: false,
+    refetchOnWindowFocus: false
+  });
+}
+
+// src/use-executions.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+import {
+  queryExecutions,
+  mapDirectExecution,
+  ActionType
+} from "@unifold/core";
+import { useUnifold as useUnifold5 } from "@unifold/react-provider";
+function useExecutions(options) {
+  const { publishableKey } = useUnifold5();
+  const { externalUserId, refetchInterval = false, enabled = true, actionType = ActionType.Deposit } = options;
+  return useQuery3({
+    // Key parity with @unifold/ui-react's useExecutions.
+    queryKey: ["unifold", "executions", actionType, externalUserId, publishableKey],
+    queryFn: () => queryExecutions(externalUserId, publishableKey, actionType),
+    select: (response) => response.data.map(mapDirectExecution),
+    enabled: enabled && !!externalUserId && !!publishableKey,
+    refetchInterval,
+    staleTime: 0,
+    gcTime: 1e3 * 60 * 5,
+    refetchOnWindowFocus: false
+  });
+}
+
+// src/use-allowed-country.ts
+import { useQuery as useQuery4, keepPreviousData } from "@tanstack/react-query";
+import { getIpAddress, getProjectConfig } from "@unifold/core";
+import { useUnifold as useUnifold6 } from "@unifold/react-provider";
+function useAllowedCountry() {
+  const { publishableKey } = useUnifold6();
+  const ipQuery = useQuery4({
+    // Key parity with @unifold/core's useUserIp.
+    queryKey: ["unifold", "userIpInfo"],
+    queryFn: async () => {
+      const data = await getIpAddress();
+      const subdivision = data.subdivision_code || data.state || null;
+      return { alpha2: data.alpha2, country: data.country, subdivisionCode: subdivision };
+    },
+    refetchOnMount: false,
+    refetchOnReconnect: true,
+    refetchOnWindowFocus: false,
+    staleTime: 1e3 * 60 * 60,
+    gcTime: 1e3 * 60 * 60 * 24
+  });
+  const ip = ipQuery.data;
+  const configQuery = useQuery4({
+    // Key parity with @unifold/ui-react's useProjectConfig.
+    queryKey: ip?.alpha2 ? ["unifold", "projectConfig", publishableKey, ip.alpha2, ip.subdivisionCode ?? null] : ["unifold", "projectConfig", publishableKey],
+    queryFn: () => getProjectConfig(
+      publishableKey,
+      ip?.alpha2 ? { countryCode: ip.alpha2, subdivisionCode: ip.subdivisionCode ?? void 0 } : void 0
+    ),
+    enabled: !!publishableKey && !ipQuery.isLoading,
+    placeholderData: keepPreviousData,
+    staleTime: 1e3 * 60 * 30
+  });
+  const isLoading = ipQuery.isLoading || configQuery.isLoading;
+  const error = ipQuery.error || configQuery.error || null;
+  const projectConfig = configQuery.data;
+  let isAllowed = null;
+  if (ip && projectConfig) {
+    const blockedCodes = projectConfig.blocked_country_codes || [];
+    const blockedSubdivisions = projectConfig.blocked_country_subdivisions || [];
+    const countryUpper = ip.alpha2.toUpperCase();
+    const subdivisionUpper = (ip.subdivisionCode ?? "").toUpperCase();
+    const countryBlocked = blockedCodes.some((code) => code.toUpperCase() === countryUpper);
+    const subdivisionBlocked = blockedSubdivisions.some((entry) => {
+      if (entry.country_code.toUpperCase() !== countryUpper) return false;
+      return entry.subdivision_codes.some((code) => code.toUpperCase() === subdivisionUpper);
+    });
+    isAllowed = !countryBlocked && !subdivisionBlocked;
+  }
+  return {
+    isAllowed,
+    alpha2: ip?.alpha2 ?? null,
+    country: ip?.country ?? null,
+    subdivisionCode: ip?.subdivisionCode ?? null,
+    isLoading,
+    error
+  };
+}
+
+// src/use-address-validation.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+import {
+  verifyRecipientAddress
+} from "@unifold/core";
+import { useUnifold as useUnifold7 } from "@unifold/react-provider";
+function useAddressValidation(options) {
+  const { publishableKey } = useUnifold7();
+  const { recipientAddress, destination, enabled = true } = options;
+  const shouldValidate = enabled && !!publishableKey && !!recipientAddress && !!destination;
+  const { data, isLoading, error } = useQuery5({
+    // Key parity with @unifold/ui-react's useAddressValidation.
+    queryKey: [
+      "unifold",
+      "addressValidation",
+      recipientAddress,
+      destination?.chainType,
+      destination?.chainId,
+      destination?.tokenAddress
+    ],
+    queryFn: () => verifyRecipientAddress(
+      {
+        chain_type: destination.chainType,
+        chain_id: destination.chainId,
+        token_address: destination.tokenAddress,
+        recipient_address: recipientAddress
+      },
+      publishableKey
+    ),
+    enabled: shouldValidate,
+    refetchOnMount: false,
+    refetchOnReconnect: false,
+    refetchOnWindowFocus: false,
+    staleTime: 1e3 * 60 * 5,
+    gcTime: 1e3 * 60 * 30
+  });
+  if (!shouldValidate) {
+    return { isValid: null, failureCode: null, metadata: null, isLoading: false, error: null };
+  }
+  return {
+    isValid: data?.valid ?? null,
+    failureCode: data?.failure_code ?? null,
+    metadata: data?.metadata ?? null,
+    isLoading,
+    error: error ?? null
+  };
+}
+
+// src/index.ts
+import {
+  createUnifoldClient as createUnifoldClient2,
+  UnifoldClient,
+  DepositSession as DepositSession2,
+  DepositSessionEventType as DepositSessionEventType2,
+  DepositSessionWaitError,
+  ExecutionStatus as ExecutionStatus2,
+  ActionType as ActionType2
+} from "@unifold/core";
+export {
+  ActionType2 as ActionType,
+  DepositSession2 as DepositSession,
+  DepositSessionEventType2 as DepositSessionEventType,
+  DepositSessionWaitError,
+  ExecutionStatus2 as ExecutionStatus,
+  UnifoldClient,
+  UnifoldProvider,
+  createUnifoldClient2 as createUnifoldClient,
+  useAddressValidation,
+  useAllowedCountry,
+  useDeposit,
+  useDepositAddresses,
+  useExecutions,
+  useSupportedDepositTokens,
+  useUnifold8 as useUnifold,
+  useUnifoldClient
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@unifold/headless-react",
+  "version": "0.1.70-beta.1",
+  "description": "Unifold Headless React SDK - hooks-only (no UI) crypto deposit flows",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "react": "^18.2.0 || ^19.0.0"
+  },
+  "dependencies": {
+    "@tanstack/react-query": "^5.90.11",
+    "@unifold/core": "0.1.70-beta.1",
+    "@unifold/react-provider": "0.1.70-beta.1"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-react": "^7.34.1",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "prettier": "^3.2.5",
+    "react": "^19.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "unifold",
+    "headless",
+    "hooks",
+    "react",
+    "sdk",
+    "crypto",
+    "deposit",
+    "web3"
+  ],
+  "author": "unifold.io",
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,tsx}\"",
+    "type-check": "tsc --noEmit"
+  }
+}