@layerswap/wallet-stellar 2.1.0

package/dist/esm/constants.js

@@ -0,0 +1,8 @@
+import KnownInternalNames from '@layerswap/utils/known-ids';
+export const name = 'Stellar';
+export const id = 'stellar';
+export const supportedNetworkNames = [
+    KnownInternalNames.Networks.StellarMainnet,
+    KnownInternalNames.Networks.StellarTestnet,
+];
+export const STELLAR_SESSION_KEY = 'layerswap:stellar-wallet';

package/dist/esm/index.js

@@ -0,0 +1,50 @@
+import { LazyBalanceProvider, LazyGasProvider, NetworkType, } from '@layerswap/widget-types';
+import { id } from './constants';
+import { createStellarConnection } from './service/createStellarConnection';
+import { stellarKitManager } from './service/stellarKitManager';
+import { createStellarTransfer } from './transferProvider/createStellarTransfer';
+export function createStellarProvider(config = {}) {
+    const { walletConnect, customConnection, balanceProviders, gasProviders, transferProviders, } = config;
+    const initialize = () => {
+        void stellarKitManager.init(walletConnect).catch(error => {
+            console.error('[Stellar] Failed to initialize wallet connectors', error);
+        });
+    };
+    const init = (_context) => {
+        initialize();
+        return () => stellarKitManager.dispose();
+    };
+    const createConnection = (props) => {
+        initialize();
+        return customConnection
+            ? customConnection(props)
+            : createStellarConnection(props, { walletConnectProjectId: walletConnect?.projectId });
+    };
+    const defaultBalanceProviders = [
+        new LazyBalanceProvider(network => network.type === NetworkType.Stellar, () => import('./stellarBalanceProvider').then(module => new module.StellarBalanceProvider())),
+    ];
+    const finalBalanceProviders = balanceProviders !== undefined
+        ? (Array.isArray(balanceProviders) ? balanceProviders : [balanceProviders])
+        : defaultBalanceProviders;
+    const defaultGasProviders = [
+        new LazyGasProvider(network => network.type === NetworkType.Stellar, () => import('./stellarGasProvider').then(module => new module.StellarGasProvider())),
+    ];
+    const finalGasProviders = gasProviders !== undefined
+        ? (Array.isArray(gasProviders) ? gasProviders : [gasProviders])
+        : defaultGasProviders;
+    const finalTransferProviders = transferProviders !== undefined
+        ? (Array.isArray(transferProviders) ? transferProviders : [transferProviders])
+        : [createStellarTransfer];
+    return {
+        id,
+        init,
+        createConnection,
+        balanceProvider: finalBalanceProviders,
+        gasProvider: finalGasProviders,
+        transferProvider: finalTransferProviders,
+    };
+}
+export { createStellarConnection } from './service/createStellarConnection';
+export { stellarStore } from './service/stellarStore';
+export { stellarKitManager } from './service/stellarKitManager';
+export { validateStellarOperationXdr, validateStellarXdr } from './transferProvider/validateStellarXdr';

package/dist/esm/service/StellarConnectionService.js

