@layerswap/wallet-starknet 1.0.0

package/dist/esm/useStarknetConnection.js

@@ -0,0 +1,159 @@
+import { useConnect, useDisconnect } from "@starknet-react/core";
+import { TransactionMessageType } from "@layerswap/widget/types";
+import { KnownInternalNames, useWalletStore } from "@layerswap/widget/internal";
+import { resolveStarknetWalletConnectorIcon } from "./utils";
+const starknetNames = [KnownInternalNames.Networks.StarkNetGoerli, KnownInternalNames.Networks.StarkNetMainnet, KnownInternalNames.Networks.StarkNetSepolia];
+export default function useStarknetConnection({ networks }) {
+    const commonSupportedNetworks = [
+        KnownInternalNames.Networks.StarkNetMainnet,
+        KnownInternalNames.Networks.StarkNetGoerli,
+        KnownInternalNames.Networks.StarkNetSepolia
+    ];
+    const withdrawalSupportedNetworks = [
+        ...commonSupportedNetworks
+    ];
+    const name = 'Starknet';
+    const id = 'starknet';
+    const { connectors } = useConnect();
+    const { disconnectAsync } = useDisconnect();
+    const wallets = useWalletStore((state) => state.connectedWallets);
+    const addWallet = useWalletStore((state) => state.connectWallet);
+    const removeWallet = useWalletStore((state) => state.disconnectWallet);
+    const isMainnet = networks?.some(network => network.name === KnownInternalNames.Networks.StarkNetMainnet);
+    const getWallet = () => {
+        const wallet = wallets.find(wallet => wallet.providerName === name);
+        if (!wallet)
+            return;
+        return [wallet];
+    };
+    const connectWallet = async ({ connector }) => {
+        try {
+            const wallet = getWallet();
+            if (wallet) {
+                await disconnectWallets();
+            }
+            const starknetConnector = connectors.find(c => c.id === connector.id);
+            const result = await starknetConnector?.connect({});
+            const walletChain = `0x${result?.chainId?.toString(16)}`;
+            const wrongChanin = walletChain == '0x534e5f4d41494e' ? !isMainnet : isMainnet;
+            if (result?.account && wrongChanin) {
+                disconnectWallets();
+                const errorMessage = `Please switch the network in your wallet to ${isMainnet ? 'Mainnet' : 'Sepolia'} and click connect again`;
+                throw new Error(errorMessage);
+            }
+            if (result?.account && starknetConnector) {
+                const starkent = networks.find(n => n.name === KnownInternalNames.Networks.StarkNetMainnet || n.name === KnownInternalNames.Networks.StarkNetSepolia);
+                const { RpcProvider, WalletAccount } = await import('starknet');
+                const rpcProvider = new RpcProvider({
+                    nodeUrl: starkent?.node_url,
+                });
+                const starknetWalletAccount = await WalletAccount.connectSilent(rpcProvider, starknetConnector.wallet);
+                const wallet = {
+                    id: connector.name,
+                    displayName: `${connector.name} - Starknet`,
+                    address: result?.account,
+                    addresses: [result?.account],
+                    chainId: walletChain,
+                    icon: resolveStarknetWalletConnectorIcon({ connector: connector.name, address: result?.account }),
+                    providerName: name,
+                    metadata: {
+                        starknetAccount: starknetWalletAccount,
+                        // wallet: account
+                    },
+                    isActive: true,
+                    disconnect: () => disconnectWallets(),
+                    withdrawalSupportedNetworks,
+                    autofillSupportedNetworks: commonSupportedNetworks,
+                    asSourceSupportedNetworks: commonSupportedNetworks,
+                    networkIcon: networks.find(n => starknetNames.some(name => name === n.name))?.logo
+                };
+                addWallet(wallet);
+                return wallet;
+            }
+        }
+        catch (e) {
+            console.log(e);
+            throw new Error(e);
+        }
+    };
+    const disconnectWallets = async () => {
+        try {
+            await disconnectAsync();
+            removeWallet(name);
+        }
+        catch (e) {
+            console.log(e);
+        }
+    };
+    const availableWalletsForConnect = connectors.map(connector => {
+        const name = (!connectorsConfigs.some(c => c.id === connector.id) || connector?.["_wallet"]) ? connector.name : `${connectorsConfigs.find(c => c.id === connector.id)?.name}`;
+        return {
+            name: name,
+            id: connector.id,
+            icon: typeof connector.icon === 'string' ? connector.icon : (connector.icon.light.startsWith('data:') ? connector.icon.light : `data:image/svg+xml;base64,${btoa(connector.icon.light.replaceAll('currentColor', '#FFFFFF'))}`),
+            type: connector?.["_wallet"] ? 'injected' : 'other',
+            installUrl: connector?.["_wallet"] ? undefined : connectorsConfigs.find(c => c.id === connector.id)?.installLink,
+        };
+    });
+    const switchAccount = async (wallet, address) => {
+        // as we do not have multiple accounts management we will leave the method empty
+    };
+    const transfer = async (params, wallet) => {
+        const { callData } = params;
+        try {
+            const { transaction_hash: transferTxHash } = (await wallet?.metadata?.starknetAccount?.execute(JSON.parse(callData || "")) || {});
+            if (transferTxHash) {
+                return transferTxHash;
+            }
+        }
+        catch (error) {
+            const e = new Error();
+            e.message = error;
+            if (error === "An error occurred (USER_REFUSED_OP)" || error === "Execute failed") {
+                e.name = TransactionMessageType.TransactionRejected;
+                throw e;
+            }
+            else if (error === "failedTransfer") {
+                e.name = TransactionMessageType.TransactionFailed;
+                throw e;
+            }
+            else {
+                e.name = TransactionMessageType.UexpectedErrorMessage;
+                throw e;
+            }
+        }
+    };
+    const provider = {
+        connectWallet,
+        disconnectWallets,
+        switchAccount,
+        transfer,
+        connectedWallets: getWallet(),
+        activeWallet: getWallet()?.[0],
+        withdrawalSupportedNetworks,
+        autofillSupportedNetworks: commonSupportedNetworks,
+        asSourceSupportedNetworks: commonSupportedNetworks,
+        availableWalletsForConnect,
+        name,
+        id,
+        providerIcon: networks.find(n => starknetNames.some(name => name === n.name))?.logo,
+    };
+    return provider;
+}
+const connectorsConfigs = [
+    {
+        id: "braavos",
+        name: "Braavos",
+        installLink: "https://chromewebstore.google.com/detail/braavos-starknet-wallet/jnlgamecbpmbajjfhmmmlhejkemejdma"
+    },
+    {
+        id: "argentX",
+        name: 'Argent X',
+        installLink: "https://chromewebstore.google.com/detail/argent-x-starknet-wallet/dlcobpjiigpikoobohmabehhmhfoodbb"
+    },
+    {
+        id: "keplr",
+        name: 'Keplr',
+        installLink: "https://chromewebstore.google.com/detail/keplr/dmkamcknogkgcdfhhbddcghachkejeap"
+    }
+];

