@daimo/pay/build/src/hooks/useDaimoPay.js

Seamless crypto payments. Onboard users from any chain, any coin into your app with one click.

import { useContext, useSyncExternalStore, useMemo, useCallback } from 'react';
import { waitForPaymentState } from '../payment/paymentStore.js';
import { PaymentContext } from '../provider/PaymentProvider.js';

function useDaimoPay() {
  const store = useContext(PaymentContext);
  if (!store) {
    throw new Error("useDaimoPay must be used within <PaymentProvider>");
  }
  const paymentFsmState = useSyncExternalStore(
    store.subscribe,
    store.getState,
    store.getState
  );
  const order = useMemo(() => {
    if (paymentFsmState.type === "idle") return null;
    return paymentFsmState.order ?? null;
  }, [paymentFsmState]);
  const paymentState = paymentFsmState.type;
  const paymentErrorMessage = paymentFsmState.type === "error" ? paymentFsmState.message : null;
  const paymentWarningMessage = paymentFsmState.type === "warning" ? paymentFsmState.message : null;
  const dispatch = useCallback((e) => store.dispatch(e), [store]);
  const createPreviewOrder = useCallback(
    async (payParams) => {
      dispatch({ type: "set_pay_params", payParams });
      const previewOrderState = await waitForPaymentState(store, "preview");
      return previewOrderState;
    },
    [dispatch, store]
  );
  const setPayId = useCallback(
    async (payId) => {
      dispatch({ type: "set_pay_id", payId });
      const previewOrderState = await waitForPaymentState(
        store,
        "unhydrated",
        "payment_unpaid",
        "payment_started",
        "payment_completed",
        "payment_bounced"
      );
      return previewOrderState;
    },
    [dispatch, store]
  );
  const hydrateOrder = useCallback(
    async (refundAddress) => {
      dispatch({ type: "hydrate_order", refundAddress });
      const hydratedOrderState = await waitForPaymentState(
        store,
        "payment_unpaid"
      );
      return hydratedOrderState;
    },
    [dispatch, store]
  );
  const paySource = useCallback(
    () => dispatch({ type: "pay_source" }),
    [dispatch]
  );
  const payEthSource = useCallback(
    async (args) => {
      dispatch({ type: "pay_ethereum_source", ...args });
      const paidState = await waitForPaymentState(
        store,
        "payment_started",
        "payment_completed",
        "payment_bounced"
      );
      return paidState;
    },
    [dispatch, store]
  );
  const paySolanaSource = useCallback(
    async (args) => {
      dispatch({ type: "pay_solana_source", ...args });
      const paidState = await waitForPaymentState(
        store,
        "payment_started",
        "payment_completed",
        "payment_bounced"
      );
      return paidState;
    },
    [dispatch, store]
  );
  const reset = useCallback(() => dispatch({ type: "reset" }), [dispatch]);
  const setChosenUsd = useCallback(
    (usd) => dispatch({ type: "set_chosen_usd", usd }),
    [dispatch]
  );
  const setWarning = useCallback(
    (message) => dispatch({ type: "warning", order: order ?? void 0, message }),
    [dispatch, order]
  );
  const dismissWarning = useCallback(() => {
    let priorOrder;
    switch (paymentFsmState.type) {
      case "preview":
      case "unhydrated":
      case "payment_unpaid":
      case "payment_started":
      case "payment_completed":
      case "payment_bounced":
        priorOrder = paymentFsmState.order;
        break;
      default:
        priorOrder = void 0;
    }
    dispatch({ type: "dismiss_warning", order: priorOrder });
  }, [dispatch, paymentFsmState]);
  return {
    order,
    paymentState,
    paymentErrorMessage,
    paymentWarningMessage,
    createPreviewOrder,
    hydrateOrder,
    setPayId,
    paySource,
    payEthSource,
    paySolanaSource,
    reset,
    setChosenUsd,
    setWarning,
    dismissWarning
  };
}

export { useDaimoPay };
//# sourceMappingURL=useDaimoPay.js.map