@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

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

@@ -0,0 +1,127 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Lock } from 'lucide-react';
+import { useCallback, useEffect, useState } from 'react';
+import toast from 'react-hot-toast';
+import { useAccount } from 'wagmi';
+import { ActivationTokenPicker } from './ActivationTokentPicker';
+import { useActivationData, useLoopringAccount, useLoopringTokens } from './hooks';
+import { LoopringAPI } from '../../../../../../../lib/loopring/LoopringAPI';
+import { ChainId } from '../../../../../../../lib/loopring/defs';
+import { useConfig } from 'wagmi';
+import AppSettings from '../../../../../../../lib/AppSettings';
+import WalletMessage from '../../../messages/Message';
+import { ButtonWrapper, ChangeNetworkButton, ConnectWalletButton, SendTransactionButton } from '../../Common/buttons';
+import SignatureIcon from '../../../../../../../components/Icons/SignatureIcon';
+import WalletIcon from '../../../../../../../components/Icons/WalletIcon';
+export const LoopringWalletWithdraw = ({ swapBasicData, refuel }) => {
+    const [loading, setLoading] = useState(false);
+    const [transferDone, setTransferDone] = useState();
+    const [activationPubKey, setActivationPubKey] = useState();
+    const [selectedActivationAsset, setSelectedActivationAsset] = useState();
+    const { source_network, source_token } = swapBasicData;
+    const { isConnected, address: fromAddress, chain } = useAccount();
+    const { account: accInfo, isLoading: loadingAccount, noAccount, mutate: refetchAccount } = useLoopringAccount({ address: fromAddress });
+    const { availableBalances, defaultValue, loading: activationDataIsLoading, feeData } = useActivationData(accInfo?.accountId);
+    const [unlockedAccount, setUnlockedAccount] = useState();
+    const { tokens } = useLoopringTokens();
+    const loopringToken = tokens?.find(t => t.symbol === selectedActivationAsset);
+    const config = useConfig();
+    useEffect(() => {
+        if (fromAddress) {
+            setUnlockedAccount(undefined);
+        }
+    }, [fromAddress]);
+    const handleUnlockAccount = useCallback(async () => {
+        setLoading(true);
+        try {
+            if (!accInfo)
+                return;
+            const res = await LoopringAPI.userAPI.unlockAccount(accInfo, config);
+            setUnlockedAccount(res);
+        }
+        catch (e) {
+            toast(e.message);
+            throw e;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [accInfo, config]);
+    const activateAccout = useCallback(async () => {
+        setLoading(true);
+        try {
+            if (!accInfo || !selectedActivationAsset || !loopringToken)
+                return;
+            const publicKey = await LoopringAPI.userAPI.activateAccount({
+                accInfo,
+                token: { id: loopringToken?.tokenId, symbol: loopringToken?.symbol }
+            }, config);
+            setActivationPubKey(publicKey);
+            await refetchAccount();
+        }
+        catch (e) {
+            toast(e.message);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [accInfo, selectedActivationAsset, refetchAccount, loopringToken]);
+    const handleTransfer = useCallback(async ({ amount, callData, depositAddress, swapId }) => {
+        setLoading(true);
+        try {
+            if (!swapId || !accInfo || !unlockedAccount || !source_token || !amount)
+                return;
+            const transferResult = await LoopringAPI.userAPI.transfer({
+                accInfo,
+                amount: amount.toString(),
+                depositAddress: depositAddress,
+                call_data: callData,
+                token: source_token,
+                unlockedAccount
+            }, config);
+            if (transferResult.hash) {
+                setTransferDone(true);
+                return transferResult.hash;
+            }
+            else {
+                toast(transferResult.resultInfo?.message || "Unexpected error.");
+            }
+        }
+        catch (e) {
+            setLoading(false);
+            if (e?.message)
+                toast(e.message);
+        }
+    }, [source_network, accInfo, unlockedAccount, source_token]);
+    if (noAccount) {
+        //TODO fix text
+        return _jsx(WalletMessage, { status: "error", header: 'Account is not activated', details: `Make a deposit to your address for activating Loopring account` });
+    }
+    if (accInfo?.frozen) {
+        if (accInfo.publicKey.x === activationPubKey?.x
+            && accInfo.publicKey.y === activationPubKey?.y) {
+            return _jsx(WalletMessage, { status: "pending", header: 'Your account is beeing activated', details: `You will be able to make transfers in 3-5 minutes.` });
+        }
+        else {
+            return _jsx(WalletMessage, { status: "pending", header: 'Your account is frozen', details: `If you have just activated your account it will be unfrozen in couple of minutes.` });
+        }
+    }
+    if (!isConnected) {
+        return _jsx(ConnectWalletButton, {});
+    }
+    let walletChainId = AppSettings.ApiVersion === "sandbox" ? ChainId.SEPOLIA : ChainId.MAINNET;
+    if (source_network && chain?.id !== Number(walletChainId)) {
+        return (_jsx(ChangeNetworkButton, { chainId: Number(walletChainId), network: source_network }));
+    }
+    const shouldActivate = accInfo && !(accInfo.publicKey.x
+        || accInfo.publicKey.y);
+    if (shouldActivate && !activationDataIsLoading && (!availableBalances || !defaultValue || !feeData))
+        return _jsx(WalletMessage, { status: "error", header: 'Not enough fee', details: `The balance of the account is not enough to activate it․` });
+    return (_jsx(_Fragment, { children: _jsx("div", { className: "w-full space-y-5 flex flex-col justify-between h-full text-secondary-text", children: _jsx("div", { className: 'space-y-4', children: (accInfo && unlockedAccount) ?
+                    _jsx(SendTransactionButton, { isDisabled: !!(loading || transferDone), onClick: handleTransfer, icon: _jsx(WalletIcon, { className: "stroke-2 w-6 h-6" }), swapData: swapBasicData, refuel: refuel })
+                    :
+                        _jsxs(_Fragment, { children: [shouldActivate &&
+                                    _jsx(ActivationTokenPicker, { onSelect: setSelectedActivationAsset, selectedValue: selectedActivationAsset, availableBalances: availableBalances, defaultValue: defaultValue, feeData: feeData }), _jsx(ButtonWrapper, { isDisabled: loadingAccount || !accInfo || loading || activationDataIsLoading, isSubmitting: loadingAccount || loading, onClick: shouldActivate ? activateAccout : handleUnlockAccount, icon: shouldActivate ?
+                                        _jsx(SignatureIcon, { className: "h-5 w-5 ml-2", "aria-hidden": "true" })
+                                        : _jsx(Lock, { className: "h-5 w-5 ml-2", "aria-hidden": "true" }), children: shouldActivate ? _jsx(_Fragment, { children: "Activate account" }) : _jsx(_Fragment, { children: "Unlock account" }) })] }) }) }) }));
+};

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

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { Transaction, Connection } from '@solana/web3.js';
+import { SignerWalletAdapterProps } from '@solana/wallet-adapter-base';
+import { WithdrawPageProps } from '../../Common/sharedTypes';
+export declare const SVMWalletWithdrawStep: FC<WithdrawPageProps>;
+export declare const configureAndSendCurrentTransaction: (transaction: Transaction, connection: Connection, signTransaction: SignerWalletAdapterProps["signTransaction"]) => Promise<string | undefined>;

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

@@ -0,0 +1,106 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useState } from 'react';
+import { Transaction, Connection, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import useWallet from '../../../../../../../hooks/useWallet';
+import { useWallet as useSolanaWallet } from '@solana/wallet-adapter-react';
+import WalletIcon from '../../../../../../../components/Icons/WalletIcon';
+import { useSettingsState } from '../../../../../../../context/settings';
+import { transactionSenderAndConfirmationWaiter } from './transactionSender';
+import { ConnectWalletButton, SendTransactionButton } from '../../Common/buttons';
+import TransactionMessages from '../../../messages/TransactionMessages';
+import WalletMessage from '../../../messages/Message';
+import { useSelectedAccount } from '../../../../../../../context/balanceAccounts';
+import { useBalance } from '../../../../../../../lib/balances/useBalance';
+export const SVMWalletWithdrawStep = ({ swapBasicData, refuel }) => {
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState();
+    const [insufficientTokens, setInsufficientTokens] = useState([]);
+    const { source_network, source_token } = swapBasicData;
+    const { provider } = useWallet(source_network, 'withdrawal');
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    const wallet = selectedSourceAccount?.wallet;
+    const { wallet: solanaWallet, signTransaction } = useSolanaWallet();
+    const walletPublicKey = solanaWallet?.adapter.publicKey;
+    const solanaNode = source_network?.node_url;
+    const networkName = source_network?.name;
+    const { networks } = useSettingsState();
+    const networkWithTokens = networks.find(n => n.name === networkName);
+    const { balances } = useBalance(selectedSourceAccount?.address, networkWithTokens);
+    const handleTransfer = useCallback(async ({ amount, callData, swapId }) => {
+        setLoading(true);
+        setError(undefined);
+        try {
+            if (!signTransaction)
+                throw new Error('Missing signTransaction');
+            if (!callData)
+                throw new Error('Missing callData');
+            if (!swapId)
+                throw new Error('Missing swapId');
+            const connection = new Connection(`${solanaNode}`, "confirmed");
+            const arrayBufferCallData = Uint8Array.from(atob(callData), c => c.charCodeAt(0));
+            const transaction = Transaction.from(arrayBufferCallData);
+            const feeInLamports = await transaction.getEstimatedFee(connection);
+            const feeInSol = feeInLamports / LAMPORTS_PER_SOL;
+            const nativeTokenBalance = balances?.find(b => b.token == source_network?.token?.symbol);
+            const tokenbalanceData = balances?.find(b => b.token == source_token?.symbol);
+            const tokenBalanceAmount = tokenbalanceData?.amount;
+            const nativeTokenBalanceAmount = nativeTokenBalance?.amount;
+            const insufficientTokensArr = [];
+            if (source_network?.token && (Number(nativeTokenBalanceAmount) < feeInSol || isNaN(Number(nativeTokenBalanceAmount)))) {
+                insufficientTokensArr.push(source_network.token?.symbol);
+            }
+            if (source_network?.token?.symbol !== source_token?.symbol && amount && source_token?.symbol && Number(tokenBalanceAmount) < amount) {
+                insufficientTokensArr.push(source_token?.symbol);
+            }
+            setInsufficientTokens(insufficientTokensArr);
+            const signature = await configureAndSendCurrentTransaction(transaction, connection, signTransaction);
+            return signature;
+        }
+        catch (e) {
+            setLoading(false);
+            if (e?.message) {
+                if (e?.logs?.some(m => m?.includes('insufficient funds')) || e.message.includes('Attempt to debit an account'))
+                    setError('insufficientFunds');
+                else
+                    setError(e.message);
+            }
+            throw e;
+        }
+    }, [walletPublicKey, signTransaction, source_network, source_token]);
+    if (!wallet || !walletPublicKey) {
+        return _jsx(ConnectWalletButton, {});
+    }
+    return (_jsxs("div", { className: "w-full space-y-3 flex flex-col justify-between h-full text-primary-text", children: [_jsx(TransactionMessage, { error: error, isLoading: loading, insufficientTokens: insufficientTokens }), wallet && !loading &&
+                _jsx(SendTransactionButton, { isDisabled: !!loading, isSubmitting: !!loading, onClick: handleTransfer, icon: _jsx(WalletIcon, { className: "stroke-2 w-6 h-6", "aria-hidden": "true" }), error: !!error, refuel: refuel, swapData: swapBasicData })] }));
+};
+const TransactionMessage = ({ isLoading, error, insufficientTokens }) => {
+    if (isLoading) {
+        return _jsx(TransactionMessages.ConfirmTransactionMessage, {});
+    }
+    else if (error === "insufficientFunds") {
+        return _jsx(WalletMessage, { status: "error", header: 'Insufficient funds', details: `The balance of ${insufficientTokens?.join(" and ")} in the connected wallet is not enough` });
+    }
+    else if (error === "User rejected the request.") {
+        return _jsx(TransactionMessages.TransactionRejectedMessage, {});
+    }
+    else if (error) {
+        return _jsx(TransactionMessages.UexpectedErrorMessage, { message: error });
+    }
+    else
+        return _jsx(_Fragment, {});
+};
+export const configureAndSendCurrentTransaction = async (transaction, connection, signTransaction) => {
+    const blockHash = await connection.getLatestBlockhash();
+    transaction.recentBlockhash = blockHash.blockhash;
+    transaction.lastValidBlockHeight = blockHash.lastValidBlockHeight;
+    const signed = await signTransaction(transaction);
+    const res = await transactionSenderAndConfirmationWaiter({
+        connection,
+        serializedTransaction: signed.serialize(),
+        blockhashWithExpiryBlockHeight: blockHash,
+    });
+    if (res?.meta?.err) {
+        throw new Error(res.meta.err.toString());
+    }
+    return res?.transaction.signatures[0];
+};

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/SVMWalletWithdraw/transactionSender.d.ts

@@ -0,0 +1,8 @@
+import { BlockhashWithExpiryBlockHeight, Connection, VersionedTransactionResponse } from "@solana/web3.js";
+type TransactionSenderAndConfirmationWaiterArgs = {
+    connection: Connection;
+    serializedTransaction: Buffer;
+    blockhashWithExpiryBlockHeight: BlockhashWithExpiryBlockHeight;
+};
+export declare function transactionSenderAndConfirmationWaiter({ connection, serializedTransaction, blockhashWithExpiryBlockHeight, }: TransactionSenderAndConfirmationWaiterArgs): Promise<VersionedTransactionResponse | null>;
+export {};

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/SVMWalletWithdraw/transactionSender.js

@@ -0,0 +1,73 @@
+import { TransactionExpiredBlockheightExceededError, } from "@solana/web3.js";
+import { retry } from "../../../../../../../lib/retry";
+import sleep from "../../../../../../../lib/wallets/utils/sleep";
+const SEND_OPTIONS = {
+    skipPreflight: true,
+};
+export async function transactionSenderAndConfirmationWaiter({ connection, serializedTransaction, blockhashWithExpiryBlockHeight, }) {
+    const txid = await connection.sendRawTransaction(serializedTransaction, SEND_OPTIONS);
+    const controller = new AbortController();
+    const abortSignal = controller.signal;
+    const abortableResender = async () => {
+        while (true) {
+            await sleep(2000);
+            if (abortSignal.aborted)
+                return;
+            try {
+                await connection.sendRawTransaction(serializedTransaction, SEND_OPTIONS);
+            }
+            catch (e) {
+                console.warn(`Failed to resend transaction: ${e}`);
+            }
+        }
+    };
+    try {
+        abortableResender();
+        const lastValidBlockHeight = blockhashWithExpiryBlockHeight.lastValidBlockHeight;
+        // this would throw TransactionExpiredBlockheightExceededError
+        await Promise.race([
+            connection.confirmTransaction({
+                ...blockhashWithExpiryBlockHeight,
+                lastValidBlockHeight,
+                signature: txid,
+            }, "confirmed"),
+            new Promise(async (resolve) => {
+                // in case ws socket died
+                while (!abortSignal.aborted) {
+                    await sleep(2000);
+                    const tx = await connection.getSignatureStatus(txid, {
+                        searchTransactionHistory: false,
+                    });
+                    if (tx?.value?.confirmationStatus === "confirmed") {
+                        resolve(tx);
+                    }
+                }
+            }),
+        ]);
+    }
+    catch (e) {
+        if (e instanceof TransactionExpiredBlockheightExceededError) {
+            // we consume this error and getTransaction would return null
+            return null;
+        }
+        else {
+            // invalid state from web3.js
+            throw e;
+        }
+    }
+    finally {
+        controller.abort();
+    }
+    // in case rpc is not synced yet, we add some retries
+    const response = retry(async () => {
+        const response = await connection.getTransaction(txid, {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0,
+        });
+        if (!response) {
+            throw new Error("Transaction not found");
+        }
+        return response;
+    });
+    return response;
+}

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

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

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/StarknetWalletWithdraw.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useState } from 'react';
+import useWallet from '../../../../../../hooks/useWallet';
+import WalletIcon from '../../../../../../components/Icons/WalletIcon';
+import { ConnectWalletButton, SendTransactionButton } from '../Common/buttons';
+import TransactionMessages from '../../messages/TransactionMessages';
+import { useSelectedAccount } from '../../../../../../context/balanceAccounts';
+export const StarknetWalletWithdrawStep = ({ swapBasicData, refuel }) => {
+    const [error, setError] = useState();
+    const [loading, setLoading] = useState(false);
+    const [transferDone, setTransferDone] = useState();
+    const { source_network, source_token } = swapBasicData;
+    const { provider } = useWallet(source_network, 'withdrawal');
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    const wallet = selectedSourceAccount?.wallet;
+    const handleTransfer = useCallback(async ({ callData, swapId }) => {
+        if (!swapId || !source_token) {
+            return;
+        }
+        setLoading(true);
+        try {
+            if (!wallet) {
+                throw Error("Starknet wallet not connected");
+            }
+            const { transaction_hash: transferTxHash } = (await wallet?.metadata?.starknetAccount?.execute(JSON.parse(callData || "")) || {});
+            if (transferTxHash) {
+                setTransferDone(true);
+                return transferTxHash;
+            }
+            else {
+                setError('failedTransfer');
+            }
+        }
+        catch (e) {
+            setLoading(false);
+            setError(e.message);
+            throw e;
+        }
+    }, [wallet, source_network, source_token]);
+    if (!wallet) {
+        return _jsx(ConnectWalletButton, {});
+    }
+    return (_jsxs("div", { className: "w-full space-y-3 flex flex-col justify-between h-full text-secondary-text", children: [_jsx(TransactionMessage, { isLoading: loading, error: error }), !loading &&
+                _jsx(SendTransactionButton, { isDisabled: !!(loading || transferDone) || !wallet, isSubmitting: !!(loading || transferDone), onClick: handleTransfer, icon: _jsx(WalletIcon, { className: "h-6 w-6 stroke-2", "aria-hidden": "true" }), refuel: refuel, swapData: swapBasicData, error: !!error })] }));
+};
+const TransactionMessage = ({ isLoading, error }) => {
+    if (isLoading) {
+        return _jsx(TransactionMessages.ConfirmTransactionMessage, {});
+    }
+    else if (error === "An error occurred (USER_REFUSED_OP)" || error === "Execute failed") {
+        return _jsx(TransactionMessages.TransactionRejectedMessage, {});
+    }
+    else if (error === "failedTransfer") {
+        return _jsx(TransactionMessages.TransactionFailedMessage, {});
+    }
+    else if (error) {
+        return _jsx(TransactionMessages.UexpectedErrorMessage, { message: error });
+    }
+    else
+        return _jsx(_Fragment, {});
+};

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

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

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/TonWalletWithdraw.js

@@ -0,0 +1,131 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useState } from 'react';
+import toast from 'react-hot-toast';
+import useWallet from '../../../../../../hooks/useWallet';
+import WalletIcon from '../../../../../../components/Icons/WalletIcon';
+import { useTonConnectUI } from '@tonconnect/ui-react';
+import { Address, JettonMaster, beginCell, toNano } from '@ton/ton';
+import tonClient from '../../../../../../lib/wallets/ton/client';
+import { ConnectWalletButton, SendTransactionButton } from '../Common/buttons';
+import TransactionMessages from '../../messages/TransactionMessages';
+import { useConnectModal } from '../../../../../../components/Wallet/WalletModal';
+import { useSelectedAccount } from '../../../../../../context/balanceAccounts';
+export const TonWalletWithdrawStep = ({ swapBasicData, refuel }) => {
+    const [loading, setLoading] = useState(false);
+    const { connect } = useConnectModal();
+    const { source_network, source_token } = swapBasicData;
+    const { provider } = useWallet(source_network, 'withdrawal');
+    const [tonConnectUI] = useTonConnectUI();
+    const [transactionErrorMessage, setTransactionErrorMessage] = useState(undefined);
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    const wallet = selectedSourceAccount?.wallet;
+    const handleConnect = useCallback(async () => {
+        setLoading(true);
+        setTransactionErrorMessage(undefined);
+        try {
+            await connect(provider);
+        }
+        catch (e) {
+            toast(e.message);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [provider]);
+    const handleTransfer = useCallback(async ({ amount, callData, depositAddress, swapId }) => {
+        setLoading(true);
+        setTransactionErrorMessage(undefined);
+        if (!swapId || !depositAddress || !source_token || !selectedSourceAccount?.address || !callData || amount === undefined) {
+            setLoading(false);
+            toast('Something went wrong, please try again.');
+            return;
+        }
+        try {
+            const transaction = await transactionBuilder(amount, source_token, depositAddress, selectedSourceAccount?.address, callData);
+            const res = await tonConnectUI.sendTransaction(transaction);
+            if (res) {
+                return res.boc;
+            }
+        }
+        catch (e) {
+            setLoading(false);
+            setTransactionErrorMessage(e.message);
+            throw e;
+        }
+    }, [source_network, source_token, tonConnectUI]);
+    if (!wallet) {
+        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 }), !loading &&
+                _jsx(SendTransactionButton, { isDisabled: !!loading, isSubmitting: !!loading, onClick: handleTransfer, icon: _jsx(WalletIcon, { className: "stroke-2 w-6 h-6", "aria-hidden": "true" }), error: !!transactionErrorMessage, swapData: swapBasicData, refuel: refuel })] }));
+};
+const TransactionMessage = ({ isLoading, error }) => {
+    if (isLoading) {
+        return _jsx(TransactionMessages.ConfirmTransactionMessage, {});
+    }
+    else if (error && error.includes('Reject request')) {
+        return _jsx(TransactionMessages.TransactionRejectedMessage, {});
+    }
+    else if (error && error.includes('Transaction was not sent')) {
+        return _jsx(TransactionMessages.TransactionFailedMessage, {});
+    }
+    else if (error) {
+        return _jsx(TransactionMessages.UexpectedErrorMessage, { message: error });
+    }
+    else
+        return _jsx(_Fragment, {});
+};
+const transactionBuilder = async (amount, token, depositAddress, sourceAddress, callData) => {
+    const parsedCallData = JSON.parse(callData);
+    if (token.contract) {
+        const destinationAddress = Address.parse(depositAddress);
+        const userAddress = Address.parse(sourceAddress);
+        const forwardPayload = beginCell()
+            .storeUint(0, 32) // 0 opcode means we have a comment
+            .storeStringTail(parsedCallData.comment)
+            .endCell();
+        const body = beginCell()
+            .storeUint(0x0f8a7ea5, 32) // opcode for jetton transfer
+            .storeUint(0, 64) // query id
+            .storeCoins(parsedCallData.amount) // jetton amount
+            .storeAddress(destinationAddress) // TON wallet destination address
+            .storeAddress(destinationAddress) // response excess destination
+            .storeBit(0) // no custom payload
+            .storeCoins(toNano('0.00002')) // forward amount (if >0, will send notification message)
+            .storeBit(1) // we store forwardPayload as a reference
+            .storeRef(forwardPayload)
+            .endCell();
+        const jettonMasterAddress = Address.parse(token.contract);
+        const jettonMaster = tonClient.open(JettonMaster.create(jettonMasterAddress));
+        const jettonAddress = await jettonMaster.getWalletAddress(userAddress);
+        const tx = {
+            validUntil: Math.floor(Date.now() / 1000) + 360,
+            messages: [
+                {
+                    address: jettonAddress.toString(), // sender jetton wallet
+                    amount: toNano('0.045').toString(), // for commission fees, excess will be returned
+                    payload: body.toBoc().toString("base64") // payload with jetton transfer and comment body
+                }
+            ]
+        };
+        return tx;
+    }
+    else {
+        const body = beginCell()
+            .storeUint(0, 32) // write 32 zero bits to indicate that a text comment will follow
+            .storeStringTail(parsedCallData.comment) // write our text comment
+            .endCell();
+        const tx = {
+            validUntil: Math.floor(Date.now() / 1000) + 360,
+            messages: [
+                {
+                    address: depositAddress,
+                    amount: toNano(amount).toString(),
+                    payload: body.toBoc().toString("base64") // payload with comment in body
+                }
+            ]
+        };
+        return tx;
+    }
+};

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

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

