@layerswap/wallet-starknet 1.0.0

package/dist/esm/StarknetProvider.js

@@ -0,0 +1,116 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DiscoveryConnector_wallet, _DiscoveryConnector_store;
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { mainnet, sepolia } from "@starknet-react/chains";
+import { Connector, ConnectorNotConnectedError, UserNotConnectedError, StarknetConfig, publicProvider } from '@starknet-react/core';
+import { AppSettings } from "@layerswap/widget/internal";
+//@ts-ignore
+import { ArgentMobileConnector } from "starknetkit/argentMobile";
+// @ts-ignore
+import { InjectedConnector } from "starknetkit/injected";
+// @ts-ignore
+import { WebWalletConnector } from "starknetkit/webwallet";
+const WALLETCONNECT_PROJECT_ID = AppSettings.WalletConnectConfig.projectId;
+class DiscoveryConnector extends Connector {
+    constructor(wallet, store) {
+        super();
+        _DiscoveryConnector_wallet.set(this, void 0);
+        _DiscoveryConnector_store.set(this, void 0);
+        __classPrivateFieldSet(this, _DiscoveryConnector_wallet, wallet, "f");
+        __classPrivateFieldSet(this, _DiscoveryConnector_store, store, "f");
+    }
+    get id() {
+        return `${__classPrivateFieldGet(this, _DiscoveryConnector_wallet, "f").id}-mobile`;
+    }
+    get icon() {
+        return {
+            dark: __classPrivateFieldGet(this, _DiscoveryConnector_wallet, "f").icon,
+            light: __classPrivateFieldGet(this, _DiscoveryConnector_wallet, "f").icon
+        };
+    }
+    get name() {
+        return `${__classPrivateFieldGet(this, _DiscoveryConnector_wallet, "f").name} (mobile)`;
+    }
+    available() {
+        return true;
+    }
+    connect() {
+        window.open(__classPrivateFieldGet(this, _DiscoveryConnector_wallet, "f").downloads[__classPrivateFieldGet(this, _DiscoveryConnector_store, "f")], "_blank");
+        return undefined;
+    }
+    get wallet() {
+        throw new ConnectorNotConnectedError();
+    }
+    disconnect() {
+        throw new UserNotConnectedError();
+    }
+    account() {
+        throw new ConnectorNotConnectedError();
+    }
+    ready() {
+        throw new Error("Method not implemented.");
+    }
+    chainId() {
+        throw new Error("Method not implemented.");
+    }
+    request(call) {
+        throw new Error("Method not implemented.");
+    }
+}
+_DiscoveryConnector_wallet = new WeakMap(), _DiscoveryConnector_store = new WeakMap();
+const StarknetProvider = ({ children }) => {
+    const [connectors, setConnectors] = useState([]);
+    const resolveConnectors = async () => {
+        const isSafari = typeof window !== "undefined"
+            ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent)
+            : false;
+        const isAndroid = navigator.userAgent.match(/Android/i);
+        const isIOS = navigator.userAgent.match(/iPhone|iPad|iPod/i);
+        const defaultConnectors = [];
+        if (!isSafari) {
+            if (!(isAndroid || isIOS)) {
+                defaultConnectors.push(new InjectedConnector({ options: { id: "argentX" } }));
+                defaultConnectors.push(new InjectedConnector({ options: { id: "keplr" } }));
+            }
+            defaultConnectors.push(new InjectedConnector({ options: { id: "braavos" } }));
+        }
+        if ((isAndroid || isIOS) && !defaultConnectors.some(c => c.id === "braavos")) {
+            const starknet = (await import('get-starknet-core')).default;
+            const discoverWallets = (await starknet.getDiscoveryWallets()).filter(w => {
+                return (isAndroid && w.downloads["android"]) || (isIOS && w.downloads["ios"]);
+            });
+            if (discoverWallets.length)
+                defaultConnectors.push(...discoverWallets.map(w => new DiscoveryConnector(w, isAndroid ? "android" : "ios")));
+        }
+        defaultConnectors.push(ArgentMobileConnector.init({
+            options: {
+                dappName: 'Layerswap',
+                projectId: WALLETCONNECT_PROJECT_ID,
+                url: 'https://www.layerswap.io/app/',
+                description: 'Move crypto across exchanges, blockchains, and wallets.',
+            }
+        }));
+        defaultConnectors.push(new WebWalletConnector());
+        return defaultConnectors;
+    };
+    useEffect(() => {
+        (async () => {
+            const result = await resolveConnectors();
+            setConnectors(result);
+        })();
+    }, []);
+    const chains = [mainnet, sepolia];
+    return (_jsx(StarknetConfig, { chains: chains, provider: publicProvider(), connectors: connectors, children: children }));
+};
+export default StarknetProvider;

