@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/components/Pages/Swap/Withdraw/Summary/index.js

@@ -0,0 +1,57 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useSwapDataState } from "../../../../../context/swap";
+import Summary from "./Summary";
+import { TransactionType } from "../../../../../lib/apiClients/layerSwapApiClient";
+import { shortenEmail } from "../../../../../components/utils/ShortenAddress";
+import KnownInternalNames from "../../../../../lib/knownIds";
+import { useInitialSettings } from "../../../../../context/settings";
+import useWallet from "../../../../../hooks/useWallet";
+import { useSelectedAccount } from "../../../../../context/balanceAccounts";
+const SwapSummary = () => {
+    const { hideFrom, account, } = useInitialSettings();
+    const { swapBasicData, swapDetails, quote, refuel, quoteIsLoading } = useSwapDataState();
+    const { source_network, destination_network, source_token, destination_token, source_exchange } = swapBasicData || {};
+    const { provider } = useWallet(source_network, "withdrawal");
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    if (!swapBasicData || !source_network || !source_token || !destination_token || !destination_network) {
+        return _jsx(_Fragment, {});
+    }
+    const swapInputTransaction = swapDetails?.transactions?.find(t => t.type === TransactionType.Input);
+    const swapOutputTransaction = swapDetails?.transactions?.find(t => t.type === TransactionType.Output);
+    const requested_amount = (swapInputTransaction?.amount ?? swapBasicData.requested_amount) || undefined;
+    const receiveAmount = quote?.receive_amount;
+    const calculatedReceiveAmount = swapOutputTransaction?.amount ?? receiveAmount;
+    let sourceAccountAddress = "";
+    if (hideFrom && account) {
+        sourceAccountAddress = account;
+    }
+    else if (swapInputTransaction?.from) {
+        sourceAccountAddress = swapInputTransaction?.from;
+    }
+    else if (selectedSourceAccount?.address) {
+        sourceAccountAddress = selectedSourceAccount.address;
+    }
+    else if (source_network?.name === KnownInternalNames.Exchanges.Coinbase && swapDetails?.exchange_account_connected) {
+        sourceAccountAddress = shortenEmail(swapDetails?.exchange_account_name, 10);
+    }
+    else if (source_exchange) {
+        sourceAccountAddress = "Exchange";
+    }
+    else {
+        sourceAccountAddress = "Network";
+    }
+    const swapData = {
+        swap: {
+            ...swapBasicData,
+            requested_amount: requested_amount
+        },
+        quote: {
+            quote: quote,
+            refuel
+        },
+        sourceAccountAddress,
+        receiveAmount: calculatedReceiveAmount
+    };
+    return _jsx(Summary, { ...swapData, quoteIsLoading: quoteIsLoading });
+};
+export default SwapSummary;

package/dist/components/Pages/{SwapPages → Swap}/Withdraw/SwapDetails.d.ts

@@ -1,6 +1,7 @@
 import { FC } from 'react';
 type Props = {
     type: "widget" | "contained";
+    onWalletWithdrawalSuccess?: () => void;
 };
 declare const SwapDetails: FC<Props>;
 export default SwapDetails;

