@unifold/headless-react 0.1.70-beta.1

package/dist/index.js

@@ -0,0 +1,420 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActionType: () => import_core8.ActionType,
+  DepositSession: () => import_core8.DepositSession,
+  DepositSessionEventType: () => import_core8.DepositSessionEventType,
+  DepositSessionWaitError: () => import_core8.DepositSessionWaitError,
+  ExecutionStatus: () => import_core8.ExecutionStatus,
+  UnifoldClient: () => import_core8.UnifoldClient,
+  UnifoldProvider: () => import_react_provider8.UnifoldProvider,
+  createUnifoldClient: () => import_core8.createUnifoldClient,
+  useAddressValidation: () => useAddressValidation,
+  useAllowedCountry: () => useAllowedCountry,
+  useDeposit: () => useDeposit,
+  useDepositAddresses: () => useDepositAddresses,
+  useExecutions: () => useExecutions,
+  useSupportedDepositTokens: () => useSupportedDepositTokens,
+  useUnifold: () => import_react_provider8.useUnifold,
+  useUnifoldClient: () => useUnifoldClient
+});
+module.exports = __toCommonJS(index_exports);
+var import_react_provider8 = require("@unifold/react-provider");
+
+// src/use-unifold-client.ts
+var import_react = require("react");
+var import_core = require("@unifold/core");
+var import_react_provider = require("@unifold/react-provider");
+function useUnifoldClient() {
+  const { publishableKey } = (0, import_react_provider.useUnifold)();
+  return (0, import_react.useMemo)(
+    () => publishableKey ? (0, import_core.createUnifoldClient)({ publishableKey }) : null,
+    [publishableKey]
+  );
+}
+
+// src/use-deposit.ts
+var import_react2 = require("react");
+var import_core2 = require("@unifold/core");
+var import_react_provider2 = require("@unifold/react-provider");
+var IDLE_SNAPSHOT = {
+  status: "idle",
+  addresses: [],
+  executions: [],
+  latestExecution: null,
+  isCheckingDeposit: false,
+  error: null
+};
+function useDeposit(options) {
+  const { publishableKey } = (0, import_react_provider2.useUnifold)();
+  const {
+    externalUserId,
+    destination,
+    confirmationMode = "auto",
+    method,
+    autoStart = true
+  } = options;
+  const callbacksRef = (0, import_react2.useRef)(options);
+  (0, import_react2.useEffect)(() => {
+    callbacksRef.current = options;
+  });
+  const [session, setSession] = (0, import_react2.useState)(null);
+  const sessionKey = [
+    publishableKey,
+    externalUserId ?? "",
+    destination.chainType,
+    destination.chainId,
+    destination.tokenAddress,
+    destination.recipientAddress,
+    JSON.stringify(destination.contractCalls ?? null),
+    confirmationMode,
+    method ?? ""
+  ].join("|");
+  (0, import_react2.useEffect)(() => {
+    if (!publishableKey || !externalUserId) {
+      setSession(null);
+      return;
+    }
+    const nextSession = new import_core2.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 import_core2.DepositSessionEventType.ADDRESSES_CREATED:
+          callbacks.onAddressesReady?.(event.data.object.addresses);
+          break;
+        case import_core2.DepositSessionEventType.EXECUTION_DETECTED:
+          callbacks.onExecutionDetected?.(event.data.object);
+          break;
+        case import_core2.DepositSessionEventType.EXECUTION_UPDATED:
+          callbacks.onExecutionUpdated?.(event.data.object);
+          break;
+        case import_core2.DepositSessionEventType.EXECUTION_SUCCEEDED:
+          callbacks.onSuccess?.(event.data.object);
+          break;
+        case import_core2.DepositSessionEventType.EXECUTION_FAILED:
+          callbacks.onError?.({
+            code: "DEPOSIT_FAILED",
+            message: "Deposit failed",
+            fatal: false,
+            cause: event.data.object
+          });
+          break;
+        case import_core2.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 = (0, import_react2.useCallback)(
+    (listener) => session ? session.subscribe(listener) : () => {
+    },
+    [session]
+  );
+  const getSnapshot = (0, import_react2.useCallback)(
+    () => session ? session.getSnapshot() : IDLE_SNAPSHOT,
+    [session]
+  );
+  const snapshot = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, () => IDLE_SNAPSHOT);
+  const getAddress = (0, import_react2.useCallback)(
+    (query) => snapshot.addresses.find((a) => a.chainType === query.chainType),
+    [snapshot.addresses]
+  );
+  const controls = (0, import_react2.useMemo)(
+    () => ({
+      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
+var import_react_query = require("@tanstack/react-query");
+var import_core3 = require("@unifold/core");
+var import_react_provider3 = require("@unifold/react-provider");
+function useDepositAddresses(options) {
+  const { publishableKey } = (0, import_react_provider3.useUnifold)();
+  const { externalUserId, destination, actionType, enabled = true } = options;
+  return (0, import_react_query.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: () => (0, import_core3.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(import_core3.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
+var import_react_query2 = require("@tanstack/react-query");
+var import_core4 = require("@unifold/core");
+var import_react_provider4 = require("@unifold/react-provider");
+function useSupportedDepositTokens(options = {}) {
+  const { publishableKey } = (0, import_react_provider4.useUnifold)();
+  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 (0, import_react_query2.useQuery)({
+    // Key parity with @unifold/ui-react's useSupportedDepositTokens.
+    queryKey: [
+      "unifold",
+      "supportedDepositTokens",
+      publishableKey,
+      destination?.tokenAddress ?? null,
+      destination?.chainId ?? null,
+      destination?.chainType ?? null,
+      productType ?? null
+    ],
+    queryFn: () => (0, import_core4.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
+var import_react_query3 = require("@tanstack/react-query");
+var import_core5 = require("@unifold/core");
+var import_react_provider5 = require("@unifold/react-provider");
+function useExecutions(options) {
+  const { publishableKey } = (0, import_react_provider5.useUnifold)();
+  const { externalUserId, refetchInterval = false, enabled = true, actionType = import_core5.ActionType.Deposit } = options;
+  return (0, import_react_query3.useQuery)({
+    // Key parity with @unifold/ui-react's useExecutions.
+    queryKey: ["unifold", "executions", actionType, externalUserId, publishableKey],
+    queryFn: () => (0, import_core5.queryExecutions)(externalUserId, publishableKey, actionType),
+    select: (response) => response.data.map(import_core5.mapDirectExecution),
+    enabled: enabled && !!externalUserId && !!publishableKey,
+    refetchInterval,
+    staleTime: 0,
+    gcTime: 1e3 * 60 * 5,
+    refetchOnWindowFocus: false
+  });
+}
+
+// src/use-allowed-country.ts
+var import_react_query4 = require("@tanstack/react-query");
+var import_core6 = require("@unifold/core");
+var import_react_provider6 = require("@unifold/react-provider");
+function useAllowedCountry() {
+  const { publishableKey } = (0, import_react_provider6.useUnifold)();
+  const ipQuery = (0, import_react_query4.useQuery)({
+    // Key parity with @unifold/core's useUserIp.
+    queryKey: ["unifold", "userIpInfo"],
+    queryFn: async () => {
+      const data = await (0, import_core6.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 = (0, import_react_query4.useQuery)({
+    // Key parity with @unifold/ui-react's useProjectConfig.
+    queryKey: ip?.alpha2 ? ["unifold", "projectConfig", publishableKey, ip.alpha2, ip.subdivisionCode ?? null] : ["unifold", "projectConfig", publishableKey],
+    queryFn: () => (0, import_core6.getProjectConfig)(
+      publishableKey,
+      ip?.alpha2 ? { countryCode: ip.alpha2, subdivisionCode: ip.subdivisionCode ?? void 0 } : void 0
+    ),
+    enabled: !!publishableKey && !ipQuery.isLoading,
+    placeholderData: import_react_query4.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
+var import_react_query5 = require("@tanstack/react-query");
+var import_core7 = require("@unifold/core");
+var import_react_provider7 = require("@unifold/react-provider");
+function useAddressValidation(options) {
+  const { publishableKey } = (0, import_react_provider7.useUnifold)();
+  const { recipientAddress, destination, enabled = true } = options;
+  const shouldValidate = enabled && !!publishableKey && !!recipientAddress && !!destination;
+  const { data, isLoading, error } = (0, import_react_query5.useQuery)({
+    // Key parity with @unifold/ui-react's useAddressValidation.
+    queryKey: [
+      "unifold",
+      "addressValidation",
+      recipientAddress,
+      destination?.chainType,
+      destination?.chainId,
+      destination?.tokenAddress
+    ],
+    queryFn: () => (0, import_core7.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
+var import_core8 = require("@unifold/core");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionType,
+  DepositSession,
+  DepositSessionEventType,
+  DepositSessionWaitError,
+  ExecutionStatus,
+  UnifoldClient,
+  UnifoldProvider,
+  createUnifoldClient,
+  useAddressValidation,
+  useAllowedCountry,
+  useDeposit,
+  useDepositAddresses,
+  useExecutions,
+  useSupportedDepositTokens,
+  useUnifold,
+  useUnifoldClient
+});