like-robinhood 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Lucas Barrena
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# like-robinhood

package/index.js

@@ -0,0 +1,211 @@
+const { zeroPadValue } = require('ethers')
+const { programs, tokenInfoEvents, tokenActivityEvents } = require('./programs/index.js')
+
+const RPC_URL = 'https://rpc.mainnet.chain.robinhood.com'
+
+module.exports = class Robinhood {
+  static programs = programs
+
+  constructor (opts = {}) {
+    this.rpc = opts.rpc || RPC_URL
+    this.id = 1
+  }
+
+  async getTokenCreation (tokenAddress) {
+    const queries = getTokenInfoQueries(tokenAddress, { fromBlock: blockTag(0), toBlock: 'latest' })
+    const logs = []
+
+    // Parallelism is not needed for now to avoid rate limits
+    // We aim for one query here and the returned value can be cached
+    for (const query of queries) {
+      const result = await this.request('eth_getLogs', [query])
+
+      logs.push(...result)
+    }
+
+    const tokenInfos = parseTokenInfoLogs(tokenAddress, logs)
+
+    return tokenInfos
+  }
+
+  async getTokenEvents (address, opts = {}) {
+    const eventNames = opts.eventNames || [...tokenActivityEvents.values()].map(e => e.event.name)
+    const selectedEvents = [...tokenActivityEvents.values()].filter(e => {
+      return eventNames.includes(e.event.name)
+    })
+
+    const start = opts.after || opts.start
+    const startBlock = start ? Number(start.blockNumber) : 0
+    const startLogIndex = start
+      ? Number(start.logIndex || 0) + (opts.after ? 1 : 0)
+      : 0
+    const endBlock = opts.end ? Number(opts.end.blockNumber) : null
+    const endLogIndex = opts.end ? Number(opts.end.logIndex || 0) : null
+    const limit = typeof opts.limit === 'number' ? (opts.limit >= 0 ? opts.limit : 0) : Infinity
+
+    const logs = await this.request('eth_getLogs', [{
+      address,
+      fromBlock: blockTag(startBlock),
+      toBlock: blockTag(endBlock === null ? 'latest' : endBlock),
+      topics: [
+        selectedEvents.map(e => e.event.topicHash)
+      ]
+    }])
+
+    const eligibleLogs = logs.filter(log => {
+      const blockNumber = Number(log.blockNumber)
+      const logIndex = Number(log.logIndex)
+
+      const afterStart = blockNumber > startBlock || (blockNumber === startBlock && logIndex >= startLogIndex)
+      const beforeEnd = endBlock === null || blockNumber < endBlock || (blockNumber === endBlock && logIndex < endLogIndex)
+
+      return afterStart && beforeEnd
+    })
+
+    eligibleLogs.sort((left, right) => {
+      const leftBlock = Number(left.blockNumber)
+      const rightBlock = Number(right.blockNumber)
+
+      if (leftBlock !== rightBlock) {
+        return leftBlock < rightBlock ? -1 : 1
+      }
+
+      return Number(left.logIndex) - Number(right.logIndex)
+    })
+
+    const pageLogs = eligibleLogs.slice(0, limit)
+
+    const events = pageLogs.map(log => {
+      const key = log.topics[0].toLowerCase()
+      const e = tokenActivityEvents.get(key)
+      const event = e.contract.interface.parseLog({
+        topics: log.topics,
+        data: log.data
+      })
+
+      return {
+        program: e.programId,
+        contract: e.contractId,
+        name: event.name,
+        data: event.args.toObject(),
+        blockNumber: Number(log.blockNumber),
+        transactionHash: log.transactionHash,
+        transactionIndex: Number(log.transactionIndex),
+        logIndex: Number(log.logIndex)
+      }
+    })
+
+    return events
+  }
+
+  async request (method, params) {
+    for (let retry = 1; retry <= 3; retry++) {
+      try {
+        const response = await fetch(RPC_URL, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: this.id++,
+            method,
+            params
+          })
+        })
+
+        const data = await response.json()
+
+        if (data.error) {
+          throw new Error(data.error.message)
+        }
+
+        return data.result
+      } catch (err) {
+        if (retry === 3) {
+          throw err
+        }
+
+        await new Promise(resolve => setTimeout(resolve, 1000))
+      }
+    }
+  }
+}
+
+function getTokenInfoQueries (tokenAddress, opts = {}) {
+  const tokenTopic = zeroPadValue(tokenAddress, 32)
+  const queries = []
+
+  for (const e of tokenInfoEvents.values()) {
+    let query = queries[e.indexedTokenPosition]
+
+    if (!query) {
+      query = {
+        fromBlock: blockTag(opts.fromBlock),
+        toBlock: blockTag(opts.toBlock),
+        blockHash: opts.blockHash,
+        address: [],
+        topics: [[]]
+      }
+
+      queries[e.indexedTokenPosition] = query
+
+      if (e.indexedTokenPosition >= 1) {
+        for (let i = 1; i < e.indexedTokenPosition; i++) {
+          query.topics[i] = null // Allows any value at this position
+        }
+
+        query.topics[e.indexedTokenPosition] = tokenTopic
+      }
+    }
+
+    query.address.push(e.contract.address)
+    query.topics[0].push(e.event.topicHash)
+  }
+
+  return queries.filter(Boolean)
+}
+
+function parseTokenInfoLogs (tokenAddress, logs) {
+  const tokenInfo = []
+
+  for (const log of logs) {
+    const e = tokenInfoEvents.get(log.address.toLowerCase() + ':' + log.topics[0].toLowerCase())
+
+    if (!e) {
+      continue
+    }
+
+    const event = e.contract.interface.parseLog({ topics: log.topics, data: log.data })
+    const args = event.args.toObject()
+
+    if (args[e.argument].toLowerCase() !== tokenAddress.toLowerCase()) {
+      continue
+    }
+
+    tokenInfo.push({
+      program: e.programId,
+      contract: e.contractId,
+      name: event.name,
+      data: args,
+      blockNumber: Number(log.blockNumber),
+      transactionHash: log.transactionHash,
+      transactionIndex: Number(log.transactionIndex),
+      logIndex: Number(log.logIndex)
+    })
+  }
+
+  return tokenInfo
+}
+
+function blockTag (value) {
+  if (value === 'latest' || value === Infinity) {
+    return 'latest'
+  }
+
+  if (typeof value === 'number' || typeof value === 'string'/* || typeof value === 'bigint' */) {
+    return '0x' + BigInt(value).toString(16)
+  }
+
+  throw new Error('Invalid block tag value: ' + value + ' (' + (typeof value) + ')')
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "like-robinhood",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "files": [],
+  "scripts": {
+    "test": "standard && brittle test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lukks/like-robinhood.git"
+  },
+  "author": "Lucas Barrena (LuKks)",
+  "license": "UNLICENSED",
+  "bugs": {
+    "url": "https://github.com/lukks/like-robinhood/issues"
+  },
+  "homepage": "https://github.com/lukks/like-robinhood#readme",
+  "devDependencies": {
+    "require-npm-global": "github:lukks/require-npm-global"
+  },
+  "dependencies": {
+    "ethers": "^6.17.0"
+  }
+}