yapid-js 1.0.0

package/README.md

@@ -0,0 +1,202 @@
+# yapid-js
+
+Official JavaScript SDK for [YapID](https://id.yaphub.xyz) — Anonymous persistent identity for the web.
+
+No email. No password. No tracking. 12 words. That's it.
+
+[![npm version](https://img.shields.io/npm/v/yapid-js)](https://npmjs.com/package/yapid-js)
+[![Privacy Score](https://img.shields.io/badge/Privacy%20Score-93%25-7c3aed)](https://id.yaphub.xyz)
+[![License](https://img.shields.io/badge/License-BSL%201.1-amber)](https://github.com/yaphub/yapid/blob/main/LICENSE)
+
+---
+
+## Install
+
+```bash
+npm install yapid-js
+```
+
+---
+
+## Quick Start
+
+### Frontend (Browser)
+
+```html
+<!-- Option 1: Script Tag (no npm needed) -->
+<script src="https://id.yaphub.xyz/yapid-button.js"></script>
+<yapid-button onlogin="onLogin"></yapid-button>
+
+<script>
+function onLogin(session) {
+  console.log('Logged in:', session.accountId);
+}
+</script>
+```
+
+```js
+// Option 2: npm
+import { YapID } from 'yapid-js';
+
+const client = new YapID();
+
+// Redirect to YapID login
+client.login('https://your-site.com/callback');
+
+// After redirect back — get token from URL
+const { token, state } = client.getTokenFromUrl();
+if (client.verifyState(state)) {
+  const session = await client.verify(token);
+  console.log(session.accountId);
+}
+```
+
+### Backend (Node.js)
+
+```js
+import { verifyToken, yapidMiddleware } from 'yapid-js/server';
+
+// Single verify
+const session = await verifyToken(req.headers.authorization?.replace('Bearer ', ''));
+if (session.valid) {
+  console.log(session.accountId, session.isPremium);
+}
+
+// Express middleware
+import express from 'express';
+const app = express();
+
+app.use('/api', yapidMiddleware({ required: true }));
+
+app.get('/api/profile', (req, res) => {
+  res.json({ user: req.yapid });
+});
+```
+
+### React
+
+```jsx
+import { useYapID, YapIDProvider, YapIDButton } from 'yapid-js/react';
+
+// Wrap your app
+function App() {
+  return (
+    <YapIDProvider>
+      <MyApp />
+    </YapIDProvider>
+  );
+}
+
+// Use the hook
+function Profile() {
+  const { isLoggedIn, accountId, isPremium, login, logout } = useYapID();
+
+  if (!isLoggedIn) {
+    return <button onClick={login}>Sign in with YapID</button>;
+  }
+
+  return (
+    <div>
+      <p>Welcome, {accountId}</p>
+      {isPremium && <p>★ Premium</p>}
+      <button onClick={logout}>Logout</button>
+    </div>
+  );
+}
+
+// Or just use the pre-built button
+function Header() {
+  return (
+    <YapIDButton
+      theme="dark"
+      size="medium"
+      onLogin={(session) => console.log(session)}
+    />
+  );
+}
+```
+
+---
+
+## API Reference
+
+### Client (`yapid-js`)
+
+| Method | Description |
+|---|---|
+| `verify(token)` | Verify an access token |
+| `login(redirectUrl)` | Redirect to YapID login |
+| `getLoginUrl(redirectUrl)` | Get login URL without redirecting |
+| `getTokenFromUrl()` | Extract token from URL hash after redirect |
+| `verifyState(state)` | Verify CSRF state |
+| `getUserInfo(token)` | Get user info (OIDC) |
+| `refresh(refreshToken)` | Refresh access token |
+| `logout(token)` | Logout current session |
+| `logoutAll(token)` | Logout from all devices |
+| `status()` | Check service status |
+
+### Server (`yapid-js/server`)
+
+| Export | Description |
+|---|---|
+| `verifyToken(token)` | Verify token server-side |
+| `yapidMiddleware(options)` | Express.js middleware |
+| `YapIDServer` | Server SDK class |
+
+### React (`yapid-js/react`)
+
+| Export | Description |
+|---|---|
+| `useYapID()` | React Hook |
+| `YapIDProvider` | Context Provider |
+| `YapIDButton` | Pre-built React Button |
+
+---
+
+## Session Object
+
+```ts
+{
+  valid:         boolean,
+  sub:           string,   // accountId (UUID)
+  accountId:     string,   // alias for sub
+  yapid_premium: boolean,
+  isPremium:     boolean,  // alias
+  yapid_avatar:  string,
+  yapid_name:    string | null,
+  scope:         string,   // 'openid profile'
+  expires_in:    number,   // seconds
+  profile: {
+    displayName: string | null,
+    avatarSeed:  string,
+  }
+}
+```
+
+---
+
+## Privacy
+
+YapID has a **93% privacy score** — higher than any commercial alternative:
+
+| Service | Privacy Score |
+|---|---|
+| **YapID** | **93%** |
+| Wallet Connect | 67% |
+| Auth0 / Clerk | 41% |
+| Sign in with Google | 12% |
+
+- ✓ No email required
+- ✓ No IP address stored
+- ✓ AES-256-GCM session encryption
+- ✓ Ed25519 cryptographic signatures
+- ✓ SHA-256 wallet hash (server never sees public key)
+- ✓ No third-party tracking
+
+---
+
+## License
+
+BSL 1.1 — Source available, commercial competing use restricted for 4 years. Converts to Apache 2.0 in 2030.
+
+[Full License](https://github.com/yaphub/yapid/blob/main/LICENSE)

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "yapid-js",
+  "version": "1.0.0",
+  "description": "Official JavaScript SDK for YapID — Anonymous persistent identity for the web",
+  "type": "module",
+  "main": "./src/index.js",
+  "module": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./server": "./src/server.js",
+    "./react": "./src/react.js"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "yapid",
+    "yap",
+    "anonymous",
+    "identity",
+    "auth",
+    "oauth",
+    "privacy",
+    "web3",
+    "bip39",
+    "ed25519"
+  ],
+  "author": "YAP <contact@cabalspy.xyz>",
+  "license": "BSL-1.1",
+  "homepage": "https://id.yaphub.xyz",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yaphub/yapid-js"
+  },
+  "bugs": {
+    "url": "https://github.com/yaphub/yapid-js/issues"
+  },
+  "peerDependencies": {
+    "react": ">=17.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,199 @@
+/**
+ * yapid-js
+ * =========
+ * Official JavaScript/TypeScript SDK for YapID
+ * Anonymous persistent identity for the web.
+ *
+ * npm install yapid-js
+ *
+ * Usage (Browser):
+ *   import { YapID } from 'yapid-js';
+ *   const yapid = new YapID();
+ *   const session = await yapid.verify(token);
+ *
+ * Usage (Node.js / Backend):
+ *   import { verifyToken } from 'yapid-js/server';
+ *   const result = await verifyToken(token);
+ */
+
+const YAPID_ENDPOINT = 'https://id.yaphub.xyz';
+
+// ── Types ─────────────────────────────────────────────────────
+/**
+ * @typedef {Object} YapIDSession
+ * @property {boolean} valid
+ * @property {string}  sub           - accountId (UUID)
+ * @property {string}  accountId     - Alias für sub (Rückwärtskompatibel)
+ * @property {boolean} yapid_premium
+ * @property {boolean} isPremium     - Alias für yapid_premium
+ * @property {string}  yapid_avatar
+ * @property {string|null} yapid_name
+ * @property {string}  scope
+ * @property {number}  expires_in
+ * @property {Object}  profile
+ * @property {string|null} profile.displayName
+ * @property {string}  profile.avatarSeed
+ */
+
+// ── Client SDK ────────────────────────────────────────────────
+export class YapID {
+  constructor(options = {}) {
+    this.endpoint = options.endpoint || YAPID_ENDPOINT;
+  }
+
+  /**
+   * Token verifizieren
+   * @param {string} token - Access Token
+   * @returns {Promise<YapIDSession>}
+   */
+  async verify(token) {
+    const res = await fetch(`${this.endpoint}/api/verify`, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ access_token: token, token }),
+    });
+    if (!res.ok) throw new Error(`YapID verify failed: ${res.status}`);
+    return res.json();
+  }
+
+  /**
+   * Login-URL generieren (OAuth Redirect)
+   * @param {string} redirectUrl - URL zu der nach Login zurückgeleitet wird
+   * @param {Object} options
+   * @param {string} options.scope - Standard: 'openid profile'
+   * @param {string} options.state - CSRF State (optional, wird auto-generiert)
+   * @returns {{ url: string, state: string }}
+   */
+  getLoginUrl(redirectUrl, options = {}) {
+    const state = options.state || this._generateState();
+    const url   = new URL(`${this.endpoint}/login`);
+    url.searchParams.set('redirect', redirectUrl);
+    url.searchParams.set('state', state);
+    url.searchParams.set('scope', options.scope || 'openid profile');
+    return { url: url.toString(), state };
+  }
+
+  /**
+   * Redirect zu YapID Login
+   * @param {string} redirectUrl
+   * @param {Object} options
+   */
+  login(redirectUrl, options = {}) {
+    if (typeof window === 'undefined') throw new Error('login() only works in browser');
+    const { url, state } = this.getLoginUrl(redirectUrl || window.location.href, options);
+    sessionStorage.setItem('yapid_state', state);
+    window.location.href = url;
+  }
+
+  /**
+   * Token aus URL Hash nach Redirect extrahieren
+   * @returns {{ token: string|null, refreshToken: string|null, state: string|null }}
+   */
+  getTokenFromUrl() {
+    if (typeof window === 'undefined') return { token: null, refreshToken: null, state: null };
+    const hash   = window.location.hash;
+    if (!hash.includes('yapid_token=')) return { token: null, refreshToken: null, state: null };
+    const params = new URLSearchParams(hash.slice(1));
+    return {
+      token:        params.get('yapid_token'),
+      refreshToken: params.get('yapid_refresh'),
+      state:        params.get('state'),
+    };
+  }
+
+  /**
+   * State verifizieren (CSRF Schutz)
+   * @param {string} returnedState
+   * @returns {boolean}
+   */
+  verifyState(returnedState) {
+    if (typeof window === 'undefined') return true;
+    const saved = sessionStorage.getItem('yapid_state');
+    sessionStorage.removeItem('yapid_state');
+    if (!saved || !returnedState) return true; // kein State = optional
+    return saved === returnedState;
+  }
+
+  /**
+   * UserInfo abrufen
+   * @param {string} token
+   * @returns {Promise<Object>}
+   */
+  async getUserInfo(token) {
+    const res = await fetch(`${this.endpoint}/api/userinfo`, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) throw new Error(`YapID userinfo failed: ${res.status}`);
+    return res.json();
+  }
+
+  /**
+   * Token refreshen
+   * @param {string} refreshToken
+   * @returns {Promise<Object>}
+   */
+  async refresh(refreshToken) {
+    const res = await fetch(`${this.endpoint}/auth/refresh`, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ refresh_token: refreshToken }),
+    });
+    if (!res.ok) throw new Error(`YapID refresh failed: ${res.status}`);
+    return res.json();
+  }
+
+  /**
+   * Logout (diese Session)
+   * @param {string} token
+   */
+  async logout(token) {
+    await fetch(`${this.endpoint}/auth/logout`, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ access_token: token }),
+    }).catch(() => {});
+  }
+
+  /**
+   * Logout von allen Geräten
+   * @param {string} token
+   */
+  async logoutAll(token) {
+    const res = await fetch(`${this.endpoint}/auth/logout-all`, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ access_token: token }),
+    });
+    if (!res.ok) throw new Error(`YapID logout-all failed: ${res.status}`);
+    return res.json();
+  }
+
+  /**
+   * Service Status prüfen
+   * @returns {Promise<Object>}
+   */
+  async status() {
+    const res = await fetch(`${this.endpoint}/api/status`);
+    return res.json();
+  }
+
+  _generateState() {
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+      return Array.from(crypto.getRandomValues(new Uint8Array(16)))
+        .map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    return Math.random().toString(36).slice(2) + Date.now().toString(36);
+  }
+}
+
+// ── Convenience Exports ───────────────────────────────────────
+export const yapid = new YapID();
+
+/**
+ * Quick verify — für einfache Nutzung
+ * @param {string} token
+ * @returns {Promise<YapIDSession>}
+ */
+export const verifyToken = (token) => yapid.verify(token);
+
+export default YapID;