@@ -0,0 +1,205 @@
+import { NetworkType } from '@layerswap/widget-types';
+import { buildDeepLink, clearPendingDynamicWcMetadata, createRegistryConnector, getDynamicWcMetadata, getPendingDynamicWcMetadata, isWalletConnectRegistryConnector, setDynamicWcMetadata, setPendingMetadataForRegistry, subscribeDisplayUri, walletIconResolver, } from '@layerswap/wallet-core';
+import { id as PROVIDER_ID, name as PROVIDER_NAME } from '../constants';
+import { STELLAR_APPKIT_WALLET_CONNECT_ID } from './StellarWalletConnectModule';
+import { stellarKitManager } from './stellarKitManager';
+import { stellarStore } from './stellarStore';
+import { toStellarConnector } from './stellarConnector';
+export class StellarConnectionService {
+    constructor(kitManager = stellarKitManager) {
+        this.kitManager = kitManager;
+        this.networks = [];
+        this.networksKey = '';
+        this.deps = {};
+    }
+    setNetworks(networks, networkAdapter) {
+        const key = networks.map(network => networkAdapter.getId(network)).join('|');
+        if (this.networksKey === key)
+            return;
+        this.networks = networks;
+        this.networkAdapter = networkAdapter;
+        this.networksKey = key;
+    }
+    configure(deps) {
+        this.deps = { ...this.deps, ...deps };
+    }
+    getAvailableConnectors() {
+        const isMobilePlatform = this.deps.isMobilePlatform ?? false;
+        const configured = stellarStore.getState().wallets
+            .filter(wallet => wallet.id !== STELLAR_APPKIT_WALLET_CONNECT_ID)
+            .map(toStellarConnector)
+            .filter(connector => !isMobilePlatform || connector.isMobileSupported);
+        const recent = (this.deps.recentConnectors ?? [])
+            .filter(connector => !isMobilePlatform || connector.isMobileSupported);
+        return [...configured, ...recent];
+    }
+    getAdditionalConnectors() {
+        const isMobilePlatform = this.deps.isMobilePlatform ?? false;
+        return (this.deps.registryConnectors ?? [])
+            .filter(wallet => !isMobilePlatform || wallet.isMobileSupported)
+            .map(wallet => createRegistryConnector(wallet, isMobilePlatform, PROVIDER_NAME));
+    }
+    getConnectedWallets() {
+        const { wallets, activeWalletId, activeAddress } = stellarStore.getState();
+        if (!activeWalletId || !activeAddress)
+            return [];
+        const snapshot = wallets.find(wallet => wallet.id === activeWalletId);
+        if (!snapshot)
+            return [];
+        return [this.resolveWallet(snapshot, activeAddress)];
+    }
+    async connectWallet({ connector }) {
+        const wallets = stellarStore.getState().wallets;
+        const registryConnector = isWalletConnectRegistryConnector(connector) ? connector : undefined;
+        const wallet = registryConnector
+            ? wallets.find(item => item.type === 'BRIDGE_WALLET')
+            : wallets.find(item => item.id === connector.id);
+        if (!wallet)
+            throw new Error('Stellar wallet connector not found');
+        const isWalletConnect = wallet.type === 'BRIDGE_WALLET';
+        const isMobilePlatform = this.deps.isMobilePlatform ?? false;
+        const mobile = registryConnector?.mobile;
+        const deepLink = mobile?.native || mobile?.universal || undefined;
+        const resolveURI = registryConnector && mobile && deepLink
+            ? (uri) => buildDeepLink({ id: registryConnector.id, mobile }, uri)
+            : undefined;
+        const useAppKit = isWalletConnect && isMobilePlatform && !registryConnector;
+        const kitWallet = useAppKit ? wallets.find(item => item.id === STELLAR_APPKIT_WALLET_CONNECT_ID) ?? wallet : wallet;
+        let unsubscribeDisplayUri;
+        const setSelectedConnectorIfCurrent = (next) => {
+            if (!this.deps.getSelectedConnector) {
+                this.deps.setSelectedConnector?.(next);
+                return;
+            }
+            const current = this.deps.getSelectedConnector();
+            if (current?.id === connector.id)
+                this.deps.setSelectedConnector?.(next);
+        };
+        try {
+            if (isWalletConnect) {
+                setPendingMetadataForRegistry(PROVIDER_ID, registryConnector ? { ...registryConnector, deepLink } : undefined);
+                const wantsQrModal = !useAppKit && (!isMobilePlatform || !resolveURI);
+                if (wantsQrModal) {
+                    this.deps.setSelectedConnector?.({
+                        ...connector,
+                        qr: { state: 'loading', value: undefined },
+                        showQrCode: true,
+                    });
+                }
+                if (!useAppKit) {
+                    unsubscribeDisplayUri = subscribeDisplayUri({
+                        source: this.kitManager,
+                        resolveURI,
+                        isMobilePlatform,
+                        onQr: qr => setSelectedConnectorIfCurrent({ ...connector, qr, showQrCode: true }),
+                    });
+                }
+                if (registryConnector)
+                    this.deps.addRecentConnector?.(registryConnector);
+            }
+            const { address } = await this.kitManager.connect(kitWallet.id);
+            if (registryConnector) {
+                setDynamicWcMetadata(PROVIDER_ID, address, {
+                    name: registryConnector.name,
+                    icon: registryConnector.icon || '',
+                    id: registryConnector.id,
+                    deepLink,
+                });
+            }
+            return this.resolveWallet(kitWallet, address);
+        }
+        finally {
+            unsubscribeDisplayUri?.();
+            if (isWalletConnect)
+                clearPendingDynamicWcMetadata(PROVIDER_ID);
+        }
+    }
+    async disconnectWallets() {
+        await this.kitManager.disconnect();
+    }
+    async requestAdditionalConnectors(params = {}) {
+        if (!this.deps.requestRegistryConnectors || !this.hasWalletConnectTransport()) {
+            return { connectors: [], nextPage: null, totalCount: 0 };
+        }
+        const result = await this.deps.requestRegistryConnectors(params);
+        const isMobilePlatform = this.deps.isMobilePlatform ?? false;
+        const connectors = result.connectors
+            .filter(wallet => !isMobilePlatform || wallet.isMobileSupported)
+            .map(wallet => createRegistryConnector(wallet, isMobilePlatform, PROVIDER_NAME));
+        return {
+            connectors,
+            nextPage: result.nextPage,
+            totalCount: result.totalCount,
+        };
+    }
+    buildProvider() {
+        const connectedWallets = this.getConnectedWallets();
+        const activeWallet = connectedWallets[0];
+        const supportedNetworks = this.getSupportedNetworks();
+        const networkLogo = this.getNetworkLogo();
+        return {
+            connectWallet: this.connectWallet.bind(this),
+            disconnectWallets: this.disconnectWallets.bind(this),
+            requestAdditionalConnectors: this.hasWalletConnectTransport()
+                ? this.requestAdditionalConnectors.bind(this)
+                : undefined,
+            availableConnectors: this.getAvailableConnectors(),
+            additionalConnectors: this.hasWalletConnectTransport()
+                ? this.getAdditionalConnectors()
+                : undefined,
+            connectedWallets,
+            activeWallet,
+            autofillSupportedNetworks: supportedNetworks,
+            withdrawalSupportedNetworks: supportedNetworks,
+            asSourceSupportedNetworks: supportedNetworks,
+            name: PROVIDER_NAME,
+            id: PROVIDER_ID,
+            capabilities: this.hasWalletConnectTransport() ? {
+                walletConnectRegistry: {
+                    networkTypes: [NetworkType.Stellar],
+                },
+            } : undefined,
+            providerIcon: networkLogo,
+            ready: stellarStore.getState().ready,
+        };
+    }
+    resolveWallet(snapshot, address) {
+        const supportedNetworks = this.getSupportedNetworks();
+        const isWalletConnect = snapshot.type === 'BRIDGE_WALLET';
+        const dynamicMetadata = isWalletConnect
+            ? getDynamicWcMetadata(PROVIDER_ID, address) || getPendingDynamicWcMetadata(PROVIDER_ID)
+            : null;
+        const displayName = dynamicMetadata?.name || snapshot.name;
+        const walletId = dynamicMetadata?.id || snapshot.id;
+        const icon = dynamicMetadata?.icon || snapshot.icon;
+        return {
+            id: walletId,
+            address,
+            addresses: [address],
+            displayName: `${displayName} - Stellar`,
+            providerName: PROVIDER_NAME,
+            isActive: true,
+            icon: walletIconResolver(address, icon),
+            networkIcon: this.getNetworkLogo(),
+            disconnect: () => this.disconnectWallets(),
+            autofillSupportedNetworks: supportedNetworks,
+            withdrawalSupportedNetworks: supportedNetworks,
+            asSourceSupportedNetworks: supportedNetworks,
+            metadata: { deepLink: dynamicMetadata?.deepLink },
+        };
+    }
+    hasWalletConnectTransport() {
+        return stellarStore.getState().wallets.some(wallet => wallet.type === 'BRIDGE_WALLET');
+    }
+    getNetworkLogo() {
+        const network = this.networks.find(item => this.networkAdapter?.isStellarNetwork(item));
+        return network && this.networkAdapter ? this.networkAdapter.getIcon(network) : undefined;
+    }
+    getSupportedNetworks() {
+        if (!this.networkAdapter)
+            return [];
+        return this.networks
+            .filter(network => this.networkAdapter?.isStellarNetwork(network))
+            .map(network => this.networkAdapter.getId(network));
+    }
+}

