Merge pull request #105 from rsksmart/feat/rns-precache

Feat/rns precache

package.json

@@ -59,8 +59,10 @@
     "@oclif/plugin-help": "^2.2.3",
     "@rsksmart/rif-marketplace-nfts": "~0.0.2",
     "@rsksmart/rif-marketplace-storage": "^0.1.0-dev.0",
+    "@rsksmart/rns-auction-registrar": "1.0.2",
     "@rsksmart/rns-reverse": "^1.0.2",
     "@rsksmart/rns-rskregistrar": "^1.2.1",
+    "abi-decoder": "^2.3.0",
     "async-sema": "^3.1.0",
     "coingecko-api": "^1.0.10",
     "colors": "^1.4.0",

src/@types/abi-decoder/index.d.ts

@@ -0,0 +1,18 @@
+declare module 'abi-decoder' {
+
+    export interface Parameter {
+        value: string
+    }
+
+    export interface DecodedData {
+        params: Parameter[]
+    }
+
+    export class AbiDecoder {
+      static addABI(abi: any[]): void
+
+      static decodeMethod(input: string): DecodedData
+    }
+
+    export default AbiDecoder
+}

src/definitions.ts

@@ -138,6 +138,12 @@ export interface Config {
     // Sets if RNS service should be enabled
     enabled?: boolean
 
+    // Auction registrar contract's options
+    registrar?: BlockchainServiceOptions
+
+    // FIFSAddrRegistrar contract's options
+    fifsAddrRegistrar?: BlockchainServiceOptions
+
     // Owner contract's options
     owner?: BlockchainServiceOptions
 

src/rns/index.ts

@@ -20,9 +20,12 @@ import soldDomainHooks from './hooks/sold-domain.hooks'
 
 import rnsContractAbi from '@rsksmart/rns-rskregistrar/RSKOwnerData.json'
 import rnsReverseContractAbi from '@rsksmart/rns-reverse/NameResolverData.json'
+import auctionRegistrarContractAbi from '@rsksmart/rns-auction-registrar/TokenRegistrarData.json'
 import simplePlacementsContractAbi from '@rsksmart/rif-marketplace-nfts/ERC721SimplePlacementsABI.json'
 import { errorHandler } from '../utils'
 
+import { processRskOwner, processAuctionRegistrar } from './rns.precache'
+
 const logger = loggingFactory('rns')
 
 export class RnsService extends Service {
@@ -49,6 +52,9 @@ async function precache (eth?: Eth): Promise<void> {
   const eventsDataQueue: EventData[] = []
   const dataQueuePusher = (event: EventData): void => { eventsDataQueue.push(event) }
 
+  await processAuctionRegistrar(eth, precacheLogger, auctionRegistrarContractAbi.abi as AbiItem[])
+  await processRskOwner(eth, precacheLogger, rnsContractAbi.abi as AbiItem[])
+
   await fetchEventsForService(eth, 'rns.owner', rnsContractAbi.abi as AbiItem[], dataQueuePusher)
   await fetchEventsForService(eth, 'rns.reverse', rnsReverseContractAbi.abi as AbiItem[], dataQueuePusher)
   await fetchEventsForService(eth, 'rns.placement', simplePlacementsContractAbi as AbiItem[], dataQueuePusher)

src/rns/rns.precache.ts

@@ -0,0 +1,77 @@
+import { Eth } from 'web3-eth'
+import config from 'config'
+import Utils from 'web3-utils'
+import abiDecoder from 'abi-decoder'
+import { BlockchainServiceOptions, Logger } from '../definitions'
+
+import Domain from './models/domain.model'
+
+abiDecoder.addABI([
+  {
+    constant: false,
+    inputs: [
+      {
+        name: '_to',
+        type: 'address'
+      },
+      {
+        name: '_value',
+        type: 'uint256'
+      },
+      {
+        name: '_data',
+        type: 'bytes'
+      }
+    ],
+    name: 'transferAndCall',
+    outputs: [
+      {
+        name: '',
+        type: 'bool'
+      }
+    ],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function'
+  }
+])
+
+export async function processRskOwner (eth: Eth, logger: Logger, contractAbi: Utils.AbiItem[]) {
+  logger.info('Processing events Transfer from FIFSAddrRegistrar')
+  const rskOwner = new eth.Contract(contractAbi, config.get<string>('rns.owner.contractAddress'))
+  const startingBlock = config.get<BlockchainServiceOptions>('rns.owner')?.eventsEmitter?.startingBlock || 'genesis'
+  const rskOwnerEvents = await rskOwner.getPastEvents('Transfer', {
+    filter: { from: config.get<string>('rns.fifsAddrRegistrar.contractAddress') },
+    fromBlock: startingBlock
+  })
+  for (const rskOwnerEvent of rskOwnerEvents) {
+    const transaction = await eth.getTransaction(rskOwnerEvent.transactionHash)
+    const decodedData = abiDecoder.decodeMethod(transaction.input)
+    const name = Utils.hexToAscii('0x' + decodedData.params[2].value.slice(218, decodedData.params[2].value.length))
+    const tokenId = Utils.sha3(name)
+    const ownerAddress = rskOwnerEvent.returnValues.to.toLowerCase()
+    const [domain, created] = await Domain.findCreateFind({ where: { tokenId }, defaults: { name, ownerAddress } })
+
+    if (!created) {
+      domain.ownerAddress = ownerAddress
+      await domain.save()
+    }
+  }
+}
+
+export async function processAuctionRegistrar (eth: Eth, logger: Logger, contractAbi: Utils.AbiItem[]) {
+  logger.info('Processing events HashRegistered')
+  const startingBlock = config.get<BlockchainServiceOptions>('rns.registrar')?.eventsEmitter?.startingBlock || 'genesis'
+  const auctionRegistrar = new eth.Contract(contractAbi, config.get<string>('rns.registrar.contractAddress'))
+  const auctionRegistrarEvents = await auctionRegistrar.getPastEvents('HashRegistered', {
+    filter: { from: '0x0000000000000000000000000000000000000000' },
+    fromBlock: startingBlock
+  })
+  for (const event of auctionRegistrarEvents) {
+    const tokenId = event.returnValues.hash
+    const ownerAddress = event.returnValues.owner.toLowerCase()
+    const expirationDate = parseInt(event.returnValues.registrationDate) * 1000
+    const req = new Domain({ tokenId, ownerAddress, expirationDate })
+    await req.save()
+  }
+}

src/rns/rns.processor.ts

@@ -12,11 +12,12 @@ import { Logger } from '../definitions'
 async function transferHandler (logger: Logger, eventData: EventData): Promise<void> {
   // Transfer(address indexed from, address indexed to, uint256 indexed tokenId)
 
-  if (eventData.returnValues.from !== '0x0000000000000000000000000000000000000000') {
-    const tokenId = Utils.numberToHex(eventData.returnValues.tokenId)
-    const ownerAddress = eventData.returnValues.to.toLowerCase()
-    const [domain, created] = await Domain.findCreateFind({ where: { tokenId }, defaults: { ownerAddress } })
+  const tokenId = Utils.numberToHex(eventData.returnValues.tokenId)
+  const ownerAddress = eventData.returnValues.to.toLowerCase()
+
+  const [domain, created] = await Domain.findCreateFind({ where: { tokenId }, defaults: { ownerAddress } })
 
+  if (eventData.returnValues.from !== '0x0000000000000000000000000000000000000000') {
     // if not exist then create (1 insert), Domain.findCreateFind
     // else create a SoldDomain and update with the new owner the registry (1 insert + update)
     if (created) {
@@ -43,6 +44,12 @@ async function transferHandler (logger: Logger, eventData: EventData): Promise<v
         logger.info(`Transfer event: no Domain ${domain.name} updated`)
       }
     }
+  } else {
+    if (domain.ownerAddress == null) {
+      domain.ownerAddress = ownerAddress
+      await domain.save()
+      logger.info(`Transfer event: ${tokenId} ownership updated`)
+    }
   }
 }