@calp-pro/honeypot-not 1.1.53

package/.github/workflows/update.yml

@@ -0,0 +1,59 @@
+name: Update honeypot.bin & honeypot-not.bin
+
+on:
+  push:
+    branches:
+      - main
+  schedule:
+    - cron: '0 * * * *'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  update-data:
+
+    permissions:
+      contents: write
+      id-token: write  # Required for OIDC
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v6
+
+    - name: Setup Node.js
+      uses: actions/setup-node@v6
+      with:
+        node-version: '24'
+        registry-url: 'https://registry.npmjs.org'
+
+    - name: Update npm
+      run: npm install -g npm@latest
+
+    - name: Install dependencies
+      run: npm install
+
+    - name: Run update
+      run: npm start
+      timeout-minutes: 50
+      continue-on-error: true
+
+    - name: Commit and push changes
+      id: commit
+      run: |
+        git config --global user.name "github-actions[bot]"
+        git config --global user.email "github-actions[bot]@users.noreply.github.com"
+        git add good_pairs.bin good_tokens.bin good_p2tt.bin honeypot.bin honeypot-not.bin
+        if ! git diff --cached --quiet; then
+          npm version patch --force -m "chore: update *.bin to %s [skip ci]"
+          git push --follow-tags
+          echo "can_publish=true" >> $GITHUB_OUTPUT
+        elif [ "${{ github.event_name }}" != "schedule" ]; then
+          echo "can_publish=true" >> $GITHUB_OUTPUT
+        else
+          echo "No changes"
+        fi
+

package/README.md