package/dist/esm/service/StellarWalletConnectModule.js

@@ -0,0 +1,218 @@
+import { ModuleType, Networks } from '@creit.tech/stellar-wallets-kit/types';
+const STELLAR_WALLET_CONNECT_STORAGE_PREFIX = 'layerswapStellarWalletConnect';
+export const STELLAR_WALLET_CONNECT_ID = 'wallet_connect';
+export const STELLAR_APPKIT_WALLET_CONNECT_ID = 'wallet_connect_appkit';
+export const StellarWalletConnectChain = {
+    Public: 'stellar:pubnet',
+    Testnet: 'stellar:testnet',
+};
+const StellarWalletConnectMethod = {
+    Sign: 'stellar_signXDR',
+    SignAndSubmit: 'stellar_signAndSubmitXDR',
+    SignMessage: 'stellar_signMessage',
+    SignAuthEntry: 'stellar_signAuthEntry',
+};
+const stellarAccounts = (session) => session.namespaces.stellar?.accounts
+    ?.map(account => account.split(':')[2])
+    .filter((address) => !!address) ?? [];
+const stellarAccount = (session, expectedAddress) => {
+    const accounts = stellarAccounts(session);
+    return expectedAddress
+        ? accounts.find(address => address === expectedAddress)
+        : accounts[0];
+};
+/**
+ * Stellar Wallets Kit module backed directly by WalletConnect SignClient.
+ * The Kit still owns wallet selection and signing dispatch, while Layerswap owns
+ * presentation of the emitted `wc:` URI through its shared QR modal.
+ */
+export class StellarWalletConnectModule {
+    constructor(config, clientFactory = async () => {
+        const { SignClient } = await import('@walletconnect/sign-client');
+        return SignClient.init({
+            projectId: config.projectId,
+            metadata: {
+                name: config.name,
+                description: config.description,
+                url: config.url,
+                icons: config.icons,
+            },
+            customStoragePrefix: STELLAR_WALLET_CONNECT_STORAGE_PREFIX,
+        });
+    }, chains = [StellarWalletConnectChain.Public, StellarWalletConnectChain.Testnet]) {
+        this.config = config;
+        this.clientFactory = clientFactory;
+        this.chains = chains;
+        this.moduleType = ModuleType.BRIDGE_WALLET;
+        this.productId = STELLAR_WALLET_CONNECT_ID;
+        this.productName = 'WalletConnect';
+        this.productUrl = 'https://walletconnect.com/';
+        this.productIcon = 'https://stellar.creit.tech/wallet-icons/walletconnect.png';
+        this.displayUriListeners = new Set();
+        this.sessionDeleteListeners = new Set();
+    }
+    async isAvailable() {
+        return typeof window !== 'undefined';
+    }
+    async isPlatformWrapper() {
+        if (typeof window === 'undefined')
+            return false;
+        const stellar = window.stellar;
+        return stellar?.provider === 'freighter' && stellar.platform === 'mobile';
+    }
+    onDisplayUri(listener) {
+        this.displayUriListeners.add(listener);
+        return () => this.displayUriListeners.delete(listener);
+    }
+    onSessionDelete(listener) {
+        this.sessionDeleteListeners.add(listener);
+        return () => this.sessionDeleteListeners.delete(listener);
+    }
+    warmup() {
+        void this.getClient().catch(() => {
+            // A real connect attempt reports initialization failures to the UI.
+        });
+    }
+    async getAddress() {
+        const client = await this.getClient();
+        const chains = this.chains;
+        const { uri, approval } = await client.connect({
+            requiredNamespaces: {
+                stellar: {
+                    chains,
+                    methods: [StellarWalletConnectMethod.Sign],
+                    events: [],
+                },
+            },
+            optionalNamespaces: {
+                stellar: {
+                    chains,
+                    methods: [
+                        StellarWalletConnectMethod.SignAndSubmit,
+                        StellarWalletConnectMethod.SignAuthEntry,
+                        StellarWalletConnectMethod.SignMessage,
+                    ],
+                    events: [],
+                },
+            },
+        });
+        if (uri) {
+            for (const listener of this.displayUriListeners)
+                listener(uri);
+        }
+        const session = await approval();
+        const address = stellarAccount(session);
+        if (!address) {
+            await client.disconnect({
+                topic: session.topic,
+                reason: { code: -1, message: 'Session approved without a Stellar account' },
+            });
+            throw new Error('The approved WalletConnect session has no Stellar account');
+        }
+        this.activeTopic = session.topic;
+        return { address };
+    }
+    async getConnectedAddress(expectedAddress) {
+        const client = await this.getClient();
+        const session = this.findSession(client, expectedAddress);
+        const address = session && stellarAccount(session, expectedAddress);
+        if (!address) {
+            throw new Error('The Stellar WalletConnect session expired; reconnect the wallet');
+        }
+        this.activeTopic = session.topic;
+        return { address };
+    }
+    async signTransaction(xdr, opts) {
+        const result = await this.request(StellarWalletConnectMethod.Sign, { xdr }, opts?.networkPassphrase, opts?.address);
+        if (!result?.signedXDR)
+            throw new Error('WalletConnect wallet returned no signed Stellar XDR');
+        return { signedTxXdr: result.signedXDR, signerAddress: opts?.address };
+    }
+    async signAndSubmitTransaction(xdr, opts) {
+        const result = await this.request(StellarWalletConnectMethod.SignAndSubmit, { xdr }, opts?.networkPassphrase, opts?.address);
+        if (result.status !== 'success' && result.status !== 'pending') {
+            throw new Error(`Unexpected Stellar WalletConnect status: ${result.status}`);
+        }
+        return { status: result.status };
+    }
+    async signAuthEntry(authEntry, opts) {
+        return this.request(StellarWalletConnectMethod.SignAuthEntry, { entryXdr: authEntry }, opts?.networkPassphrase, opts?.address);
+    }
+    async signMessage(message, opts) {
+        const result = await this.request(StellarWalletConnectMethod.SignMessage, { message }, opts?.networkPassphrase, opts?.address);
+        return { signedMessage: result.signature, signerAddress: result.signerAddress };
+    }
+    async getNetwork() {
+        throw new Error('WalletConnect does not expose the active Stellar network');
+    }
+    async disconnect() {
+        const client = this.client;
+        if (!client)
+            return;
+        const sessions = client.session.values.filter(session => stellarAccount(session));
+        await Promise.all(sessions.map(session => client.disconnect({
+            topic: session.topic,
+            reason: { code: -1, message: 'Session closed' },
+        })));
+    }
+    dispose() {
+        if (this.client && this.sessionEndedHandler) {
+            this.client.off('session_delete', this.sessionEndedHandler);
+            this.client.off('session_expire', this.sessionEndedHandler);
+        }
+        this.displayUriListeners.clear();
+        this.sessionDeleteListeners.clear();
+        this.sessionEndedHandler = undefined;
+        this.activeTopic = undefined;
+        this.client = undefined;
+        this.clientPromise = undefined;
+    }
+    async getClient() {
+        if (this.client)
+            return this.client;
+        if (!this.clientPromise) {
+            this.clientPromise = this.clientFactory().then(client => {
+                this.client = client;
+                this.sessionEndedHandler = event => {
+                    if (this.activeTopic && event.topic !== this.activeTopic)
+                        return;
+                    this.activeTopic = undefined;
+                    for (const listener of this.sessionDeleteListeners)
+                        listener();
+                };
+                client.on('session_delete', this.sessionEndedHandler);
+                client.on('session_expire', this.sessionEndedHandler);
+                return client;
+            }).finally(() => {
+                this.clientPromise = undefined;
+            });
+        }
+        return this.clientPromise;
+    }
+    async request(method, params, networkPassphrase, address) {
+        const client = await this.getClient();
+        const session = this.findSession(client, address);
+        if (!session) {
+            throw new Error('No active Stellar WalletConnect session for the selected address');
+        }
+        this.activeTopic = session.topic;
+        const chainId = networkPassphrase === Networks.PUBLIC
+            ? StellarWalletConnectChain.Public
+            : StellarWalletConnectChain.Testnet;
+        return client.request({
+            topic: session.topic,
+            chainId,
+            request: { method, params },
+        });
+    }
+    findSession(client, address) {
+        const active = this.activeTopic
+            ? client.session.values.find(session => (session.topic === this.activeTopic && stellarAccount(session, address)))
+            : undefined;
+        if (active)
+            return active;
+        return [...client.session.values]
+            .reverse()
+            .find(session => stellarAccount(session, address));
+    }
+}

