diff --git a/.obsidian/graph.json b/.obsidian/graph.json index 20e675e..815cd4c 100644 --- a/.obsidian/graph.json +++ b/.obsidian/graph.json @@ -30,8 +30,8 @@ "collapse-forces": false, "centerStrength": 0, "repelStrength": 20, - "linkStrength": 1, + "linkStrength": 0.876960037198729, "linkDistance": 500, - "scale": 0.10689967036573943, + "scale": 0.09848280266864441, "close": true } \ No newline at end of file diff --git a/.obsidian/hotkeys.json b/.obsidian/hotkeys.json index bc6a4da..c70b5bd 100644 --- a/.obsidian/hotkeys.json +++ b/.obsidian/hotkeys.json @@ -51,5 +51,14 @@ ], "key": "P" } + ], + "insert-current-date": [ + { + "modifiers": [ + "Alt", + "Mod" + ], + "key": " " + } ] } \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-discordrpc/main.js b/.obsidian/plugins/obsidian-discordrpc/main.js new file mode 100644 index 0000000..a4ca9d8 --- /dev/null +++ b/.obsidian/plugins/obsidian-discordrpc/main.js @@ -0,0 +1,1771 @@ +'use strict'; + +var require$$0 = require('electron'); +var EventEmitter = require('events'); +var require$$0$1 = require('timers'); +var net = require('net'); +var obsidian = require('obsidian'); + +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + +var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0); +var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter); +var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1); +var net__default = /*#__PURE__*/_interopDefaultLegacy(net); + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise */ + +var extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); +}; + +function __extends(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +} + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +function __generator(thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +} + +var _nodeResolve_empty = {}; + +var _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({ + __proto__: null, + 'default': _nodeResolve_empty +}); + +function createCommonjsModule(fn, basedir, module) { + return module = { + path: basedir, + exports: {}, + require: function (path, base) { + return commonjsRequire(path, (base === undefined || base === null) ? module.path : base); + } + }, fn(module, module.exports), module.exports; +} + +function getAugmentedNamespace(n) { + if (n.__esModule) return n; + var a = Object.defineProperty({}, '__esModule', {value: true}); + Object.keys(n).forEach(function (k) { + var d = Object.getOwnPropertyDescriptor(n, k); + Object.defineProperty(a, k, d.get ? d : { + enumerable: true, + get: function () { + return n[k]; + } + }); + }); + return a; +} + +function commonjsRequire () { + throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs'); +} + +var require$$1 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1); + +let register; +try { + const { app } = require$$0__default['default']; + register = app.setAsDefaultProtocolClient.bind(app); +} catch (err) { + try { + register = require$$1; + } catch (e) {} // eslint-disable-line no-empty +} + +if (typeof register !== 'function') { + register = () => false; +} + +function pid() { + if (typeof process !== 'undefined') { + return process.pid; + } + return null; +} + +const uuid4122 = () => { + let uuid = ''; + for (let i = 0; i < 32; i += 1) { + if (i === 8 || i === 12 || i === 16 || i === 20) { + uuid += '-'; + } + let n; + if (i === 12) { + n = 4; + } else { + const random = Math.random() * 16 | 0; + if (i === 16) { + n = (random & 3) | 0; + } else { + n = random; + } + } + uuid += n.toString(16); + } + return uuid; +}; + +var util = { + pid, + register, + uuid: uuid4122, +}; + +var browser$2 = createCommonjsModule(function (module, exports) { + +// ref: https://github.com/tc39/proposal-global +var getGlobal = function () { + // the only reliable means to get the global object is + // `Function('return this')()` + // However, this causes CSP violations in Chrome apps. + if (typeof self !== 'undefined') { return self; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + throw new Error('unable to locate global object'); +}; + +var global = getGlobal(); + +module.exports = exports = global.fetch; + +// Needed for TypeScript and Webpack. +if (global.fetch) { + exports.default = global.fetch.bind(global); +} + +exports.Headers = global.Headers; +exports.Request = global.Request; +exports.Response = global.Response; +}); + +const { uuid: uuid$1 } = util; + +const OPCodes = { + HANDSHAKE: 0, + FRAME: 1, + CLOSE: 2, + PING: 3, + PONG: 4, +}; + +function getIPCPath(id) { + if (process.platform === 'win32') { + return `\\\\?\\pipe\\discord-ipc-${id}`; + } + const { env: { XDG_RUNTIME_DIR, TMPDIR, TMP, TEMP } } = process; + const prefix = XDG_RUNTIME_DIR || TMPDIR || TMP || TEMP || '/tmp'; + return `${prefix.replace(/\/$/, '')}/discord-ipc-${id}`; +} + +function getIPC(id = 0) { + return new Promise((resolve, reject) => { + const path = getIPCPath(id); + const onerror = () => { + if (id < 10) { + resolve(getIPC(id + 1)); + } else { + reject(new Error('Could not connect')); + } + }; + const sock = net__default['default'].createConnection(path, () => { + sock.removeListener('error', onerror); + resolve(sock); + }); + sock.once('error', onerror); + }); +} + +async function findEndpoint(tries = 0) { + if (tries > 30) { + throw new Error('Could not find endpoint'); + } + const endpoint = `http://127.0.0.1:${6463 + (tries % 10)}`; + try { + const r = await browser$2(endpoint); + if (r.status === 404) { + return endpoint; + } + return findEndpoint(tries + 1); + } catch (e) { + return findEndpoint(tries + 1); + } +} + +function encode(op, data) { + data = JSON.stringify(data); + const len = Buffer.byteLength(data); + const packet = Buffer.alloc(8 + len); + packet.writeInt32LE(op, 0); + packet.writeInt32LE(len, 4); + packet.write(data, 8, len); + return packet; +} + +const working = { + full: '', + op: undefined, +}; + +function decode(socket, callback) { + const packet = socket.read(); + if (!packet) { + return; + } + + let { op } = working; + let raw; + if (working.full === '') { + op = working.op = packet.readInt32LE(0); + const len = packet.readInt32LE(4); + raw = packet.slice(8, len + 8); + } else { + raw = packet.toString(); + } + + try { + const data = JSON.parse(working.full + raw); + callback({ op, data }); // eslint-disable-line callback-return + working.full = ''; + working.op = undefined; + } catch (err) { + working.full += raw; + } + + decode(socket, callback); +} + +class IPCTransport extends EventEmitter__default['default'] { + constructor(client) { + super(); + this.client = client; + this.socket = null; + } + + async connect() { + const socket = this.socket = await getIPC(); + socket.on('close', this.onClose.bind(this)); + socket.on('error', this.onClose.bind(this)); + this.emit('open'); + socket.write(encode(OPCodes.HANDSHAKE, { + v: 1, + client_id: this.client.clientId, + })); + socket.pause(); + socket.on('readable', () => { + decode(socket, ({ op, data }) => { + switch (op) { + case OPCodes.PING: + this.send(data, OPCodes.PONG); + break; + case OPCodes.FRAME: + if (!data) { + return; + } + if (data.cmd === 'AUTHORIZE' && data.evt !== 'ERROR') { + findEndpoint() + .then((endpoint) => { + this.client.request.endpoint = endpoint; + }) + .catch((e) => { + this.client.emit('error', e); + }); + } + this.emit('message', data); + break; + case OPCodes.CLOSE: + this.emit('close', data); + break; + default: + break; + } + }); + }); + } + + onClose(e) { + this.emit('close', e); + } + + send(data, op = OPCodes.FRAME) { + this.socket.write(encode(op, data)); + } + + async close() { + return new Promise((r) => { + this.once('close', r); + this.send({}, OPCodes.CLOSE); + this.socket.end(); + }); + } + + ping() { + this.send(uuid$1(), OPCodes.PING); + } +} + +var ipc = IPCTransport; +var encode_1 = encode; +var decode_1 = decode; +ipc.encode = encode_1; +ipc.decode = decode_1; + +function keyMirror(arr) { + const tmp = {}; + for (const value of arr) { + tmp[value] = value; + } + return tmp; +} + + +var browser$1 = typeof window !== 'undefined'; + +var RPCCommands$1 = keyMirror([ + 'DISPATCH', + 'AUTHORIZE', + 'AUTHENTICATE', + 'GET_GUILD', + 'GET_GUILDS', + 'GET_CHANNEL', + 'GET_CHANNELS', + 'CREATE_CHANNEL_INVITE', + 'GET_RELATIONSHIPS', + 'GET_USER', + 'SUBSCRIBE', + 'UNSUBSCRIBE', + 'SET_USER_VOICE_SETTINGS', + 'SET_USER_VOICE_SETTINGS_2', + 'SELECT_VOICE_CHANNEL', + 'GET_SELECTED_VOICE_CHANNEL', + 'SELECT_TEXT_CHANNEL', + 'GET_VOICE_SETTINGS', + 'SET_VOICE_SETTINGS_2', + 'SET_VOICE_SETTINGS', + 'CAPTURE_SHORTCUT', + 'SET_ACTIVITY', + 'SEND_ACTIVITY_JOIN_INVITE', + 'CLOSE_ACTIVITY_JOIN_REQUEST', + 'ACTIVITY_INVITE_USER', + 'ACCEPT_ACTIVITY_INVITE', + 'INVITE_BROWSER', + 'DEEP_LINK', + 'CONNECTIONS_CALLBACK', + 'BRAINTREE_POPUP_BRIDGE_CALLBACK', + 'GIFT_CODE_BROWSER', + 'GUILD_TEMPLATE_BROWSER', + 'OVERLAY', + 'BROWSER_HANDOFF', + 'SET_CERTIFIED_DEVICES', + 'GET_IMAGE', + 'CREATE_LOBBY', + 'UPDATE_LOBBY', + 'DELETE_LOBBY', + 'UPDATE_LOBBY_MEMBER', + 'CONNECT_TO_LOBBY', + 'DISCONNECT_FROM_LOBBY', + 'SEND_TO_LOBBY', + 'SEARCH_LOBBIES', + 'CONNECT_TO_LOBBY_VOICE', + 'DISCONNECT_FROM_LOBBY_VOICE', + 'SET_OVERLAY_LOCKED', + 'OPEN_OVERLAY_ACTIVITY_INVITE', + 'OPEN_OVERLAY_GUILD_INVITE', + 'OPEN_OVERLAY_VOICE_SETTINGS', + 'VALIDATE_APPLICATION', + 'GET_ENTITLEMENT_TICKET', + 'GET_APPLICATION_TICKET', + 'START_PURCHASE', + 'GET_SKUS', + 'GET_ENTITLEMENTS', + 'GET_NETWORKING_CONFIG', + 'NETWORKING_SYSTEM_METRICS', + 'NETWORKING_PEER_METRICS', + 'NETWORKING_CREATE_TOKEN', + 'SET_USER_ACHIEVEMENT', + 'GET_USER_ACHIEVEMENTS', +]); + +var RPCEvents$1 = keyMirror([ + 'CURRENT_USER_UPDATE', + 'GUILD_STATUS', + 'GUILD_CREATE', + 'CHANNEL_CREATE', + 'RELATIONSHIP_UPDATE', + 'VOICE_CHANNEL_SELECT', + 'VOICE_STATE_CREATE', + 'VOICE_STATE_DELETE', + 'VOICE_STATE_UPDATE', + 'VOICE_SETTINGS_UPDATE', + 'VOICE_SETTINGS_UPDATE_2', + 'VOICE_CONNECTION_STATUS', + 'SPEAKING_START', + 'SPEAKING_STOP', + 'GAME_JOIN', + 'GAME_SPECTATE', + 'ACTIVITY_JOIN', + 'ACTIVITY_JOIN_REQUEST', + 'ACTIVITY_SPECTATE', + 'ACTIVITY_INVITE', + 'NOTIFICATION_CREATE', + 'MESSAGE_CREATE', + 'MESSAGE_UPDATE', + 'MESSAGE_DELETE', + 'LOBBY_DELETE', + 'LOBBY_UPDATE', + 'LOBBY_MEMBER_CONNECT', + 'LOBBY_MEMBER_DISCONNECT', + 'LOBBY_MEMBER_UPDATE', + 'LOBBY_MESSAGE', + 'CAPTURE_SHORTCUT_CHANGE', + 'OVERLAY', + 'OVERLAY_UPDATE', + 'ENTITLEMENT_CREATE', + 'ENTITLEMENT_DELETE', + 'USER_ACHIEVEMENT_UPDATE', + 'READY', + 'ERROR', +]); + +var RPCErrors = { + CAPTURE_SHORTCUT_ALREADY_LISTENING: 5004, + GET_GUILD_TIMED_OUT: 5002, + INVALID_ACTIVITY_JOIN_REQUEST: 4012, + INVALID_ACTIVITY_SECRET: 5005, + INVALID_CHANNEL: 4005, + INVALID_CLIENTID: 4007, + INVALID_COMMAND: 4002, + INVALID_ENTITLEMENT: 4015, + INVALID_EVENT: 4004, + INVALID_GIFT_CODE: 4016, + INVALID_GUILD: 4003, + INVALID_INVITE: 4011, + INVALID_LOBBY: 4013, + INVALID_LOBBY_SECRET: 4014, + INVALID_ORIGIN: 4008, + INVALID_PAYLOAD: 4000, + INVALID_PERMISSIONS: 4006, + INVALID_TOKEN: 4009, + INVALID_USER: 4010, + LOBBY_FULL: 5007, + NO_ELIGIBLE_ACTIVITY: 5006, + OAUTH2_ERROR: 5000, + PURCHASE_CANCELED: 5008, + PURCHASE_ERROR: 5009, + RATE_LIMITED: 5011, + SELECT_CHANNEL_TIMED_OUT: 5001, + SELECT_VOICE_FORCE_REQUIRED: 5003, + SERVICE_UNAVAILABLE: 1001, + TRANSACTION_ABORTED: 1002, + UNAUTHORIZED_FOR_ACHIEVEMENT: 5010, + UNKNOWN_ERROR: 1000, +}; + +var RPCCloseCodes = { + CLOSE_NORMAL: 1000, + CLOSE_UNSUPPORTED: 1003, + CLOSE_ABNORMAL: 1006, + INVALID_CLIENTID: 4000, + INVALID_ORIGIN: 4001, + RATELIMITED: 4002, + TOKEN_REVOKED: 4003, + INVALID_VERSION: 4004, + INVALID_ENCODING: 4005, +}; + +var LobbyTypes = { + PRIVATE: 1, + PUBLIC: 2, +}; + +var RelationshipTypes$1 = { + NONE: 0, + FRIEND: 1, + BLOCKED: 2, + PENDING_INCOMING: 3, + PENDING_OUTGOING: 4, + IMPLICIT: 5, +}; + +var constants = { + browser: browser$1, + RPCCommands: RPCCommands$1, + RPCEvents: RPCEvents$1, + RPCErrors: RPCErrors, + RPCCloseCodes: RPCCloseCodes, + LobbyTypes: LobbyTypes, + RelationshipTypes: RelationshipTypes$1 +}; + +const { browser } = constants; + +// eslint-disable-next-line +const WebSocket = browser ? window.WebSocket : require$$1; + +const pack = (d) => JSON.stringify(d); +const unpack = (s) => JSON.parse(s); + +class WebSocketTransport extends EventEmitter__default['default'] { + constructor(client) { + super(); + this.client = client; + this.ws = null; + this.tries = 0; + } + + async connect() { + const port = 6463 + (this.tries % 10); + this.tries += 1; + + this.ws = new WebSocket( + `ws://127.0.0.1:${port}/?v=1&client_id=${this.client.clientId}`, + browser ? undefined : { origin: this.client.options.origin }, + ); + this.ws.onopen = this.onOpen.bind(this); + this.ws.onclose = this.onClose.bind(this); + this.ws.onerror = this.onError.bind(this); + this.ws.onmessage = this.onMessage.bind(this); + } + + onOpen() { + this.emit('open'); + } + + onClose(event) { + if (!event.wasClean) { + return; + } + this.emit('close', event); + } + + onError(event) { + try { + this.ws.close(); + } catch {} // eslint-disable-line no-empty + + if (this.tries > 20) { + this.emit('error', event.error); + } else { + setTimeout(() => { + this.connect(); + }, 250); + } + } + + onMessage(event) { + this.emit('message', unpack(event.data)); + } + + send(data) { + this.ws.send(pack(data)); + } + + ping() {} // eslint-disable-line no-empty-function + + close() { + return new Promise((r) => { + this.once('close', r); + this.ws.close(); + }); + } +} + +var websocket = WebSocketTransport; + +var transports = { + ipc: ipc, + websocket: websocket, +}; + +const { setTimeout: setTimeout$1, clearTimeout } = require$$0__default$1['default']; + + +const { RPCCommands, RPCEvents, RelationshipTypes } = constants; +const { pid: getPid, uuid } = util; + +function subKey(event, args) { + return `${event}${JSON.stringify(args)}`; +} + +/** + * @typedef {RPCClientOptions} + * @extends {ClientOptions} + * @prop {string} transport RPC transport. one of `ipc` or `websocket` + */ + +/** + * The main hub for interacting with Discord RPC + * @extends {BaseClient} + */ +class RPCClient extends EventEmitter__default['default'] { + /** + * @param {RPCClientOptions} [options] Options for the client. + * You must provide a transport + */ + constructor(options = {}) { + super(); + + this.options = options; + + this.accessToken = null; + this.clientId = null; + + /** + * Application used in this client + * @type {?ClientApplication} + */ + this.application = null; + + /** + * User used in this application + * @type {?User} + */ + this.user = null; + + const Transport = transports[options.transport]; + if (!Transport) { + throw new TypeError('RPC_INVALID_TRANSPORT', options.transport); + } + + this.fetch = (method, path, { data, query } = {}) => + browser$2(`${this.fetch.endpoint}${path}${query ? new URLSearchParams(query) : ''}`, { + method, + body: data, + headers: { + Authorization: `Bearer ${this.accessToken}`, + }, + }).then(async (r) => { + const body = await r.json(); + if (!r.ok) { + const e = new Error(r.status); + e.body = body; + throw e; + } + return body; + }); + + this.fetch.endpoint = 'https://discord.com/api'; + + /** + * Raw transport userd + * @type {RPCTransport} + * @private + */ + this.transport = new Transport(this); + this.transport.on('message', this._onRpcMessage.bind(this)); + + /** + * Map of nonces being expected from the transport + * @type {Map} + * @private + */ + this._expecting = new Map(); + + /** + * Map of current subscriptions + * @type {Map} + * @private + */ + this._subscriptions = new Map(); + + this._connectPromise = undefined; + } + + /** + * Search and connect to RPC + */ + connect(clientId) { + if (this._connectPromise) { + return this._connectPromise; + } + this._connectPromise = new Promise((resolve, reject) => { + this.clientId = clientId; + const timeout = setTimeout$1(() => reject(new Error('RPC_CONNECTION_TIMEOUT')), 10e3); + timeout.unref(); + this.once('connected', () => { + clearTimeout(timeout); + resolve(this); + }); + this.transport.once('close', () => { + this._expecting.forEach((e) => { + e.reject(new Error('connection closed')); + }); + this.emit('disconnected'); + reject(new Error('connection closed')); + }); + this.transport.connect().catch(reject); + }); + return this._connectPromise; + } + + /** + * @typedef {RPCLoginOptions} + * @param {string} clientId Client ID + * @param {string} [clientSecret] Client secret + * @param {string} [accessToken] Access token + * @param {string} [rpcToken] RPC token + * @param {string} [tokenEndpoint] Token endpoint + * @param {string[]} [scopes] Scopes to authorize with + */ + + /** + * Performs authentication flow. Automatically calls Client#connect if needed. + * @param {RPCLoginOptions} options Options for authentication. + * At least one property must be provided to perform login. + * @example client.login({ clientId: '1234567', clientSecret: 'abcdef123' }); + * @returns {Promise} + */ + async login(options = {}) { + let { clientId, accessToken } = options; + await this.connect(clientId); + if (!options.scopes) { + this.emit('ready'); + return this; + } + if (!accessToken) { + accessToken = await this.authorize(options); + } + return this.authenticate(accessToken); + } + + /** + * Request + * @param {string} cmd Command + * @param {Object} [args={}] Arguments + * @param {string} [evt] Event + * @returns {Promise} + * @private + */ + request(cmd, args, evt) { + return new Promise((resolve, reject) => { + const nonce = uuid(); + this.transport.send({ cmd, args, evt, nonce }); + this._expecting.set(nonce, { resolve, reject }); + }); + } + + /** + * Message handler + * @param {Object} message message + * @private + */ + _onRpcMessage(message) { + if (message.cmd === RPCCommands.DISPATCH && message.evt === RPCEvents.READY) { + if (message.data.user) { + this.user = message.data.user; + } + this.emit('connected'); + } else if (this._expecting.has(message.nonce)) { + const { resolve, reject } = this._expecting.get(message.nonce); + if (message.evt === 'ERROR') { + const e = new Error(message.data.message); + e.code = message.data.code; + e.data = message.data; + reject(e); + } else { + resolve(message.data); + } + this._expecting.delete(message.nonce); + } else { + const subid = subKey(message.evt, message.args); + if (!this._subscriptions.has(subid)) { + return; + } + this._subscriptions.get(subid)(message.data); + } + } + + /** + * Authorize + * @param {Object} options options + * @returns {Promise} + * @private + */ + async authorize({ scopes, clientSecret, rpcToken, redirectUri } = {}) { + if (clientSecret && rpcToken === true) { + const body = await this.fetch('POST', '/oauth2/token/rpc', { + data: new URLSearchParams({ + client_id: this.clientId, + client_secret: clientSecret, + }), + }); + rpcToken = body.rpc_token; + } + + const { code } = await this.request('AUTHORIZE', { + scopes, + client_id: this.clientId, + rpc_token: rpcToken, + }); + + const response = await this.fetch('POST', '/oauth2/token', { + data: new URLSearchParams({ + client_id: this.clientId, + client_secret: clientSecret, + code, + grant_type: 'authorization_code', + redirect_uri: redirectUri, + }), + }); + + return response.access_token; + } + + /** + * Authenticate + * @param {string} accessToken access token + * @returns {Promise} + * @private + */ + authenticate(accessToken) { + return this.request('AUTHENTICATE', { access_token: accessToken }) + .then(({ application, user }) => { + this.accessToken = accessToken; + this.application = application; + this.user = user; + this.emit('ready'); + return this; + }); + } + + + /** + * Fetch a guild + * @param {Snowflake} id Guild ID + * @param {number} [timeout] Timeout request + * @returns {Promise} + */ + getGuild(id, timeout) { + return this.request(RPCCommands.GET_GUILD, { guild_id: id, timeout }); + } + + /** + * Fetch all guilds + * @param {number} [timeout] Timeout request + * @returns {Promise>} + */ + getGuilds(timeout) { + return this.request(RPCCommands.GET_GUILDS, { timeout }); + } + + /** + * Get a channel + * @param {Snowflake} id Channel ID + * @param {number} [timeout] Timeout request + * @returns {Promise} + */ + getChannel(id, timeout) { + return this.request(RPCCommands.GET_CHANNEL, { channel_id: id, timeout }); + } + + /** + * Get all channels + * @param {Snowflake} [id] Guild ID + * @param {number} [timeout] Timeout request + * @returns {Promise>} + */ + async getChannels(id, timeout) { + const { channels } = await this.request(RPCCommands.GET_CHANNELS, { + timeout, + guild_id: id, + }); + return channels; + } + + /** + * @typedef {CertifiedDevice} + * @prop {string} type One of `AUDIO_INPUT`, `AUDIO_OUTPUT`, `VIDEO_INPUT` + * @prop {string} uuid This device's Windows UUID + * @prop {object} vendor Vendor information + * @prop {string} vendor.name Vendor's name + * @prop {string} vendor.url Vendor's url + * @prop {object} model Model information + * @prop {string} model.name Model's name + * @prop {string} model.url Model's url + * @prop {string[]} related Array of related product's Windows UUIDs + * @prop {boolean} echoCancellation If the device has echo cancellation + * @prop {boolean} noiseSuppression If the device has noise suppression + * @prop {boolean} automaticGainControl If the device has automatic gain control + * @prop {boolean} hardwareMute If the device has a hardware mute + */ + + /** + * Tell discord which devices are certified + * @param {CertifiedDevice[]} devices Certified devices to send to discord + * @returns {Promise} + */ + setCertifiedDevices(devices) { + return this.request(RPCCommands.SET_CERTIFIED_DEVICES, { + devices: devices.map((d) => ({ + type: d.type, + id: d.uuid, + vendor: d.vendor, + model: d.model, + related: d.related, + echo_cancellation: d.echoCancellation, + noise_suppression: d.noiseSuppression, + automatic_gain_control: d.automaticGainControl, + hardware_mute: d.hardwareMute, + })), + }); + } + + /** + * @typedef {UserVoiceSettings} + * @prop {Snowflake} id ID of the user these settings apply to + * @prop {?Object} [pan] Pan settings, an object with `left` and `right` set between + * 0.0 and 1.0, inclusive + * @prop {?number} [volume=100] The volume + * @prop {bool} [mute] If the user is muted + */ + + /** + * Set the voice settings for a user, by id + * @param {Snowflake} id ID of the user to set + * @param {UserVoiceSettings} settings Settings + * @returns {Promise} + */ + setUserVoiceSettings(id, settings) { + return this.request(RPCCommands.SET_USER_VOICE_SETTINGS, { + user_id: id, + pan: settings.pan, + mute: settings.mute, + volume: settings.volume, + }); + } + + /** + * Move the user to a voice channel + * @param {Snowflake} id ID of the voice channel + * @param {Object} [options] Options + * @param {number} [options.timeout] Timeout for the command + * @param {boolean} [options.force] Force this move. This should only be done if you + * have explicit permission from the user. + * @returns {Promise} + */ + selectVoiceChannel(id, { timeout, force = false } = {}) { + return this.request(RPCCommands.SELECT_VOICE_CHANNEL, { channel_id: id, timeout, force }); + } + + /** + * Move the user to a text channel + * @param {Snowflake} id ID of the voice channel + * @param {Object} [options] Options + * @param {number} [options.timeout] Timeout for the command + * have explicit permission from the user. + * @returns {Promise} + */ + selectTextChannel(id, { timeout } = {}) { + return this.request(RPCCommands.SELECT_TEXT_CHANNEL, { channel_id: id, timeout }); + } + + /** + * Get current voice settings + * @returns {Promise} + */ + getVoiceSettings() { + return this.request(RPCCommands.GET_VOICE_SETTINGS) + .then((s) => ({ + automaticGainControl: s.automatic_gain_control, + echoCancellation: s.echo_cancellation, + noiseSuppression: s.noise_suppression, + qos: s.qos, + silenceWarning: s.silence_warning, + deaf: s.deaf, + mute: s.mute, + input: { + availableDevices: s.input.available_devices, + device: s.input.device_id, + volume: s.input.volume, + }, + output: { + availableDevices: s.output.available_devices, + device: s.output.device_id, + volume: s.output.volume, + }, + mode: { + type: s.mode.type, + autoThreshold: s.mode.auto_threshold, + threshold: s.mode.threshold, + shortcut: s.mode.shortcut, + delay: s.mode.delay, + }, + })); + } + + /** + * Set current voice settings, overriding the current settings until this session disconnects. + * This also locks the settings for any other rpc sessions which may be connected. + * @param {Object} args Settings + * @returns {Promise} + */ + setVoiceSettings(args) { + return this.request(RPCCommands.SET_VOICE_SETTINGS, { + automatic_gain_control: args.automaticGainControl, + echo_cancellation: args.echoCancellation, + noise_suppression: args.noiseSuppression, + qos: args.qos, + silence_warning: args.silenceWarning, + deaf: args.deaf, + mute: args.mute, + input: args.input ? { + device_id: args.input.device, + volume: args.input.volume, + } : undefined, + output: args.output ? { + device_id: args.output.device, + volume: args.output.volume, + } : undefined, + mode: args.mode ? { + mode: args.mode.type, + auto_threshold: args.mode.autoThreshold, + threshold: args.mode.threshold, + shortcut: args.mode.shortcut, + delay: args.mode.delay, + } : undefined, + }); + } + + /** + * Capture a shortcut using the client + * The callback takes (key, stop) where `stop` is a function that will stop capturing. + * This `stop` function must be called before disconnecting or else the user will have + * to restart their client. + * @param {Function} callback Callback handling keys + * @returns {Promise} + */ + captureShortcut(callback) { + const subid = subKey(RPCEvents.CAPTURE_SHORTCUT_CHANGE); + const stop = () => { + this._subscriptions.delete(subid); + return this.request(RPCCommands.CAPTURE_SHORTCUT, { action: 'STOP' }); + }; + this._subscriptions.set(subid, ({ shortcut }) => { + callback(shortcut, stop); + }); + return this.request(RPCCommands.CAPTURE_SHORTCUT, { action: 'START' }) + .then(() => stop); + } + + /** + * Sets the presence for the logged in user. + * @param {object} args The rich presence to pass. + * @param {number} [pid] The application's process ID. Defaults to the executing process' PID. + * @returns {Promise} + */ + setActivity(args = {}, pid = getPid()) { + let timestamps; + let assets; + let party; + let secrets; + if (args.startTimestamp || args.endTimestamp) { + timestamps = { + start: args.startTimestamp, + end: args.endTimestamp, + }; + if (timestamps.start instanceof Date) { + timestamps.start = Math.round(timestamps.start.getTime()); + } + if (timestamps.end instanceof Date) { + timestamps.end = Math.round(timestamps.end.getTime()); + } + if (timestamps.start > 2147483647000) { + throw new RangeError('timestamps.start must fit into a unix timestamp'); + } + if (timestamps.end > 2147483647000) { + throw new RangeError('timestamps.end must fit into a unix timestamp'); + } + } + if ( + args.largeImageKey || args.largeImageText + || args.smallImageKey || args.smallImageText + ) { + assets = { + large_image: args.largeImageKey, + large_text: args.largeImageText, + small_image: args.smallImageKey, + small_text: args.smallImageText, + }; + } + if (args.partySize || args.partyId || args.partyMax) { + party = { id: args.partyId }; + if (args.partySize || args.partyMax) { + party.size = [args.partySize, args.partyMax]; + } + } + if (args.matchSecret || args.joinSecret || args.spectateSecret) { + secrets = { + match: args.matchSecret, + join: args.joinSecret, + spectate: args.spectateSecret, + }; + } + + return this.request(RPCCommands.SET_ACTIVITY, { + pid, + activity: { + state: args.state, + details: args.details, + timestamps, + assets, + party, + secrets, + buttons: args.buttons, + instance: !!args.instance, + }, + }); + } + + /** + * Clears the currently set presence, if any. This will hide the "Playing X" message + * displayed below the user's name. + * @param {number} [pid] The application's process ID. Defaults to the executing process' PID. + * @returns {Promise} + */ + clearActivity(pid = getPid()) { + return this.request(RPCCommands.SET_ACTIVITY, { + pid, + }); + } + + /** + * Invite a user to join the game the RPC user is currently playing + * @param {User} user The user to invite + * @returns {Promise} + */ + sendJoinInvite(user) { + return this.request(RPCCommands.SEND_ACTIVITY_JOIN_INVITE, { + user_id: user.id || user, + }); + } + + /** + * Request to join the game the user is playing + * @param {User} user The user whose game you want to request to join + * @returns {Promise} + */ + sendJoinRequest(user) { + return this.request(RPCCommands.SEND_ACTIVITY_JOIN_REQUEST, { + user_id: user.id || user, + }); + } + + /** + * Reject a join request from a user + * @param {User} user The user whose request you wish to reject + * @returns {Promise} + */ + closeJoinRequest(user) { + return this.request(RPCCommands.CLOSE_ACTIVITY_JOIN_REQUEST, { + user_id: user.id || user, + }); + } + + createLobby(type, capacity, metadata) { + return this.request(RPCCommands.CREATE_LOBBY, { + type, + capacity, + metadata, + }); + } + + updateLobby(lobby, { type, owner, capacity, metadata } = {}) { + return this.request(RPCCommands.UPDATE_LOBBY, { + id: lobby.id || lobby, + type, + owner_id: (owner && owner.id) || owner, + capacity, + metadata, + }); + } + + deleteLobby(lobby) { + return this.request(RPCCommands.DELETE_LOBBY, { + id: lobby.id || lobby, + }); + } + + connectToLobby(id, secret) { + return this.request(RPCCommands.CONNECT_TO_LOBBY, { + id, + secret, + }); + } + + sendToLobby(lobby, data) { + return this.request(RPCCommands.SEND_TO_LOBBY, { + id: lobby.id || lobby, + data, + }); + } + + disconnectFromLobby(lobby) { + return this.request(RPCCommands.DISCONNECT_FROM_LOBBY, { + id: lobby.id || lobby, + }); + } + + updateLobbyMember(lobby, user, metadata) { + return this.request(RPCCommands.UPDATE_LOBBY_MEMBER, { + lobby_id: lobby.id || lobby, + user_id: user.id || user, + metadata, + }); + } + + getRelationships() { + const types = Object.keys(RelationshipTypes); + return this.request(RPCCommands.GET_RELATIONSHIPS) + .then((o) => o.relationships.map((r) => ({ + ...r, + type: types[r.type], + }))); + } + + /** + * Subscribe to an event + * @param {string} event Name of event e.g. `MESSAGE_CREATE` + * @param {Object} [args] Args for event e.g. `{ channel_id: '1234' }` + * @param {Function} callback Callback when an event for the subscription is triggered + * @returns {Promise} + */ + subscribe(event, args, callback) { + if (!callback && typeof args === 'function') { + callback = args; + args = undefined; + } + return this.request(RPCCommands.SUBSCRIBE, args, event).then(() => { + const subid = subKey(event, args); + this._subscriptions.set(subid, callback); + return { + unsubscribe: () => this.request(RPCCommands.UNSUBSCRIBE, args, event) + .then(() => this._subscriptions.delete(subid)), + }; + }); + } + + /** + * Destroy the client + */ + async destroy() { + await this.transport.close(); + } +} + +var client = RPCClient; + +var src = { + Client: client, + register(id) { + return util.register(`discord-${id}`); + }, +}; + +var Logger = /** @class */ (function () { + function Logger() { + this.plugin = this.plugin; + } + Logger.prototype.log = function (message, showPopups) { + if (showPopups) { + new obsidian.Notice(message); + } + console.log("discordrpc: " + message); + }; + Logger.prototype.logIgnoreNoNotice = function (message) { + new obsidian.Notice(message); + console.log("discordrpc: " + message); + }; + return Logger; +}()); + +var DiscordRPCSettings = /** @class */ (function () { + function DiscordRPCSettings() { + this.showVaultName = true; + this.showCurrentFileName = true; + this.showPopups = true; + this.customVaultName = ""; + this.showFileExtension = false; + this.useLoadedTime = false; + this.connectOnStart = true; + this.autoHideStatusBar = true; + } + return DiscordRPCSettings; +}()); +var PluginState; +(function (PluginState) { + PluginState[PluginState["connected"] = 0] = "connected"; + PluginState[PluginState["connecting"] = 1] = "connecting"; + PluginState[PluginState["disconnected"] = 2] = "disconnected"; +})(PluginState || (PluginState = {})); + +var DiscordRPCSettingsTab = /** @class */ (function (_super) { + __extends(DiscordRPCSettingsTab, _super); + function DiscordRPCSettingsTab() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.logger = new Logger(); + return _this; + } + DiscordRPCSettingsTab.prototype.display = function () { + var _this = this; + var containerEl = this.containerEl; + var plugin = this.plugin; + containerEl.empty(); + containerEl.createEl("h2", { text: "Discord Rich Presence Settings" }); + containerEl.createEl("h3", { text: "Vault Name Settings" }); + new obsidian.Setting(containerEl) + .setName("Show Vault Name") + .setDesc("Enable this to show the name of the vault you are working with.") + .addToggle(function (boolean) { + return boolean.setValue(plugin.settings.showVaultName).onChange(function (value) { + plugin.settings.showVaultName = value; + plugin.saveData(plugin.settings); + if (boolean.getValue()) { + _this.logger.logIgnoreNoNotice("Vault Name is now Visable"); + } + else { + _this.logger.logIgnoreNoNotice("Vault Name is no longer Visable"); + } + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + new obsidian.Setting(containerEl) + .setName("Set Custom Vault Name") + .setDesc("Change the vault name shown publicly. Leave blank to use your actual vault name.") + .addText(function (text) { + return text.setValue(plugin.settings.customVaultName).onChange(function (value) { + plugin.settings.customVaultName = value; + plugin.saveData(plugin.settings); + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + containerEl.createEl("h3", { text: "File Name Settings" }); + new obsidian.Setting(containerEl) + .setName("Show Current File Name") + .setDesc("Enable this to show the name of the file you are working on.") + .addToggle(function (boolean) { + return boolean + .setValue(plugin.settings.showCurrentFileName) + .onChange(function (value) { + plugin.settings.showCurrentFileName = value; + plugin.saveData(plugin.settings); + if (boolean.getValue()) { + _this.logger.logIgnoreNoNotice("File Name is now Visable"); + } + else { + _this.logger.logIgnoreNoNotice("File Name is no longer Visable"); + } + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + new obsidian.Setting(containerEl) + .setName("Show File Extension") + .setDesc("Enable this to show file extension.") + .addToggle(function (boolean) { + return boolean + .setValue(plugin.settings.showFileExtension) + .onChange(function (value) { + plugin.settings.showFileExtension = value; + plugin.saveData(plugin.settings); + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + containerEl.createEl("h3", { text: "Time Settings" }); + new obsidian.Setting(containerEl) + .setName("Use Obsidian Total Time") + .setDesc("Enable to use the total time you have been using Obsidian, instead of the time spent editing a single file.") + .addToggle(function (boolean) { + boolean.setValue(plugin.settings.useLoadedTime).onChange(function (value) { + plugin.settings.useLoadedTime = value; + plugin.saveData(plugin.settings); + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + containerEl.createEl("h3", { text: "Status Bar Settings" }); + new obsidian.Setting(containerEl) + .setName("Automatically hide Status Bar") + .setDesc("Automatically hide status bar after successfully connecting to Discord.") + .addToggle(function (boolean) { + boolean.setValue(plugin.settings.autoHideStatusBar).onChange(function (value) { + plugin.settings.autoHideStatusBar = value; + plugin.saveData(plugin.settings); + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + containerEl.createEl("h3", { text: "Startup Settings" }); + new obsidian.Setting(containerEl) + .setName("Automatically Connect to Discord") + .setDesc("Automatically connect to Discord on startup. You can always click the status bar to manually connect.") + .addToggle(function (boolean) { + boolean.setValue(plugin.settings.connectOnStart).onChange(function (value) { + plugin.settings.connectOnStart = value; + plugin.saveData(plugin.settings); + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + containerEl.createEl("h3", { text: "Notice Settings" }); + new obsidian.Setting(containerEl) + .setName("Show Notices") + .setDesc("Enable this to show connection Notices.") + .addToggle(function (boolean) { + return boolean.setValue(plugin.settings.showPopups).onChange(function (value) { + plugin.settings.showPopups = value; + plugin.saveData(plugin.settings); + if (boolean.getValue()) { + _this.logger.logIgnoreNoNotice("Notices Enabled"); + } + else { + _this.logger.logIgnoreNoNotice("Notices Disabled"); + } + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + }; + return DiscordRPCSettingsTab; +}(obsidian.PluginSettingTab)); + +var StatusBar = /** @class */ (function () { + function StatusBar(statusBarEl) { + this.statusBarEl = statusBarEl; + } + StatusBar.prototype.displayState = function (state, autoHide) { + switch (state) { + case PluginState.connected: + this.displayConnected(autoHide ? 10000 : 0); + break; + case PluginState.connecting: + this.statusBarEl.setText("Connecting to Discord..."); + break; + case PluginState.disconnected: + this.statusBarEl.setText("\uD83D\uDDD8 Reconnect to Discord"); + break; + } + }; + StatusBar.prototype.displayConnected = function (timeout) { + var _this = this; + this.statusBarEl.setText("\uD83C\uDF0D Connected to Discord"); + if (timeout && timeout > 0) { + window.setTimeout(function () { + _this.statusBarEl.setText(""); + }, timeout); + } + else { + window.setTimeout(function () { + _this.statusBarEl.setText("\uD83C\uDF0D"); + }, 5000); + } + }; + return StatusBar; +}()); + +var ObsidianDiscordRPC = /** @class */ (function (_super) { + __extends(ObsidianDiscordRPC, _super); + function ObsidianDiscordRPC() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.logger = new Logger(); + return _this; + } + ObsidianDiscordRPC.prototype.setState = function (state) { + this.state = state; + }; + ObsidianDiscordRPC.prototype.getState = function () { + return this.state; + }; + ObsidianDiscordRPC.prototype.getApp = function () { + return this.app; + }; + ObsidianDiscordRPC.prototype.getPluginManifest = function () { + return this.manifest; + }; + ObsidianDiscordRPC.prototype.onload = function () { + return __awaiter(this, void 0, void 0, function () { + var statusBarEl, _a, activeLeaf_1, files; + var _this = this; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + statusBarEl = this.addStatusBarItem(); + this.statusBar = new StatusBar(statusBarEl); + _a = this; + return [4 /*yield*/, this.loadData()]; + case 1: + _a.settings = (_b.sent()) || new DiscordRPCSettings(); + this.registerEvent(this.app.workspace.on("file-open", this.onFileOpen, this)); + this.registerDomEvent(statusBarEl, "click", function () { return __awaiter(_this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!(this.getState() == PluginState.disconnected)) return [3 /*break*/, 2]; + return [4 /*yield*/, this.connectDiscord()]; + case 1: + _a.sent(); + return [3 /*break*/, 4]; + case 2: + if (!(this.getState() == PluginState.connected)) return [3 /*break*/, 4]; + return [4 /*yield*/, this.disconnectDiscord()]; + case 3: + _a.sent(); + _a.label = 4; + case 4: return [2 /*return*/]; + } + }); + }); }); + this.addSettingTab(new DiscordRPCSettingsTab(this.app, this)); + this.addCommand({ + id: "reconnect-discord", + name: "Reconnect to Discord", + callback: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.connectDiscord()]; + case 1: return [2 /*return*/, _a.sent()]; + } + }); }); }, + }); + this.addCommand({ + id: "disconnect-discord", + name: "Disconnect from Discord", + callback: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.disconnectDiscord()]; + case 1: return [2 /*return*/, _a.sent()]; + } + }); }); }, + }); + if (!this.settings.connectOnStart) return [3 /*break*/, 3]; + return [4 /*yield*/, this.connectDiscord()]; + case 2: + _b.sent(); + activeLeaf_1 = this.app.workspace.activeLeaf; + files = this.app.vault.getMarkdownFiles(); + files.forEach(function (file) { + if (file.basename === activeLeaf_1.getDisplayText()) { + _this.onFileOpen(file); + } + }); + return [3 /*break*/, 4]; + case 3: + this.setState(PluginState.disconnected); + this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar); + _b.label = 4; + case 4: return [2 /*return*/]; + } + }); + }); + }; + ObsidianDiscordRPC.prototype.onFileOpen = function (file) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + this.currentFile = file; + if (!(this.getState() === PluginState.connected)) return [3 /*break*/, 2]; + return [4 /*yield*/, this.setActivity(this.app.vault.getName(), file.basename, file.extension)]; + case 1: + _a.sent(); + _a.label = 2; + case 2: return [2 /*return*/]; + } + }); + }); + }; + ObsidianDiscordRPC.prototype.onunload = function () { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.saveData(this.settings)]; + case 1: + _a.sent(); + this.rpc.clearActivity(); + this.rpc.destroy(); + return [2 /*return*/]; + } + }); + }); + }; + ObsidianDiscordRPC.prototype.connectDiscord = function () { + return __awaiter(this, void 0, void 0, function () { + var _this = this; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + this.loadedTime = new Date(); + this.rpc = new src.Client({ + transport: "ipc", + }); + this.setState(PluginState.connecting); + this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar); + this.rpc.once("ready", function () { + _this.setState(PluginState.connected); + _this.statusBar.displayState(_this.getState(), _this.settings.autoHideStatusBar); + _this.logger.log("Connected to Discord", _this.settings.showPopups); + }); + _a.label = 1; + case 1: + _a.trys.push([1, 4, , 5]); + return [4 /*yield*/, this.rpc.login({ + clientId: "763813185022197831", + })]; + case 2: + _a.sent(); + return [4 /*yield*/, this.setActivity(this.app.vault.getName(), "...", "")]; + case 3: + _a.sent(); + return [3 /*break*/, 5]; + case 4: + _a.sent(); + this.setState(PluginState.disconnected); + this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar); + this.logger.log("Failed to connect to Discord", this.settings.showPopups); + return [3 /*break*/, 5]; + case 5: return [2 /*return*/]; + } + }); + }); + }; + ObsidianDiscordRPC.prototype.disconnectDiscord = function () { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + this.rpc.clearActivity(); + this.rpc.destroy(); + this.setState(PluginState.disconnected); + this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar); + this.logger.log("Disconnected from Discord", this.settings.showPopups); + return [2 /*return*/]; + }); + }); + }; + ObsidianDiscordRPC.prototype.setActivity = function (vaultName, fileName, fileExtension) { + return __awaiter(this, void 0, void 0, function () { + var vault, file, date; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!(this.getState() === PluginState.connected)) return [3 /*break*/, 8]; + vault = void 0; + if (this.settings.customVaultName === "") { + vault = vaultName; + } + else { + vault = this.settings.customVaultName; + } + file = void 0; + if (this.settings.showFileExtension) { + file = fileName + "." + fileExtension; + } + else { + file = fileName; + } + date = void 0; + if (this.settings.useLoadedTime) { + date = this.loadedTime; + } + else { + date = new Date(); + } + if (!(this.settings.showVaultName && this.settings.showCurrentFileName)) return [3 /*break*/, 2]; + return [4 /*yield*/, this.rpc.setActivity({ + details: "Editing " + file, + state: "Vault: " + vault, + startTimestamp: date, + largeImageKey: "logo", + largeImageText: "Obsidian", + })]; + case 1: + _a.sent(); + return [3 /*break*/, 8]; + case 2: + if (!this.settings.showVaultName) return [3 /*break*/, 4]; + return [4 /*yield*/, this.rpc.setActivity({ + state: "Vault: " + vault, + startTimestamp: date, + largeImageKey: "logo", + largeImageText: "Obsidian", + })]; + case 3: + _a.sent(); + return [3 /*break*/, 8]; + case 4: + if (!this.settings.showCurrentFileName) return [3 /*break*/, 6]; + return [4 /*yield*/, this.rpc.setActivity({ + details: "Editing " + file, + startTimestamp: date, + largeImageKey: "logo", + largeImageText: "Obsidian", + })]; + case 5: + _a.sent(); + return [3 /*break*/, 8]; + case 6: return [4 /*yield*/, this.rpc.setActivity({ + startTimestamp: date, + largeImageKey: "logo", + largeImageText: "Obsidian", + })]; + case 7: + _a.sent(); + _a.label = 8; + case 8: return [2 /*return*/]; + } + }); + }); + }; + return ObsidianDiscordRPC; +}(obsidian.Plugin)); + +module.exports = ObsidianDiscordRPC; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["../node_modules/tslib/tslib.es6.js","../node_modules/discord-rpc/src/util.js","../node_modules/node-fetch/browser.js","../node_modules/discord-rpc/src/transports/ipc.js","../node_modules/discord-rpc/src/constants.js","../node_modules/discord-rpc/src/transports/websocket.js","../node_modules/discord-rpc/src/transports/index.js","../node_modules/discord-rpc/src/client.js","../node_modules/discord-rpc/src/index.js","../src/logger.ts","../src/settings/settings.ts","../src/settings/settings-tab.ts","../src/status-bar.ts","../src/main.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || from);\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    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\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    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\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","'use strict';\n\nlet register;\ntry {\n  const { app } = require('electron');\n  register = app.setAsDefaultProtocolClient.bind(app);\n} catch (err) {\n  try {\n    register = require('register-scheme');\n  } catch (e) {} // eslint-disable-line no-empty\n}\n\nif (typeof register !== 'function') {\n  register = () => false;\n}\n\nfunction pid() {\n  if (typeof process !== 'undefined') {\n    return process.pid;\n  }\n  return null;\n}\n\nconst uuid4122 = () => {\n  let uuid = '';\n  for (let i = 0; i < 32; i += 1) {\n    if (i === 8 || i === 12 || i === 16 || i === 20) {\n      uuid += '-';\n    }\n    let n;\n    if (i === 12) {\n      n = 4;\n    } else {\n      const random = Math.random() * 16 | 0;\n      if (i === 16) {\n        n = (random & 3) | 0;\n      } else {\n        n = random;\n      }\n    }\n    uuid += n.toString(16);\n  }\n  return uuid;\n};\n\nmodule.exports = {\n  pid,\n  register,\n  uuid: uuid4122,\n};\n","\"use strict\";\n\n// ref: https://github.com/tc39/proposal-global\nvar getGlobal = function () {\n\t// the only reliable means to get the global object is\n\t// `Function('return this')()`\n\t// However, this causes CSP violations in Chrome apps.\n\tif (typeof self !== 'undefined') { return self; }\n\tif (typeof window !== 'undefined') { return window; }\n\tif (typeof global !== 'undefined') { return global; }\n\tthrow new Error('unable to locate global object');\n}\n\nvar global = getGlobal();\n\nmodule.exports = exports = global.fetch;\n\n// Needed for TypeScript and Webpack.\nif (global.fetch) {\n\texports.default = global.fetch.bind(global);\n}\n\nexports.Headers = global.Headers;\nexports.Request = global.Request;\nexports.Response = global.Response;","'use strict';\n\nconst net = require('net');\nconst EventEmitter = require('events');\nconst fetch = require('node-fetch');\nconst { uuid } = require('../util');\n\nconst OPCodes = {\n  HANDSHAKE: 0,\n  FRAME: 1,\n  CLOSE: 2,\n  PING: 3,\n  PONG: 4,\n};\n\nfunction getIPCPath(id) {\n  if (process.platform === 'win32') {\n    return `\\\\\\\\?\\\\pipe\\\\discord-ipc-${id}`;\n  }\n  const { env: { XDG_RUNTIME_DIR, TMPDIR, TMP, TEMP } } = process;\n  const prefix = XDG_RUNTIME_DIR || TMPDIR || TMP || TEMP || '/tmp';\n  return `${prefix.replace(/\\/$/, '')}/discord-ipc-${id}`;\n}\n\nfunction getIPC(id = 0) {\n  return new Promise((resolve, reject) => {\n    const path = getIPCPath(id);\n    const onerror = () => {\n      if (id < 10) {\n        resolve(getIPC(id + 1));\n      } else {\n        reject(new Error('Could not connect'));\n      }\n    };\n    const sock = net.createConnection(path, () => {\n      sock.removeListener('error', onerror);\n      resolve(sock);\n    });\n    sock.once('error', onerror);\n  });\n}\n\nasync function findEndpoint(tries = 0) {\n  if (tries > 30) {\n    throw new Error('Could not find endpoint');\n  }\n  const endpoint = `http://127.0.0.1:${6463 + (tries % 10)}`;\n  try {\n    const r = await fetch(endpoint);\n    if (r.status === 404) {\n      return endpoint;\n    }\n    return findEndpoint(tries + 1);\n  } catch (e) {\n    return findEndpoint(tries + 1);\n  }\n}\n\nfunction encode(op, data) {\n  data = JSON.stringify(data);\n  const len = Buffer.byteLength(data);\n  const packet = Buffer.alloc(8 + len);\n  packet.writeInt32LE(op, 0);\n  packet.writeInt32LE(len, 4);\n  packet.write(data, 8, len);\n  return packet;\n}\n\nconst working = {\n  full: '',\n  op: undefined,\n};\n\nfunction decode(socket, callback) {\n  const packet = socket.read();\n  if (!packet) {\n    return;\n  }\n\n  let { op } = working;\n  let raw;\n  if (working.full === '') {\n    op = working.op = packet.readInt32LE(0);\n    const len = packet.readInt32LE(4);\n    raw = packet.slice(8, len + 8);\n  } else {\n    raw = packet.toString();\n  }\n\n  try {\n    const data = JSON.parse(working.full + raw);\n    callback({ op, data }); // eslint-disable-line callback-return\n    working.full = '';\n    working.op = undefined;\n  } catch (err) {\n    working.full += raw;\n  }\n\n  decode(socket, callback);\n}\n\nclass IPCTransport extends EventEmitter {\n  constructor(client) {\n    super();\n    this.client = client;\n    this.socket = null;\n  }\n\n  async connect() {\n    const socket = this.socket = await getIPC();\n    socket.on('close', this.onClose.bind(this));\n    socket.on('error', this.onClose.bind(this));\n    this.emit('open');\n    socket.write(encode(OPCodes.HANDSHAKE, {\n      v: 1,\n      client_id: this.client.clientId,\n    }));\n    socket.pause();\n    socket.on('readable', () => {\n      decode(socket, ({ op, data }) => {\n        switch (op) {\n          case OPCodes.PING:\n            this.send(data, OPCodes.PONG);\n            break;\n          case OPCodes.FRAME:\n            if (!data) {\n              return;\n            }\n            if (data.cmd === 'AUTHORIZE' && data.evt !== 'ERROR') {\n              findEndpoint()\n                .then((endpoint) => {\n                  this.client.request.endpoint = endpoint;\n                })\n                .catch((e) => {\n                  this.client.emit('error', e);\n                });\n            }\n            this.emit('message', data);\n            break;\n          case OPCodes.CLOSE:\n            this.emit('close', data);\n            break;\n          default:\n            break;\n        }\n      });\n    });\n  }\n\n  onClose(e) {\n    this.emit('close', e);\n  }\n\n  send(data, op = OPCodes.FRAME) {\n    this.socket.write(encode(op, data));\n  }\n\n  async close() {\n    return new Promise((r) => {\n      this.once('close', r);\n      this.send({}, OPCodes.CLOSE);\n      this.socket.end();\n    });\n  }\n\n  ping() {\n    this.send(uuid(), OPCodes.PING);\n  }\n}\n\nmodule.exports = IPCTransport;\nmodule.exports.encode = encode;\nmodule.exports.decode = decode;\n","'use strict';\n\nfunction keyMirror(arr) {\n  const tmp = {};\n  for (const value of arr) {\n    tmp[value] = value;\n  }\n  return tmp;\n}\n\n\nexports.browser = typeof window !== 'undefined';\n\nexports.RPCCommands = keyMirror([\n  'DISPATCH',\n  'AUTHORIZE',\n  'AUTHENTICATE',\n  'GET_GUILD',\n  'GET_GUILDS',\n  'GET_CHANNEL',\n  'GET_CHANNELS',\n  'CREATE_CHANNEL_INVITE',\n  'GET_RELATIONSHIPS',\n  'GET_USER',\n  'SUBSCRIBE',\n  'UNSUBSCRIBE',\n  'SET_USER_VOICE_SETTINGS',\n  'SET_USER_VOICE_SETTINGS_2',\n  'SELECT_VOICE_CHANNEL',\n  'GET_SELECTED_VOICE_CHANNEL',\n  'SELECT_TEXT_CHANNEL',\n  'GET_VOICE_SETTINGS',\n  'SET_VOICE_SETTINGS_2',\n  'SET_VOICE_SETTINGS',\n  'CAPTURE_SHORTCUT',\n  'SET_ACTIVITY',\n  'SEND_ACTIVITY_JOIN_INVITE',\n  'CLOSE_ACTIVITY_JOIN_REQUEST',\n  'ACTIVITY_INVITE_USER',\n  'ACCEPT_ACTIVITY_INVITE',\n  'INVITE_BROWSER',\n  'DEEP_LINK',\n  'CONNECTIONS_CALLBACK',\n  'BRAINTREE_POPUP_BRIDGE_CALLBACK',\n  'GIFT_CODE_BROWSER',\n  'GUILD_TEMPLATE_BROWSER',\n  'OVERLAY',\n  'BROWSER_HANDOFF',\n  'SET_CERTIFIED_DEVICES',\n  'GET_IMAGE',\n  'CREATE_LOBBY',\n  'UPDATE_LOBBY',\n  'DELETE_LOBBY',\n  'UPDATE_LOBBY_MEMBER',\n  'CONNECT_TO_LOBBY',\n  'DISCONNECT_FROM_LOBBY',\n  'SEND_TO_LOBBY',\n  'SEARCH_LOBBIES',\n  'CONNECT_TO_LOBBY_VOICE',\n  'DISCONNECT_FROM_LOBBY_VOICE',\n  'SET_OVERLAY_LOCKED',\n  'OPEN_OVERLAY_ACTIVITY_INVITE',\n  'OPEN_OVERLAY_GUILD_INVITE',\n  'OPEN_OVERLAY_VOICE_SETTINGS',\n  'VALIDATE_APPLICATION',\n  'GET_ENTITLEMENT_TICKET',\n  'GET_APPLICATION_TICKET',\n  'START_PURCHASE',\n  'GET_SKUS',\n  'GET_ENTITLEMENTS',\n  'GET_NETWORKING_CONFIG',\n  'NETWORKING_SYSTEM_METRICS',\n  'NETWORKING_PEER_METRICS',\n  'NETWORKING_CREATE_TOKEN',\n  'SET_USER_ACHIEVEMENT',\n  'GET_USER_ACHIEVEMENTS',\n]);\n\nexports.RPCEvents = keyMirror([\n  'CURRENT_USER_UPDATE',\n  'GUILD_STATUS',\n  'GUILD_CREATE',\n  'CHANNEL_CREATE',\n  'RELATIONSHIP_UPDATE',\n  'VOICE_CHANNEL_SELECT',\n  'VOICE_STATE_CREATE',\n  'VOICE_STATE_DELETE',\n  'VOICE_STATE_UPDATE',\n  'VOICE_SETTINGS_UPDATE',\n  'VOICE_SETTINGS_UPDATE_2',\n  'VOICE_CONNECTION_STATUS',\n  'SPEAKING_START',\n  'SPEAKING_STOP',\n  'GAME_JOIN',\n  'GAME_SPECTATE',\n  'ACTIVITY_JOIN',\n  'ACTIVITY_JOIN_REQUEST',\n  'ACTIVITY_SPECTATE',\n  'ACTIVITY_INVITE',\n  'NOTIFICATION_CREATE',\n  'MESSAGE_CREATE',\n  'MESSAGE_UPDATE',\n  'MESSAGE_DELETE',\n  'LOBBY_DELETE',\n  'LOBBY_UPDATE',\n  'LOBBY_MEMBER_CONNECT',\n  'LOBBY_MEMBER_DISCONNECT',\n  'LOBBY_MEMBER_UPDATE',\n  'LOBBY_MESSAGE',\n  'CAPTURE_SHORTCUT_CHANGE',\n  'OVERLAY',\n  'OVERLAY_UPDATE',\n  'ENTITLEMENT_CREATE',\n  'ENTITLEMENT_DELETE',\n  'USER_ACHIEVEMENT_UPDATE',\n  'READY',\n  'ERROR',\n]);\n\nexports.RPCErrors = {\n  CAPTURE_SHORTCUT_ALREADY_LISTENING: 5004,\n  GET_GUILD_TIMED_OUT: 5002,\n  INVALID_ACTIVITY_JOIN_REQUEST: 4012,\n  INVALID_ACTIVITY_SECRET: 5005,\n  INVALID_CHANNEL: 4005,\n  INVALID_CLIENTID: 4007,\n  INVALID_COMMAND: 4002,\n  INVALID_ENTITLEMENT: 4015,\n  INVALID_EVENT: 4004,\n  INVALID_GIFT_CODE: 4016,\n  INVALID_GUILD: 4003,\n  INVALID_INVITE: 4011,\n  INVALID_LOBBY: 4013,\n  INVALID_LOBBY_SECRET: 4014,\n  INVALID_ORIGIN: 4008,\n  INVALID_PAYLOAD: 4000,\n  INVALID_PERMISSIONS: 4006,\n  INVALID_TOKEN: 4009,\n  INVALID_USER: 4010,\n  LOBBY_FULL: 5007,\n  NO_ELIGIBLE_ACTIVITY: 5006,\n  OAUTH2_ERROR: 5000,\n  PURCHASE_CANCELED: 5008,\n  PURCHASE_ERROR: 5009,\n  RATE_LIMITED: 5011,\n  SELECT_CHANNEL_TIMED_OUT: 5001,\n  SELECT_VOICE_FORCE_REQUIRED: 5003,\n  SERVICE_UNAVAILABLE: 1001,\n  TRANSACTION_ABORTED: 1002,\n  UNAUTHORIZED_FOR_ACHIEVEMENT: 5010,\n  UNKNOWN_ERROR: 1000,\n};\n\nexports.RPCCloseCodes = {\n  CLOSE_NORMAL: 1000,\n  CLOSE_UNSUPPORTED: 1003,\n  CLOSE_ABNORMAL: 1006,\n  INVALID_CLIENTID: 4000,\n  INVALID_ORIGIN: 4001,\n  RATELIMITED: 4002,\n  TOKEN_REVOKED: 4003,\n  INVALID_VERSION: 4004,\n  INVALID_ENCODING: 4005,\n};\n\nexports.LobbyTypes = {\n  PRIVATE: 1,\n  PUBLIC: 2,\n};\n\nexports.RelationshipTypes = {\n  NONE: 0,\n  FRIEND: 1,\n  BLOCKED: 2,\n  PENDING_INCOMING: 3,\n  PENDING_OUTGOING: 4,\n  IMPLICIT: 5,\n};\n","'use strict';\n\nconst EventEmitter = require('events');\nconst { browser } = require('../constants');\n\n// eslint-disable-next-line\nconst WebSocket = browser ? window.WebSocket : require('ws');\n\nconst pack = (d) => JSON.stringify(d);\nconst unpack = (s) => JSON.parse(s);\n\nclass WebSocketTransport extends EventEmitter {\n  constructor(client) {\n    super();\n    this.client = client;\n    this.ws = null;\n    this.tries = 0;\n  }\n\n  async connect() {\n    const port = 6463 + (this.tries % 10);\n    this.tries += 1;\n\n    this.ws = new WebSocket(\n      `ws://127.0.0.1:${port}/?v=1&client_id=${this.client.clientId}`,\n      browser ? undefined : { origin: this.client.options.origin },\n    );\n    this.ws.onopen = this.onOpen.bind(this);\n    this.ws.onclose = this.onClose.bind(this);\n    this.ws.onerror = this.onError.bind(this);\n    this.ws.onmessage = this.onMessage.bind(this);\n  }\n\n  onOpen() {\n    this.emit('open');\n  }\n\n  onClose(event) {\n    if (!event.wasClean) {\n      return;\n    }\n    this.emit('close', event);\n  }\n\n  onError(event) {\n    try {\n      this.ws.close();\n    } catch {} // eslint-disable-line no-empty\n\n    if (this.tries > 20) {\n      this.emit('error', event.error);\n    } else {\n      setTimeout(() => {\n        this.connect();\n      }, 250);\n    }\n  }\n\n  onMessage(event) {\n    this.emit('message', unpack(event.data));\n  }\n\n  send(data) {\n    this.ws.send(pack(data));\n  }\n\n  ping() {} // eslint-disable-line no-empty-function\n\n  close() {\n    return new Promise((r) => {\n      this.once('close', r);\n      this.ws.close();\n    });\n  }\n}\n\nmodule.exports = WebSocketTransport;\n","'use strict';\n\nmodule.exports = {\n  ipc: require('./ipc'),\n  websocket: require('./websocket'),\n};\n","'use strict';\n\nconst EventEmitter = require('events');\nconst { setTimeout, clearTimeout } = require('timers');\nconst fetch = require('node-fetch');\nconst transports = require('./transports');\nconst { RPCCommands, RPCEvents, RelationshipTypes } = require('./constants');\nconst { pid: getPid, uuid } = require('./util');\n\nfunction subKey(event, args) {\n  return `${event}${JSON.stringify(args)}`;\n}\n\n/**\n * @typedef {RPCClientOptions}\n * @extends {ClientOptions}\n * @prop {string} transport RPC transport. one of `ipc` or `websocket`\n */\n\n/**\n * The main hub for interacting with Discord RPC\n * @extends {BaseClient}\n */\nclass RPCClient extends EventEmitter {\n  /**\n   * @param {RPCClientOptions} [options] Options for the client.\n   * You must provide a transport\n   */\n  constructor(options = {}) {\n    super();\n\n    this.options = options;\n\n    this.accessToken = null;\n    this.clientId = null;\n\n    /**\n     * Application used in this client\n     * @type {?ClientApplication}\n     */\n    this.application = null;\n\n    /**\n     * User used in this application\n     * @type {?User}\n     */\n    this.user = null;\n\n    const Transport = transports[options.transport];\n    if (!Transport) {\n      throw new TypeError('RPC_INVALID_TRANSPORT', options.transport);\n    }\n\n    this.fetch = (method, path, { data, query } = {}) =>\n      fetch(`${this.fetch.endpoint}${path}${query ? new URLSearchParams(query) : ''}`, {\n        method,\n        body: data,\n        headers: {\n          Authorization: `Bearer ${this.accessToken}`,\n        },\n      }).then(async (r) => {\n        const body = await r.json();\n        if (!r.ok) {\n          const e = new Error(r.status);\n          e.body = body;\n          throw e;\n        }\n        return body;\n      });\n\n    this.fetch.endpoint = 'https://discord.com/api';\n\n    /**\n     * Raw transport userd\n     * @type {RPCTransport}\n     * @private\n     */\n    this.transport = new Transport(this);\n    this.transport.on('message', this._onRpcMessage.bind(this));\n\n    /**\n     * Map of nonces being expected from the transport\n     * @type {Map}\n     * @private\n     */\n    this._expecting = new Map();\n\n    /**\n     * Map of current subscriptions\n     * @type {Map}\n     * @private\n     */\n    this._subscriptions = new Map();\n\n    this._connectPromise = undefined;\n  }\n\n  /**\n   * Search and connect to RPC\n   */\n  connect(clientId) {\n    if (this._connectPromise) {\n      return this._connectPromise;\n    }\n    this._connectPromise = new Promise((resolve, reject) => {\n      this.clientId = clientId;\n      const timeout = setTimeout(() => reject(new Error('RPC_CONNECTION_TIMEOUT')), 10e3);\n      timeout.unref();\n      this.once('connected', () => {\n        clearTimeout(timeout);\n        resolve(this);\n      });\n      this.transport.once('close', () => {\n        this._expecting.forEach((e) => {\n          e.reject(new Error('connection closed'));\n        });\n        this.emit('disconnected');\n        reject(new Error('connection closed'));\n      });\n      this.transport.connect().catch(reject);\n    });\n    return this._connectPromise;\n  }\n\n  /**\n   * @typedef {RPCLoginOptions}\n   * @param {string} clientId Client ID\n   * @param {string} [clientSecret] Client secret\n   * @param {string} [accessToken] Access token\n   * @param {string} [rpcToken] RPC token\n   * @param {string} [tokenEndpoint] Token endpoint\n   * @param {string[]} [scopes] Scopes to authorize with\n   */\n\n  /**\n   * Performs authentication flow. Automatically calls Client#connect if needed.\n   * @param {RPCLoginOptions} options Options for authentication.\n   * At least one property must be provided to perform login.\n   * @example client.login({ clientId: '1234567', clientSecret: 'abcdef123' });\n   * @returns {Promise<RPCClient>}\n   */\n  async login(options = {}) {\n    let { clientId, accessToken } = options;\n    await this.connect(clientId);\n    if (!options.scopes) {\n      this.emit('ready');\n      return this;\n    }\n    if (!accessToken) {\n      accessToken = await this.authorize(options);\n    }\n    return this.authenticate(accessToken);\n  }\n\n  /**\n   * Request\n   * @param {string} cmd Command\n   * @param {Object} [args={}] Arguments\n   * @param {string} [evt] Event\n   * @returns {Promise}\n   * @private\n   */\n  request(cmd, args, evt) {\n    return new Promise((resolve, reject) => {\n      const nonce = uuid();\n      this.transport.send({ cmd, args, evt, nonce });\n      this._expecting.set(nonce, { resolve, reject });\n    });\n  }\n\n  /**\n   * Message handler\n   * @param {Object} message message\n   * @private\n   */\n  _onRpcMessage(message) {\n    if (message.cmd === RPCCommands.DISPATCH && message.evt === RPCEvents.READY) {\n      if (message.data.user) {\n        this.user = message.data.user;\n      }\n      this.emit('connected');\n    } else if (this._expecting.has(message.nonce)) {\n      const { resolve, reject } = this._expecting.get(message.nonce);\n      if (message.evt === 'ERROR') {\n        const e = new Error(message.data.message);\n        e.code = message.data.code;\n        e.data = message.data;\n        reject(e);\n      } else {\n        resolve(message.data);\n      }\n      this._expecting.delete(message.nonce);\n    } else {\n      const subid = subKey(message.evt, message.args);\n      if (!this._subscriptions.has(subid)) {\n        return;\n      }\n      this._subscriptions.get(subid)(message.data);\n    }\n  }\n\n  /**\n   * Authorize\n   * @param {Object} options options\n   * @returns {Promise}\n   * @private\n   */\n  async authorize({ scopes, clientSecret, rpcToken, redirectUri } = {}) {\n    if (clientSecret && rpcToken === true) {\n      const body = await this.fetch('POST', '/oauth2/token/rpc', {\n        data: new URLSearchParams({\n          client_id: this.clientId,\n          client_secret: clientSecret,\n        }),\n      });\n      rpcToken = body.rpc_token;\n    }\n\n    const { code } = await this.request('AUTHORIZE', {\n      scopes,\n      client_id: this.clientId,\n      rpc_token: rpcToken,\n    });\n\n    const response = await this.fetch('POST', '/oauth2/token', {\n      data: new URLSearchParams({\n        client_id: this.clientId,\n        client_secret: clientSecret,\n        code,\n        grant_type: 'authorization_code',\n        redirect_uri: redirectUri,\n      }),\n    });\n\n    return response.access_token;\n  }\n\n  /**\n   * Authenticate\n   * @param {string} accessToken access token\n   * @returns {Promise}\n   * @private\n   */\n  authenticate(accessToken) {\n    return this.request('AUTHENTICATE', { access_token: accessToken })\n      .then(({ application, user }) => {\n        this.accessToken = accessToken;\n        this.application = application;\n        this.user = user;\n        this.emit('ready');\n        return this;\n      });\n  }\n\n\n  /**\n   * Fetch a guild\n   * @param {Snowflake} id Guild ID\n   * @param {number} [timeout] Timeout request\n   * @returns {Promise<Guild>}\n   */\n  getGuild(id, timeout) {\n    return this.request(RPCCommands.GET_GUILD, { guild_id: id, timeout });\n  }\n\n  /**\n   * Fetch all guilds\n   * @param {number} [timeout] Timeout request\n   * @returns {Promise<Collection<Snowflake, Guild>>}\n   */\n  getGuilds(timeout) {\n    return this.request(RPCCommands.GET_GUILDS, { timeout });\n  }\n\n  /**\n   * Get a channel\n   * @param {Snowflake} id Channel ID\n   * @param {number} [timeout] Timeout request\n   * @returns {Promise<Channel>}\n   */\n  getChannel(id, timeout) {\n    return this.request(RPCCommands.GET_CHANNEL, { channel_id: id, timeout });\n  }\n\n  /**\n   * Get all channels\n   * @param {Snowflake} [id] Guild ID\n   * @param {number} [timeout] Timeout request\n   * @returns {Promise<Collection<Snowflake, Channel>>}\n   */\n  async getChannels(id, timeout) {\n    const { channels } = await this.request(RPCCommands.GET_CHANNELS, {\n      timeout,\n      guild_id: id,\n    });\n    return channels;\n  }\n\n  /**\n   * @typedef {CertifiedDevice}\n   * @prop {string} type One of `AUDIO_INPUT`, `AUDIO_OUTPUT`, `VIDEO_INPUT`\n   * @prop {string} uuid This device's Windows UUID\n   * @prop {object} vendor Vendor information\n   * @prop {string} vendor.name Vendor's name\n   * @prop {string} vendor.url Vendor's url\n   * @prop {object} model Model information\n   * @prop {string} model.name Model's name\n   * @prop {string} model.url Model's url\n   * @prop {string[]} related Array of related product's Windows UUIDs\n   * @prop {boolean} echoCancellation If the device has echo cancellation\n   * @prop {boolean} noiseSuppression If the device has noise suppression\n   * @prop {boolean} automaticGainControl If the device has automatic gain control\n   * @prop {boolean} hardwareMute If the device has a hardware mute\n   */\n\n  /**\n   * Tell discord which devices are certified\n   * @param {CertifiedDevice[]} devices Certified devices to send to discord\n   * @returns {Promise}\n   */\n  setCertifiedDevices(devices) {\n    return this.request(RPCCommands.SET_CERTIFIED_DEVICES, {\n      devices: devices.map((d) => ({\n        type: d.type,\n        id: d.uuid,\n        vendor: d.vendor,\n        model: d.model,\n        related: d.related,\n        echo_cancellation: d.echoCancellation,\n        noise_suppression: d.noiseSuppression,\n        automatic_gain_control: d.automaticGainControl,\n        hardware_mute: d.hardwareMute,\n      })),\n    });\n  }\n\n  /**\n   * @typedef {UserVoiceSettings}\n   * @prop {Snowflake} id ID of the user these settings apply to\n   * @prop {?Object} [pan] Pan settings, an object with `left` and `right` set between\n   * 0.0 and 1.0, inclusive\n   * @prop {?number} [volume=100] The volume\n   * @prop {bool} [mute] If the user is muted\n   */\n\n  /**\n   * Set the voice settings for a user, by id\n   * @param {Snowflake} id ID of the user to set\n   * @param {UserVoiceSettings} settings Settings\n   * @returns {Promise}\n   */\n  setUserVoiceSettings(id, settings) {\n    return this.request(RPCCommands.SET_USER_VOICE_SETTINGS, {\n      user_id: id,\n      pan: settings.pan,\n      mute: settings.mute,\n      volume: settings.volume,\n    });\n  }\n\n  /**\n   * Move the user to a voice channel\n   * @param {Snowflake} id ID of the voice channel\n   * @param {Object} [options] Options\n   * @param {number} [options.timeout] Timeout for the command\n   * @param {boolean} [options.force] Force this move. This should only be done if you\n   * have explicit permission from the user.\n   * @returns {Promise}\n   */\n  selectVoiceChannel(id, { timeout, force = false } = {}) {\n    return this.request(RPCCommands.SELECT_VOICE_CHANNEL, { channel_id: id, timeout, force });\n  }\n\n  /**\n   * Move the user to a text channel\n   * @param {Snowflake} id ID of the voice channel\n   * @param {Object} [options] Options\n   * @param {number} [options.timeout] Timeout for the command\n   * have explicit permission from the user.\n   * @returns {Promise}\n   */\n  selectTextChannel(id, { timeout } = {}) {\n    return this.request(RPCCommands.SELECT_TEXT_CHANNEL, { channel_id: id, timeout });\n  }\n\n  /**\n   * Get current voice settings\n   * @returns {Promise}\n   */\n  getVoiceSettings() {\n    return this.request(RPCCommands.GET_VOICE_SETTINGS)\n      .then((s) => ({\n        automaticGainControl: s.automatic_gain_control,\n        echoCancellation: s.echo_cancellation,\n        noiseSuppression: s.noise_suppression,\n        qos: s.qos,\n        silenceWarning: s.silence_warning,\n        deaf: s.deaf,\n        mute: s.mute,\n        input: {\n          availableDevices: s.input.available_devices,\n          device: s.input.device_id,\n          volume: s.input.volume,\n        },\n        output: {\n          availableDevices: s.output.available_devices,\n          device: s.output.device_id,\n          volume: s.output.volume,\n        },\n        mode: {\n          type: s.mode.type,\n          autoThreshold: s.mode.auto_threshold,\n          threshold: s.mode.threshold,\n          shortcut: s.mode.shortcut,\n          delay: s.mode.delay,\n        },\n      }));\n  }\n\n  /**\n   * Set current voice settings, overriding the current settings until this session disconnects.\n   * This also locks the settings for any other rpc sessions which may be connected.\n   * @param {Object} args Settings\n   * @returns {Promise}\n   */\n  setVoiceSettings(args) {\n    return this.request(RPCCommands.SET_VOICE_SETTINGS, {\n      automatic_gain_control: args.automaticGainControl,\n      echo_cancellation: args.echoCancellation,\n      noise_suppression: args.noiseSuppression,\n      qos: args.qos,\n      silence_warning: args.silenceWarning,\n      deaf: args.deaf,\n      mute: args.mute,\n      input: args.input ? {\n        device_id: args.input.device,\n        volume: args.input.volume,\n      } : undefined,\n      output: args.output ? {\n        device_id: args.output.device,\n        volume: args.output.volume,\n      } : undefined,\n      mode: args.mode ? {\n        mode: args.mode.type,\n        auto_threshold: args.mode.autoThreshold,\n        threshold: args.mode.threshold,\n        shortcut: args.mode.shortcut,\n        delay: args.mode.delay,\n      } : undefined,\n    });\n  }\n\n  /**\n   * Capture a shortcut using the client\n   * The callback takes (key, stop) where `stop` is a function that will stop capturing.\n   * This `stop` function must be called before disconnecting or else the user will have\n   * to restart their client.\n   * @param {Function} callback Callback handling keys\n   * @returns {Promise<Function>}\n   */\n  captureShortcut(callback) {\n    const subid = subKey(RPCEvents.CAPTURE_SHORTCUT_CHANGE);\n    const stop = () => {\n      this._subscriptions.delete(subid);\n      return this.request(RPCCommands.CAPTURE_SHORTCUT, { action: 'STOP' });\n    };\n    this._subscriptions.set(subid, ({ shortcut }) => {\n      callback(shortcut, stop);\n    });\n    return this.request(RPCCommands.CAPTURE_SHORTCUT, { action: 'START' })\n      .then(() => stop);\n  }\n\n  /**\n   * Sets the presence for the logged in user.\n   * @param {object} args The rich presence to pass.\n   * @param {number} [pid] The application's process ID. Defaults to the executing process' PID.\n   * @returns {Promise}\n   */\n  setActivity(args = {}, pid = getPid()) {\n    let timestamps;\n    let assets;\n    let party;\n    let secrets;\n    if (args.startTimestamp || args.endTimestamp) {\n      timestamps = {\n        start: args.startTimestamp,\n        end: args.endTimestamp,\n      };\n      if (timestamps.start instanceof Date) {\n        timestamps.start = Math.round(timestamps.start.getTime());\n      }\n      if (timestamps.end instanceof Date) {\n        timestamps.end = Math.round(timestamps.end.getTime());\n      }\n      if (timestamps.start > 2147483647000) {\n        throw new RangeError('timestamps.start must fit into a unix timestamp');\n      }\n      if (timestamps.end > 2147483647000) {\n        throw new RangeError('timestamps.end must fit into a unix timestamp');\n      }\n    }\n    if (\n      args.largeImageKey || args.largeImageText\n      || args.smallImageKey || args.smallImageText\n    ) {\n      assets = {\n        large_image: args.largeImageKey,\n        large_text: args.largeImageText,\n        small_image: args.smallImageKey,\n        small_text: args.smallImageText,\n      };\n    }\n    if (args.partySize || args.partyId || args.partyMax) {\n      party = { id: args.partyId };\n      if (args.partySize || args.partyMax) {\n        party.size = [args.partySize, args.partyMax];\n      }\n    }\n    if (args.matchSecret || args.joinSecret || args.spectateSecret) {\n      secrets = {\n        match: args.matchSecret,\n        join: args.joinSecret,\n        spectate: args.spectateSecret,\n      };\n    }\n\n    return this.request(RPCCommands.SET_ACTIVITY, {\n      pid,\n      activity: {\n        state: args.state,\n        details: args.details,\n        timestamps,\n        assets,\n        party,\n        secrets,\n        buttons: args.buttons,\n        instance: !!args.instance,\n      },\n    });\n  }\n\n  /**\n   * Clears the currently set presence, if any. This will hide the \"Playing X\" message\n   * displayed below the user's name.\n   * @param {number} [pid] The application's process ID. Defaults to the executing process' PID.\n   * @returns {Promise}\n   */\n  clearActivity(pid = getPid()) {\n    return this.request(RPCCommands.SET_ACTIVITY, {\n      pid,\n    });\n  }\n\n  /**\n   * Invite a user to join the game the RPC user is currently playing\n   * @param {User} user The user to invite\n   * @returns {Promise}\n   */\n  sendJoinInvite(user) {\n    return this.request(RPCCommands.SEND_ACTIVITY_JOIN_INVITE, {\n      user_id: user.id || user,\n    });\n  }\n\n  /**\n   * Request to join the game the user is playing\n   * @param {User} user The user whose game you want to request to join\n   * @returns {Promise}\n   */\n  sendJoinRequest(user) {\n    return this.request(RPCCommands.SEND_ACTIVITY_JOIN_REQUEST, {\n      user_id: user.id || user,\n    });\n  }\n\n  /**\n   * Reject a join request from a user\n   * @param {User} user The user whose request you wish to reject\n   * @returns {Promise}\n   */\n  closeJoinRequest(user) {\n    return this.request(RPCCommands.CLOSE_ACTIVITY_JOIN_REQUEST, {\n      user_id: user.id || user,\n    });\n  }\n\n  createLobby(type, capacity, metadata) {\n    return this.request(RPCCommands.CREATE_LOBBY, {\n      type,\n      capacity,\n      metadata,\n    });\n  }\n\n  updateLobby(lobby, { type, owner, capacity, metadata } = {}) {\n    return this.request(RPCCommands.UPDATE_LOBBY, {\n      id: lobby.id || lobby,\n      type,\n      owner_id: (owner && owner.id) || owner,\n      capacity,\n      metadata,\n    });\n  }\n\n  deleteLobby(lobby) {\n    return this.request(RPCCommands.DELETE_LOBBY, {\n      id: lobby.id || lobby,\n    });\n  }\n\n  connectToLobby(id, secret) {\n    return this.request(RPCCommands.CONNECT_TO_LOBBY, {\n      id,\n      secret,\n    });\n  }\n\n  sendToLobby(lobby, data) {\n    return this.request(RPCCommands.SEND_TO_LOBBY, {\n      id: lobby.id || lobby,\n      data,\n    });\n  }\n\n  disconnectFromLobby(lobby) {\n    return this.request(RPCCommands.DISCONNECT_FROM_LOBBY, {\n      id: lobby.id || lobby,\n    });\n  }\n\n  updateLobbyMember(lobby, user, metadata) {\n    return this.request(RPCCommands.UPDATE_LOBBY_MEMBER, {\n      lobby_id: lobby.id || lobby,\n      user_id: user.id || user,\n      metadata,\n    });\n  }\n\n  getRelationships() {\n    const types = Object.keys(RelationshipTypes);\n    return this.request(RPCCommands.GET_RELATIONSHIPS)\n      .then((o) => o.relationships.map((r) => ({\n        ...r,\n        type: types[r.type],\n      })));\n  }\n\n  /**\n   * Subscribe to an event\n   * @param {string} event Name of event e.g. `MESSAGE_CREATE`\n   * @param {Object} [args] Args for event e.g. `{ channel_id: '1234' }`\n   * @param {Function} callback Callback when an event for the subscription is triggered\n   * @returns {Promise<Object>}\n   */\n  subscribe(event, args, callback) {\n    if (!callback && typeof args === 'function') {\n      callback = args;\n      args = undefined;\n    }\n    return this.request(RPCCommands.SUBSCRIBE, args, event).then(() => {\n      const subid = subKey(event, args);\n      this._subscriptions.set(subid, callback);\n      return {\n        unsubscribe: () => this.request(RPCCommands.UNSUBSCRIBE, args, event)\n          .then(() => this._subscriptions.delete(subid)),\n      };\n    });\n  }\n\n  /**\n   * Destroy the client\n   */\n  async destroy() {\n    await this.transport.close();\n  }\n}\n\nmodule.exports = RPCClient;\n","'use strict';\n\nconst util = require('./util');\n\nmodule.exports = {\n  Client: require('./client'),\n  register(id) {\n    return util.register(`discord-${id}`);\n  },\n};\n","import { Notice } from \"obsidian\";\nimport ObsidianDiscordRPC from \"./main\";\n\nexport class Logger {\n  plugin: ObsidianDiscordRPC = (this as any).plugin;\n\n  log(message: string, showPopups: boolean): void {\n    if (showPopups) {\n      new Notice(message);\n    }\n\n    console.log(`discordrpc: ${message}`);\n  }\n\n  logIgnoreNoNotice(message: string): void {\n    new Notice(message);\n    console.log(`discordrpc: ${message}`);\n  }\n}\n","export class DiscordRPCSettings {\n  showVaultName: boolean = true;\n  showCurrentFileName: boolean = true;\n  showPopups: boolean = true;\n  customVaultName: string = \"\";\n  showFileExtension: boolean = false;\n  useLoadedTime: boolean = false;\n  connectOnStart: boolean = true;\n  autoHideStatusBar: boolean = true;\n}\n\nexport enum PluginState {\n  connected,\n  connecting,\n  disconnected,\n}\n","import { PluginSettingTab, Setting, TFile } from \"obsidian\";\nimport { Logger } from \"src/logger\";\nimport ObsidianDiscordRPC from \"src/main\";\n\nexport class DiscordRPCSettingsTab extends PluginSettingTab {\n  public logger: Logger = new Logger();\n\n  display(): void {\n    let { containerEl } = this;\n    const plugin: ObsidianDiscordRPC = (this as any).plugin;\n\n    containerEl.empty();\n    containerEl.createEl(\"h2\", { text: \"Discord Rich Presence Settings\" });\n\n    containerEl.createEl(\"h3\", { text: \"Vault Name Settings\" });\n    new Setting(containerEl)\n      .setName(\"Show Vault Name\")\n      .setDesc(\n        \"Enable this to show the name of the vault you are working with.\"\n      )\n      .addToggle((boolean) =>\n        boolean.setValue(plugin.settings.showVaultName).onChange((value) => {\n          plugin.settings.showVaultName = value;\n          plugin.saveData(plugin.settings);\n\n          if (boolean.getValue()) {\n            this.logger.logIgnoreNoNotice(\"Vault Name is now Visable\");\n          } else {\n            this.logger.logIgnoreNoNotice(\"Vault Name is no longer Visable\");\n          }\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Set Custom Vault Name\")\n      .setDesc(\n        \"Change the vault name shown publicly. Leave blank to use your actual vault name.\"\n      )\n      .addText((text) =>\n        text.setValue(plugin.settings.customVaultName).onChange((value) => {\n          plugin.settings.customVaultName = value;\n          plugin.saveData(plugin.settings);\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        })\n      );\n\n    containerEl.createEl(\"h3\", { text: \"File Name Settings\" });\n    new Setting(containerEl)\n      .setName(\"Show Current File Name\")\n      .setDesc(\"Enable this to show the name of the file you are working on.\")\n      .addToggle((boolean) =>\n        boolean\n          .setValue(plugin.settings.showCurrentFileName)\n          .onChange((value) => {\n            plugin.settings.showCurrentFileName = value;\n            plugin.saveData(plugin.settings);\n\n            if (boolean.getValue()) {\n              this.logger.logIgnoreNoNotice(\"File Name is now Visable\");\n            } else {\n              this.logger.logIgnoreNoNotice(\"File Name is no longer Visable\");\n            }\n\n            plugin.setActivity(\n              this.app.vault.getName(),\n              plugin.currentFile.basename,\n              plugin.currentFile.extension\n            );\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Show File Extension\")\n      .setDesc(\"Enable this to show file extension.\")\n      .addToggle((boolean) =>\n        boolean\n          .setValue(plugin.settings.showFileExtension)\n          .onChange((value) => {\n            plugin.settings.showFileExtension = value;\n            plugin.saveData(plugin.settings);\n\n            plugin.setActivity(\n              this.app.vault.getName(),\n              plugin.currentFile.basename,\n              plugin.currentFile.extension\n            );\n          })\n      );\n\n    containerEl.createEl(\"h3\", { text: \"Time Settings\" });\n    new Setting(containerEl)\n      .setName(\"Use Obsidian Total Time\")\n      .setDesc(\n        \"Enable to use the total time you have been using Obsidian, instead of the time spent editing a single file.\"\n      )\n      .addToggle((boolean) => {\n        boolean.setValue(plugin.settings.useLoadedTime).onChange((value) => {\n          plugin.settings.useLoadedTime = value;\n          plugin.saveData(plugin.settings);\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        });\n      });\n\n    containerEl.createEl(\"h3\", { text: \"Status Bar Settings\" });\n    new Setting(containerEl)\n      .setName(\"Automatically hide Status Bar\")\n      .setDesc(\n        \"Automatically hide status bar after successfully connecting to Discord.\"\n      )\n      .addToggle((boolean) => {\n        boolean.setValue(plugin.settings.autoHideStatusBar).onChange((value) => {\n          plugin.settings.autoHideStatusBar = value;\n          plugin.saveData(plugin.settings);\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        });\n      });\n\n    containerEl.createEl(\"h3\", { text: \"Startup Settings\" });\n    new Setting(containerEl)\n      .setName(\"Automatically Connect to Discord\")\n      .setDesc(\n        \"Automatically connect to Discord on startup. You can always click the status bar to manually connect.\"\n      )\n      .addToggle((boolean) => {\n        boolean.setValue(plugin.settings.connectOnStart).onChange((value) => {\n          plugin.settings.connectOnStart = value;\n          plugin.saveData(plugin.settings);\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        });\n      });\n\n    containerEl.createEl(\"h3\", { text: \"Notice Settings\" });\n    new Setting(containerEl)\n      .setName(\"Show Notices\")\n      .setDesc(\"Enable this to show connection Notices.\")\n      .addToggle((boolean) =>\n        boolean.setValue(plugin.settings.showPopups).onChange((value) => {\n          plugin.settings.showPopups = value;\n          plugin.saveData(plugin.settings);\n\n          if (boolean.getValue()) {\n            this.logger.logIgnoreNoNotice(\"Notices Enabled\");\n          } else {\n            this.logger.logIgnoreNoNotice(\"Notices Disabled\");\n          }\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        })\n      );\n  }\n}\n","import { PluginState } from \"./settings/settings\";\n\nexport class StatusBar {\n  private statusBarEl: HTMLElement;\n\n  constructor(statusBarEl: HTMLElement) {\n    this.statusBarEl = statusBarEl;\n  }\n\n  displayState(state: PluginState, autoHide: boolean) {\n    switch (state) {\n      case PluginState.connected:\n        this.displayConnected(autoHide ? 10000 : 0);\n        break;\n      case PluginState.connecting:\n        this.statusBarEl.setText(`Connecting to Discord...`);\n        break;\n      case PluginState.disconnected:\n        this.statusBarEl.setText(`\\u{1F5D8} Reconnect to Discord`);\n        break;\n    }\n  }\n\n  displayConnected(timeout: number) {\n    this.statusBarEl.setText(`\\u{1F30D} Connected to Discord`);\n\n    if (timeout && timeout > 0) {\n      window.setTimeout(() => {\n        this.statusBarEl.setText(\"\");\n      }, timeout);\n    } else {\n      window.setTimeout(() => {\n        this.statusBarEl.setText(`\\u{1F30D}`);\n      }, 5000);\n    }\n  }\n}\n","import { Client } from \"discord-rpc\";\r\nimport { Plugin, PluginManifest, TFile } from \"obsidian\";\r\nimport { Logger } from \"./logger\";\r\nimport { DiscordRPCSettings, PluginState } from \"./settings/settings\";\r\nimport { DiscordRPCSettingsTab } from \"./settings/settings-tab\";\r\nimport { StatusBar } from \"./status-bar\";\r\n\r\nexport default class ObsidianDiscordRPC extends Plugin {\r\n  public state: PluginState;\r\n  public settings: DiscordRPCSettings;\r\n  public statusBar: StatusBar;\r\n  public rpc: Client;\r\n  public logger: Logger = new Logger();\r\n  public currentFile: TFile;\r\n  public loadedTime: Date;\r\n\r\n  setState(state: PluginState) {\r\n    this.state = state;\r\n  }\r\n\r\n  getState(): PluginState {\r\n    return this.state;\r\n  }\r\n\r\n  public getApp(): any {\r\n    return this.app;\r\n  }\r\n\r\n  public getPluginManifest(): PluginManifest {\r\n    return this.manifest;\r\n  }\r\n\r\n  async onload() {\r\n    let statusBarEl = this.addStatusBarItem();\r\n    this.statusBar = new StatusBar(statusBarEl);\r\n\r\n    this.settings = (await this.loadData()) || new DiscordRPCSettings();\r\n\r\n    this.registerEvent(\r\n      this.app.workspace.on(\"file-open\", this.onFileOpen, this)\r\n    );\r\n\r\n    this.registerDomEvent(statusBarEl, \"click\", async () => {\r\n      if (this.getState() == PluginState.disconnected) {\r\n        await this.connectDiscord();\r\n      } else if (this.getState() == PluginState.connected){\r\n        await this.disconnectDiscord();\r\n      }\r\n    });\r\n\r\n    this.addSettingTab(new DiscordRPCSettingsTab(this.app, this));\r\n\r\n    this.addCommand({\r\n      id: \"reconnect-discord\",\r\n      name: \"Reconnect to Discord\",\r\n      callback: async () => await this.connectDiscord(),\r\n    });\r\n\r\n    this.addCommand({\r\n      id: \"disconnect-discord\",\r\n      name: \"Disconnect from Discord\",\r\n      callback: async () => await this.disconnectDiscord(),\r\n    })\r\n\r\n    if(this.settings.connectOnStart){\r\n      await this.connectDiscord();\r\n\r\n      let activeLeaf = this.app.workspace.activeLeaf;\r\n      let files: TFile[] = this.app.vault.getMarkdownFiles();\r\n\r\n      files.forEach((file) => {\r\n        if (file.basename === activeLeaf.getDisplayText()) {\r\n          this.onFileOpen(file);\r\n        }\r\n      });\r\n    } else {\r\n      this.setState(PluginState.disconnected);\r\n      this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar);\r\n    }\r\n    \r\n  }\r\n\r\n  async onFileOpen(file: TFile) {\r\n    this.currentFile = file;\r\n    if (this.getState() === PluginState.connected) {\r\n      await this.setActivity(\r\n        this.app.vault.getName(),\r\n        file.basename,\r\n        file.extension\r\n      );\r\n    }\r\n  }\r\n\r\n  async onunload() {\r\n    await this.saveData(this.settings);\r\n    this.rpc.clearActivity();\r\n    this.rpc.destroy();\r\n  }\r\n\r\n  async connectDiscord(): Promise<void> {\r\n    this.loadedTime = new Date();\r\n    \r\n    this.rpc = new Client({\r\n      transport: \"ipc\",\r\n    });\r\n\r\n    this.setState(PluginState.connecting);\r\n    this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar);\r\n\r\n    this.rpc.once(\"ready\", () => {\r\n      this.setState(PluginState.connected);\r\n      this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar);\r\n      this.logger.log(\"Connected to Discord\", this.settings.showPopups);\r\n    });\r\n\r\n    try {\r\n      await this.rpc.login({\r\n        clientId: \"763813185022197831\",\r\n      });\r\n      await this.setActivity(this.app.vault.getName(), \"...\", \"\");\r\n    } catch (error) {\r\n      this.setState(PluginState.disconnected);\r\n      this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar);\r\n      this.logger.log(\"Failed to connect to Discord\", this.settings.showPopups);\r\n    }\r\n  }\r\n\r\n  async disconnectDiscord(): Promise<void> {\r\n    this.rpc.clearActivity();\r\n    this.rpc.destroy();\r\n    this.setState(PluginState.disconnected);\r\n    this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar);\r\n    this.logger.log(\"Disconnected from Discord\", this.settings.showPopups);\r\n  }\r\n\r\n  async setActivity(\r\n    vaultName: string,\r\n    fileName: string,\r\n    fileExtension: string\r\n  ): Promise<void> {\r\n    if (this.getState() === PluginState.connected) {\r\n      let vault: string;\r\n      if (this.settings.customVaultName === \"\") {\r\n        vault = vaultName;\r\n      } else {\r\n        vault = this.settings.customVaultName;\r\n      }\r\n\r\n      let file: string;\r\n      if (this.settings.showFileExtension) {\r\n        file = fileName + \".\" + fileExtension;\r\n      } else {\r\n        file = fileName;\r\n      }\r\n\r\n      let date: Date;\r\n      if (this.settings.useLoadedTime) {\r\n        date = this.loadedTime;\r\n      } else {\r\n        date = new Date();\r\n      }\r\n\r\n      if (this.settings.showVaultName && this.settings.showCurrentFileName) {\r\n        await this.rpc.setActivity({\r\n          details: `Editing ${file}`,\r\n          state: `Vault: ${vault}`,\r\n          startTimestamp: date,\r\n          largeImageKey: \"logo\",\r\n          largeImageText: \"Obsidian\",\r\n        });\r\n      } else if (this.settings.showVaultName) {\r\n        await this.rpc.setActivity({\r\n          state: `Vault: ${vault}`,\r\n          startTimestamp: date,\r\n          largeImageKey: \"logo\",\r\n          largeImageText: \"Obsidian\",\r\n        });\r\n      } else if (this.settings.showCurrentFileName) {\r\n        await this.rpc.setActivity({\r\n          details: `Editing ${file}`,\r\n          startTimestamp: date,\r\n          largeImageKey: \"logo\",\r\n          largeImageText: \"Obsidian\",\r\n        });\r\n      } else {\r\n        await this.rpc.setActivity({\r\n          startTimestamp: date,\r\n          largeImageKey: \"logo\",\r\n          largeImageText: \"Obsidian\",\r\n        });\r\n      }\r\n    }\r\n  }\r\n}\r\n"],"names":["require$$0","uuid","net","fetch","EventEmitter","require$$1","setTimeout","require$$2","Notice","Setting","PluginSettingTab","Client","Plugin"],"mappings":"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"} diff --git a/.obsidian/plugins/obsidian-discordrpc/manifest.json b/.obsidian/plugins/obsidian-discordrpc/manifest.json new file mode 100644 index 0000000..3d17482 --- /dev/null +++ b/.obsidian/plugins/obsidian-discordrpc/manifest.json @@ -0,0 +1,9 @@ +{ + "id": "obsidian-discordrpc", + "name": "Discord Rich Presence", + "version": "1.5.0", + "description": "Update your Discord Status to show your friends what you are working on in Obsidian. With Discord Rich Presence.", + "author": "Luke Leppan", + "authorUrl": "https://lukeleppan.com", + "isDesktopOnly": false +} diff --git a/.obsidian/workspace b/.obsidian/workspace index ed7db43..9469083 100644 --- a/.obsidian/workspace +++ b/.obsidian/workspace @@ -4,12 +4,12 @@ "type": "split", "children": [ { - "id": "bc3b95f36f9e4d7b", + "id": "58828f807fb5587f", "type": "leaf", "state": { "type": "markdown", "state": { - "file": "README.md", + "file": "pages/Project Waku.md", "mode": "source", "backlinks": false, "source": false @@ -71,7 +71,7 @@ "state": { "type": "backlink", "state": { - "file": "README.md", + "file": "pages/Project Waku.md", "collapseAll": false, "extraContext": false, "sortOrder": "alphabetical", @@ -100,17 +100,17 @@ "width": 300, "collapsed": true }, - "active": "bc3b95f36f9e4d7b", + "active": "58828f807fb5587f", "lastOpenFiles": [ - "README.md", - "pages/README.md", - "pages/assets/Pasted image 20220523051608.png", - "pages/assets/Pasted image 20220520215517.png", - "pages/assets/Pasted image 20220523051208.png", - "pages/Start Here.md", - "pages/Logos Program.md", - "pages/Instructions.md", - "pages/Living Database.md", - "pages/BBA.md" + "pages/Project Waku.md", + "pages/Set of Implementations.md", + "pages/Network of Nodes.md", + "pages/Set of Protocols.md", + "pages/Recipes.md", + "pages/Project Logos.md", + "pages/Data Model and Concurrency.md", + "pages/Staking and Multi-DAG.md", + "pages/Mempool and Subnetworks.md", + "pages/Tokenomics.md" ] } \ No newline at end of file diff --git a/pages/3-sided Content Marketplace.md b/.trash/3-sided Content Marketplace.md similarity index 100% rename from pages/3-sided Content Marketplace.md rename to .trash/3-sided Content Marketplace.md diff --git a/pages/The Medium is the Message.md b/.trash/Agent.md similarity index 100% rename from pages/The Medium is the Message.md rename to .trash/Agent.md diff --git a/pages/The Status Network.md b/.trash/Community.md similarity index 100% rename from pages/The Status Network.md rename to .trash/Community.md diff --git a/pages/Round-less.md b/.trash/Round-less.md similarity index 100% rename from pages/Round-less.md rename to .trash/Round-less.md diff --git a/pages/Social Applications.md b/.trash/Social Applications.md similarity index 86% rename from pages/Social Applications.md rename to .trash/Social Applications.md index 55027c7..898b966 100644 --- a/pages/Social Applications.md +++ b/.trash/Social Applications.md @@ -7,7 +7,7 @@ dateUpdated: @today --- -# Topic: +# Topic: Social Applications #### Related: `ELI5 goes here` diff --git a/.trash/The Medium is the Message 2.md b/.trash/The Medium is the Message 2.md new file mode 100644 index 0000000..e69de29 diff --git a/.trash/The Medium is the Message 3.md b/.trash/The Medium is the Message 3.md new file mode 100644 index 0000000..e69de29 diff --git a/.trash/The Medium is the Message.md b/.trash/The Medium is the Message.md new file mode 100644 index 0000000..e69de29 diff --git a/.trash/The Status Network.md b/.trash/The Status Network.md new file mode 100644 index 0000000..e69de29 diff --git a/.trash/Topics 3.md b/.trash/Topics 3.md new file mode 100644 index 0000000..e69de29 diff --git a/pages/Verifiability.md b/.trash/Verifiability.md similarity index 100% rename from pages/Verifiability.md rename to .trash/Verifiability.md diff --git a/Templates/Recipe Template.md b/Templates/1. Recipe Template.md similarity index 100% rename from Templates/Recipe Template.md rename to Templates/1. Recipe Template.md diff --git a/Templates/2. Short Topic Template.md b/Templates/2. Short Topic Template.md new file mode 100644 index 0000000..a0acedc --- /dev/null +++ b/Templates/2. Short Topic Template.md @@ -0,0 +1,73 @@ +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: [Insert Topic] +## Chat: [Live Discussion] + +#### Tags: [Relevant Tags to Topic/Concept] see [[Tags]] + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +[What principle(s) are we trying to protect by innovating on this front? The solution that is aligned with the original Ethereum ethos to which Status is preserving ideological alignment with.] see [[Principles]] + +#### Implementation +- Description and Explanation + [Technical Why goes here. Systems that are very similar to us or are the current "best-in-class" that we are trying to improve upon for a given factor (define context-relevant network assumptions per phrase, ideally we'll come up with visual sliding bars to show complex relationships between increasing/decreasing factors and how we go from "research" assumptions to "production" engineering) and why?] +- Key Differences: + [Easy low-hanging fruit for marketing or communication that makes our implementation clearly different/better.] +- Additional Information: + [Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] + +--- + +FILL IN ABOVE TEMPLATE AND DELETE BELOW -OR- COPY PASTA BELOW AND DELETE ABOVE + +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: +## Chat: + +#### Tags: + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +N/A + +#### Implementation +- Description and Explanation + N/A +- Key Differences: + N/A +- Additional Information: + N/A diff --git a/Templates/Topic Template.md b/Templates/3. Long Topic Template.md similarity index 79% rename from Templates/Topic Template.md rename to Templates/3. Long Topic Template.md index 86e884c..a9b6493 100644 --- a/Templates/Topic Template.md +++ b/Templates/3. Long Topic Template.md @@ -3,7 +3,6 @@ title: author: dateCreated: {{date:YYYYMMDD}} dateUpdated: @today - --- # Topic: [Insert name] @@ -33,45 +32,4 @@ ELI5: Easy explainer for beginner. [Easy low-hanging fruit for marketing or communication that makes our implementation clearly different/better.] #### Knowledge Share: -[Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] - - - -*(Copy starting at the three hyphens below for a blank section template to use explain a new Topic)* - ---- - -title: -author: -dateCreated: @today -dateUpdated: @today - ---- - -# Topic: -#### Related: -`ELI5 goes here` - ---- - -## Overview - -#### Operating Definition: -[Definition here]1 - -#### Current "Standard" Implementation: - - -#### The Idea(l): - - -#### Logos Implementation: - - -#### Live Feedback: - - -#### IMPORTANT Differentiators: - - -#### Knowledge Share: \ No newline at end of file +[Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] \ No newline at end of file diff --git a/pages/BBA.md b/pages/BBA.md index 7f611f2..e2d0669 100644 --- a/pages/BBA.md +++ b/pages/BBA.md @@ -1,16 +1,20 @@ --- - -title: +title: author: -dateCreated: @today -dateUpdated: @today +dateCreated: +dateUpdated: 2022-05-23 +--- --- # Topic: Binary Byzantine Agreement (BBA) -#### Related: -`ELI5: Process of a distributed network coming to an agreement between two options OR the proposal, decision-making process, and eventual conclusion/convergence of a two-option Byzantine-contexted scenario. ` +## Chat: [Places for Live Discussion] +#### Tags: [[Tags]] + +``` +ELI5: Process of a distributed network coming to an agreement between two options OR the proposal, decision-making process, and eventual conclusion/convergence of a two-option Byzantine-contexted scenario. +``` --- ## Overview @@ -18,19 +22,88 @@ dateUpdated: @today #### Operating Definition: Binary byzantine consensus concerns the problem of getting a set of distinct processes distributed across a network to agree on a single binary value 0 or 1 where processes can fail in arbitrary ways.1 -#### Current "Standard" Implementation: +#### Principles +[What principle(s) are we trying to protect by innovating on this front? The solution that is aligned with the original Ethereum ethos to which Status is preserving ideological alignment with.] + +#### Implementation +- Description and Explanation + [Technical Why goes here. Systems that are very similar to us or are the current "best-in-class" that we are trying to improve upon for a given factor (define context-relevant network assumptions per phrase, ideally we'll come up with visual sliding bars to show complex relationships between increasing/decreasing factors and how we go from "research" assumptions to "production" engineering) and why?] +- Key Differences: + [Easy low-hanging fruit for marketing or communication that makes our implementation clearly different/better.] +- Additional Information: + [Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] + + +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: [Insert Topic] +## Chat: [Live Discussion] + +#### Tags: [Relevant Tags to Topic/Concept] see [[Tags]] + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +[What principle(s) are we trying to protect by innovating on this front? The solution that is aligned with the original Ethereum ethos to which Status is preserving ideological alignment with.] see [[Principles]] + +#### Implementation +- Description and Explanation + [Technical Why goes here. Systems that are very similar to us or are the current "best-in-class" that we are trying to improve upon for a given factor (define context-relevant network assumptions per phrase, ideally we'll come up with visual sliding bars to show complex relationships between increasing/decreasing factors and how we go from "research" assumptions to "production" engineering) and why?] +- Key Differences: + [Easy low-hanging fruit for marketing or communication that makes our implementation clearly different/better.] +- Additional Information: + [Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] + +--- + +FILL IN ABOVE TEMPLATE AND DELETE BELOW -OR- COPY PASTA BELOW AND DELETE ABOVE + +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: +## Chat: + +#### Tags: + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles N/A -#### The Idea(l): -N/A - -#### Logos Implementation: -Glacier - -#### Live Feedback: - -#### IMPORTANT Differentiators: -N/A - -#### Knowledge Share: -N/A \ No newline at end of file +#### Implementation +- Description and Explanation + N/A +- Key Differences: + N/A +- Additional Information: + N/A diff --git a/pages/Consensus.md b/pages/Consensus.md index 77eca07..b2bca1b 100644 --- a/pages/Consensus.md +++ b/pages/Consensus.md @@ -1,6 +1,9 @@ -# Consensus +--- +dateUpdated: 2022-05-24 +--- -### Related: +# Consensus +A list of Topics necessary to develop better intuition and understanding - Recipe: [[BBA]] - Prep: [|| ] @@ -32,12 +35,12 @@ - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://www.geeksforgeeks.org/message-passing-model-of-process-communication/ - Recipe: [[Gossip Protocol]] (is a subset of P2P Messaging) - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. https://en.wikipedia.org/wiki/Gossip_protocol#:~:text=A%20gossip%20protocol%20or%20epidemic,all%20members%20of%20a%20group. + 1. https://en.wikipedia.org/wiki/Gossip_protocol#:~:text=A%20gossip%20protocol%20or%20epidemic,all%20members%20of%20a%20group - Recipe: [[Permissionless]] - Prep: [||||||||||] - Cook Time: X min @@ -108,148 +111,166 @@ - Cook Time: X min - Ingredients: 1. https://medium.com/mechanism-labs/finality-in-blockchain-consensus-d1f83c120a9a5 -- Recipe: [[Social Applications]] (look up context) - - Prep: [||||||||||] - - Cook Time: X min - - Ingredients: - 1. - Recipe: [[Bootstrapping]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. https://en.wikipedia.org/wiki/Bootstrapping_node#:~:text=A%20bootstrapping%20node%2C%20also%20known,successfully%20join%20the%20overlay%20network. -- Recipe: [[Rounds]] + 1. https://en.wikipedia.org/wiki/Bootstrapping_node#:~:text=A%20bootstrapping%20node%2C%20also%20known,successfully%20join%20the%20overlay%20network +- Recipe: [[Rounds]] (Communication) - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. -- Recipe: [[Round-less]] - - Prep: [||||||||||] - - Cook Time: X min - - Ingredients: - 1. + 1. https://cseweb.ucsd.edu/~marzullo/pubs/harary.pdf + 2. https://research.cs.cornell.edu/projects/Quicksilver/public_pdfs/2007PromiseAndLimitations.pdf + 3. https://en.wikipedia.org/wiki/Gossip_protocol - Recipe: [[Paxos]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://lamport.azurewebsites.net/pubs/paxos-simple.pdf - Recipe: [[DAG-Based Consensus]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. https://www.sciencedirect.com/science/article/pii/S2352864819301476 -- Recipe: [[Liveness]] +- Recipe: [[Safety vs Liveness]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://dl.acm.org/doi/pdf/10.1145/42282.42283 (Partial Synchrony) + 2. https://www.scs.stanford.edu/~dm/blog/safety-vs-liveness.html + 3. https://medium.com/codechain/safety-and-liveness-blockchain-in-the-point-of-view-of-flp-impossibility-182e33927ce6 + 4. https://en.wikipedia.org/wiki/Thread_safety + 5. https://blog.blockstack.org/blockchains-and-consensus-protocols-liveness-and-correctness-are-inseparable/ - Recipe: [[Asynchronous (P2P)]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. http://infolab.stanford.edu/~burback/dadl/node93.html#:~:text=In%20a%20distributed%20system%2C%20communication,others%20have%20slower%20clock%20cycles. + 2. https://arxiv.org/pdf/2102.06804.pdf + 3. https://dl.acm.org/doi/10.1145/3149.214121 - Recipe: [[Execution-Layer Decoupling]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://subscription.packtpub.com/book/data/9781789804164/1/ch01lvl1sec07/layered-structure-of-the-blockchain-architecture#:~:text=For%20these%20applications%2C%20blockchain%20network,and%20rules%20that%20are%20executed + 2. https://cointelegraph.com/blockchain-for-beginners/a-beginners-guide-to-understanding-the-layers-of-blockchain-technology + 3. https://www.techopedia.com/definition/16907/decoupled-architecture - Recipe: [[Interchangeability]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. -- Recipe: [[Liveness]] + 1. https://arxiv.org/pdf/2005.14282.pdf +- Recipe: [[Distributed Systems]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. https://link.springer.com/article/10.1007/s00607-016-0508-7 +- Recipe: [[Safety vs Liveness]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://dl.acm.org/doi/10.1145/3149.214121 + 2. https://www.doc.ic.ac.uk/~jnm/book/firstbook/pdf/ch7.pdf - Recipe: [[Extensibility]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://www.semanticscholar.org/paper/An-Extensible-Consensus-Algorithm-Based-on-PBFT-Li-Wang/8b07a6c6efa551ac6531bf2f79c9010d53fff742 + 2. https://arxiv.org/pdf/2008.09518.pdf + 3. https://www.frontiersin.org/articles/10.3389/fbloc.2020.00028/full - Recipe: [[Highly-Partitioned Blockchains with Local Views]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://arxiv.org/pdf/1804.07356.pdf + 2. https://www.comp.nus.edu.sg/~hobor/Publications/2021/OverlayChain.pdf + 3. https://etd.ohiolink.edu/apexprod/rws_etd/send_file/send?accession=ksuhonors1588372348886683&disposition=inline - Recipe: [[Ordering]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://courses.grainger.illinois.edu/ece598pv/sp2021/lectureslides2021/ECE_598_PV_course_notes13.pdf - Recipe: [[Reputation]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://robertgreenfieldiv.medium.com/reputation-on-the-blockchain-624947b36897 - Recipe: [[Confidence]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.258.9605&rep=rep1&type=pdf + 2. https://www.robgjansen.com/publications/fet-csci5271.pdf + 3. https://rtg.cis.upenn.edu/qtm/doc/p2p_reputation.pdf - Recipe: [[Network Congestion]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://en.wikipedia.org/wiki/Network_congestion + 2. https://en.wikipedia.org/wiki/Network_scheduler - Recipe: [[Topology]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://dl.acm.org/doi/fullHtml/10.1145/3441692 - Recipe: [[Resilience (Consensus context)]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. -- Recipe: [[Verifiability]] - - Prep: [||||||||||] - - Cook Time: X min - - Ingredients: - 1. + 1. https://dl.acm.org/doi/abs/10.1145/800221.806706 - Recipe: [[Non-Repudiation]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://www.cryptomathic.com/products/authentication-signing/digital-signatures-faqs/what-is-non-repudiation + 2. https://jwcn-eurasipjournals.springeropen.com/articles/10.1186/s13638-020-01665-w#:~:text=In%20blockchain%2C%20the%20non%2Drepudiation,information%20receiver%20cannot%20be%20denied. - Recipe: [[Snowball]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://assets.website-files.com/5d80307810123f5ffbb34d6e/6009805681b416f34dcae012_Avalanche%20Consensus%20Whitepaper.pdf - Recipe: [[Lachesis]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://arxiv.org/abs/2108.01900 + 2. https://fantom.foundation/blog/a-brief-intro-to-lachesis-consensus-engine/ + 3. https://www.fantom.foundation/lachesis-consensus-algorithm/ - Recipe: [[Glacier]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://www.notion.so/Consensus-cca3f5b9bed341219d1cfd027bea897c#3bd35a9a31624bec95d711141cacb77b - Recipe: [[PoW]] (Proof of Work) - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://en.wikipedia.org/wiki/Proof_of_work - Recipe: [[PoS]] (Proof of Stake) - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://ethereum.org/en/developers/docs/consensus-mechanisms/pos/ - Recipe: [[Classical Consensus]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://dzone.com/articles/evolution-of-consensus-mechanisms-from-classical-m + 2. https://docs.thundercore.com/consensus-protocols-101.pdf - Recipe: [[Nakamoto Consensus]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://eprint.iacr.org/2019/943.pdf + 2. https://docs.thundercore.com/consensus-protocols-101.pdf - Recipe: [[DAG-Based Consensus]] (Avalanche-Like) - Prep: [||||||||||] - Cook Time: X min - Ingredients: - 1. + 1. https://arxiv.org/pdf/2012.06128.pdf + 2. https://www.sciencedirect.com/science/article/pii/S2352864819301476 + 3. https://assets.ctfassets.net/r1dr6vzfxhev/2t4uxvsIqk0EUau6g2sw0g/45eae33637ca92f85dd9f4a3a218e1ec/iota1_4_3.pdf + 4. https://domschiener.gitbooks.io/iota-guide/content/chapter1/current-role-of-the-coordinator.html + 5. https://tokens-economy.gitbook.io/consensus/chain-based-dag/direct-acyclic-graph-tangle-dag#:~:text=Tangle%20is%20the%20DAG%20consensus,are%20added%20to%20the%20Tangle. + 6. https://docs.thundercore.com/consensus-protocols-101.pdf diff --git a/pages/DAG Bootstrapping.md b/pages/DAG Bootstrapping.md new file mode 100644 index 0000000..a0acedc --- /dev/null +++ b/pages/DAG Bootstrapping.md @@ -0,0 +1,73 @@ +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: [Insert Topic] +## Chat: [Live Discussion] + +#### Tags: [Relevant Tags to Topic/Concept] see [[Tags]] + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +[What principle(s) are we trying to protect by innovating on this front? The solution that is aligned with the original Ethereum ethos to which Status is preserving ideological alignment with.] see [[Principles]] + +#### Implementation +- Description and Explanation + [Technical Why goes here. Systems that are very similar to us or are the current "best-in-class" that we are trying to improve upon for a given factor (define context-relevant network assumptions per phrase, ideally we'll come up with visual sliding bars to show complex relationships between increasing/decreasing factors and how we go from "research" assumptions to "production" engineering) and why?] +- Key Differences: + [Easy low-hanging fruit for marketing or communication that makes our implementation clearly different/better.] +- Additional Information: + [Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] + +--- + +FILL IN ABOVE TEMPLATE AND DELETE BELOW -OR- COPY PASTA BELOW AND DELETE ABOVE + +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: +## Chat: + +#### Tags: + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +N/A + +#### Implementation +- Description and Explanation + N/A +- Key Differences: + N/A +- Additional Information: + N/A diff --git a/pages/DAG Communication.md b/pages/DAG Communication.md new file mode 100644 index 0000000..efd15e6 --- /dev/null +++ b/pages/DAG Communication.md @@ -0,0 +1,64 @@ +--- +dateUpdated: 2022-05-24 +--- + +# DAG Communication +A list of Topics necessary to develop better intuition and understanding + +- Recipe: [[Factory of DAGs]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. + - Concept + - Algorithm +- Recipe: [[Sub-DAG]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. +- Recipe: [[Cross-DAG]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: [[Application-Level User-Driven]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: [[Direct Communication Channel]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: [[Direct Communication VGER]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: [[]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: Topic + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: Topic + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: Topic + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: Topic + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] diff --git a/pages/Data Model and Concurrency.md b/pages/Data Model and Concurrency.md index 85585c3..3b77804 100644 --- a/pages/Data Model and Concurrency.md +++ b/pages/Data Model and Concurrency.md @@ -1,6 +1,9 @@ -# Data Model and Concurrency +--- +dateUpdated: 2022-05-24 +--- -### Related: +# Data Model and Concurrency +A list of Topics necessary to develop better intuition and understanding - Reference Work - [[eUTXO]] (Direct extension of the basic UTXO model) diff --git a/pages/Decentralized Storage.md b/pages/Decentralized Storage.md new file mode 100644 index 0000000..f5bda3e --- /dev/null +++ b/pages/Decentralized Storage.md @@ -0,0 +1,2 @@ +# Decentralized Storage +A list of Topics necessary to develop better intuition and understanding \ No newline at end of file diff --git a/pages/Dispersal.md b/pages/Dispersal.md new file mode 100644 index 0000000..bfa1ef8 --- /dev/null +++ b/pages/Dispersal.md @@ -0,0 +1,2 @@ +# Dispersal +A list of Topics necessary to develop better intuition and understanding \ No newline at end of file diff --git a/pages/Distributed Systems.md b/pages/Distributed Systems.md new file mode 100644 index 0000000..a0acedc --- /dev/null +++ b/pages/Distributed Systems.md @@ -0,0 +1,73 @@ +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: [Insert Topic] +## Chat: [Live Discussion] + +#### Tags: [Relevant Tags to Topic/Concept] see [[Tags]] + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +[What principle(s) are we trying to protect by innovating on this front? The solution that is aligned with the original Ethereum ethos to which Status is preserving ideological alignment with.] see [[Principles]] + +#### Implementation +- Description and Explanation + [Technical Why goes here. Systems that are very similar to us or are the current "best-in-class" that we are trying to improve upon for a given factor (define context-relevant network assumptions per phrase, ideally we'll come up with visual sliding bars to show complex relationships between increasing/decreasing factors and how we go from "research" assumptions to "production" engineering) and why?] +- Key Differences: + [Easy low-hanging fruit for marketing or communication that makes our implementation clearly different/better.] +- Additional Information: + [Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] + +--- + +FILL IN ABOVE TEMPLATE AND DELETE BELOW -OR- COPY PASTA BELOW AND DELETE ABOVE + +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: +## Chat: + +#### Tags: + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +N/A + +#### Implementation +- Description and Explanation + N/A +- Key Differences: + N/A +- Additional Information: + N/A diff --git a/pages/Incentives.md b/pages/Incentives.md new file mode 100644 index 0000000..24d52a5 --- /dev/null +++ b/pages/Incentives.md @@ -0,0 +1,2 @@ +# Incentives +A list of Topics necessary to develop better intuition and understanding \ No newline at end of file diff --git a/pages/Leaderless.md b/pages/Leaderless.md index a1c8bde..aece6a2 100644 --- a/pages/Leaderless.md +++ b/pages/Leaderless.md @@ -3,8 +3,8 @@ title: author: -dateCreated: @today -dateUpdated: @today +dateCreated: +dateUpdated: 2022-05-23 --- diff --git a/pages/Liveness.md b/pages/Liveness.md deleted file mode 100644 index 55027c7..0000000 --- a/pages/Liveness.md +++ /dev/null @@ -1,36 +0,0 @@ ---- - -title: -author: -dateCreated: @today -dateUpdated: @today - ---- - -# Topic: -#### Related: -`ELI5 goes here` - ---- - -## Overview - -#### Operating Definition: -[Definition here]1 - -#### Current "Standard" Implementation: - - -#### The Idea(l): - - -#### Logos Implementation: - - -#### Live Feedback: - - -#### IMPORTANT Differentiators: - - -#### Knowledge Share: \ No newline at end of file diff --git a/pages/Living Database.md b/pages/Living Database.md index 5ce6122..2a47061 100644 --- a/pages/Living Database.md +++ b/pages/Living Database.md @@ -1,5 +1,7 @@ # Living Database +a description of what this can mean is found below -Building a “living database” for human-machine intelligence analysis -https://c4i.gmu.edu/~pcosta/F15/data/fileserver/file/472065/filename/Paper_1570111241.pdf \ No newline at end of file +https://c4i.gmu.edu/~pcosta/F15/data/fileserver/file/472065/filename/Paper_1570111241.pdf - Building a “living database” for human-machine intelligence analysis + +https://en.wikipedia.org/wiki/Controlled_natural_language \ No newline at end of file diff --git a/pages/Logos Program.md b/pages/Logos Program.md index eff4c17..fd5ce3c 100644 --- a/pages/Logos Program.md +++ b/pages/Logos Program.md @@ -1,8 +1,8 @@ --- title: Logos Program author: -dateCreated: @today -dateUpdated: @today 2022-05-07 +dateCreated: 2022-05-07 +dateUpdated: 2022-05-23 --- # Logos Program @@ -28,8 +28,8 @@ to [[Add New Topic]] or [[Edit an Existing Topic]] in the notebook ## Project Directory is a list of Projects involved in the Logos Program -### [[Project Logos]] ### [[Project Codex]] +### [[Project Logos]] ### [[Project Waku]] --- diff --git a/pages/Low Node Count Consensus.md b/pages/Low Node Count Consensus.md new file mode 100644 index 0000000..a0acedc --- /dev/null +++ b/pages/Low Node Count Consensus.md @@ -0,0 +1,73 @@ +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: [Insert Topic] +## Chat: [Live Discussion] + +#### Tags: [Relevant Tags to Topic/Concept] see [[Tags]] + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +[What principle(s) are we trying to protect by innovating on this front? The solution that is aligned with the original Ethereum ethos to which Status is preserving ideological alignment with.] see [[Principles]] + +#### Implementation +- Description and Explanation + [Technical Why goes here. Systems that are very similar to us or are the current "best-in-class" that we are trying to improve upon for a given factor (define context-relevant network assumptions per phrase, ideally we'll come up with visual sliding bars to show complex relationships between increasing/decreasing factors and how we go from "research" assumptions to "production" engineering) and why?] +- Key Differences: + [Easy low-hanging fruit for marketing or communication that makes our implementation clearly different/better.] +- Additional Information: + [Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] + +--- + +FILL IN ABOVE TEMPLATE AND DELETE BELOW -OR- COPY PASTA BELOW AND DELETE ABOVE + +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: +## Chat: + +#### Tags: + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +N/A + +#### Implementation +- Description and Explanation + N/A +- Key Differences: + N/A +- Additional Information: + N/A diff --git a/pages/Mempool Construction.md b/pages/Mempool Construction.md new file mode 100644 index 0000000..e69de29 diff --git a/pages/Mempool and Subnetworks.md b/pages/Mempool and Subnetworks.md new file mode 100644 index 0000000..1e8fec0 --- /dev/null +++ b/pages/Mempool and Subnetworks.md @@ -0,0 +1,27 @@ +--- +dateUpdated: 2022-05-24 +--- + +# Mempool and Subnetworks +A list of Topics necessary to develop better intuition and understanding + +- Recipe: [[Censorship-Resistant]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: [[Mempool Construction]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: [[Traditional Sharding]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] +- Recipe: [[Subnetwork Assignation Algorithm]] + - Prep: [||||||||||] + - Cook Time: X min + - Ingredients: + 1. [Insert pictures, videos, article links, research papers, etc.] diff --git a/pages/Network Layer and Mempool.md b/pages/Network Layer.md similarity index 56% rename from pages/Network Layer and Mempool.md rename to pages/Network Layer.md index 2d10115..6bfdeb8 100644 --- a/pages/Network Layer and Mempool.md +++ b/pages/Network Layer.md @@ -1,20 +1,15 @@ -# Network Layer and Mempool +--- +dateUpdated: 2022-05-24 +--- -### Related: +# Network Layer +A list of Topics necessary to develop better intuition and understanding - [[Node Discovery]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. -- [[Subnetworks]] - - Prep: [||||||||||] - - Cook Time: X min - - Ingredients: - 1. - - Design - - Implementation - - Ideas - [[Mempool]] - Prep: [||||||||||] - Cook Time: X min diff --git a/pages/Network of Nodes.md b/pages/Network of Nodes.md index 0412b21..aaef84f 100644 --- a/pages/Network of Nodes.md +++ b/pages/Network of Nodes.md @@ -1,3 +1,7 @@ +--- +dateUpdated: 2022-05-24 +--- + # Network of Nodes ## The Waku Network diff --git a/pages/New SubDAG Creation.md b/pages/New SubDAG Creation.md new file mode 100644 index 0000000..a0acedc --- /dev/null +++ b/pages/New SubDAG Creation.md @@ -0,0 +1,73 @@ +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: [Insert Topic] +## Chat: [Live Discussion] + +#### Tags: [Relevant Tags to Topic/Concept] see [[Tags]] + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +[What principle(s) are we trying to protect by innovating on this front? The solution that is aligned with the original Ethereum ethos to which Status is preserving ideological alignment with.] see [[Principles]] + +#### Implementation +- Description and Explanation + [Technical Why goes here. Systems that are very similar to us or are the current "best-in-class" that we are trying to improve upon for a given factor (define context-relevant network assumptions per phrase, ideally we'll come up with visual sliding bars to show complex relationships between increasing/decreasing factors and how we go from "research" assumptions to "production" engineering) and why?] +- Key Differences: + [Easy low-hanging fruit for marketing or communication that makes our implementation clearly different/better.] +- Additional Information: + [Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] + +--- + +FILL IN ABOVE TEMPLATE AND DELETE BELOW -OR- COPY PASTA BELOW AND DELETE ABOVE + +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: +## Chat: + +#### Tags: + +``` +ELI5: Simple explainer. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +N/A + +#### Implementation +- Description and Explanation + N/A +- Key Differences: + N/A +- Additional Information: + N/A diff --git a/pages/Node Reputation.md b/pages/Node Reputation.md index 8cf9dcc..a142ab1 100644 --- a/pages/Node Reputation.md +++ b/pages/Node Reputation.md @@ -1,6 +1,9 @@ -# Node Reputation +--- +dateUpdated: 2022-05-24 +--- -### Related: +# Node Reputation +A list of Topics necessary to develop better intuition and understanding - [[Ikingut (Reputation Algorithm)]] - Prep: [||||||||||] diff --git a/pages/Principles.md b/pages/Principles.md new file mode 100644 index 0000000..5b9181c --- /dev/null +++ b/pages/Principles.md @@ -0,0 +1,32 @@ +# Our Principles + +I. Liberty +We believe in the sovereignty of individuals. As a platform that stands for the cause of personal liberty, we aim to maximize social, political, and economic freedoms. This includes being coercion-resistant. + +II. Censorship resistance +We enable free flow of information. No content is under surveillance. We abide by the cryptoeconomic design principle of censorship resistance. Even stronger, Status is an agnostic platform for information. + +III. Security +We don't compromise on security when building features. We use state-of-the-art technologies, and research new security methods and technologies to make strong security guarantees. + +IV. Privacy +Privacy is the power to selectively reveal oneself to the world. For us, it's essential to protect privacy in both communications and transactions, as well as being a pseudo-anonymous platform. Additionally, we strive to provide the right of total anonymity. + +V. Transparency +We strive for complete openness and symmetry of information within the organization, and have no border between our core contributors and our community. We are frank about our shortcomings, especially when making short-term tradeoffs in service of our long-term goals. + +VI. Openness +The software we create is a public good. It is made available via a free and open source license, for anyone to share, modify and benefit from. We believe in permission-less participation. + +VII. Decentralization +We minimize centralization across both the software and the organization itself. In other words, we maximize the number of physical computers composing the network, and maximize the number of individuals who have control over the system(s) we are building. + +VIII. Inclusivity +We believe in fair and widespread access to our software, with an emphasis on ease-of-use. This also extends to social inclusivity, permissionless participation, interoperability, and investing in educational efforts. + +IX. Continuance +We create software incentivized to continue to exist and improve, without the stewardship of a single entity or any of the current team members. + +X. Resourcefulness +We are relentlessly resourceful. As we grow and have ready access to capital, it is our obligation to token holders to fight bureaucracy and inefficiencies within the organization. This means solving problems in the most effective way possible at lower economic costs (in terms of capital, time and resources). + diff --git a/pages/Project Codex.md b/pages/Project Codex.md index 5477ae8..e65d933 100644 --- a/pages/Project Codex.md +++ b/pages/Project Codex.md @@ -1,8 +1,8 @@ --- title: Understanding Codex Efforts author: -dateCreated: @today -dateUpdated: @today 2022-05-07 +dateCreated: 2022-05-07 +dateUpdated: 2022-05-23 --- # Understanding Codex Efforts @@ -18,16 +18,20 @@ Dmitriy Ryajov ## Necessary Terminology -### Decentralized Storage -### Durability -### Redundancy -### Dispersal (FT or ) -### Incentives -### Remote Auditing +### The Six (6) Technology Layers of Codex as a [insert here | Decentralized Storage Solution?] -FT -> +#### 1. [[Decentralized Storage]] +#### 2. [[Durability]] +#### 3. [[Redundancy]] +#### 4. [[Dispersal]] +#### 5. [[Incentives]] +#### 6. [[Remote Auditing]] + +Comments (Leo's comments re: organization of High-Level Categories) +FT -> ??? BFT -> Incentives + Remote Auditing +### Unsorted Pages: [[storage]] [[data]] [[durability]] diff --git a/pages/Project Logos.md b/pages/Project Logos.md index 7b5e4b5..1c3d79b 100644 --- a/pages/Project Logos.md +++ b/pages/Project Logos.md @@ -1,8 +1,8 @@ --- title: Understanding the Logos Blockchain Whitepaper | A High-Level Conceptual Review of the Logos Blockchain author: -dateCreated: @today -dateUpdated: @today 2022-05-07 +dateCreated: 2022-05-07 +dateUpdated: 2022-05-24 --- # Understanding the Logos Blockchain Whitepaper @@ -15,11 +15,14 @@ This document reflects an approach of whitepaper review that combines a rough-dr ## Necessary Terminology by Layer -### The Six (6) Technology Layers of Logos as a Blockchain +### The Nine (9) High-Level Categories of Logos as a Blockchain #### 1. [[Consensus]] #### 2. [[Node Reputation]] -#### 3. [[Network Layer and Mempool]] -#### 4. [[Staking and Multi-DAG]] -#### 5. [[Data Model and Concurrency]] -#### 6. [[Tokenomics]] +#### 3. [[Network Layer]] +#### 4. [[Mempool and Subnetworks]] +#### 5. [[Staking and Multi-DAG]] +#### 6. [[Data Model and Concurrency]] +#### 7. [[DAG Communication]] +#### 8. [[Bootstrapping or Factory]] +#### 9. [[Tokenomics]] diff --git a/pages/Project Waku.md b/pages/Project Waku.md index d140659..dda7bd0 100644 --- a/pages/Project Waku.md +++ b/pages/Project Waku.md @@ -17,7 +17,7 @@ dateUpdated: @today 2022-05-07 ## Necessary Terminology by Perspective -### The Three (3) Perspectives of Waku v2 +### The Three (3) High-Level Categories of Waku (v2) #### 1. [[Set of Protocols]] #### 2. [[Network of Nodes]] @@ -40,7 +40,7 @@ ___ [[privacy]] [[messaging]] [[secure-messaging]] -[[censorship-resistant]] +[[Censorship-Resistant]] [[regulation]] [[credible-neutrality]] [[adoption]] diff --git a/pages/Recipes.md b/pages/Recipes.md index 305c9ab..4849fb1 100644 --- a/pages/Recipes.md +++ b/pages/Recipes.md @@ -6,8 +6,8 @@ basically a Topic with a cooking theme a new `Recipe Template` AND/OR a new `Topic Template` You can: -1) Use command Ctrl+T or Cmd+T to insert a new [[Recipe Template]] (as seen below) for a new Topic. -2) Then you can use command Ctrl+T or Cmd+T again to populate the details of the new topic with the [[Topic Template]]. +1) Use command Ctrl+T or Cmd+T to insert a new [[1. Recipe Template]] (as seen below) for a new Topic. +2) Then you can use command Ctrl+T or Cmd+T again to populate the details of the new topic with the [[3. Long Topic Template]]. ``` - Recipe: Topic diff --git a/pages/Redundancy.md b/pages/Redundancy.md new file mode 100644 index 0000000..39c9f06 --- /dev/null +++ b/pages/Redundancy.md @@ -0,0 +1,2 @@ +# Redundancy +A list of Topics necessary to develop better intuition and understanding \ No newline at end of file diff --git a/pages/Remote Auditing.md b/pages/Remote Auditing.md new file mode 100644 index 0000000..239b5f4 --- /dev/null +++ b/pages/Remote Auditing.md @@ -0,0 +1,2 @@ +# Remote Auditing +A list of Topics necessary to develop better intuition and understanding \ No newline at end of file diff --git a/pages/Rounds.md b/pages/Rounds.md index 55027c7..4c48c98 100644 --- a/pages/Rounds.md +++ b/pages/Rounds.md @@ -1,16 +1,20 @@ --- - -title: -author: -dateCreated: @today +title: +author: +dateCreated: 5-07-2022 dateUpdated: @today +--- --- -# Topic: -#### Related: -`ELI5 goes here` +# Topic: Rounds +## Chat: [Live Discussion] +#### Tags: [Relevant Tags to Topic/Concept] see [[Tags]] + +``` +ELI5: PBFT variants have this concept of "rounds" which is all-to-all communication. We'd prefer to have "round-less" communication where nodes do not have to talk to all other nodes on a given network for scalability reasons.` +``` --- ## Overview @@ -18,19 +22,52 @@ dateUpdated: @today #### Operating Definition: [Definition here]1 -#### Current "Standard" Implementation: +#### Principles +[What principle(s) are we trying to protect by innovating on this front? The solution that is aligned with the original Ethereum ethos to which Status is preserving ideological alignment with.] see [[Principles]] +#### Implementation +- Description and Explanation + [Technical Why goes here. Systems that are very similar to us or are the current "best-in-class" that we are trying to improve upon for a given factor (define context-relevant network assumptions per phrase, ideally we'll come up with visual sliding bars to show complex relationships between increasing/decreasing factors and how we go from "research" assumptions to "production" engineering) and why?] +- Key Differences: + [Easy low-hanging fruit for marketing or communication that makes our implementation clearly different/better.] +- Additional Information: + [Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] -#### The Idea(l): +--- +FILL IN ABOVE TEMPLATE AND DELETE BELOW -OR- COPY PASTA BELOW AND DELETE ABOVE -#### Logos Implementation: +--- +title: +author: +dateCreated: +dateUpdated: @today +--- +--- -#### Live Feedback: +# Topic: +## Chat: +#### Tags: -#### IMPORTANT Differentiators: +``` +ELI5: Simple explainer. +``` +--- +## Overview -#### Knowledge Share: \ No newline at end of file +#### Operating Definition: +[Definition here]1 + +#### Principles +N/A + +#### Implementation +- Description and Explanation + N/A +- Key Differences: + N/A +- Additional Information: + N/A diff --git a/pages/Safety vs Liveness.md b/pages/Safety vs Liveness.md new file mode 100644 index 0000000..3a1edaf --- /dev/null +++ b/pages/Safety vs Liveness.md @@ -0,0 +1,40 @@ +--- +title: +author: +dateCreated: +dateUpdated: @today +--- + +--- + +# Topic: Safety vs Liveness +## Chat: [Live Discussion] + +#### Tags: [Relevant Tags to Topic/Concept] see [[Tags]] + +``` +ELI5: + +Consensus protocols provide two guarantees with respect to order and timing: + +Safety: As long as the protocol does not have more than some threshold of faulty participants, other participants cannot convince a client to accept an incorrect or invalid message. + +Liveness: So long as there is always at least one transaction suitable for inclusion that has not been deemed final by any properly-operating nodes, the set of transactions deemed final by at least one properly-operating node will increase in number. | As long as the protocol does not have more than some threshold of faulty participants, other participants cannot indefinitely delay the acceptance of a correct message. +``` +--- + +## Overview + +#### Operating Definition: +[Definition here]1 + +#### Principles +[What principle(s) are we trying to protect by innovating on this front? The solution that is aligned with the original Ethereum ethos to which Status is preserving ideological alignment with.] see [[Principles]] + +#### Implementation +- Description and Explanation + [Technical Why goes here. Systems that are very similar to us or are the current "best-in-class" that we are trying to improve upon for a given factor (define context-relevant network assumptions per phrase, ideally we'll come up with visual sliding bars to show complex relationships between increasing/decreasing factors and how we go from "research" assumptions to "production" engineering) and why?] +- Key Differences: + [Easy low-hanging fruit for marketing or communication that makes our implementation clearly different/better.] +- Additional Information: + [Quickly share unread but potentially valuable resources and comments here to be re-read by someone else who can integrate them.] diff --git a/pages/Set of Implementations.md b/pages/Set of Implementations.md index 68f6967..3ab0cc5 100644 --- a/pages/Set of Implementations.md +++ b/pages/Set of Implementations.md @@ -1,3 +1,7 @@ +--- +dateUpdated: 2022-05-24 +--- + # Set of Implementations ## Waku v2 builds on `libp2p`, @@ -13,26 +17,6 @@ For example, there are some [fundamental issues with encryption](https://github `libp2p` was developed for IPFS but now many projects use it, Ethereum 2 included. It is therefore quite mature, with many implementations and a large part of the crypto/p2p community behind it. While it’s not perfect, it’s very modular and easy to extend with new transports, user-defined protocols, etc. ``` -## **How-To (Get Cookin')** -*Instructions: There are some descriptions below which detail the usage of visual guidance metrics available in the form of "cookbook-like" instructions for how to consume this document:* - -| Gauges | Description | Visualization | -| -------- | :-----------: | :----------: | -|Difficulty| 1-10 (Ticks/Pips) | [||||||||||] | -|Time | In Minutes | X Minutes | -|Resources | Article/Video Links w/ Visual Content | Conceptual & Pictoral "Ingredients List" of Links| - -### **Gauge Definitions:** - -Prep (*Difficulty*) is defined as the ease of which the concepts can be generally understood. (Future: Make into more fun visual or something more enjoyable than a difficulty bar.) - -Cook Time (*Scope*) is in reference to the size of information necessary to learn to gain a decent level of comprehension. - -Ingredients (*Resources*) is for links relevant to helping people understand the concepts. Number references and use superscript notation to reference mentions in terminology Recipes descriptions. - - - ![[Pasted image 20220415164934.png]] - - Recipe: [[nim-waku]] - Prep: [||||||||||] - Cook Time: X min diff --git a/pages/Set of Protocols.md b/pages/Set of Protocols.md index 1021b6d..e264bfa 100644 --- a/pages/Set of Protocols.md +++ b/pages/Set of Protocols.md @@ -1,3 +1,7 @@ +--- +dateUpdated: 2022-05-24 +--- + # Set of Protocols ## Waku v2 builds on `libp2p`, diff --git a/pages/Staking and Multi-DAG.md b/pages/Staking and Multi-DAG.md index e0b185c..a182e40 100644 --- a/pages/Staking and Multi-DAG.md +++ b/pages/Staking and Multi-DAG.md @@ -1,88 +1,66 @@ +--- +dateUpdated: 2022-05-24 +--- + # Staking and Multi-DAG +A list of Topics necessary to develop better intuition and understanding -### Related: - -- [[Factory of DAGs]] +- Recipe: [[Bridge (Intermediary) Nodes]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. - - Concept - - Algorithm -- [[Sub-DAG]] +- Recipe: [[Gravity]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. -- [[Cross-DAG]] +- Recipe: [[Application-Level User-Driven]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. -- [[Bridge (Intermediary) Nodes]] +- Recipe: [[Direct Communication Channel]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. -- [[Gravity]] - - Prep: [||||||||||] - - Cook Time: X min - - Ingredients: - 1. -- [[Application-Level User-Driven]] - - Prep: [||||||||||] - - Cook Time: X min - - Ingredients: - 1. -- [[Direct Communication Channel]] - - Prep: [||||||||||] - - Cook Time: X min - - Ingredients: - 1. -- [[Direct Communication VGER]] +- Recipe: [[Direct Communication VGER]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. - Challenges - - Prep: [||||||||||] - - Cook Time: X min - - Ingredients: - 1. - [[Probabilistic finality]] and [[cross-network communication]] - [[Network Partitioning]] and [[Forks]] - [[Weak Subjectivity]] - Reputation of nodes matters to clients. Nodes are clients of other networks. - [[Verifying Weights in Staking]] - [[Glacier Algorithm Quiesces]] -- [[Approach]] - - Prep: [||||||||||] - - Cook Time: X min - - Ingredients: - 1. +- Approach 1. [[Deterministic Finality]] 2. [[Secondary Consensus Protocol]] (form local opinion on external DAG) 3. [[Intermediary DAG]] (Intersection of nodes participating mutually in common structures) -- [[Vertex Sealing]] +- Recipe: [[Vertex Sealing]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. -- [[XSub]] (Cross-sub-DAG communication) +- Recipe: [[XSub]] (Cross-sub-DAG communication) - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. -- [[XDAG]] (Cross-DAG communication) +- Recipe: [[XDAG]] (Cross-DAG communication) - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. -- [[XDAG Fees]] +- Recipe: [[XDAG Fees]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: 1. -- [[Communication Patterns]] +- Recipe: [[Communication Patterns]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: @@ -90,7 +68,7 @@ - Direct - User-Coordinated Channel - Sub-DAG-Coordinated Channel -- [[Stake Sub-DAG]] +- Recipe: [[Stake Sub-DAG]] - Prep: [||||||||||] - Cook Time: X min - Ingredients: diff --git a/pages/Start Here.md b/pages/Start Here.md index 1d01330..c8ab450 100644 --- a/pages/Start Here.md +++ b/pages/Start Here.md @@ -4,6 +4,6 @@ our Culinary Home where we create, prepare and cook World-Class Recipes [Under Construction: Insert 'Glad you finally made it' here video - VTuber Sprite of Chef] +For now just hop into one of our Restaurants where our Chefs are busy at work: [[Logos Program]] - -For now just hop into one of our Restaurants where our Chefs are busy at work: [[Logos Program]] \ No newline at end of file +Or you can skim the introduction here: [[Introduction]] \ No newline at end of file diff --git a/pages/Subnetwork Assignation Algorithm.md b/pages/Subnetwork Assignation Algorithm.md new file mode 100644 index 0000000..e69de29 diff --git a/pages/Tags.md b/pages/Tags.md index e72800f..f1e0c23 100644 --- a/pages/Tags.md +++ b/pages/Tags.md @@ -19,4 +19,4 @@ Discord Server: https://discord.gg/f9zW9QpfXW Text-Channels: #nwaku, #js-waku, #go-waku, #waku, #waku-network, #waku-outreach, #waku-rs, #waku-react-native ## Popular Tags Linking Topics -#How-To +#How-To diff --git a/pages/Tokenomics.md b/pages/Tokenomics.md index 020bbdc..3a54d80 100644 --- a/pages/Tokenomics.md +++ b/pages/Tokenomics.md @@ -1,6 +1,9 @@ -# Tokenomics +--- +dateUpdated: 2022-05-24 +--- -### Related: +# Tokenomics +A list of Topics necessary to develop better intuition and understanding - [[Fees]] - Prep: [||||||||||] diff --git a/pages/Traditional Sharding.md b/pages/Traditional Sharding.md new file mode 100644 index 0000000..e69de29 diff --git a/pages/Vac Program.md b/pages/Vac Program.md index 20f7523..c328d84 100644 --- a/pages/Vac Program.md +++ b/pages/Vac Program.md @@ -62,7 +62,7 @@ ___ [[privacy ]] [[messaging ]] [[secure-messaging ]] -[[censorship-resistant ]] +[[Censorship-Resistant ]] [[regulation ]] [[credible-neutrality ]] [[adoption ]] diff --git a/pages/durability.md b/pages/durability.md index eb6ed44..58ccda7 100644 --- a/pages/durability.md +++ b/pages/durability.md @@ -1,36 +1,2 @@ ---- - -title: -author: -dateCreated: @today -dateUpdated: @today - ---- - -# Topic: ? -#### Related: -`ELI5 goes here` - ---- - -## Overview - -#### Operating Definition: -[Definition here]1 - -#### Current "Standard" Implementation: - - -#### The Idea(l): - - -#### Logos Implementation: - - -#### Live Feedback: - - -#### IMPORTANT Differentiators: - - -#### Knowledge Share: \ No newline at end of file +# Durability +A list of Topics necessary to develop better intuition and understanding \ No newline at end of file