@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/lib/wallets/paradex/useParadex.js

@@ -1,197 +1,238 @@
-// import { Network } from "../../../Models/Network"
-// import KnownInternalNames from "../../knownIds"
-// import { useMemo } from "react"
-// import toast from "react-hot-toast"
-// import { LSConnector } from "../connectors/EthereumProvider"
-// import { InternalConnector, Wallet, WalletProvider } from "../../../Models/WalletProvider"
-// import { useConnectModal } from "../../../components/Wallet/WalletModal"
-// import { type ConnectorAlreadyConnectedError } from '@wagmi/core'
-// import useEVM from "../evm/useEVM"
-// import useStarknet from "../starknet/useStarknet"
-// import { useWalletStore } from "../../../stores/walletStore"
-// import { AuthorizeStarknet } from "./Authorize/Starknet"
-// import { walletClientToSigner } from "../../ethersToViem/ethers"
-// import AuhorizeEthereum from "./Authorize/Ethereum"
-// import { getWalletClient } from '@wagmi/core'
-// import { useConfig } from "wagmi"
-// import { switchChain, getChainId } from '@wagmi/core'
-// import { useSettingsState } from "../../../context/settings"
-// import shortenAddress from "../../../components/utils/ShortenAddress"
-// type Props = {
-//     network: Network | undefined,
-// }
-// export default function useParadex({ network }: Props): WalletProvider {
-//     const name = 'Paradex'
-//     const id = 'prdx'
-//     const { networks } = useSettingsState()
-//     const selectedProvider = useWalletStore((state) => state.selectedProveder)
-//     const selectProvider = useWalletStore((state) => state.selectProvider)
-//     const paradexAccounts = useWalletStore((state) => state.paradexAccounts)
-//     const addParadexAccount = useWalletStore((state) => state.addParadexAccount)
-//     const removeParadexAccount = useWalletStore((state) => state.removeParadexAccount)
-//     const paradexNetwork = networks.find(n => n.name === KnownInternalNames.Networks.ParadexMainnet || n.name === KnownInternalNames.Networks.ParadexTestnet)
-//     const withdrawalSupportedNetworks = [
-//         KnownInternalNames.Networks.ParadexMainnet,
-//         KnownInternalNames.Networks.ParadexTestnet,
-//     ]
-//     const autofillSupportedNetworks = [
-//         ...withdrawalSupportedNetworks
-//     ]
-//     const asSourceSupportedNetworks = [
-//         ...withdrawalSupportedNetworks
-//     ]
-//     const { connect, setSelectedConnector } = useConnectModal()
-//     const evmProvider = useEVM({ network })
-//     const starknetProvider = useStarknet()
-//     const connectWallet = async () => {
-//         try {
-//             return await connect(provider)
-//         }
-//         catch (e) {
-//             console.log(e)
-//         }
-//     }
-//     const config = useConfig()
-//     const connectConnector = async ({ connector }: { connector: InternalConnector & LSConnector }) => {
-//         try {
-//             setSelectedConnector(connector)
-//             const isEvm = evmProvider.availableWalletsForConnect?.find(w => w.id === connector.id)
-//             const isStarknet = starknetProvider.availableWalletsForConnect?.find(w => w.id === connector.id)
-//             if (isEvm) {
-//                 const connectionResult = evmProvider.connectConnector && await evmProvider.connectConnector({ connector })
-//                 if (!connectionResult) return
-//                 if (!paradexAccounts?.[connectionResult?.address?.toLowerCase()]) {
-//                     const l1Network = networks.find(n => n.name === KnownInternalNames.Networks.EthereumMainnet || n.name === KnownInternalNames.Networks.EthereumSepolia);
-//                     const l1ChainId = Number(l1Network?.chain_id)
-//                     if (!Number(l1ChainId)) {
-//                         throw Error("Could not find ethereum network")
-//                     }
-//                     let client = await getWalletClient(config)
-//                     const chainId = await client.getChainId()
-//                     if (l1ChainId !== chainId) {
-//                         try {
-//                             await sleep(1000)
-//                             await switchChain(config, { chainId: l1ChainId })
-//                         }
-//                         catch (e) {
-//                             await getChainId(config)
-//                             await sleep(1000)
-//                             const chainId = await getChainId(config)
-//                             if (l1ChainId !== chainId) {
-//                                 throw Error("Could not switch to ethereum network")
-//                             }
-//                         }
-//                         await sleep(1000)
-//                         client = await getWalletClient(config)
-//                     }
-//                     await sleep(1000)
-//                     const ethersSigner = walletClientToSigner(client)
-//                     if (!ethersSigner) {
-//                         throw Error("Could not initialize ethers signer")
-//                     }
-//                     const paradexAccount = await AuhorizeEthereum(ethersSigner)
-//                     addParadexAccount({ l1Address: connectionResult.address, paradexAddress: paradexAccount.address })
-//                 }
-//                 selectProvider(evmProvider.name)
-//                 return resolveSingleWallet(connectionResult, name, paradexAccounts, removeParadexAccount, paradexNetwork?.logo)
-//             }
-//             else if (isStarknet) {
-//                 const connectionResult = starknetProvider.connectConnector && await starknetProvider.connectConnector({ connector })
-//                 if (!connectionResult) return
-//                 if (!paradexAccounts?.[connectionResult?.address?.toLowerCase()]) {
-//                     const snAccount = connectionResult.metadata?.starknetAccount
-//                     if (!snAccount) {
-//                         throw Error("Starknet account not found")
-//                     }
-//                     const paradexAccount = await AuthorizeStarknet(snAccount)
-//                     addParadexAccount({ l1Address: connectionResult.address, paradexAddress: paradexAccount.address })
-//                 }
-//                 selectProvider(starknetProvider.name)
-//                 return resolveSingleWallet(connectionResult, name, paradexAccounts, removeParadexAccount, paradexNetwork?.logo)
-//             }
-//         } catch (e) {
-//             //TODO: handle error like in transfer
-//             const error = e as ConnectorAlreadyConnectedError
-//             if (error.name == 'ConnectorAlreadyConnectedError') {
-//                 throw new Error('Wallet is already connected.')
-//             }
-//             else if (error.message.includes("Cannot read properties of undefined (reading 'toLowerCase')")) {
-//                 throw new Error('Please update your wallet to the latest version.')
-//             }
-//             else {
-//                 throw new Error(e.message || e)
-//             }
-//         }
-//     }
-//     const connectedWallets = useMemo(() => {
-//         return [
-//             ...resolveWalletsList(evmProvider.connectedWallets, paradexAccounts, name, removeParadexAccount, paradexNetwork?.logo),
-//             ...resolveWalletsList(starknetProvider.connectedWallets, paradexAccounts, name, removeParadexAccount, paradexNetwork?.logo)
-//         ]
-//     }, [evmProvider, starknetProvider, paradexAccounts])
-//     const availableWalletsForConnect = useMemo(() => {
-//         return [...(evmProvider.availableWalletsForConnect ? evmProvider.availableWalletsForConnect : []), ...(starknetProvider?.availableWalletsForConnect ? starknetProvider.availableWalletsForConnect : [])]
-//     }, [evmProvider, starknetProvider])
-//     const switchAccount = async (wallet: Wallet, address: string) => {
-//         const evmWallet = evmProvider?.connectedWallets?.find(w => w.id === wallet.id)
-//         const starknetWallet = starknetProvider?.connectedWallets?.find(w => w.id === wallet.id)
-//         if (evmWallet && evmProvider.switchAccount && wallet.metadata?.l1Address) {
-//             evmProvider.switchAccount(evmWallet, wallet.metadata?.l1Address)
-//             selectProvider(evmProvider.name)
-//         }
-//         else if (starknetWallet && starknetProvider.switchAccount && wallet.metadata?.l1Address) {
-//             starknetProvider.switchAccount(starknetWallet, wallet.metadata.l1Address)
-//             selectProvider(starknetProvider.name)
-//         }
-//     }
-//     const activeWallet = useMemo(() => {
-//         if (selectedProvider === starknetProvider.name && starknetProvider?.activeWallet) {
-//             return resolveSingleWallet(starknetProvider.activeWallet, name, paradexAccounts, removeParadexAccount, paradexNetwork?.logo)
-//         }
-//         else if (selectedProvider === evmProvider.name && evmProvider?.activeWallet) {
-//             return resolveSingleWallet(evmProvider.activeWallet, name, paradexAccounts, removeParadexAccount, paradexNetwork?.logo)
-//         }
-//     }, [evmProvider.activeWallet, starknetProvider.activeWallet, selectedProvider])
-//     const provider = {
-//         connectWallet,
-//         connectConnector,
-//         switchAccount,
-//         connectedWallets,
-//         activeWallet,
-//         withdrawalSupportedNetworks,
-//         autofillSupportedNetworks,
-//         asSourceSupportedNetworks,
-//         availableWalletsForConnect,
-//         name,
-//         id,
-//         hideFromList: true
-//     }
-//     return provider
-// }
-// const resolveWalletsList = (wallets: Wallet[] | undefined, accounts: { [key: string]: string } | undefined, name: string, disconnect: (address: string) => void, networkIcon?: string) => {
-//     const l1Addresses = Object.keys(accounts || {})
-//     if (!l1Addresses.length || !wallets?.length) return []
-//     return wallets.filter(w => w.addresses.some(wa => l1Addresses.some(pa => pa.toLowerCase() === wa.toLowerCase())))
-//         .map(w => (resolveSingleWallet(w, name, accounts, disconnect, networkIcon))).filter(w => w) as Wallet[]
-// }
-// const resolveSingleWallet = (wallet: Wallet, name: string, accounts: { [key: string]: string } | undefined, disconnect: (address: string) => void, networkIcon?: string): Wallet | undefined => {
-//     const paradexAddress = accounts?.[wallet.address.toLowerCase()]
-//     if (!paradexAddress) return
-//     const displayName = `${wallet.id} (${shortenAddress(wallet.address)})`
-//     return {
-//         ...wallet,
-//         metadata: {
-//             ...wallet.metadata,
-//             l1Address: wallet.address
-//         },
-//         providerName: name,
-//         displayName,
-//         address: paradexAddress,
-//         addresses: [paradexAddress],
-//         disconnect: () => disconnect(wallet.address),
-//         networkIcon
-//     }
-// }
-// function sleep(ms) {
-//     return new Promise(resolve => setTimeout(resolve, ms));
-// }
+import KnownInternalNames from "../../knownIds";
+import { useMemo } from "react";
+import { useConnectModal } from "../../../components/Wallet/WalletModal";
+import useEVM from "../evm/useEVM";
+import useStarknet from "../starknet/useStarknet";
+import { useWalletStore } from "../../../stores/walletStore";
+import { AuthorizeStarknet } from "./Authorize/Starknet";
+import { walletClientToSigner } from "../../ethersToViem/ethers";
+import AuhorizeEthereum from "./Authorize/Ethereum";
+import { getWalletClient } from '@wagmi/core';
+import { useConfig } from "wagmi";
+import { switchChain, getChainId } from '@wagmi/core';
+import { useSettingsState } from "../../../context/settings";
+import shortenAddress from "../../../components/utils/ShortenAddress";
+import sleep from "../utils/sleep";
+import { useActiveParadexAccount } from "../../../components/Wallet/WalletProviders/ActiveParadexAccount";
+export default function useParadex() {
+    const name = 'Paradex';
+    const id = 'prdx';
+    const { networks } = useSettingsState();
+    const { activeConnection, setActiveAddress } = useActiveParadexAccount();
+    const paradexAccounts = useWalletStore((state) => state.paradexAccounts);
+    const addParadexAccount = useWalletStore((state) => state.addParadexAccount);
+    const removeParadexAccount = useWalletStore((state) => state.removeParadexAccount);
+    const paradexNetwork = networks.find(n => n.name === KnownInternalNames.Networks.ParadexMainnet || n.name === KnownInternalNames.Networks.ParadexTestnet);
+    const withdrawalSupportedNetworks = [
+        KnownInternalNames.Networks.ParadexMainnet,
+        KnownInternalNames.Networks.ParadexTestnet,
+    ];
+    const autofillSupportedNetworks = [
+        ...withdrawalSupportedNetworks
+    ];
+    const asSourceSupportedNetworks = [
+        ...withdrawalSupportedNetworks
+    ];
+    const { setSelectedConnector } = useConnectModal();
+    const evmProvider = useEVM();
+    const starknetProvider = useStarknet();
+    const config = useConfig();
+    const connectWallet = async (props) => {
+        const { connector } = props || {};
+        if (!connector) {
+            throw new Error("Connector is required");
+        }
+        try {
+            setSelectedConnector(connector);
+            const isEvm = evmProvider.availableWalletsForConnect?.find(w => w.id === connector.id);
+            const isStarknet = starknetProvider.availableWalletsForConnect?.find(w => w.id === connector.id);
+            let accounts;
+            if (isEvm) {
+                const connectionResult = evmProvider.connectWallet && await evmProvider.connectWallet({ connector });
+                if (!connectionResult)
+                    return;
+                if (!paradexAccounts?.[connectionResult?.address?.toLowerCase()]) {
+                    const l1Network = networks.find(n => n.name === KnownInternalNames.Networks.EthereumMainnet || n.name === KnownInternalNames.Networks.EthereumSepolia);
+                    const l1ChainId = Number(l1Network?.chain_id);
+                    if (!Number(l1ChainId)) {
+                        throw Error("Could not find ethereum network");
+                    }
+                    let client = await getWalletClient(config);
+                    const chainId = await client.getChainId();
+                    if (l1ChainId !== chainId) {
+                        try {
+                            await sleep(1000);
+                            await switchChain(config, { chainId: l1ChainId });
+                        }
+                        catch (e) {
+                            getChainId(config);
+                            await sleep(1000);
+                            const chainId = getChainId(config);
+                            if (l1ChainId !== chainId) {
+                                throw Error("Could not switch to ethereum network");
+                            }
+                        }
+                        await sleep(1000);
+                        client = await getWalletClient(config);
+                    }
+                    await sleep(1000);
+                    const ethersSigner = walletClientToSigner(client);
+                    if (!ethersSigner) {
+                        throw Error("Could not initialize ethers signer");
+                    }
+                    const paradexAccount = await AuhorizeEthereum(ethersSigner);
+                    addParadexAccount({ l1Address: connectionResult.address, paradexAddress: paradexAccount.address });
+                    accounts = { [connectionResult.address.toLowerCase()]: paradexAccount.address };
+                }
+                else {
+                    accounts = { [connectionResult.address.toLowerCase()]: paradexAccounts[connectionResult.address.toLowerCase()] };
+                }
+                setActiveAddress({
+                    address: connectionResult.address,
+                    id: connectionResult.id,
+                    providerName: "EVM"
+                });
+                return resolveSingleWallet({
+                    provider: evmProvider,
+                    walletId: connectionResult.id,
+                    l1Account: connectionResult.address,
+                    name,
+                    paradexAccounts: accounts,
+                    disconnect: removeParadexAccount,
+                    networkIcon: paradexNetwork?.logo
+                });
+            }
+            else if (isStarknet) {
+                const connectionResult = starknetProvider.connectWallet && await starknetProvider.connectWallet({ connector });
+                if (!connectionResult)
+                    return;
+                if (!paradexAccounts?.[connectionResult?.address?.toLowerCase()]) {
+                    const snAccount = connectionResult.metadata?.starknetAccount;
+                    if (!snAccount) {
+                        throw Error("Starknet account not found");
+                    }
+                    const paradexAccount = await AuthorizeStarknet(snAccount);
+                    addParadexAccount({ l1Address: connectionResult.address, paradexAddress: paradexAccount.address });
+                    accounts = { [connectionResult.address.toLowerCase()]: paradexAccount.address };
+                }
+                else {
+                    accounts = { [connectionResult.address.toLowerCase()]: paradexAccounts[connectionResult.address.toLowerCase()] };
+                }
+                setActiveAddress({
+                    address: connectionResult.address,
+                    id: connectionResult.id,
+                    providerName: "Starknet"
+                });
+                return resolveSingleWallet({
+                    provider: starknetProvider,
+                    walletId: connectionResult.id,
+                    l1Account: connectionResult.address,
+                    name,
+                    paradexAccounts: accounts,
+                    disconnect: removeParadexAccount,
+                    networkIcon: paradexNetwork?.logo
+                });
+            }
+        }
+        catch (e) {
+            //TODO: handle error like in transfer
+            const error = e;
+            if (error.name == 'ConnectorAlreadyConnectedError') {
+                throw new Error('Wallet is already connected.');
+            }
+            else if (error.message.includes("Cannot read properties of undefined (reading 'toLowerCase')")) {
+                throw new Error('Please update your wallet to the latest version.');
+            }
+            else {
+                throw new Error(e.message || e);
+            }
+        }
+    };
+    const connectedWallets = useMemo(() => {
+        if (!paradexAccounts)
+            return [];
+        return [
+            ...resolveWalletsList({ provider: evmProvider, paradexAccounts, name, disconnect: removeParadexAccount, networkIcon: paradexNetwork?.logo }),
+            ...resolveWalletsList({ provider: starknetProvider, paradexAccounts, name, disconnect: removeParadexAccount, networkIcon: paradexNetwork?.logo })
+        ];
+    }, [evmProvider, starknetProvider, paradexAccounts]);
+    const availableWalletsForConnect = useMemo(() => {
+        return [...(evmProvider.availableWalletsForConnect ? evmProvider.availableWalletsForConnect : []), ...(starknetProvider?.availableWalletsForConnect ? starknetProvider.availableWalletsForConnect : [])];
+    }, [evmProvider, starknetProvider]);
+    const switchAccount = async (wallet, address) => {
+        const providers = [evmProvider, starknetProvider];
+        const paradexProvider = providers.find(p => p?.connectedWallets?.find(w => w.id === wallet.id));
+        const paradexWallet = paradexProvider?.connectedWallets?.find(w => w.id === wallet.id);
+        if (paradexProvider?.name)
+            setActiveAddress({
+                address: address,
+                id: wallet.id,
+                providerName: paradexProvider.name
+            });
+    };
+    const activeWallet = useMemo(() => {
+        if (!activeConnection || !paradexAccounts)
+            return undefined;
+        const provider = activeConnection?.providerName === starknetProvider.name ? starknetProvider : evmProvider;
+        return resolveSingleWallet({
+            provider,
+            walletId: activeConnection?.id,
+            l1Account: activeConnection?.address,
+            name,
+            paradexAccounts,
+            disconnect: removeParadexAccount,
+            networkIcon: paradexNetwork?.logo
+        });
+    }, [evmProvider.activeWallet, starknetProvider.activeWallet, activeConnection]);
+    const provider = {
+        connectWallet,
+        switchAccount,
+        connectedWallets,
+        activeWallet,
+        withdrawalSupportedNetworks,
+        autofillSupportedNetworks,
+        asSourceSupportedNetworks,
+        availableWalletsForConnect,
+        name,
+        id,
+        hideFromList: true
+    };
+    return provider;
+}
+const resolveWalletsList = ({ provider, paradexAccounts, name, disconnect, networkIcon }) => {
+    const l1Addresses = Object.keys(paradexAccounts || {});
+    if (!l1Addresses.length || !provider.connectedWallets?.length)
+        return [];
+    return provider.connectedWallets.filter(w => w.addresses.some(wa => l1Addresses.some(pa => pa.toLowerCase() === wa.toLowerCase())))
+        .map(w => (resolveSingleWallet({
+        provider,
+        walletId: w.id,
+        l1Account: w.addresses.find(wa => l1Addresses.some(pa => pa.toLowerCase() === wa.toLowerCase())),
+        name,
+        paradexAccounts,
+        disconnect,
+    }))).filter(w => w);
+};
+const resolveSingleWallet = ({ provider, walletId, l1Account, name, paradexAccounts, disconnect, networkIcon }) => {
+    const paradexAddress = paradexAccounts?.[l1Account?.toLowerCase()];
+    const wallet = provider.connectedWallets?.find(w => w.id === walletId && w.addresses.some(wa => wa.toLowerCase() === l1Account.toLowerCase()));
+    if (!paradexAddress || !wallet)
+        return;
+    const displayName = `${wallet.id} (${shortenAddress(l1Account)})`;
+    return {
+        ...wallet,
+        asSourceSupportedNetworks: [KnownInternalNames.Networks.ParadexMainnet, KnownInternalNames.Networks.ParadexTestnet],
+        withdrawalSupportedNetworks: [KnownInternalNames.Networks.ParadexMainnet, KnownInternalNames.Networks.ParadexTestnet],
+        autofillSupportedNetworks: [KnownInternalNames.Networks.ParadexMainnet, KnownInternalNames.Networks.ParadexTestnet],
+        metadata: {
+            ...wallet.metadata,
+            l1Address: l1Account
+        },
+        providerName: name,
+        displayName,
+        address: paradexAddress,
+        addresses: [paradexAddress],
+        disconnect: () => disconnect(l1Account),
+        networkIcon
+    };
+};