package/dist/components/Pages/Swap/Withdraw/Wallet/WithdrawalProviders/TronWalletWithdraw.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useState } from 'react';
+import useWallet from '../../../../../../hooks/useWallet';
+import { useWallet as useTronWallet } from '@tronweb3/tronwallet-adapter-react-hooks';
+import { useSettingsState } from '../../../../../../context/settings';
+import { TronWeb } from 'tronweb';
+import useSWRGas from '../../../../../../lib/gases/useSWRGas';
+import { ConnectWalletButton, SendTransactionButton } from '../Common/buttons';
+import TransactionMessages from '../../messages/TransactionMessages';
+import WalletIcon from '../../../../../../components/Icons/WalletIcon';
+import { useSelectedAccount } from '../../../../../../context/balanceAccounts';
+export const TronWalletWithdraw = ({ swapBasicData, refuel }) => {
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState();
+    const { source_network, source_token } = swapBasicData;
+    const { provider } = useWallet(source_network, 'withdrawal');
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    const wallet = selectedSourceAccount?.wallet;
+    const { wallet: tronWallet, signTransaction } = useTronWallet();
+    const walletAddress = tronWallet?.adapter.address;
+    const tronNode = source_network?.node_url;
+    const networkName = source_network?.name;
+    const { networks } = useSettingsState();
+    const networkWithTokens = networks.find(n => n.name === networkName);
+    const { gasData, isGasLoading } = useSWRGas(walletAddress, networkWithTokens, source_token);
+    const handleTransfer = useCallback(async ({ amount, callData, depositAddress, swapId }) => {
+        setError(undefined);
+        setLoading(true);
+        try {
+            if (!signTransaction || !swapId || !depositAddress || !amount || !source_token)
+                throw new Error('Missing data');
+            if (!walletAddress)
+                throw new Error('Tron wallet not connected');
+            if (!callData)
+                throw new Error("No call data provided");
+            const tronWeb = new TronWeb({ fullNode: tronNode, solidityNode: tronNode });
+            const amountInWei = Math.pow(10, source_token?.decimals) * amount;
+            const initialTransaction = await buildInitialTransaction({ tronWeb, token: source_token, depositAddress, amountInWei, gas: gasData?.gas, issuerAddress: walletAddress });
+            const data = Buffer.from(callData).toString('hex');
+            const transaction = await tronWeb.transactionBuilder.addUpdateData(initialTransaction, data, "hex");
+            const signature = await signTransaction(transaction);
+            const res = await tronWeb.trx.sendRawTransaction(signature);
+            if (signature && res.result) {
+                return signature.txID;
+            }
+            else {
+                throw new Error(res.code.toString());
+            }
+        }
+        catch (e) {
+            setLoading(false);
+            if (e?.message) {
+                if (e?.logs?.some(m => m?.includes('insufficient funds')) || e.message.includes('Attempt to debit an account'))
+                    setError('insufficientFunds');
+                else
+                    setError(e.message);
+            }
+            throw e;
+        }
+    }, [walletAddress, signTransaction, source_network, gasData, source_token]);
+    if (!wallet || !walletAddress) {
+        return _jsx(ConnectWalletButton, {});
+    }
+    return (_jsxs("div", { className: "w-full space-y-3 flex flex-col justify-between h-full text-primary-text", children: [_jsx(TransactionMessage, { error: error, isLoading: loading }), wallet && !loading &&
+                _jsx(SendTransactionButton, { isDisabled: !!loading || isGasLoading, isSubmitting: !!loading || isGasLoading, onClick: handleTransfer, icon: _jsx(WalletIcon, { className: "stroke-2 w-6 h-6", "aria-hidden": "true" }), error: !!error, refuel: refuel, swapData: swapBasicData })] }));
+};
+const TransactionMessage = ({ isLoading, error }) => {
+    if (isLoading) {
+        return _jsx(TransactionMessages.ConfirmTransactionMessage, {});
+    }
+    else if (error === "BANDWITH_ERROR") {
+        return _jsx(TransactionMessages.InsufficientFundsMessage, {});
+    }
+    else if (error === "user reject this request") {
+        return _jsx(TransactionMessages.TransactionRejectedMessage, {});
+    }
+    else if (error) {
+        return _jsx(TransactionMessages.UexpectedErrorMessage, { message: error });
+    }
+    else
+        return _jsx(_Fragment, {});
+};
+const buildInitialTransaction = async (props) => {
+    const { token, depositAddress, amountInWei, gas, issuerAddress, tronWeb } = props;
+    // native token
+    if (!token.contract)
+        return await tronWeb.transactionBuilder.sendTrx(depositAddress, amountInWei, issuerAddress);
+    const estimatedFee = (gas && token) && Number((gas * Math.pow(10, token.decimals)).toFixed());
+    return (await tronWeb.transactionBuilder.triggerSmartContract(token.contract, "transfer(address,uint256)", {
+        feeLimit: estimatedFee || 100000000,
+    }, [{ type: 'address', value: depositAddress }, { type: 'uint256', value: amountInWei }], issuerAddress)).transaction;
+};

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

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