package/dist/components/Pages/Swap/Withdraw/SwapDetails.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback } from 'react';
+import { Widget } from '../../../../components/Widget/Index';
+import { useSwapDataState } from '../../../../context/swap';
+import Withdraw from './Withdraw';
+import Processing from './Processing';
+import { BackendTransactionStatus, TransactionType } from '../../../../lib/apiClients/layerSwapApiClient';
+import { SwapStatus } from '../../../../Models/SwapStatus';
+import { useSwapTransactionStore } from '../../../../stores/swapTransactionStore';
+import SubmitButton from '../../../../components/Buttons/submitButton';
+import ManualWithdraw from './ManualWithdraw';
+const SwapDetails = ({ type, onWalletWithdrawalSuccess }) => {
+    const { swapDetails, swapBasicData, quote, refuel, depositActionsResponse } = useSwapDataState();
+    const swapStatus = swapDetails?.status || SwapStatus.UserTransferPending;
+    const storedWalletTransactions = useSwapTransactionStore();
+    const swapInputTransaction = swapDetails?.transactions?.find(t => t.type === TransactionType.Input);
+    const storedWalletTransaction = storedWalletTransactions.swapTransactions?.[swapDetails?.id || ''];
+    const removeStoredTransaction = useCallback(() => {
+        useSwapTransactionStore.getState().removeSwapTransaction(swapDetails?.id || '');
+    }, [swapDetails?.id, storedWalletTransactions]);
+    if (!swapBasicData)
+        return _jsx(_Fragment, { children: _jsx("div", { className: "w-full h-[430px]", children: _jsx("div", { className: "animate-pulse flex space-x-4", children: _jsxs("div", { className: "flex-1 space-y-6 py-1", children: [_jsx("div", { className: "h-32 bg-secondary-700 rounded-lg" }), _jsx("div", { className: "h-40 bg-secondary-700 rounded-lg" }), _jsx("div", { className: "h-12 bg-secondary-700 rounded-lg" })] }) }) }) });
+    return (_jsx(Container, { type: type, children: ((swapStatus === SwapStatus.UserTransferPending
+            && !(swapInputTransaction || storedWalletTransaction))) ?
+            (swapBasicData?.use_deposit_address === true
+                ? _jsx(ManualWithdraw, { swapBasicData: swapBasicData, quote: quote, depositActions: depositActionsResponse, refuel: refuel })
+                : _jsx(Withdraw, { type: type, onWalletWithdrawalSuccess: onWalletWithdrawalSuccess }))
+            :
+                _jsxs("div", { className: 'space-y-3', children: [_jsx(Processing, {}), storedWalletTransaction?.status == BackendTransactionStatus.Failed &&
+                            _jsx(SubmitButton, { isDisabled: false, isSubmitting: false, onClick: removeStoredTransaction, children: "Try again" })] }) }));
+};
+const Container = ({ type, children }) => {
+    if (type === "widget")
+        return _jsx(Widget, { children: _jsx(_Fragment, { children: children }) });
+    else
+        return _jsx("div", { className: "w-full flex flex-col justify-between h-full space-y-3 text-secondary-text", children: children });
+};
+export default SwapDetails;

package/dist/components/Pages/Swap/Withdraw/SwapQuoteDetails.d.ts

@@ -0,0 +1,10 @@
+import { FC } from 'react';
+import { Refuel, SwapBasicData, SwapQuote } from '../../../../lib/apiClients/layerSwapApiClient';
+type Props = {
+    swapBasicData: SwapBasicData | undefined;
+    quote: SwapQuote | undefined;
+    refuel: Refuel | undefined;
+    quoteIsLoading: boolean;
+};
+export declare const SwapQuoteDetails: FC<Props>;
+export {};

package/dist/components/Pages/Swap/Withdraw/SwapQuoteDetails.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import QuoteDetails from '../Form/FeeDetails';
+export const SwapQuoteDetails = ({ swapBasicData: swapData, quote, refuel, quoteIsLoading }) => {
+    const { source_network, destination_network, use_deposit_address, destination_token, requested_amount, source_token, destination_address } = swapData || {};
+    if (!requested_amount || !source_network || !destination_network || !quote)
+        return _jsx("div", { className: 'h-[56px] w-full rounded-xl bg-secondary-500 animate-pulse' });
+    const values = {
+        amount: requested_amount.toString(),
+        from: source_network,
+        to: destination_network,
+        fromAsset: source_token,
+        toAsset: destination_token,
+        depositMethod: use_deposit_address ? 'deposit_address' : 'wallet',
+        destination_address,
+    };
+    return _jsx(QuoteDetails, { quote: { quote, refuel }, swapValues: values, isQuoteLoading: quoteIsLoading });
+};

package/dist/components/Pages/Swap/Withdraw/Wallet/Common/buttons.d.ts