package/dist/lib/wallets/solana/KnownSolanaConnectors.d.ts

@@ -1,5 +1,5 @@
 declare const KnownSolanaConnectors: {
     id: string;
-    icon: (props: any) => import("react/jsx-runtime").JSX.Element;
+    icon: (props: import("react").SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element;
 }[];
 export default KnownSolanaConnectors;

package/dist/lib/wallets/solana/transactionBuilder.d.ts

@@ -0,0 +1,4 @@
+import { PublicKey, Transaction } from "@solana/web3.js";
+import { Network, Token } from "../../../Models/Network";
+declare const transactionBuilder: (network: Network, token: Token, walletPublicKey: PublicKey, recipientAddress?: string | undefined) => Promise<Transaction>;
+export default transactionBuilder;

package/dist/lib/wallets/solana/transactionBuilder.js

@@ -1,63 +1,39 @@
-// import { Connection, PublicKey, SystemProgram, Transaction, TransactionInstruction } from "@solana/web3.js";
-// import { createAssociatedTokenAccountInstruction, createTransferInstruction, getAccount, getAssociatedTokenAddress } from '@solana/spl-token';
-// import { Network, Token } from "../../../Models/Network";
-// const transactionBuilder = async (network: Network, token: Token, walletPublicKey: PublicKey, recipientAddress?: string | undefined) => {
-//     const connection = new Connection(
-//         `${network.node_url}`,
-//         "confirmed"
-//     );
-//     const recipientPublicKey = new PublicKey(recipientAddress || new Array(32).fill(0));
-//     if (token.contract) {
-//         const sourceToken = new PublicKey(token?.contract);
-//         const transactionInstructions: TransactionInstruction[] = [];
-//         const associatedTokenFrom = await getAssociatedTokenAddress(
-//             sourceToken,
-//             walletPublicKey
-//         );
-//         const fromAccount = await getAccount(connection, associatedTokenFrom);
-//         const associatedTokenTo = await getAssociatedTokenAddress(
-//             sourceToken,
-//             recipientPublicKey
-//         );
-//         if (!(await connection.getAccountInfo(associatedTokenTo))) {
-//             transactionInstructions.push(
-//                 createAssociatedTokenAccountInstruction(
-//                     walletPublicKey,
-//                     associatedTokenTo,
-//                     recipientPublicKey,
-//                     sourceToken
-//                 )
-//             );
-//         }
-//         transactionInstructions.push(
-//             createTransferInstruction(
-//                 fromAccount.address,
-//                 associatedTokenTo,
-//                 walletPublicKey,
-//                 2000000 * Math.pow(10, Number(token?.decimals))
-//             )
-//         );
-//         const result = await connection.getLatestBlockhash()
-//         const transaction = new Transaction({
-//             feePayer: walletPublicKey,
-//             blockhash: result.blockhash,
-//             lastValidBlockHeight: result.lastValidBlockHeight
-//         }).add(...transactionInstructions);
-//         return transaction
-//     }
-//     else {
-//         const transaction = new Transaction();
-//         const amountInLamports = 20000 * Math.pow(10, Number(token?.decimals));
-//         const transferInstruction = SystemProgram.transfer({
-//             fromPubkey: walletPublicKey,
-//             toPubkey: recipientPublicKey,
-//             lamports: amountInLamports
-//         });
-//         transaction.add(transferInstruction);
-//         const { blockhash } = await connection.getLatestBlockhash();
-//         transaction.recentBlockhash = blockhash;
-//         transaction.feePayer = walletPublicKey;
-//         return transaction
-//     }
-// }
-// export default transactionBuilder
+import { Connection, PublicKey, SystemProgram, Transaction } from "@solana/web3.js";
+import { createAssociatedTokenAccountInstruction, createTransferInstruction, getAccount, getAssociatedTokenAddress } from '@solana/spl-token';
+const transactionBuilder = async (network, token, walletPublicKey, recipientAddress) => {
+    const connection = new Connection(`${network.node_url}`, "confirmed");
+    const recipientPublicKey = new PublicKey(recipientAddress || new Array(32).fill(0));
+    if (token.contract) {
+        const sourceToken = new PublicKey(token?.contract);
+        const transactionInstructions = [];
+        const associatedTokenFrom = await getAssociatedTokenAddress(sourceToken, walletPublicKey);
+        const fromAccount = await getAccount(connection, associatedTokenFrom);
+        const associatedTokenTo = await getAssociatedTokenAddress(sourceToken, recipientPublicKey);
+        if (!(await connection.getAccountInfo(associatedTokenTo))) {
+            transactionInstructions.push(createAssociatedTokenAccountInstruction(walletPublicKey, associatedTokenTo, recipientPublicKey, sourceToken));
+        }
+        transactionInstructions.push(createTransferInstruction(fromAccount.address, associatedTokenTo, walletPublicKey, 2000000 * Math.pow(10, Number(token?.decimals))));
+        const result = await connection.getLatestBlockhash();
+        const transaction = new Transaction({
+            feePayer: walletPublicKey,
+            blockhash: result.blockhash,
+            lastValidBlockHeight: result.lastValidBlockHeight
+        }).add(...transactionInstructions);
+        return transaction;
+    }
+    else {
+        const transaction = new Transaction();
+        const amountInLamports = 20000 * Math.pow(10, Number(token?.decimals));
+        const transferInstruction = SystemProgram.transfer({
+            fromPubkey: walletPublicKey,
+            toPubkey: recipientPublicKey,
+            lamports: amountInLamports
+        });
+        transaction.add(transferInstruction);
+        const { blockhash } = await connection.getLatestBlockhash();
+        transaction.recentBlockhash = blockhash;
+        transaction.feePayer = walletPublicKey;
+        return transaction;
+    }
+};
+export default transactionBuilder;

package/dist/lib/wallets/solana/useSVM.d.ts

@@ -0,0 +1,2 @@
+import { WalletProvider } from "../../../Models/WalletProvider";
+export default function useSVM(): WalletProvider;