@layerswap/widget 0.1.4 → 0.1.14

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

@@ -1,194 +1,197 @@
-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";
-export default function useParadex({ network }) {
-    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 }) => {
-        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;
-            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, address) => {
-        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, accounts, name, disconnect, networkIcon) => {
-    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);
-};
-const resolveSingleWallet = (wallet, name, accounts, disconnect, networkIcon) => {
-    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 { 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));
+// }

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

@@ -1,4 +0,0 @@
-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,39 +1,63 @@
-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;
+// 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

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

@@ -1,5 +0,0 @@
-import { Network } from "../../../Models/Network";
-import { WalletProvider } from "../../../Models/WalletProvider";
-export default function useSVM({ network }: {
-    network: Network | undefined;
-}): WalletProvider;