package/dist/esm/index.js

@@ -0,0 +1,15 @@
+import StarknetProviderWrapper from "./StarknetProvider";
+import useStarknetConnection from "./useStarknetConnection";
+import { StarknetBalanceProvider } from "./starknetBalanceProvider";
+import { StarknetGasProvider } from "./starknetGasProvider";
+import { StarknetAddressUtilsProvider } from "./starknetAddressUtilsProvider";
+import { StarknetNftProvider } from "./starknetNftProvider";
+export const StarknetProvider = {
+    id: "starknet",
+    wrapper: StarknetProviderWrapper,
+    walletConnectionProvider: useStarknetConnection,
+    addressUtilsProvider: new StarknetAddressUtilsProvider(),
+    balanceProvider: new StarknetBalanceProvider(),
+    gasProvider: new StarknetGasProvider(),
+    nftProvider: new StarknetNftProvider(),
+};

package/dist/esm/jsons/ERC20.json

@@ -0,0 +1,258 @@
+[
+    {
+        "members": [
+            {
+                "name": "low",
+                "offset": 0,
+                "type": "felt"
+            },
+            {
+                "name": "high",
+                "offset": 1,
+                "type": "felt"
+            }
+        ],
+        "name": "Uint256",
+        "size": 2,
+        "type": "struct"
+    },
+    {
+        "inputs": [
+            {
+                "name": "name",
+                "type": "felt"
+            },
+            {
+                "name": "symbol",
+                "type": "felt"
+            },
+            {
+                "name": "recipient",
+                "type": "felt"
+            }
+        ],
+        "name": "constructor",
+        "outputs": [],
+        "type": "constructor"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "name": "name",
+                "type": "felt"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "name": "symbol",
+                "type": "felt"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "name": "totalSupply",
+                "type": "Uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "name": "decimals",
+                "type": "felt"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "account",
+                "type": "felt"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "name": "balance",
+                "type": "Uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "owner",
+                "type": "felt"
+            },
+            {
+                "name": "spender",
+                "type": "felt"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "name": "remaining",
+                "type": "Uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "recipient",
+                "type": "felt"
+            },
+            {
+                "name": "amount",
+                "type": "Uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "name": "success",
+                "type": "felt"
+            }
+        ],
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "sender",
+                "type": "felt"
+            },
+            {
+                "name": "recipient",
+                "type": "felt"
+            },
+            {
+                "name": "amount",
+                "type": "Uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "name": "success",
+                "type": "felt"
+            }
+        ],
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "spender",
+                "type": "felt"
+            },
+            {
+                "name": "amount",
+                "type": "Uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "name": "success",
+                "type": "felt"
+            }
+        ],
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "spender",
+                "type": "felt"
+            },
+            {
+                "name": "added_value",
+                "type": "Uint256"
+            }
+        ],
+        "name": "increaseAllowance",
+        "outputs": [
+            {
+                "name": "success",
+                "type": "felt"
+            }
+        ],
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "spender",
+                "type": "felt"
+            },
+            {
+                "name": "subtracted_value",
+                "type": "Uint256"
+            }
+        ],
+        "name": "decreaseAllowance",
+        "outputs": [
+            {
+                "name": "success",
+                "type": "felt"
+            }
+        ],
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "recipient",
+                "type": "felt"
+            },
+            {
+                "name": "amount",
+                "type": "Uint256"
+            }
+        ],
+        "name": "mint",
+        "outputs": [],
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "user",
+                "type": "felt"
+            },
+            {
+                "name": "amount",
+                "type": "Uint256"
+            }
+        ],
+        "name": "burn",
+        "outputs": [],
+        "type": "function"
+    }
+]

