feat: adds channel filter to sold domains

rsksmart · Jul 24, 2020 · 8145b86 · 8145b86
1 parent b807b8d
commit 8145b86
Show file tree

Hide file tree

Showing 4 changed files with 67 additions and 80 deletions.
diff --git a/src/app.ts b/src/app.ts
@@ -29,7 +29,7 @@ export const services = {
   [SupportedServices.RNS]: rns
 }
 
-export async function appFactory(): Promise<Application> {
+export async function appFactory (): Promise<Application> {
   const app: Application = express(feathers())
 
   logger.verbose('Current configuration: ', config)
@@ -68,7 +68,7 @@ export async function appFactory(): Promise<Application> {
 
   // Log errors in hooks
   app.hooks({
-    error(context) {
+    error (context) {
       logger.error(`Error in '${context.path}' service method '${context.method}'`, context.error.stack)
     }
   })

diff --git a/src/services/authentication.ts b/src/services/authentication.ts
@@ -1,66 +1,33 @@
-import { ServiceAddons, Params } from '@feathersjs/feathers';
-import { AuthenticationService, JWTStrategy, AuthenticationResult, AuthenticationBaseStrategy } from '@feathersjs/authentication';
-import { Application } from '../definitions';
+import { ServiceAddons, Params } from '@feathersjs/feathers'
+import { AuthenticationService, AuthenticationBaseStrategy, AuthenticationRequest } from '@feathersjs/authentication'
+import { Application } from '../definitions'
 
 declare module '../definitions' {
     interface ServiceTypes {
-        'authentication': AuthenticationService & ServiceAddons<any>;
+        'authentication': AuthenticationService & ServiceAddons<any>
     }
 }
 
-class MyJWT extends JWTStrategy {
-    async authenticate(authentication: AuthenticationResult, params: Params) {
-        console.log('MyJWT -> authenticate------------------------------')
-        console.log(authentication)
-        console.log('------------------------------')
-        console.log(params)
-        console.log('------------------------------')
-        return super.authenticate(authentication, params)
-    }
-}
 class AnonymousStrategy extends AuthenticationBaseStrategy {
-    async authenticate(authentication, params) {
+    authenticate(authentication: AuthenticationRequest, params: Params) {
         const channels: [] = authentication.channels
-        console.log('AnonymousStrategy -> authenticate------------------------------')
-        console.log(authentication)
-        console.log('------------------------------')
         params.connection.ownerAddress = authentication.ownerAddress
         channels.forEach(channel => {
             this.app?.channel(channel).join(params.connection)
-        });
-        console.log('this.app.channels:', this.app.channels)
-        console.log('------------------------------')
-        return {
-            anonymous: true
-        }
-    }
-}
-
-class MyAuthService extends AuthenticationService {
-    async getPayload(authResult, params) {
-        // Call original `getPayload` first
-        const payload = await super.getPayload(authResult, params);
-        const { user } = authResult;
+        })
 
-        if (user && user.permissions) {
-            payload.permissions = user.permissions;
-        }
-
-        return payload;
+        return Promise.resolve({ anonymous: true })
     }
 }
 
 export default function (app: Application) {
-    const authentication = new MyAuthService(app as any) //FIXME: remove `as any`
+    const authentication = new AuthenticationService(app as any)
 
     app.set('authentication', {
-        "secret": "8a58b86565c23c9ea90",
-        "entity": null,
-        "authStrategies": ["anonymous"],
+        secret: '8a58b86565c23c9ea90',
+        entity: null,
+        authStrategies: ['anonymous']
     })
-
-    authentication.register('anonymous', new AnonymousStrategy());
-    // authentication.register('jwt', new MyJWT());
-
-    app.use('/authentication', authentication);
-}
+    authentication.register('anonymous', new AnonymousStrategy())
+    app.use('/authentication', authentication)
+}
diff --git a/src/services/rns/rns.channels.ts b/src/services/rns/rns.channels.ts
@@ -8,24 +8,25 @@ export default function (app: Application) {
   }
   app.on('connection', (connection: any) => {
     app.channel('offers').join(connection)
-    // app.channel('domains').join(connection)
     app.channel('sold').join(connection)
   })
 
-  app.service(ServiceAddresses.RNS_DOMAINS).publish((data, context) => {
-    // Filter the channels to only authenticated
-    return app.channel(`domains`)
+  app.service(ServiceAddresses.RNS_DOMAINS).publish((data) => {
+    return app.channel('domains')
+      .filter(connection => {
+        const connectedAccount: string = connection.ownerAddress
+        const dataAccount: string = data.ownerAddress
+
+        return connectedAccount && dataAccount && connectedAccount.toLowerCase() === dataAccount.toLowerCase()
+      })
+  })
+  app.service(ServiceAddresses.RNS_SOLD).publish((data) => {
+    return app.channel('domains')
       .filter(connection => {
         const connectedAccount: string = connection.ownerAddress
         const dataAccount: string = data.ownerAddress
-        console.log('----------------------')
-        console.log('rns.channels.ts -> domains publish -> connectedAccount:', connectedAccount)
-        console.log('rns.channels.ts -> domains publish -> dataAccount:', dataAccount)
-        console.log('----------------------')
         return connectedAccount && dataAccount && connectedAccount.toLowerCase() === dataAccount.toLowerCase()
       })
   })
   app.service(ServiceAddresses.RNS_OFFERS).publish(() => app.channel('offers'))
-  // app.service(ServiceAddresses.RNS_DOMAINS).publish(() => app.channel('domains'))
-  app.service(ServiceAddresses.RNS_SOLD).publish(() => app.channel('sold'))
 }
diff --git a/src/services/rns/rns.processor.ts b/src/services/rns/rns.processor.ts
@@ -11,8 +11,9 @@ import Domain from './models/domain.model'
 import DomainExpiration from './models/expiration.model'
 import DomainOwner from './models/owner.model'
 import Transfer from './models/transfer.model'
+import SoldDomain from './models/sold-domain.model'
 
-async function transferHandler(logger: Logger, eventData: EventData, eth: Eth, services: RnsServices): Promise<void> {
+async function transferHandler (logger: Logger, eventData: EventData, eth: Eth, services: RnsServices): Promise<void> {
   const tokenId = Utils.numberToHex(eventData.returnValues.tokenId)
   const ownerAddress = eventData.returnValues.to.toLowerCase()
 
@@ -41,7 +42,7 @@ async function transferHandler(logger: Logger, eventData: EventData, eth: Eth, s
         }
 
         if (domainsService.emit) {
-          domainsService.emit('patched', { tokenId, })
+          domainsService.emit('patched', { tokenId })
         }
       }
     }
@@ -86,7 +87,7 @@ async function transferHandler(logger: Logger, eventData: EventData, eth: Eth, s
   }
 }
 
-async function expirationChangedHandler(logger: Logger, eventData: EventData, _: Eth, services: RnsServices): Promise<void> {
+async function expirationChangedHandler (logger: Logger, eventData: EventData, _: Eth, services: RnsServices): Promise<void> {
   // event ExpirationChanged(uint256 tokenId, uint expirationTime);
 
   const tokenId = Utils.numberToHex(eventData.returnValues.tokenId)
@@ -119,7 +120,7 @@ async function expirationChangedHandler(logger: Logger, eventData: EventData, _:
   }
 }
 
-async function nameChangedHandler(logger: Logger, eventData: EventData, _: Eth, services: RnsServices): Promise<void> {
+async function nameChangedHandler (logger: Logger, eventData: EventData, _: Eth, services: RnsServices): Promise<void> {
   const name = eventData.returnValues.name
   const domainsService = services.domains
 
@@ -137,7 +138,7 @@ async function nameChangedHandler(logger: Logger, eventData: EventData, _: Eth,
   }
 }
 
-async function tokenPlacedHandler(logger: Logger, eventData: EventData, eth: Eth, services: RnsServices): Promise<void> {
+async function tokenPlacedHandler (logger: Logger, eventData: EventData, eth: Eth, services: RnsServices): Promise<void> {
   // event TokenPlaced(uint256 indexed tokenId, address indexed paymentToken, uint256 cost);
 
   const transactionHash = eventData.transactionHash
@@ -174,7 +175,7 @@ async function tokenPlacedHandler(logger: Logger, eventData: EventData, eth: Eth
   logger.info(`TokenPlaced event: ${tokenId} created`)
 }
 
-async function tokenUnplacedHandler(logger: Logger, eventData: EventData, eth: Eth, services: RnsServices): Promise<void> {
+async function tokenUnplacedHandler (logger: Logger, eventData: EventData, eth: Eth, services: RnsServices): Promise<void> {
   // event TokenUnplaced(uint256 indexed tokenId);
   const tokenId = Utils.numberToHex(eventData.returnValues.tokenId)
   const storedOffer = await DomainOffer.findOne({ where: { tokenId } })
@@ -188,29 +189,47 @@ async function tokenUnplacedHandler(logger: Logger, eventData: EventData, eth: E
   }
 }
 
-async function tokenSoldHandler(logger: Logger, eventData: EventData, eth: Eth, services: RnsServices): Promise<void> {
-  // event TokenSold(uint256 indexed tokenId);
-
-  const transactionHash = eventData.transactionHash
+async function tokenSoldHandler (
+  logger: Logger,
+  eventData: EventData,
+  eth: Eth,
+  { sold: soldService, offers: offersService }: RnsServices
+): Promise<void> {
+  const {
+    transactionHash,
+    blockNumber
+  } = eventData
   const tokenId = Utils.numberToHex(eventData.returnValues.tokenId)
   const domainOffer = await DomainOffer.findOne({ where: { tokenId } })
 
   if (domainOffer) {
     logger.info(`Found last offer for ${tokenId}`)
-    const soldService = services.sold
-
-    const soldDomain = await soldService.create({
+    const {
+      ownerAddress,
+      price,
+      priceString,
+      paymentToken
+    } = domainOffer
+
+    const soldDomain = await SoldDomain.create({
       id: transactionHash,
-      tokenId: tokenId,
-      price: domainOffer.price,
-      priceString: domainOffer.priceString,
-      paymentToken: domainOffer.paymentToken,
-      soldDate: await getBlockDate(eth, eventData.blockNumber)
+      tokenId,
+      price,
+      priceString,
+      paymentToken,
+      soldDate: await getBlockDate(eth, blockNumber)
     })
 
     if (soldDomain) {
-      const offersService = services.offers
+      if (soldService.emit) {
+        soldService.emit('created', { tokenId, ownerAddress })
+      }
+
       await offersService.remove(domainOffer.offerId)
+
+      if (offersService.emit) {
+        offersService.emit('created', { tokenId, ownerAddress })
+      }
       logger.info(`TokenSold event: Sold Domain ${tokenId} in transaction ${transactionHash}`)
     } else {
       logger.info(`TokenSold event: ${tokenId} not updated`)
@@ -227,11 +246,11 @@ const commands = {
   TokenSold: tokenSoldHandler
 }
 
-function isValidEvent(value: string): value is keyof typeof commands {
+function isValidEvent (value: string): value is keyof typeof commands {
   return value in commands
 }
 
-export default function rnsProcessorFactory(logger: Logger, eth: Eth, services: RnsServices) {
+export default function rnsProcessorFactory (logger: Logger, eth: Eth, services: RnsServices) {
   return async function (eventData: EventData): Promise<void> {
     if (isValidEvent(eventData.event)) {
       logger.info(`Processing event ${eventData.event}`)