@@ -0,0 +1,25 @@
+import { ComponentProps, FC } from "react";
+import { ActionData, TransferProps } from "./sharedTypes";
+import { SubmitButtonProps } from "../../../../../../components/Buttons/submitButton";
+import { Network } from "../../../../../../Models/Network";
+import { SwapBasicData } from "../../../../../../lib/apiClients/layerSwapApiClient";
+export declare const ConnectWalletButton: FC<SubmitButtonProps>;
+export declare const ChangeNetworkMessage: FC<{
+    data: ActionData;
+    network: string;
+}>;
+type ChangeNetworkProps = {
+    chainId: number | string;
+    network: Network;
+};
+export declare const ChangeNetworkButton: FC<ChangeNetworkProps>;
+export declare const ButtonWrapper: FC<SubmitButtonProps>;
+type ButtonWrapperProps = ComponentProps<typeof ButtonWrapper>;
+type SendFromWalletButtonProps = Omit<ButtonWrapperProps, 'onClick'> & {
+    error?: boolean;
+    onClick: (props: TransferProps) => Promise<string | undefined>;
+    swapData: SwapBasicData;
+    refuel: boolean;
+};
+export declare const SendTransactionButton: FC<SendFromWalletButtonProps>;
+export {};

package/dist/components/Pages/Swap/Withdraw/Wallet/Common/buttons.js