package/src/react.js

@@ -0,0 +1,258 @@
+/**
+ * yapid-js/react
+ * ===============
+ * React Hook und Komponenten für YapID
+ *
+ * import { useYapID, YapIDProvider, YapIDButton } from 'yapid-js/react';
+ */
+
+import { useState, useEffect, useCallback, createContext, useContext } from 'react';
+import { YapID } from './index.js';
+
+const YAPID_ENDPOINT = 'https://id.yaphub.xyz';
+
+// ── Context ───────────────────────────────────────────────────
+const YapIDContext = createContext(null);
+
+/**
+ * YapID Provider — wraps your app
+ *
+ * @example
+ * function App() {
+ *   return (
+ *     <YapIDProvider>
+ *       <YourApp />
+ *     </YapIDProvider>
+ *   );
+ * }
+ */
+export function YapIDProvider({ children, options = {} }) {
+  const value = useYapIDInternal(options);
+  return React.createElement(YapIDContext.Provider, { value }, children);
+}
+
+// ── Internal Hook ─────────────────────────────────────────────
+function useYapIDInternal(options = {}) {
+  const [session,  setSession]  = useState(null);
+  const [loading,  setLoading]  = useState(true);
+  const [error,    setError]    = useState(null);
+
+  const client = new YapID(options);
+
+  // Redirect-Return prüfen und Token verifizieren
+  useEffect(() => {
+    async function init() {
+      try {
+        const { token, refreshToken, state } = client.getTokenFromUrl();
+
+        if (token) {
+          // State verifizieren
+          if (!client.verifyState(state)) {
+            setError('State mismatch — possible CSRF attack');
+            setLoading(false);
+            return;
+          }
+
+          // URL Hash entfernen
+          window.history.replaceState(null, '', window.location.pathname + window.location.search);
+
+          const data = await client.verify(token);
+          if (data.valid) {
+            setSession({ ...data, token, refreshToken });
+          }
+        }
+      } catch (e) {
+        setError(e.message);
+      } finally {
+        setLoading(false);
+      }
+    }
+
+    init();
+  }, []);
+
+  /**
+   * Login — redirectet zu YapID
+   * @param {string} redirectUrl - Standard: aktuelle URL
+   */
+  const login = useCallback((redirectUrl) => {
+    client.login(redirectUrl || window.location.href);
+  }, []);
+
+  /**
+   * Token verifizieren
+   * @param {string} token
+   */
+  const verify = useCallback(async (token) => {
+    try {
+      const data = await client.verify(token);
+      if (data.valid) setSession({ ...data, token });
+      return data;
+    } catch (e) {
+      setError(e.message);
+      return { valid: false };
+    }
+  }, []);
+
+  /**
+   * Logout
+   */
+  const logout = useCallback(async () => {
+    if (session?.token) {
+      await client.logout(session.token);
+    }
+    setSession(null);
+  }, [session]);
+
+  /**
+   * Logout von allen Geräten
+   */
+  const logoutAll = useCallback(async () => {
+    if (session?.token) {
+      await client.logoutAll(session.token);
+    }
+    setSession(null);
+  }, [session]);
+
+  return {
+    session,
+    loading,
+    error,
+    isLoggedIn:  !!session?.valid,
+    accountId:   session?.sub || session?.accountId || null,
+    isPremium:   session?.yapid_premium || session?.isPremium || false,
+    profile:     session?.profile || null,
+    token:       session?.token || null,
+    login,
+    verify,
+    logout,
+    logoutAll,
+  };
+}
+
+/**
+ * useYapID Hook
+ *
+ * @example
+ * function MyComponent() {
+ *   const { isLoggedIn, accountId, isPremium, login, logout } = useYapID();
+ *
+ *   if (!isLoggedIn) {
+ *     return <button onClick={login}>Sign in with YapID</button>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Welcome, {accountId}</p>
+ *       {isPremium && <p>★ Premium</p>}
+ *       <button onClick={logout}>Logout</button>
+ *     </div>
+ *   );
+ * }
+ */
+export function useYapID(options = {}) {
+  const context = useContext(YapIDContext);
+  // Wenn kein Provider — standalone Hook
+  if (!context) return useYapIDInternal(options);
+  return context;
+}
+
+/**
+ * YapIDButton React Komponente
+ *
+ * @example
+ * <YapIDButton
+ *   theme="dark"
+ *   size="medium"
+ *   text="Sign in with YapID"
+ *   onLogin={(session) => console.log(session)}
+ * />
+ */
+export function YapIDButton({ theme = 'dark', size = 'medium', text = 'Sign in with YapID', onLogin, className, style }) {
+  const { isLoggedIn, accountId, isPremium, profile, login, logout } = useYapID();
+  const [showPanel, setShowPanel] = useState(false);
+
+  const sizes = {
+    small:  { padding: '6px 14px',  fontSize: '11px', height: '32px' },
+    medium: { padding: '9px 20px',  fontSize: '12px', height: '40px' },
+    large:  { padding: '12px 28px', fontSize: '14px', height: '48px' },
+  };
+
+  const themes = {
+    dark:   { background: '#111', color: '#f0f0f0', border: '1px solid #2a2a2a' },
+    light:  { background: '#fff', color: '#111',    border: '1px solid #e0e0e0' },
+    purple: { background: '#7c3aed', color: '#fff', border: '1px solid #6d28d9' },
+  };
+
+  const baseStyle = {
+    display:        'inline-flex',
+    alignItems:     'center',
+    gap:            '8px',
+    fontFamily:     "'Space Mono', monospace",
+    fontWeight:     700,
+    cursor:         'pointer',
+    letterSpacing:  '.04em',
+    borderRadius:   '8px',
+    transition:     'all .2s',
+    whiteSpace:     'nowrap',
+    ...sizes[size]  || sizes.medium,
+    ...themes[theme] || themes.dark,
+    ...style,
+  };
+
+  const handleClick = () => {
+    if (isLoggedIn) setShowPanel(p => !p);
+    else login();
+  };
+
+  useEffect(() => {
+    if (!isLoggedIn || !onLogin) return;
+    // onLogin nur nach Redirect-Return aufrufen — wird in useYapID gehandhabt
+  }, [isLoggedIn]);
+
+  const label = isLoggedIn
+    ? (profile?.displayName || (accountId || '').slice(0, 8) + '…')
+    : text;
+
+  return React.createElement('div', { style: { position: 'relative', display: 'inline-block' } },
+    React.createElement('button', { onClick: handleClick, style: baseStyle, className },
+      React.createElement('img', {
+        src: theme === 'light'
+          ? `${YAPID_ENDPOINT}/yaphub-dark.png`
+          : `${YAPID_ENDPOINT}/yaphub.png`,
+        alt: 'YapID',
+        style: { width: '14px', height: '14px', objectFit: 'contain' },
+      }),
+      label,
+      isLoggedIn && React.createElement('span', {
+        style: {
+          width: '7px', height: '7px', borderRadius: '50%',
+          background: '#22c55e', boxShadow: '0 0 6px #22c55e',
+        }
+      })
+    ),
+    showPanel && isLoggedIn && React.createElement('div', {
+      style: {
+        position: 'absolute', top: 'calc(100% + 8px)', left: 0,
+        background: '#111', border: '1px solid #2a2a2a', borderRadius: '10px',
+        padding: '16px', zIndex: 9999, minWidth: '220px',
+        fontFamily: "'Space Mono', monospace", fontSize: '11px', color: '#888',
+        boxShadow: '0 8px 32px rgba(0,0,0,.7)',
+      }
+    },
+      React.createElement('div', { style: { color: '#a78bfa', fontWeight: 700, marginBottom: '6px', fontSize: '12px' } },
+        'YapID',
+        isPremium && React.createElement('span', {
+          style: { fontSize: '9px', color: '#f59e0b', border: '1px solid rgba(245,158,11,.3)', borderRadius: '8px', padding: '1px 6px', marginLeft: '6px' }
+        }, '★ Premium')
+      ),
+      React.createElement('div', { style: { fontSize: '9px', color: '#444', wordBreak: 'break-all', marginBottom: '14px', lineHeight: 1.7 } }, accountId),
+      React.createElement('button', {
+        onClick: () => { logout(); setShowPanel(false); },
+        style: { width: '100%', padding: '7px', background: 'none', border: '1px solid #2a2a2a', borderRadius: '6px', color: '#666', fontFamily: 'inherit', fontSize: '10px', cursor: 'pointer' }
+      }, 'Logout')
+    )
+  );
+}
+
+export default useYapID;