package/dist/esm/starknetAddressUtilsProvider.js

@@ -0,0 +1,26 @@
+import { validateAndParseAddress } from "./utils";
+import { KnownInternalNames } from "@layerswap/widget/internal";
+export class StarknetAddressUtilsProvider {
+    supportsNetwork(network) {
+        return (KnownInternalNames.Networks.StarkNetMainnet.includes(network.name) || KnownInternalNames.Networks.StarkNetSepolia.includes(network.name))
+            || (KnownInternalNames.Networks.ParadexMainnet.includes(network.name) || KnownInternalNames.Networks.ParadexTestnet.includes(network.name));
+    }
+    isValidAddress(address) {
+        if (!address) {
+            return false;
+        }
+        return validateAndParseAddress(address);
+    }
+    addressFormat(address) {
+        const removeHexPrefix = (hex) => {
+            return hex?.replace("0x", "");
+        };
+        const addHexPrefix = (hex) => {
+            return `0x${hex}`;
+        };
+        const addAddressPadding = (address) => {
+            return addHexPrefix(removeHexPrefix(address)?.padStart(64, '0'));
+        };
+        return addAddressPadding(address?.toLowerCase());
+    }
+}

package/dist/esm/starknetBalanceProvider.js

@@ -0,0 +1,42 @@
+import Erc20Abi from './jsons/ERC20.json';
+import { KnownInternalNames, insertIfNotExists, formatUnits } from "@layerswap/widget/internal";
+import { BalanceProvider } from "@layerswap/widget/types";
+export class StarknetBalanceProvider extends BalanceProvider {
+    constructor() {
+        super(...arguments);
+        this.supportsNetwork = (network) => {
+            return (KnownInternalNames.Networks.StarkNetMainnet.includes(network.name) || KnownInternalNames.Networks.StarkNetGoerli.includes(network.name) || KnownInternalNames.Networks.StarkNetSepolia.includes(network.name));
+        };
+        this.fetchBalance = async (address, network) => {
+            const { Contract, RpcProvider, uint256, } = await import("starknet");
+            const { BigNumber } = await import("ethers");
+            let balances = [];
+            if (!network?.tokens)
+                return;
+            const provider = new RpcProvider({
+                nodeUrl: network.node_url,
+            });
+            const tokens = insertIfNotExists(network.tokens || [], network.token);
+            for (const token of tokens) {
+                try {
+                    const erc20 = new Contract(Erc20Abi, token.contract, provider);
+                    const balanceResult = await erc20.balanceOf(address);
+                    const balanceInWei = BigNumber.from(uint256.uint256ToBN(balanceResult.balance).toString()).toString();
+                    const balance = {
+                        network: network.name,
+                        token: token.symbol,
+                        amount: Number(formatUnits(BigInt(balanceInWei), token.decimals)),
+                        request_time: new Date().toJSON(),
+                        decimals: token.decimals,
+                        isNativeCurrency: false,
+                    };
+                    balances.push(balance);
+                }
+                catch (e) {
+                    balances.push(this.resolveTokenBalanceFetchError(e, token, network));
+                }
+            }
+            return balances;
+        };
+    }
+}

package/dist/esm/starknetGasProvider.js