@@ -0,0 +1,34 @@
+# <picture><source media="(prefers-color-scheme: dark)" srcset="https://cdn.jsdelivr.net/npm/uniswap-v2-loader@5.0.1/logo-dark.svg"><img alt="calp.pro icon" src="https://cdn.jsdelivr.net/npm/uniswap-v2-loader@5.0.1/logo-light.svg" height="32" align="absmiddle"></picture>&nbsp;&nbsp;honeypot-not
+
+Filter pairs which don't have honeypot tokens.<br>
+Honeypot validation by [https://honeypot.is/ethereum](https://honeypot.is/ethereum).<br>
+All pairs processed from protocols:
+- **Uniswap V2**
+  * `0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f` fabric [contract](https://etherscan.io/address/0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f)
+- **SushiSwap**
+  * `0xc0aee478e3658e2610c5f7a4a2e1777ce9e4f2ac` fabric [contract](https://etherscan.io/address/0xc0aee478e3658e2610c5f7a4a2e1777ce9e4f2ac)
+- **PancakeSwap**
+  * `0x1097053fd2ea711dad45caccc45eff7548fcb362` fabric [contract](https://etherscan.io/address/0x1097053fd2ea711dad45caccc45eff7548fcb362)
+- **ShibaSwap**
+  * `0x115934131916c8b277dd010ee02de363c09d037c` fabric [contract](https://etherscan.io/address/0x115934131916c8b277dd010ee02de363c09d037c)
+- **DefiSwap**
+  * `0x9deb29c9a4c7a88a3c0257393b7f3335338d9a9d` fabric [contract](https://etherscan.io/address/0x9deb29c9a4c7a88a3c0257393b7f3335338d9a9d)
+- **EtherVista**
+  * `0x9a27cb5ae0b2cee0bb71f9a85c0d60f3920757b4` fabric [contract](https://etherscan.io/address/0x9a27cb5ae0b2cee0bb71f9a85c0d60f3920757b4)
+- **RadioShack**
+  * `0x91fae1bc94a9793708fbc66adcb59087c46dee10` fabric [contract](https://etherscan.io/address/0x91fae1bc94a9793708fbc66adcb59087c46dee10)
+
+Positive results stored at DEX DB dump files:
+- `good_pairs.bin`
+- `good_tokens.bin`
+- `good_p2tt.bin`
+
+File `honeypost.bin` store of honeypot (bad) tokenes addresses.<br>
+File `honeypost-not.bin` store NOT honeypot (good) tokenes addresses.<br>
+
+## Install and run:
+git clone https://github.com/calp-pro/honeypot-not
+cd honeypot-not
+npm install
+npm start
+```

package/csv2binary.js

@@ -0,0 +1,32 @@
+const fs = require('fs')
+
+if (!fs.existsSync('honeypot.csv')) {
+    console.log('No file "honeypot.csv" for convert to binary.')
+    process.exit(0)
+}
+
+const count = {good: 0, bad: 0}
+const lines = fs.readFileSync('honeypot.csv').toString().trim().split('\n')
+
+console.log('Found "honeypot.csv" file with', lines.length, 'tokens.')
+console.log('Converting to:')
+console.log('\t - honeypot.bin (bad)')
+console.log('\t - honeypot-not.bin (good)')
+console.time('convert')
+for (var i = 0; i < lines.length; i++) {
+    const [address, honeypot_is] = lines[i].split(',')
+    if (honeypot_is == 'true') {
+        count.bad++
+        fs.appendFileSync('honeypot.bin', Buffer.from(address.slice(2), 'hex'))
+    } else {
+        count.good++                
+        fs.appendFileSync('honeypot-not.bin', Buffer.from(address.slice(2), 'hex'))
+    }
+}
+console.timeEnd('convert')
+
+console.log('good:', count.good, 'bad:', count.bad)
+
+
+
+

package/index.js

@@ -0,0 +1,12 @@
+const dex_db = require('@calp-pro/dex-db')
+const fn = require('path').join(__dirname, 'good')
+
+var db
+
+module.exports = () => {
+    if (!db) {
+        db = dex_db()
+        db.load(fn)
+    }
+    return db
+}

package/is.js

@@ -0,0 +1,167 @@
+const fs = require('fs')
+const rl = require('readline')
+
+const uniswap_v2_dump = require('uniswap-v2-dump')
+const sushiswap_dump = require('sushiswap-dump')
+const pancakeswap_dump = require('pancakeswap-dump')
+const shibaswap_dump = require('shibaswap-dump')
+const defiswap_dump = require('defiswap-dump')
+const ethervista_dump = require('ethervista-dump')
+const radioshack_dump = require('radioshack-dump')
+
+const dex_db = require('@calp-pro/dex-db')
+
+const db = dex_db()
+if (fs.existsSync('good_pairs.bin')) {
+    db.load('good')
+    console.log('DEX DB dump "good" found with pairs:', db.get_all_pairs().length)
+}
+
+const honeypot = new Map() 
+
+const token_checked_count = {
+    good: 0,
+    bad: 0
+}
+if (fs.existsSync('honeypot.bin')) {
+    var buf = fs.readFileSync('honeypot.bin')
+    for (var i = 0; i < buf.length; i += 20) {
+        const address = '0x' + buf.slice(i, i + 20).toString('hex')
+        honeypot.set(address, true)
+        token_checked_count.bad++
+    }
+    console.log('Found "honeypot.bin" file with tokens checked:', token_checked_count.bad)
+}
+if (fs.existsSync('honeypot-not.bin')) {
+    var buf = fs.readFileSync('honeypot-not.bin')
+    for (var i = 0; i < buf.length; i += 20) {
+        const address = '0x' + buf.slice(i, i + 20).toString('hex')
+        honeypot.set(address, false)
+        token_checked_count.good++
+    }
+    console.log('Found "honeypot-not.bin" file with tokens checked:', token_checked_count.good)
+}
+
+Promise.all(
+    [
+        uniswap_v2_dump,
+        sushiswap_dump,
+        pancakeswap_dump,
+        shibaswap_dump,
+        defiswap_dump,
+        ethervista_dump,
+        radioshack_dump,
+    ].map(_ => _.load({workers: 0}))
+)
+.then(pairs => {
+    pairs = pairs.flat()
+
+    const count = {good: 0, bad: 0, cache_hit: 0, requests: 0}
+    
+    const check_request = address => {
+        count.requests++
+        return fetch('https://api.honeypot.is/v2/IsHoneypot?address=' + address)
+            .then(_ => {
+                if (_.ok) return _.json().then(_ => {
+                    if (!_) {
+                        throw 'Invalid JSON missed honeypotResult'
+                    } else if (_.simulationSuccess == false) {
+                        honeypot.set(address, true)
+                        fs.appendFileSync('honeypot.bin', Buffer.from(address.slice(2), 'hex'))
+                        throw 'Honeypot!'
+                    } else if (!_.honeypotResult) {
+                        throw 'Invalid JSON missed honeypotResult'
+                    } else if (_.honeypotResult.isHoneypot == true) {
+                        honeypot.set(address, true)
+                        fs.appendFileSync('honeypot.bin', Buffer.from(address.slice(2), 'hex'))
+                        throw 'Honeypot!'
+                    } else if (_.honeypotResult.isHoneypot == false) {
+                        honeypot.set(address, false)
+                        fs.appendFileSync('honeypot-not.bin', Buffer.from(address.slice(2), 'hex'))
+                    } else {
+                        throw 'Invalid JSON honeypotResult.isHoneypot'
+                    }
+                })
+                throw 'Request failed'
+            })
+    }
+
+
+    return pairs.reduce(
+        (p, pair, i) =>
+            p
+            .then(() => {
+                if (i % 1000 == 0) {
+                    db.sort()
+                    db.save('good')
+                }
+
+                rl.clearLine(process.stdout, 0)
+                rl.cursorTo(process.stdout, 0)
+                process.stdout.write(`${Math.round(10000 * i / pairs.length) / 100}% | good ${count.good} | bad ${count.bad} | cache_hit ${Math.floor(count.cache_hit)} | requests ${count.requests}`)
+
+                if (db.get_pair_tokens(pair.pair)[0]) {
+                    count.good++
+                    count.cache_hit++
+                } else {
+                    const is_honey_t0 = honeypot.get(pair.token0)
+                    
+                    if (is_honey_t0 == true) {
+                        count.bad++
+                        count.cache_hit += 0.5
+                    } else {
+                        const is_honey_t1 = honeypot.get(pair.token1)
+                        
+                        if (is_honey_t1 == true) {
+                            count.bad++
+                            count.cache_hit += 0.5
+                        } else if (is_honey_t1 == false) {
+                            count.cache_hit += 0.5
+                            if (is_honey_t0 == false) {
+                                count.good++
+                                db.index([pair.pair, pair.token0, pair.token1])
+                            } else {
+                                return check_request(pair.token0)
+                                .then(() => {
+                                    count.good++
+                                    db.index([pair.pair, pair.token0, pair.token1])
+                                })
+                                .catch(() => {
+                                    count.bad++
+                                })
+                            }
+                        } else {
+                            if (is_honey_t0 == false) {
+                                count.cache_hit += 0.5
+                                return check_request(pair.token1)
+                                .then(() => {
+                                    count.good++
+                                    db.index([pair.pair, pair.token0, pair.token1])
+                                })
+                                .catch(() => {
+                                    count.bad++
+                                })
+                            } else {
+                                return Promise.all([
+                                    check_request(pair.token0),
+                                    check_request(pair.token1)
+                                ])
+                                .then(() => {
+                                    count.good++
+                                    db.index([pair.pair, pair.token0, pair.token1])
+                                })
+                                .catch(() => {
+                                    count.bad++
+                                })                                
+                            }
+                        }
+                    }
+                }            
+            }),
+        Promise.resolve()
+    )
+    .then(() => {
+        db.sort()
+        db.save('good')
+    })
+})

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@calp-pro/honeypot-not",
+  "version": "1.1.53",
+  "description": "Filter all protocols by honeypot.is check",
+  "keywords": [
+    "honeypot.is",
+    "DEX"
+  ],
+  "homepage": "https://github.com/calp-pro/honeypot-is#readme",
+  "bugs": {
+    "url": "https://github.com/calp-pro/honeypot-is/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/calp-pro/honeypot-is.git"
+  },
+  "license": "MIT",
+  "author": "Vladimir Spirin (spirin.vladimir@gmail.com)",
+  "type": "commonjs",
+  "main": "index.js",
+  "scripts": {
+    "start": "node is.js",
+    "test": "node --test test.js"
+  },
+  "dependencies": {
+    "@calp-pro/dex-db": "2.1.*",
+    "defiswap-dump": "1.0.*",
+    "ethervista-dump": "1.0.*",
+    "pancakeswap-dump": "1.0.*",
+    "radioshack-dump": "1.0.*",
+    "shibaswap-dump": "1.0.*",
+    "sushiswap-dump": "1.0.*",
+    "uniswap-v2-dump": "3.0.*"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/test.js

@@ -0,0 +1,20 @@
+const { describe, before, it } = require('node:test')
+const assert = require('node:assert/strict')
+const honeypot_not = require('./index')
+
+describe('Honeypot-not', () => {
+
+    it('Find arbitrage pairs addresses between WBTC/WETH tokens at PancakeSwap and SushiSwap', () => {
+        var db = honeypot_not()
+        const pairs = db.find_pairs_with_tokens(
+            '0x2260fac5e5542a773aa44fbcfedf7c193bc2c599'/*WBTC*/,
+            '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'/*WETH*/
+        )
+        assert.equal(pairs[0], '0x4ab6702b3ed3877e9b1f203f90cbef13d663b0e8', 'WBTC/WETH (Pancake) https://etherscan.io/address/0x4ab6702b3ed3877e9b1f203f90cbef13d663b0e8')
+        assert.equal(pairs[1], '0xceff51756c56ceffca006cd410b03ffc46dd3a58', 'WBTC/WETH (Sushi) https://etherscan.io/address/0xceff51756c56ceffca006cd410b03ffc46dd3a58')
+    })
+
+})
+
+
+