package/dist/esm/utils/KnownStarknetConnectors.js

@@ -0,0 +1,24 @@
+import { ArgentXIcon, ArgentIcon, BraavosIcon, KeplrIcon } from "@layerswap/widget/internal";
+const KnownStarknetConnectors = [
+    {
+        id: 'ready wallet (formerly argent)',
+        icon: ArgentXIcon
+    },
+    {
+        id: 'ready (formerly argent)',
+        icon: ArgentIcon
+    },
+    {
+        id: 'Ready (formerly Argent)',
+        icon: ArgentIcon
+    },
+    {
+        id: 'braavos',
+        icon: BraavosIcon
+    },
+    {
+        id: 'keplr',
+        icon: KeplrIcon
+    }
+];
+export default KnownStarknetConnectors;

package/dist/esm/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./starkNetAddressValidator";
+export * from "./KnownStarknetConnectors";
+export * from "./resolveIcon";

package/dist/esm/utils/resolveIcon.js

@@ -0,0 +1,9 @@
+import { walletIconResolver } from "@layerswap/widget/internal";
+import KnownStarknetConnectors from "./KnownStarknetConnectors";
+export const resolveStarknetWalletConnectorIcon = ({ connector, address, iconUrl }) => {
+    const knownConnector = KnownStarknetConnectors.find(c => c.id.toLowerCase() === connector?.toLowerCase());
+    if (knownConnector && knownConnector.icon)
+        return knownConnector.icon;
+    else
+        return walletIconResolver(address, iconUrl);
+};

package/dist/esm/utils/starkNetAddressValidator.js

@@ -0,0 +1,46 @@
+import BN from 'bn.js';
+const TWO = toBN(2);
+const MASK_251 = TWO.pow(toBN(251));
+const MASK_221 = TWO.pow(toBN(221));
+export function validateAndParseAddress(address) {
+    if (typeof address !== 'string') {
+        return false;
+    }
+    if (!assertInRange(address, MASK_221, MASK_251)) {
+        return false;
+    }
+    const result = addAddressPadding(address);
+    if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
+        return false;
+    }
+    return true;
+}
+function addAddressPadding(address) {
+    return addHexPrefix(removeHexPrefix(address).padStart(64, '0'));
+}
+function addHexPrefix(hex) {
+    return `0x${removeHexPrefix(hex)}`;
+}
+function removeHexPrefix(hex) {
+    return hex.replace(/^0x/, '');
+}
+function assertInRange(input, lowerBound, upperBound) {
+    try {
+        const inputBn = toBN(input);
+        if (!inputBn.gte(toBN(lowerBound)) || !inputBn.lt(toBN(upperBound))) {
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+function toBN(number, base) {
+    if (typeof number === 'string' && isHex(number) && !base)
+        return new BN(removeHexPrefix(number), 'hex');
+    return new BN(number, base);
+}
+function isHex(hex) {
+    return hex.startsWith('0x');
+}