@@ -0,0 +1,43 @@
+import { KnownInternalNames, formatUnits } from "@layerswap/widget/internal";
+import { CallData, cairo } from "starknet";
+export class StarknetGasProvider {
+    constructor() {
+        this.getGas = async ({ network, token, wallet, amount }) => {
+            const testnetWatchdog = '0x0423074c4bf903478daaa719bb3b1539d23af07db07101d263c78d75e5e6e0a3';
+            const mainnetWatchdog = '0x022993789c33e54e0d296fc266a9c9a2e9dcabe2e48941f5fa1bd5692ac4a8c4';
+            const mainnetRecipient = '0x19252B1dEef483477C4D30cFcc3e5Ed9C82FAFEA44669c182A45A01b4FdB97a';
+            const testnetRecipient = '0x065a93bf9a33c87346f534a3b6c825e5c9e86a8e612cba683d0271aae5062d21';
+            const version = (network.name.split('_').pop() === 'SEPOLIA' || network.name.split('_').pop() === 'GOERLI') ? 'sandbox' : 'prod';
+            const recipient = version === 'prod' ? mainnetRecipient : testnetRecipient;
+            const watchdogContract = version === 'prod' ? mainnetWatchdog : testnetWatchdog;
+            const starknetWalletAccount = wallet?.metadata?.starknetAccount;
+            if (!token || !network.token || !token.contract || !starknetWalletAccount)
+                return;
+            const amt = BigInt(amount ?? 100000);
+            const transferCall = {
+                contractAddress: token.contract.toLowerCase(),
+                entrypoint: "transfer",
+                calldata: CallData.compile({
+                    recipient,
+                    amount: cairo.uint256(amt),
+                })
+            };
+            const watch = {
+                contractAddress: watchdogContract,
+                entrypoint: "watch",
+                calldata: ["69420"],
+            };
+            const resp = await starknetWalletAccount.estimateInvokeFee([transferCall, watch], { skipValidate: true });
+            if (!resp?.suggestedMaxFee) {
+                throw new Error(`Couldn't get fee estimation for the transfer. Response: ${JSON.stringify(resp)}`);
+            }
+            ;
+            const feeInWei = resp.suggestedMaxFee.toString();
+            const gas = Number(formatUnits(BigInt(feeInWei), network.token.decimals));
+            return { gas, token: network.token };
+        };
+    }
+    supportsNetwork(network) {
+        return (KnownInternalNames.Networks.StarkNetMainnet.includes(network.name) || KnownInternalNames.Networks.StarkNetGoerli.includes(network.name) || KnownInternalNames.Networks.StarkNetSepolia.includes(network.name));
+    }
+}

package/dist/esm/starknetNftProvider.js

@@ -0,0 +1,48 @@
+import { Contract, RpcProvider } from "starknet";
+import { KnownInternalNames } from "@layerswap/widget/internal";
+const NFT_ABI = [
+    {
+        "name": "balanceOf",
+        "type": "function",
+        "inputs": [
+            {
+                "name": "owner",
+                "type": "felt"
+            }
+        ],
+        "outputs": [
+            {
+                "name": "balance",
+                "type": "felt"
+            }
+        ],
+        "stateMutability": "view"
+    }
+];
+export class StarknetNftProvider {
+    constructor() {
+        this.getBalance = async ({ address, network, contractAddress }) => {
+            if (!contractAddress || !network.node_url) {
+                throw new Error("Missing NFT contract address or node URL");
+            }
+            const provider = new RpcProvider({
+                nodeUrl: network.node_url
+            });
+            try {
+                const contract = new Contract(NFT_ABI, contractAddress, provider);
+                const response = await contract.balanceOf(address);
+                if (!response || typeof response.balance === 'undefined') {
+                    throw new Error("Invalid response from NFT contract");
+                }
+                return Number(response.balance);
+            }
+            catch (error) {
+                console.error("Error fetching NFT balance:", error);
+                throw error;
+            }
+        };
+    }
+    supportsNetwork(network) {
+        return (KnownInternalNames.Networks.StarkNetMainnet.includes(network.name) || KnownInternalNames.Networks.StarkNetGoerli.includes(network.name) || KnownInternalNames.Networks.StarkNetSepolia.includes(network.name));
+    }
+}