@@ -0,0 +1,168 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useState } from "react";
+import WalletIcon from "../../../../../../components/Icons/WalletIcon";
+import SubmitButton from "../../../../../../components/Buttons/submitButton";
+import useWallet from "../../../../../../hooks/useWallet";
+import { useSwapDataState, useSwapDataUpdate } from "../../../../../../context/swap";
+import toast from "react-hot-toast";
+import { Loader2 } from "lucide-react";
+import WalletMessage from "../../messages/Message";
+import { useConnectModal } from "../../../../../../components/Wallet/WalletModal";
+import { useInitialSettings } from "../../../../../../context/settings";
+import { useSwapTransactionStore } from "../../../../../../stores/swapTransactionStore";
+import { BackendTransactionStatus } from "../../../../../../lib/apiClients/layerSwapApiClient";
+import sleep from "../../../../../../lib/wallets/utils/sleep";
+import { isDiffByPercent } from "../../../../../../components/utils/numbers";
+import posthog from "posthog-js";
+import { useWalletWithdrawalState } from "../../../../../../context/withdrawalContext";
+import { useSelectedAccount } from "../../../../../../context/balanceAccounts";
+import { useSwapCreateCallback } from "../../../../../../context/callbackProvider";
+export const ConnectWalletButton = ({ ...props }) => {
+    const { swapBasicData } = useSwapDataState();
+    const { source_network } = swapBasicData || {};
+    const [loading, setLoading] = useState(false);
+    const { provider } = useWallet(source_network, 'withdrawal');
+    const { connect } = useConnectModal();
+    const clickHandler = useCallback(async () => {
+        try {
+            setLoading(true);
+            if (!provider)
+                throw new Error(`No provider from ${source_network?.name}`);
+            await connect(provider);
+        }
+        catch (e) {
+            toast.error(e.message);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [provider]);
+    return _jsx(ButtonWrapper, { onClick: props.onClick ?? clickHandler, icon: loading ? _jsx(Loader2, { className: "h-6 w-6 animate-spin" }) : (props.icon ?? _jsx(WalletIcon, { className: "stroke-2 w-6 h-6" })), isDisabled: loading || props.isDisabled, isSubmitting: loading || props.isSubmitting, ...props, children: "Send from wallet" });
+};
+export const ChangeNetworkMessage = ({ data, network }) => {
+    if (data.isPending) {
+        return _jsx(WalletMessage, { status: "pending", header: 'Network switch required', details: "Confirm switching the network with your wallet" });
+    }
+    else if (data.isError) {
+        return _jsx(WalletMessage, { status: "error", header: 'Network switch failed', details: `Please try again or switch your wallet network manually to ${network}` });
+    }
+};
+export const ChangeNetworkButton = (props) => {
+    const { chainId, network } = props;
+    const [error, setError] = useState(null);
+    const [isPending, setIsPending] = useState(false);
+    const { provider } = useWallet(network, "withdrawal");
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    const clickHandler = useCallback(async () => {
+        try {
+            setIsPending(true);
+            if (!provider)
+                throw new Error(`No provider from ${network?.name}`);
+            if (!provider.switchChain)
+                throw new Error(`No switchChain from ${network?.name}`);
+            if (!selectedSourceAccount)
+                throw new Error(`No selectedSourceAccount from ${network?.name}`);
+            return await provider.switchChain(selectedSourceAccount.wallet, chainId);
+        }
+        catch (e) {
+            setError(e);
+        }
+        finally {
+            setIsPending(false);
+        }
+    }, [provider, chainId]);
+    return _jsxs(_Fragment, { children: [_jsx(ChangeNetworkMessage, { data: {
+                    isPending: isPending,
+                    isError: !!error,
+                    error
+                }, network: network.display_name }), !isPending &&
+                _jsx(ButtonWrapper, { onClick: clickHandler, icon: _jsx(WalletIcon, { className: "stroke-2 w-6 h-6" }), children: error ? _jsx("span", { children: "Try again" })
+                        : _jsx("span", { children: "Switch network" }) })] });
+};
+export const ButtonWrapper = ({ ...props }) => {
+    return _jsx(SubmitButton, { text_align: 'center', buttonStyle: 'filled', size: "medium", type: "button", className: "text-primary-text text-base", ...props, children: props.children });
+};
+export const SendTransactionButton = ({ error, onClick, swapData, refuel, ...props }) => {
+    const [actionStateText, setActionStateText] = useState();
+    const [loading, setLoading] = useState(false);
+    const { quote, quoteIsLoading } = useSwapDataState();
+    const { createSwap, setSwapId, setQuoteLoading } = useSwapDataUpdate();
+    const { setSwapTransaction } = useSwapTransactionStore();
+    const initialSettings = useInitialSettings();
+    const triggerSwapCreateCallback = useSwapCreateCallback();
+    const { onWalletWithdrawalSuccess: onWalletWithdrawalSuccess } = useWalletWithdrawalState();
+    const { provider } = useWallet(swapData.source_network, "withdrawal");
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    const handleClick = async () => {
+        try {
+            if (!selectedSourceAccount) {
+                throw new Error('Selected source account is undefined');
+            }
+            if (!selectedSourceAccount?.wallet.isActive) {
+                throw new Error('Wallet is not active');
+            }
+            setLoading(true);
+            setActionStateText("Preparing");
+            setSwapId(undefined);
+            const swapValues = {
+                amount: swapData.requested_amount.toString(),
+                from: swapData.source_network,
+                to: swapData.destination_network,
+                fromAsset: swapData.source_token,
+                toAsset: swapData.destination_token,
+                refuel: refuel,
+                destination_address: swapData.destination_address,
+                depositMethod: 'wallet',
+            };
+            const newSwapData = await createSwap(swapValues, initialSettings);
+            const swapId = newSwapData?.swap?.id;
+            if (!swapId) {
+                throw new Error('Swap ID is undefined');
+            }
+            if (isDiffByPercent(quote?.receive_amount, newSwapData.quote.receive_amount, 2)) {
+                setActionStateText("Updating quotes");
+                setQuoteLoading(true);
+                await sleep(3500);
+                setQuoteLoading(false);
+            }
+            setActionStateText("Opening Wallet");
+            setSwapId(swapId);
+            const depositAction = newSwapData?.deposit_actions && newSwapData?.deposit_actions[0];
+            const transferProps = {
+                amount: depositAction?.amount,
+                callData: depositAction?.call_data,
+                depositAddress: depositAction?.to_address,
+                sequenceNumber: newSwapData.swap?.metadata.sequence_number,
+                swapId: swapId,
+                userDestinationAddress: newSwapData.swap?.destination_address
+            };
+            const hash = await onClick(transferProps);
+            if (hash) {
+                onWalletWithdrawalSuccess?.();
+                setSwapTransaction(swapId, BackendTransactionStatus.Pending, hash);
+                triggerSwapCreateCallback(newSwapData);
+            }
+        }
+        catch (e) {
+            setSwapId(undefined);
+            console.log('Error in SendTransactionButton:', e);
+            const swapWithdrawalError = new Error(e);
+            swapWithdrawalError.name = `SwapWithdrawalError`;
+            swapWithdrawalError.cause = e;
+            posthog.capture('$exception', {
+                name: swapWithdrawalError.name,
+                cause: swapWithdrawalError.cause,
+                message: swapWithdrawalError.message,
+                stack: swapWithdrawalError.stack,
+                where: 'TransactionError',
+                severity: 'error',
+            });
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    if (quoteIsLoading || loading)
+        return (_jsx(ButtonWrapper, { ...props, isSubmitting: true, isDisabled: true, children: actionStateText || "Preparing" }));
+    return (_jsx(ButtonWrapper, { ...props, isSubmitting: props.isSubmitting || loading || quoteIsLoading, onClick: handleClick, isDisabled: quoteIsLoading, children: error ? 'Try again' : 'Send from wallet' }));
+};

package/dist/components/Pages/Swap/Withdraw/Wallet/Common/sharedTypes.d.ts

@@ -0,0 +1,20 @@
+import { SwapBasicData } from "../../../../../../lib/apiClients/layerSwapApiClient";
+export type ActionData = {
+    error: Error | null;
+    isError: boolean;
+    isPending: boolean;
+};
+export type WithdrawPageProps = {
+    swapId: string | undefined;
+    swapBasicData: SwapBasicData;
+    refuel: boolean;
+    savedTransactionHash?: string;
+};
+export type TransferProps = {
+    callData?: string;
+    depositAddress?: string;
+    amount?: number;
+    swapId?: string;
+    userDestinationAddress?: string;
+    sequenceNumber?: number;
+};

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/BitcoinWalletWithdraw/index.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { WithdrawPageProps } from '../../Common/sharedTypes';
+export declare const BitcoinWalletWithdrawStep: FC<WithdrawPageProps>;

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/BitcoinWalletWithdraw/index.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useMemo, useState } from 'react';
+import toast from 'react-hot-toast';
+import useWallet from '../../../../../../../hooks/useWallet';
+import WalletIcon from '../../../../../../../components/Icons/WalletIcon';
+import { ConnectWalletButton, SendTransactionButton } from '../../Common/buttons';
+import { useAccount, useConfig } from '@bigmi/react';
+import KnownInternalNames from '../../../../../../../lib/knownIds';
+import { JsonRpcClient } from '../../../../../../../lib/apiClients/jsonRpcClient';
+import { sendTransaction } from './sendTransaction';
+import { useConnectModal } from '../../../../../../../components/Wallet/WalletModal';
+import TransactionMessages from '../../../messages/TransactionMessages';
+import { posthog } from 'posthog-js';
+import { useSelectedAccount } from '../../../../../../../context/balanceAccounts';
+export const BitcoinWalletWithdrawStep = ({ swapBasicData, refuel }) => {
+    const [loading, setLoading] = useState(false);
+    const { connect } = useConnectModal();
+    const { source_network, source_token } = swapBasicData;
+    const { provider } = useWallet(source_network, 'withdrawal');
+    const [transactionErrorMessage, setTransactionErrorMessage] = useState(undefined);
+    const { connector } = useAccount();
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    const dataLoading = !source_network || !source_token;
+    const isTestnet = source_network?.name === KnownInternalNames.Networks.BitcoinTestnet;
+    const config = useConfig();
+    const publicClient = config.getClient();
+    const handleConnect = useCallback(async () => {
+        setLoading(true);
+        setTransactionErrorMessage(undefined);
+        try {
+            await connect(provider);
+        }
+        catch (e) {
+            toast(e.message);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [provider]);
+    const rpcClient = useMemo(() => {
+        return source_network && new JsonRpcClient(source_network.node_url);
+    }, [source_network]);
+    const handleTransfer = useCallback(async ({ amount, callData, depositAddress, swapId }) => {
+        setTransactionErrorMessage(undefined);
+        try {
+            setLoading(true);
+            if (!amount || !depositAddress || !source_network || !source_token || !callData || !selectedSourceAccount || !connector || !rpcClient) {
+                throw new Error('Missing required parameters for transfer');
+            }
+            const txHash = await sendTransaction({
+                amount,
+                depositAddress,
+                userAddress: selectedSourceAccount.address,
+                isTestnet,
+                rpcClient,
+                callData,
+                connector,
+                publicClient
+            });
+            return txHash;
+        }
+        catch (e) {
+            setLoading(false);
+            setTransactionErrorMessage(e.message);
+            throw e;
+        }
+    }, [source_network, source_token, selectedSourceAccount, connector, rpcClient, isTestnet]);
+    if (!selectedSourceAccount) {
+        return _jsx(ConnectWalletButton, { isDisabled: loading, isSubmitting: loading, onClick: handleConnect });
+    }
+    return (_jsxs("div", { className: "w-full space-y-3 flex flex-col justify-between h-full text-primary-text", children: [transactionErrorMessage &&
+                _jsx(TransactionMessage, { isLoading: loading, error: transactionErrorMessage }), _jsx(SendTransactionButton, { isDisabled: !!loading || dataLoading, isSubmitting: !!loading || dataLoading, onClick: handleTransfer, icon: _jsx(WalletIcon, { className: "stroke-2 w-6 h-6", "aria-hidden": "true" }), swapData: swapBasicData, refuel: refuel })] }));
+};
+const TransactionMessage = ({ isLoading, error }) => {
+    if (isLoading) {
+        return _jsx(TransactionMessages.ConfirmTransactionMessage, {});
+    }
+    else if (error && error.includes('User rejected the request.')) {
+        return _jsx(TransactionMessages.TransactionRejectedMessage, {});
+    }
+    else if (error && error.includes('Insufficient balance.')) {
+        return _jsx(TransactionMessages.InsufficientFundsMessage, {});
+    }
+    else if (error) {
+        const swapWithdrawalError = new Error(error);
+        swapWithdrawalError.name = `SwapWithdrawalError`;
+        swapWithdrawalError.cause = error;
+        posthog.captureException('$exception', {
+            name: swapWithdrawalError.name,
+            message: swapWithdrawalError.message,
+            stack: swapWithdrawalError.stack,
+            cause: swapWithdrawalError.cause,
+            where: 'swapWithdrawalError',
+            severity: 'error',
+        });
+        return _jsx(TransactionMessages.UexpectedErrorMessage, { message: error });
+    }
+    else
+        return _jsx(_Fragment, {});
+};

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/BitcoinWalletWithdraw/sendTransaction.d.ts

@@ -0,0 +1,15 @@
+import { Connector } from "@bigmi/client";
+import { JsonRpcClient } from "../../../../../../../lib/apiClients/jsonRpcClient";
+import { BtcRpcRequestFn, Chain, Client, Transport } from "@bigmi/core";
+type sendTransactionParams = {
+    amount: number;
+    depositAddress: string;
+    userAddress: string;
+    isTestnet: boolean;
+    callData: string;
+    connector: Connector;
+    rpcClient: JsonRpcClient;
+    publicClient: Client<Transport<string, Record<string, any>, BtcRpcRequestFn>, Chain>;
+};
+export declare const sendTransaction: ({ amount, callData, depositAddress, isTestnet, publicClient, rpcClient, userAddress, connector }: sendTransactionParams) => Promise<string>;
+export {};

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/BitcoinWalletWithdraw/sendTransaction.js

@@ -0,0 +1,33 @@
+import { transactionBuilder } from "./transactionBuilder";
+import { Psbt } from "bitcoinjs-lib";
+export const sendTransaction = async ({ amount, callData, depositAddress, isTestnet, publicClient, rpcClient, userAddress, connector }) => {
+    const provider = (await connector?.getProvider());
+    if (!provider) {
+        throw new Error('Provider not found');
+    }
+    const amountInSatoshi = Math.floor(amount * 1e8);
+    const hexMemo = Number(callData).toString(16);
+    const { psbt, inputsToSign } = await transactionBuilder({
+        amount: amountInSatoshi,
+        depositAddress,
+        userAddress,
+        memo: hexMemo,
+        version: isTestnet ? 'testnet' : 'mainnet',
+        publicClient,
+        rpcClient
+    });
+    const psbtHex = psbt.toHex();
+    const signature = await provider.request({
+        method: 'signPsbt',
+        params: {
+            psbt: psbtHex,
+            inputsToSign,
+            finalize: false
+        }
+    });
+    const signedPsbt = Psbt.fromHex(signature).finalizeAllInputs();
+    const tx = signedPsbt.extractTransaction();
+    const txHex = tx.toHex();
+    const txHash = await rpcClient.call('sendrawtransaction', [txHex]);
+    return txHash;
+};

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/BitcoinWalletWithdraw/transactionBuilder/buildPsbt.d.ts

@@ -0,0 +1,6 @@
+import { Psbt } from 'bitcoinjs-lib';
+import type { TransactionBuilderParams, Utxo } from './types';
+export declare function buildPsbt({ amount, depositAddress, userAddress, memo, version, rpcClient, }: TransactionBuilderParams): Promise<{
+    psbt: Psbt;
+    utxos: Utxo[];
+}>;

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/BitcoinWalletWithdraw/transactionBuilder/buildPsbt.js

@@ -0,0 +1,79 @@
+import axios from 'axios';
+import { Psbt, Transaction, networks, opcodes, script, initEccLib } from 'bitcoinjs-lib';
+import { estimateFee } from './estimateFee';
+import ecc from '@bitcoinerlab/secp256k1';
+initEccLib(ecc);
+const MIN_FEE = 1000n; // sats, as BigInt
+async function fetchUtxos(address, version) {
+    const base = `https://mempool.space${version === 'testnet' ? '/testnet' : ''}`;
+    const { data } = await axios.get(`${base}/api/address/${address}/utxo`);
+    return data;
+}
+async function fetchAllRawTxs(utxos, version) {
+    const base = `https://mempool.space${version === 'testnet' ? '/testnet' : ''}/api/tx/`;
+    const pairs = await Promise.all(utxos.map(u => axios
+        .get(`${base}${u.txid}/hex`)
+        .then(res => [u.txid, Transaction.fromHex(res.data)])));
+    return Object.fromEntries(pairs);
+}
+function selectUtxos(utxos, target) {
+    const sorted = utxos.slice().sort((a, b) => a.value - b.value);
+    let sum = 0n;
+    const selected = [];
+    for (const u of sorted) {
+        selected.push(u);
+        sum += BigInt(u.value);
+        if (sum >= target)
+            break;
+    }
+    if (sum < target) {
+        throw new Error(`Insufficient funds: need ${target} sats, have only ${sum}`);
+    }
+    return { selected, total: sum };
+}
+export async function buildPsbt({ amount, depositAddress, userAddress, memo, version, rpcClient, }) {
+    const network = version === 'testnet' ? networks.testnet : networks.bitcoin;
+    // fetch & cache
+    const utxos = await fetchUtxos(userAddress, version);
+    const rawTxMap = await fetchAllRawTxs(utxos, version);
+    // validate memo
+    const data = Buffer.from(memo || '', 'utf8');
+    if (data.length > 80)
+        throw new Error('Memo too long; max 80 bytes');
+    let psbt;
+    let fee = MIN_FEE;
+    let totalSelected;
+    // 4️⃣ iterate until selection covers amount + fee
+    do {
+        const target = BigInt(amount) + fee;
+        const { selected, total } = selectUtxos(utxos, target);
+        totalSelected = total;
+        // build a fresh PSBT
+        psbt = new Psbt({ network });
+        // inputs
+        for (const u of selected) {
+            const tx = rawTxMap[u.txid];
+            const out = tx.outs[u.vout];
+            psbt.addInput({
+                hash: u.txid,
+                index: u.vout,
+                witnessUtxo: { script: out.script, value: out.value },
+            });
+        }
+        // main output
+        psbt.addOutput({ address: depositAddress, value: BigInt(amount) });
+        // OP_RETURN
+        psbt.addOutput({
+            script: script.compile([opcodes.OP_RETURN, data]),
+            value: 0n,
+        });
+        // re‐estimate fee on this draft PSBT
+        fee = BigInt((await estimateFee(psbt, rpcClient, version)).toFixed());
+    } while (totalSelected < BigInt(amount) + fee);
+    // 5️⃣ add change if any
+    const change = totalSelected - BigInt(amount) - fee;
+    if (change > 0n) {
+        psbt.addOutput({ address: userAddress, value: change });
+    }
+    return { psbt, utxos };
+}

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/BitcoinWalletWithdraw/transactionBuilder/estimateFee.d.ts

@@ -0,0 +1,3 @@
+import { JsonRpcClient } from '../../../../../../../../lib/apiClients/jsonRpcClient';
+import { Psbt } from 'bitcoinjs-lib';
+export declare const estimateFee: (psbt: Psbt, rpcClient: JsonRpcClient, version: "testnet" | "mainnet") => Promise<number>;

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/BitcoinWalletWithdraw/transactionBuilder/estimateFee.js

@@ -0,0 +1,15 @@
+import axios from 'axios';
+export const estimateFee = async (psbt, rpcClient, version) => {
+    const recommendedFee = await fetchRecommendedFee(version);
+    const satsPerVbyte = recommendedFee.fastestFee;
+    const fee = calculateFee(psbt.txInputs.length, psbt.txOutputs.length, satsPerVbyte);
+    return fee;
+};
+async function fetchRecommendedFee(version) {
+    const base = `https://mempool.space${version === 'testnet' ? '/testnet' : ''}`;
+    const { data } = await axios.get(`${base}/api/v1/fees/recommended`);
+    return data;
+}
+function calculateFee(numInputs, numOutputs, feePerByte) {
+    return (numInputs * 148 + numOutputs * 34 + 10) * feePerByte;
+}

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/BitcoinWalletWithdraw/transactionBuilder/index.d.ts

@@ -0,0 +1,6 @@
+import { TransactionBuilderParams } from "./types";
+export declare const transactionBuilder: (props: TransactionBuilderParams) => Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    inputsToSign: any[];
+    utxos: import("./types").Utxo[];
+}>;

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/BitcoinWalletWithdraw/transactionBuilder/index.js

@@ -0,0 +1,28 @@
+import { address, networks } from 'bitcoinjs-lib';
+import { buildPsbt } from "./buildPsbt";
+export const transactionBuilder = async (props) => {
+    const { psbt, utxos } = await buildPsbt(props);
+    const inputsToSign = Array.from(psbt.data.inputs
+        .reduce((map, input, index) => {
+        const accountAddress = input.witnessUtxo
+            ? address.fromOutputScript(input.witnessUtxo.script, props.version == 'testnet' ? networks.testnet : networks.bitcoin)
+            : props.publicClient?.account?.address;
+        if (map.has(accountAddress)) {
+            map.get(accountAddress).signingIndexes.push(index);
+        }
+        else {
+            map.set(accountAddress, {
+                address: accountAddress,
+                sigHash: 1, // Default to Transaction.SIGHASH_ALL - 1
+                signingIndexes: [index],
+            });
+        }
+        return map;
+    }, new Map())
+        .values());
+    return {
+        psbt,
+        inputsToSign,
+        utxos
+    };
+};