@coin-voyage/paykit/dist/hooks/usePaymentState.js

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

import { useAccount } from "@coin-voyage/crypto/hooks";
import { useBackendApi } from "../components/contexts/api";
import { assert, ChainType, PayOrderMode, zDepositPayOrder } from "@coin-voyage/shared/common";
import { useResolveSuiNSName } from "@mysten/dapp-kit";
import { useCallback, useState } from "react";
import { mainnet } from "viem/chains";
import { useEnsName } from "wagmi";
import { ROUTES } from "../types/routes";
import { usePayOrderQuotes } from "./usePayOrderQuotes";
import { usePayWithToken } from "./usePayWithToken";
export function usePaymentState({ payOrder, setPayOrder, setRoute, log, }) {
    const api = useBackendApi();
    const [connectorChainType, setConnectorChainType] = useState();
    const [selectedWallet, setSelectedWallet] = useState();
    const { account: senderAccount } = useAccount({
        selectedWallet,
        chainType: connectorChainType,
    });
    const { data: suiEnsName } = useResolveSuiNSName(senderAccount.address, {
        enabled: !!senderAccount.address &&
            senderAccount.chainType === ChainType.SUI &&
            senderAccount.isConnected,
    });
    const { data: evmEnsName } = useEnsName({
        chainId: mainnet.id,
        address: senderAccount.address,
        query: {
            enabled: !!senderAccount.address &&
                senderAccount.chainType === ChainType.EVM &&
                senderAccount.isConnected,
        },
    });
    const payOrderQuotes = usePayOrderQuotes({
        payOrder,
        address: senderAccount.address,
        chainType: connectorChainType
    });
    const [selectedTokenOption, setSelectedTokenOption] = useState();
    const { payWithToken } = usePayWithToken({
        senderAddr: senderAccount.address,
        payOrder,
        setPayOrder,
        chainType: connectorChainType,
        log,
    });
    const fetchPayOrder = useCallback(async (id) => {
        const order = await api.getPayOrder(id);
        if (!order) {
            log(`[CHECKOUT] No order found for ${id}`);
            return undefined;
        }
        return order;
    }, [api]);
    const refreshOrder = useCallback(async () => {
        if (!payOrder?.id)
            return;
        const order = await fetchPayOrder(payOrder.id);
        if (order)
            setPayOrder(order);
    }, [payOrder?.id, fetchPayOrder]);
    const copyDepositPayOrder = async () => {
        if (!payOrder?.id) {
            log(`No payOrder to copy`);
            return;
        }
        if (payOrder.mode !== PayOrderMode.DEPOSIT) {
            log(`Cannot recreacte SALE order`);
            return;
        }
        const receiving_address = payOrder.request.receiving_address;
        assert(!!receiving_address);
        const chainId = payOrder.request.currency?.chain_id;
        assert(!!chainId);
        const newDepositOrder = await api.createDepositPayOrder({
            receiving_address: receiving_address,
            destination_currency: {
                chain_id: chainId,
                address: payOrder.request.currency?.address || null,
            },
            destination_amount: payOrder.request.amount?.token?.ui_amount.toString(),
            metadata: payOrder.metadata,
        });
        if (!newDepositOrder) {
            console.error(`[CHECKOUT] Error creating payOrder`);
            return;
        }
        setPayId(newDepositOrder.id);
    };
    const createDepositPayOrder = useCallback(async (payOrderParams, onError) => {
        try {
            const result = zDepositPayOrder.safeParse(payOrderParams);
            if (result.error) {
                return onError?.(`[CREATE DEPOSIT]: ${result.error.issues
                    .map((i) => `${i.path.join(".")}: ${i.message}`)
                    .join(", ")}`);
            }
            const payOrder = await api.createDepositPayOrder(payOrderParams, true);
            if (!payOrder) {
                log(`[CREATE DEPOSIT] Error creating payOrder`);
                return;
            }
            setPayOrder(payOrder);
        }
        catch (e) {
            onError?.(e.message);
        }
    }, [api, setPayOrder, log]);
    const resetPayOrder = useCallback(() => {
        setSelectedTokenOption(undefined);
        setConnectorChainType(undefined);
        setSelectedWallet(undefined);
        setRoute(ROUTES.SELECT_METHOD);
    }, [setRoute]);
    const setPayId = useCallback(async (payId) => {
        if (!payId || payOrder?.id === payId)
            return;
        const order = await fetchPayOrder(payId);
        if (order)
            setPayOrder(order);
    }, [payOrder?.id, fetchPayOrder]);
    return {
        setPayId,
        createDepositPayOrder,
        payOrder,
        connectorChainType,
        setConnectorChainType,
        selectedWallet,
        setSelectedWallet,
        selectedTokenOption,
        payOrderQuotes,
        setSelectedTokenOption,
        copyDepositPayOrder: copyDepositPayOrder,
        payWithToken,
        refreshOrder,
        resetPayOrder,
        senderEnsName: evmEnsName ?? suiEnsName ?? undefined,
    };
}
//# sourceMappingURL=usePaymentState.js.map