aiolabs/lightning-pub
2
0
Fork 0
Code Issues 9 Pull requests 4 Projects Releases Packages Wiki Activity Actions

Remove unused code (Mediator class)

Browse source
This commit is contained in:
Daniel Lugo 2021-04-29 18:48:26 -04:00
parent d5d48d5744
commit d3c2d3e645
1 changed files with 0 additions and 595 deletions
Download patch file Download diff file Expand all files Collapse all files

595
services/gunDB/Mediator/index.js
View file

@ -12,7 +12,6 @@ Gun.log = () => {}
require('gun/lib/open') require('gun/lib/open')
// @ts-ignore // @ts-ignore
require('gun/lib/load') require('gun/lib/load')
const debounce = require('lodash/debounce')
//@ts-ignore //@ts-ignore
const { encryptedEmit, encryptedOn } = require('../../../utils/ECC/socket') const { encryptedEmit, encryptedOn } = require('../../../utils/ECC/socket')
const Key = require('../contact-api/key') const Key = require('../contact-api/key')
@ -215,14 +214,9 @@ mySEA.secret = async (recipientOrSenderEpub, recipientOrSenderSEA) => {
return sec return sec
} }
const auth = require('../../auth/auth')
const { Constants } = require('shock-common') const { Constants } = require('shock-common')
const { Action, Event } = Constants
const API = require('../contact-api/index') const API = require('../contact-api/index')
const Config = require('../config')
// const { nonEncryptedRoutes } = require('../../../utils/protectedRoutes')
/** /**
* @typedef {import('../contact-api/SimpleGUN').GUNNode} GUNNode * @typedef {import('../contact-api/SimpleGUN').GUNNode} GUNNode
@ -492,579 +486,6 @@ const freshGun = () => {
} }
} }
/**
* @param {string} token
* @returns {Promise<boolean>}
*/
const isValidToken = async token => {
const validation = await auth.validateToken(token)
if (typeof validation !== 'object') {
return false
}
if (validation === null) {
return false
}
if (typeof validation.valid !== 'boolean') {
return false
}
return validation.valid
}
/**
* @param {string} token
* @throws {Error} If the token is invalid
* @returns {Promise<void>}
*/
const throwOnInvalidToken = async token => {
const isValid = await isValidToken(token)
if (!isValid) {
throw new Error('Token expired.')
}
}
class Mediator {
/**
* @param {Readonly<SimpleSocket>} socket
*/
constructor(socket) {
this.socket = this.encryptSocketInstance(socket)
this.connected = true
this.socket.on('disconnect', this.onDisconnect)
this.socket.on(Action.ACCEPT_REQUEST, this.acceptRequest)
this.socket.on(
Action.GENERATE_NEW_HANDSHAKE_NODE,
this.generateHandshakeNode
)
this.socket.on('GENERATE_ORDER_ADDRESS', this.generateOrderAddress)
this.socket.on('INIT_FEED_WALL', this.initWall)
this.socket.on(Action.SEND_HANDSHAKE_REQUEST, this.sendHandshakeRequest)
this.socket.on(
Action.SEND_HANDSHAKE_REQUEST_WITH_INITIAL_MSG,
this.sendHRWithInitialMsg
)
this.socket.on(Action.SEND_MESSAGE, this.sendMessage)
this.socket.on(Action.SEND_PAYMENT, this.sendPayment)
this.socket.on(Action.DISCONNECT, this.disconnect)
this.socket.on(Event.ON_CHATS, this.onChats)
this.socket.on(Event.ON_HANDSHAKE_ADDRESS, this.onHandshakeAddress)
this.socket.on(Event.ON_RECEIVED_REQUESTS, this.onReceivedRequests)
this.socket.on(Event.ON_SENT_REQUESTS, this.onSentRequests)
this.socket.on(Event.ON_SEED_BACKUP, this.onSeedBackup)
this.socket.on(Constants.Misc.IS_GUN_AUTH, this.isGunAuth)
Object.values(Action).forEach(actionConstant =>
this.socket.on(actionConstant, this.setLastSeenApp)
)
}
/** @param {SimpleSocket} socket */
encryptSocketInstance = socket => {
const emit = encryptedEmit(socket)
const on = encryptedOn(socket)
return {
/**
* @type {SimpleSocket['on']}
*/
on,
/** @type {SimpleSocket['emit']} */
emit
}
}
/** @param {{ token: string }} body */
setLastSeenApp = async body => {
logger.info('setLastSeen Called')
try {
await throwOnInvalidToken(body.token)
await API.Actions.setLastSeenApp()
this.socket.emit(Action.SET_LAST_SEEN_APP, {
ok: true,
msg: null,
origBody: body
})
} catch (e) {
this.socket.emit(Action.SET_LAST_SEEN_APP, {
ok: false,
msg: e.message,
origBody: body
})
}
}
isGunAuth = () => {
try {
const isGunAuth = isAuthenticated()
this.socket.emit(Constants.Misc.IS_GUN_AUTH, {
ok: true,
msg: {
isGunAuth
},
origBody: {}
})
} catch (err) {
this.socket.emit(Constants.Misc.IS_GUN_AUTH, {
ok: false,
msg: err.message,
origBody: {}
})
}
}
/**
* @param {Readonly<{ requestID: string , token: string }>} body
*/
acceptRequest = async body => {
try {
const { requestID, token } = body
await throwOnInvalidToken(token)
await API.Actions.acceptRequest(requestID, gun, user, mySEA)
this.socket.emit(Action.ACCEPT_REQUEST, {
ok: true,
msg: null,
origBody: body
})
} catch (err) {
logger.info(err)
this.socket.emit(Action.ACCEPT_REQUEST, {
ok: false,
msg: err.message,
origBody: body
})
}
}
onDisconnect = () => {
this.connected = false
}
/**
* @param {Readonly<{ token: string }>} body
*/
generateHandshakeNode = async body => {
try {
const { token } = body
await throwOnInvalidToken(token)
await API.Actions.generateHandshakeAddress()
this.socket.emit(Action.GENERATE_NEW_HANDSHAKE_NODE, {
ok: true,
msg: null,
origBody: body
})
} catch (err) {
logger.info(err)
this.socket.emit(Action.GENERATE_NEW_HANDSHAKE_NODE, {
ok: false,
msg: err.message,
origBody: body
})
}
}
/**
* @param {Readonly<{ token: string }>} body
*/
generateOrderAddress = async body => {
try {
const { token } = body
await throwOnInvalidToken(token)
await API.Actions.generateOrderAddress(user)
this.socket.emit('GENERATE_ORDER_ADDRESS', {
ok: true,
msg: null,
origBody: body
})
} catch (err) {
logger.info(err)
this.socket.emit('GENERATE_ORDER_ADDRESS', {
ok: false,
msg: err.message,
origBody: body
})
}
}
/**
* @param {Readonly<{ token: string }>} body
*/
initWall = async body => {
try {
const { token } = body
await throwOnInvalidToken(token)
await API.Actions.initWall()
this.socket.emit('INIT_FEED_WALL', {
ok: true,
msg: null,
origBody: body
})
} catch (err) {
logger.info(err)
this.socket.emit('INIT_FEED_WALL', {
ok: false,
msg: err.message,
origBody: body
})
}
}
/**
* @param {Readonly<{ recipientPublicKey: string , token: string }>} body
*/
sendHandshakeRequest = async body => {
try {
if (Config.SHOW_LOG) {
logger.info('\n')
logger.info('------------------------------')
logger.info('will now try to send a handshake request')
logger.info('------------------------------')
logger.info('\n')
}
const { recipientPublicKey, token } = body
await throwOnInvalidToken(token)
await API.Actions.sendHandshakeRequest(
recipientPublicKey,
gun,
user,
mySEA
)
if (Config.SHOW_LOG) {
logger.info('\n')
logger.info('------------------------------')
logger.info('handshake request successfuly sent')
logger.info('------------------------------')
logger.info('\n')
}
this.socket.emit(Action.SEND_HANDSHAKE_REQUEST, {
ok: true,
msg: null,
origBody: body
})
} catch (err) {
if (Config.SHOW_LOG) {
logger.info('\n')
logger.info('------------------------------')
logger.info('handshake request send fail: ' + err.message)
logger.info('------------------------------')
logger.info('\n')
}
this.socket.emit(Action.SEND_HANDSHAKE_REQUEST, {
ok: false,
msg: err.message,
origBody: body
})
}
}
/**
* @param {Readonly<{ initialMsg: string , recipientPublicKey: string , token: string }>} body
*/
sendHRWithInitialMsg = async body => {
try {
const { initialMsg, recipientPublicKey, token } = body
await throwOnInvalidToken(token)
await API.Actions.sendHRWithInitialMsg(
initialMsg,
recipientPublicKey,
gun,
user,
mySEA
)
this.socket.emit(Action.SEND_HANDSHAKE_REQUEST_WITH_INITIAL_MSG, {
ok: true,
msg: null,
origBody: body
})
} catch (err) {
logger.info(err)
this.socket.emit(Action.SEND_HANDSHAKE_REQUEST_WITH_INITIAL_MSG, {
ok: false,
msg: err.message,
origBody: body
})
}
}
/**
* @param {Readonly<{ body: string , recipientPublicKey: string , token: string }>} reqBody
*/
sendMessage = async reqBody => {
try {
const { body, recipientPublicKey, token } = reqBody
await throwOnInvalidToken(token)
this.socket.emit(Action.SEND_MESSAGE, {
ok: true,
msg: await API.Actions.sendMessage(
recipientPublicKey,
body,
user,
mySEA
),
origBody: reqBody
})
} catch (err) {
logger.info(err)
this.socket.emit(Action.SEND_MESSAGE, {
ok: false,
msg: err.message,
origBody: reqBody
})
}
}
/**
* @param {Readonly<{ uuid: string, recipientPub: string, amount: number, memo: string, token: string, feeLimit:number }>} reqBody
*/
sendPayment = async reqBody => {
try {
const { recipientPub, amount, memo, feeLimit, token } = reqBody
await throwOnInvalidToken(token)
const preimage = await API.Actions.sendPayment(
recipientPub,
amount,
memo,
feeLimit
)
this.socket.emit(Action.SEND_PAYMENT, {
ok: true,
msg: preimage,
origBody: reqBody
})
} catch (err) {
logger.info(err)
this.socket.emit(Action.SEND_PAYMENT, {
ok: false,
msg: err.message,
origBody: reqBody
})
}
}
//////////////////////////////////////////////////////////////////////////////
/**
* @param {Readonly<{ token: string }>} body
*/
onChats = async body => {
try {
const { token } = body
// logger.info('ON_CHATS', body)
await throwOnInvalidToken(token)
API.Events.onChats(chats => {
if (Config.SHOW_LOG) {
logger.info('---chats---')
logger.info(JSON.stringify(chats))
logger.info('-----------------------')
}
this.socket.emit(Event.ON_CHATS, {
msg: chats,
ok: true,
origBody: body
})
})
} catch (err) {
logger.info(err)
this.socket.emit(Event.ON_CHATS, {
ok: false,
msg: err.message,
origBody: body
})
}
}
/**
* @param {Readonly<{ token: string }>} body
*/
onHandshakeAddress = async body => {
try {
const { token } = body
await throwOnInvalidToken(token)
API.Events.onCurrentHandshakeAddress(addr => {
if (Config.SHOW_LOG) {
logger.info('---addr---')
logger.info(addr || 'null or empty string')
logger.info('-----------------------')
}
this.socket.emit(Event.ON_HANDSHAKE_ADDRESS, {
ok: true,
msg: addr,
origBody: body
})
}, user)
} catch (err) {
logger.info(err)
this.socket.emit(Event.ON_HANDSHAKE_ADDRESS, {
ok: false,
msg: err.message,
origBody: body
})
}
}
/**
* @param {Readonly<{ token: string }>} body
*/
onReceivedRequests = async body => {
try {
const { token } = body
await throwOnInvalidToken(token)
API.Events.onSimplerReceivedRequests(receivedRequests => {
this.socket.emit(Event.ON_RECEIVED_REQUESTS, {
msg: receivedRequests,
ok: true,
origBody: body
})
})
} catch (err) {
logger.info(err)
this.socket.emit(Event.ON_RECEIVED_REQUESTS, {
msg: err.message,
ok: false,
origBody: body
})
}
}
onSentRequestsSubbed = false
/**
* @param {Readonly<{ token: string }>} body
*/
onSentRequests = async body => {
try {
const { token } = body
await throwOnInvalidToken(token)
if (!this.onSentRequestsSubbed) {
this.onSentRequestsSubbed = true
API.Events.onSimplerSentRequests(
debounce(sentRequests => {
// logger.info(
// `new Reqss in mediator: ${JSON.stringify(sentRequests)}`
// )
this.socket.emit(Event.ON_SENT_REQUESTS, {
msg: sentRequests,
ok: true,
origBody: body
})
}, 1000)
)
}
} catch (err) {
logger.info(err)
this.socket.emit(Event.ON_SENT_REQUESTS, {
msg: err.message,
ok: false,
origBody: body
})
}
}
/**
* @param {Readonly<{ token: string }>} body
*/
onSeedBackup = async body => {
try {
const { token } = body
await throwOnInvalidToken(token)
await API.Events.onSeedBackup(
seedBackup => {
this.socket.emit(Event.ON_SEED_BACKUP, {
ok: true,
msg: seedBackup,
origBody: body
})
},
user,
mySEA
)
} catch (err) {
logger.info(err)
this.socket.emit(Event.ON_SEED_BACKUP, {
ok: false,
msg: err.message,
origBody: body
})
}
}
/** @param {Readonly<{ pub: string, token: string }>} body */
disconnect = async body => {
try {
const { pub, token } = body
await throwOnInvalidToken(token)
await API.Actions.disconnect(pub)
this.socket.emit(Action.DISCONNECT, {
ok: true,
msg: null,
origBody: body
})
} catch (err) {
this.socket.emit(Action.DISCONNECT, {
ok: false,
msg: err.message,
origBody: body
})
}
}
}
/** /**
* Creates an user for gun. Returns a promise containing the public key of the * Creates an user for gun. Returns a promise containing the public key of the
* newly created user. * newly created user.
@ -1183,25 +604,9 @@ const register = async (alias, pass) => {
}) })
} }
/**
* @param {SimpleSocket} socket
* @throws {Error} If gun is not authenticated or is in the process of
* authenticating. Use `isAuthenticating()` and `isAuthenticated()` to check for
* this first.
* @returns {Mediator}
*/
const createMediator = socket => {
// if (isAuthenticating() || !isAuthenticated()) {
// throw new Error("Gun must be authenticated to create a Mediator");
// }
return new Mediator(socket)
}
module.exports = { module.exports = {
authenticate, authenticate,
logoff, logoff,
createMediator,
isAuthenticated, isAuthenticated,
isAuthenticating, isAuthenticating,
isRegistering, isRegistering,