@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 { createDepositPayOrder as createDepositPayOrderInternal, getPayOrder } from "@coin-voyage/shared/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, apiKey, }) {
    const [connectorChainType, setConnectorChainType] = useState();
    const [selectedWallet, setSelectedWallet] = useState();
    // Wallet state.
    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,
        apiKey
    });
    const [selectedTokenOption, setSelectedTokenOption] = useState();
    const { payWithToken } = usePayWithToken({
        senderAddr: senderAccount.address,
        payOrder,
        setPayOrder,
        chainType: connectorChainType,
        log,
        apiKey,
    });
    const refreshOrder = useCallback(async () => {
        if (!payOrder?.id) {
            return;
        }
        const order = await getPayOrder(payOrder.id, apiKey);
        if (!order) {
            log(`[CHECKOUT] No order found for ${payOrder.id}`);
            return;
        }
        setPayOrder(order);
    }, [payOrder?.id]);
    const copyDepositPayOrder = async () => {
        if (!payOrder?.id) {
            log(`No payOrder to copy`);
            return;
        }
        if (payOrder.mode !== PayOrderMode.DEPOSIT) {
            log(`Cannot recreacte SALE order`);
            return;
        }
        assert(!!payOrder.receiving_address);
        assert(!!payOrder.destination_currency?.chain_id);
        const newDepositOrder = await createDepositPayOrderInternal({
            receiving_address: payOrder.receiving_address,
            destination_currency: {
                chain_id: payOrder.destination_currency?.chain_id,
                address: payOrder.destination_currency?.address,
            },
            destination_amount: payOrder.destination_amount?.ui_amount.toString(),
            metadata: payOrder.metadata,
        }, apiKey);
        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 createDepositPayOrderInternal(payOrderParams, apiKey, true);
            if (!payOrder) {
                log(`[CREATE DEPOSIT] Error creating payOrder`);
                return;
            }
            setPayOrder(payOrder);
        }
        catch (e) {
            onError?.(e.message);
        }
    }, [apiKey]);
    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 getPayOrder(payId, apiKey);
        if (!order) {
            log(`[CHECKOUT] No order found for ${payId}`);
            return;
        }
        setPayOrder(order);
    }, [payOrder, apiKey]);
    return {
        setPayId,
        createDepositPayOrder,
        payOrder,
        connectorChainType,
        setConnectorChainType,
        selectedWallet,
        setSelectedWallet,
        selectedTokenOption,
        payOrderQuotes,
        setSelectedTokenOption,
        copyDepositPayOrder: copyDepositPayOrder,
        payWithToken,
        refreshOrder,
        resetPayOrder,
        senderEnsName: evmEnsName ?? suiEnsName ?? undefined,
    };
}
//# sourceMappingURL=usePaymentState.js.map