package/dist/esm/service/createStellarConnection.js

@@ -0,0 +1,63 @@
+import { connectModalStore, createMemoizedConnectionStore, getAdditionalConnectorsStore } from '@layerswap/wallet-core';
+import { isMobile } from '@layerswap/utils';
+import { id as PROVIDER_ID } from '../constants';
+import { StellarConnectionService } from './StellarConnectionService';
+import { stellarKitManager } from './stellarKitManager';
+import { stellarStore } from './stellarStore';
+export function createStellarConnection(initialProps, options = {}) {
+    let networks = initialProps.networks;
+    let networkAdapter = initialProps.networkAdapter;
+    const service = new StellarConnectionService();
+    service.setNetworks(networks, networkAdapter);
+    const additionalConnectorsStore = options.walletConnectProjectId
+        ? getAdditionalConnectorsStore(PROVIDER_ID, options.walletConnectProjectId)
+        : undefined;
+    service.configure({
+        setSelectedConnector: connector => connectModalStore.setSelectedConnector(connector),
+        getSelectedConnector: () => connectModalStore.getSnapshot().selectedConnector,
+        addRecentConnector: additionalConnectorsStore?.addRecentConnector,
+        requestRegistryConnectors: additionalConnectorsStore?.requestAdditionalConnectors,
+        registryConnectors: additionalConnectorsStore?.getSnapshot().browseConnectors,
+        recentConnectors: additionalConnectorsStore?.getSnapshot().recentConnectors,
+        isMobilePlatform: isMobile(),
+    });
+    return createMemoizedConnectionStore({
+        computeInputs: () => {
+            const state = stellarStore.getState();
+            const additional = additionalConnectorsStore?.getSnapshot();
+            return {
+                wallets: state.wallets,
+                activeWalletId: state.activeWalletId,
+                activeAddress: state.activeAddress,
+                networkPassphrase: state.networkPassphrase,
+                ready: state.ready,
+                error: state.error,
+                browseConnectors: additional?.browseConnectors,
+                recentConnectors: additional?.recentConnectors,
+                networks,
+            };
+        },
+        buildSnapshot: inputs => {
+            service.configure({
+                registryConnectors: inputs.browseConnectors,
+                recentConnectors: inputs.recentConnectors,
+            });
+            return service.buildProvider();
+        },
+        subscribe: sync => [
+            stellarStore.subscribe(sync),
+            ...(additionalConnectorsStore ? [additionalConnectorsStore.subscribe(sync)] : []),
+            connectModalStore.subscribe(() => {
+                if (!connectModalStore.getSnapshot().isWalletModalOpen)
+                    return;
+                void additionalConnectorsStore?.ensureBrowseLoaded();
+                stellarKitManager.warmUpWalletConnect();
+            }),
+        ],
+        onUpdateProps: nextProps => {
+            networks = nextProps.networks;
+            networkAdapter = nextProps.networkAdapter;
+            service.setNetworks(networks, networkAdapter);
+        },
+    });
+}