package/src/server.js

@@ -0,0 +1,97 @@
+/**
+ * yapid-js/server
+ * ================
+ * Node.js Backend SDK für YapID
+ * Für serverseitige Token-Verifikation
+ *
+ * import { verifyToken, YapIDServer } from 'yapid-js/server';
+ */
+
+const YAPID_ENDPOINT = 'https://id.yaphub.xyz';
+
+/**
+ * Token serverseitig verifizieren
+ * @param {string} token - Access Token aus dem Request
+ * @returns {Promise<import('./index.js').YapIDSession>}
+ *
+ * @example
+ * // Express.js Middleware
+ * app.use(async (req, res, next) => {
+ *   const token = req.headers.authorization?.replace('Bearer ', '');
+ *   const session = await verifyToken(token);
+ *   if (!session.valid) return res.status(401).json({ error: 'Unauthorized' });
+ *   req.user = session;
+ *   next();
+ * });
+ */
+export async function verifyToken(token, options = {}) {
+  if (!token) return { valid: false };
+  const endpoint = options.endpoint || YAPID_ENDPOINT;
+
+  try {
+    const res = await fetch(`${endpoint}/api/verify`, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ access_token: token, token }),
+    });
+    if (!res.ok) return { valid: false };
+    return res.json();
+  } catch {
+    return { valid: false };
+  }
+}
+
+/**
+ * Express.js Middleware
+ * @param {Object} options
+ * @param {boolean} options.required - Wenn true, gibt 401 zurück wenn kein Token
+ * @returns {Function} Express Middleware
+ *
+ * @example
+ * import { yapidMiddleware } from 'yapid-js/server';
+ * app.use(yapidMiddleware());
+ * app.get('/protected', (req, res) => {
+ *   res.json({ user: req.yapid });
+ * });
+ */
+export function yapidMiddleware(options = {}) {
+  return async (req, res, next) => {
+    const token = req.headers.authorization?.replace('Bearer ', '')
+      || req.query?.yapid_token
+      || req.body?.yapid_token;
+
+    if (!token) {
+      if (options.required) {
+        return res.status(401).json({ error: 'YapID token required' });
+      }
+      req.yapid = null;
+      return next();
+    }
+
+    const session = await verifyToken(token, options);
+    if (!session.valid) {
+      if (options.required) {
+        return res.status(401).json({ error: 'Invalid YapID token' });
+      }
+      req.yapid = null;
+      return next();
+    }
+
+    req.yapid = session;
+    next();
+  };
+}
+
+/**
+ * Server SDK Klasse
+ */
+export class YapIDServer {
+  constructor(options = {}) {
+    this.endpoint = options.endpoint || YAPID_ENDPOINT;
+  }
+
+  async verify(token)         { return verifyToken(token, { endpoint: this.endpoint }); }
+  middleware(options = {})    { return yapidMiddleware({ ...options, endpoint: this.endpoint }); }
+}
+
+export default YapIDServer;