package/dist/esm/service/stellarConnector.js

@@ -0,0 +1,23 @@
+import { name as PROVIDER_NAME } from '../constants';
+// Wallets Kit reports both installed extensions and wallets that are usable
+// without installation as `isAvailable`. Albedo/xBull open their own web flow,
+// while BRIDGE_WALLET modules (currently WalletConnect) use a pairing transport.
+// Neither kind should ever be presented as a missing browser extension.
+const LOADABLE_WALLET_IDS = new Set(['albedo', 'xbull']);
+export function toStellarConnector(wallet) {
+    const isBridgeWallet = wallet.type === 'BRIDGE_WALLET';
+    const isLoadable = isBridgeWallet || LOADABLE_WALLET_IDS.has(wallet.id);
+    const isUnavailable = !isLoadable && !wallet.isAvailable && !wallet.isPlatformWrapper;
+    return {
+        id: wallet.id,
+        name: wallet.name,
+        icon: wallet.icon,
+        type: isBridgeWallet ? 'walletConnect' : isUnavailable ? 'other' : 'injected',
+        installUrl: wallet.url,
+        hasBrowserExtension: isBridgeWallet ? false : undefined,
+        extensionNotFound: isUnavailable,
+        isLoadable,
+        isMobileSupported: isLoadable || wallet.isPlatformWrapper,
+        providerName: PROVIDER_NAME,
+    };
+}