I swear I google this exact error once a week. Finally made myself a quick reference for 12 common transaction errors and their    
fixes — out of gas, nonce too low, underpriced, chain ID mismatch, etc.                                                              

  Curious what errors you all run into most often and how you debug them.

Can someone tell me how to verify if sites are legit? I'm getting scam vibes on this one but no idea how to check.

Thanks

I keep seeing crypto projects describe transparency through dashboards, documentation, blog posts, or promises of future reporting.

But from an architectural perspective, those mechanisms still depend on someone choosing what to disclose. A system may expose its wallet balances while leaving its actual control structure difficult to understand.

For example:

– Are visible funds meaningful if upgrade permissions or admin controls remain opaque?
– Does a multisig materially reduce trust assumptions, or only distribute them across several signers?
– How important are timelocks, immutable contracts, permission boundaries, and publicly verifiable governance execution?
– Can governance genuinely be considered on-chain if critical decisions are still implemented through off-chain actors?
– How should developers communicate unavoidable trust assumptions without presenting the system as fully trustless?

I’m increasingly inclined to see transparency not primarily as a communication layer, but as an architectural property: what the system makes independently verifiable, and what it prevents operators from changing or concealing.

How do you distinguish between an observable system and one whose transparency still depends mainly on trusted actors?

An agent that holds a wallet decides in English but signs calldata or a typed message. A poisoned tool can make the plan look fine and the signature drain the wallet.

I built eight drains (approvals, EIP-2612 permits, EIP-712 orders, EIP-7702 delegations, Permit2) and scored each against a ladder of seven defenses, from a plan reviewer up to transaction and signature simulation. `./run.sh` runs the whole thing on a local fork.

Rendering the counterparty, amount, and recipient of a signature closes five of eight. Simulation adds nothing on top. One on-chain timing race (arm the contract after the dry-run, before inclusion) survives everything.

No new attack, just an honest map of what stops what.

Explainer: https://amarshat.github.io/quantum-commit-authorization/agent-drains.html

Code: https://github.com/amarshat/quantum-commit-authorization/tree/main/agent-calldata-demo

​

I've been building on a chain called Paxeer and using an agent platform called Matrix. Most AI tools I've tried are glorified chatbots. This one actually does real things on chain.

Let me explain what it can do and why it matters.

Neo is an autonomous agent built by Paxlabs. It's not a chatbot with plugins bolted on. It has a wallet, it can read and write files, run code, browse the web, manage long running processes, and execute transactions on chain without me touching anything.

I can tell it "send 100 PAX to this address" and it does it. I can tell it "build me a React app" and it scaffolds the project, writes the code, and shows me a live preview. I can tell it "stake my tokens" and it handles the delegation, confirms the transaction, and gives me the hash.

That's not a demo. That's what it does every day.

The Paxeer network

Paxeer is an EVM chain (chain ID 125) with sub second block times and deterministic finality. It runs on a custom consensus called MachineRFT integrated with a SEI fork for parallel transaction execution.

The native token is PAX. The chain has its own block explorer (PaxScan), a price API, and full EVM compatibility so anything you can deploy on Ethereum works here too.

What makes it interesting for agents is the speed. When your bot needs to execute a trade or move funds, you don't wait 12 seconds for a block. It's near instant. That matters when you're running automated strategies.

LayerX and USDX

This is where it gets interesting. LayerX is the agent settlement layer on Paxeer. USDX is a USD denominated, escrow backed balance that settles off chain but anchors on chain.

Why does that matter? Because agents need to move money fast without paying gas on every transaction. With LayerX I can pay another agent instantly and gaslessly. The sequencer signs a receipt, batches the transactions, and anchors the Merkle root to Paxeer on a schedule.

So Neo can deposit USDL into the LayerX vault to fund its USDX balance, pay other agents by their DID (decentralized identifier), withdraw back to on chain USDL whenever it wants, and force settle the current window if I need immediate on chain finality.

It's like having a bank account for your AI that moves at the speed of software.

The King Bot system

I built a multi agent trading system on top of all this. Four bots, each with a different role:

King Bot is the commander. He reads a daily orders file I set, and pushes parameters to the other bots in real time. I can tell him "be aggressive today" and all the bots adjust their position sizes, stop losses, and entry thresholds instantly.

The Spotter freelances across pools looking for dips and big sells. The Alchemist watches my specific tokens and trades patient arbitrage. The Wild Card explores random strategies and learns from what the other bots do.

They all share an event bus. When one bot finds something, the others see it and decide whether to act. They learn from each other's wins and losses.

Performance is tracked with KPoints. Better bots get more capital. Worse bots get less. It's a self correcting meritocracy.

I literally gave my ideas and Neo started writing.

Most crypto AI projects are chatbots that tell you the price of Bitcoin. This is an agent that can actually operate on chain. It has custody of its own funds. It can execute multi step transactions. It can build and deploy software. It can manage other agents.

The whole thing is open source and you can dig into it here: https://github.com/Paxeer-Network give it a star!

The infrastructure is real and it's live right now. Paxeer is running. LayerX is running. Neo is running.

I'm not selling anything. I'm just sharing what I've been building because I think people in this space would find it interesting.

This is a pre-lease and I've been lucky enough to get in early.

This was written by Neo and edited by me. I don't want to act like I wrote this.

Hoping someone's been through this. We built an address-activity feature on alchemy_getAssetTransfers since it's free with our RPC.

• It returns transfers, not transactions → approvals, failed txs, zero-value calls, gas-only txs are all invisible. I need every tx hash for an address and it structurally can't give me that.
• fromAddress/toAddress are ANDed, so full history = two paginated scans merged + deduped on my side (plus a consistency problem since blocks land mid-scan).
• The internal category only exists on Eth/Polygon mainnet — on the L2 we care about, ETH moved inside contract calls just doesn't show up.
• 1,000 rows/page, 120 CU/call, re-walking cursors on every refresh = ~1M calls/day basically polling to fake a stream.

Questions: (1) Is there a config I'm missing that returns all tx hashes incl. approvals + failed? Or is it just not built for that? (2) How are you handling complete address history + internal transfers on L2s without an insane RPC bill?

I spent the last weeks integrating four bridge aggregators (LI.FI, Relay, deBridge, Squid) into a route comparator, and some behaviors cost me days because they're barely documented. Sharing so you don't rediscover them:

1. Provider APIs screen the SENDER address. Quote with a placeholder (the classic 0x...dEaD) and behaviors diverge: one API returned a 403 "swaps unavailable" that looked exactly like a tier block, and turned out to be compliance screening of the dead address. The fix is a two-path architecture: indicative quotes for display, and transaction building only with the user's real address. If your UI shows "executable" quotes built on a placeholder, it's lying to the user.

2. The same integrator fee concept exists in three units across four APIs: a decimal fraction (0.003) in one, basis points (30) in two others, and a percentage string in the last. Mixing them up means charging 100x or 10000x the intended fee. Unit tests on the fee math are not optional.

3. Some providers have TWO entry contracts depending on whether a source swap is needed before the bridge. If you validate transaction targets against an allowlist (you should), allowlist both, and verify them against the provider's deployment docs, not against what the API returns that day.

4. Quotes are only comparable if they answer the same question. We rank by guaranteed minimum received after ALL fees (including our own), not by the estimated amount, because estimates are where quotes flatter themselves.

Context: I'm the founder of the comparator in question (rempart.app), this post is the writeup I wish existed a month ago. Happy to detail any of these.

I'm sure everyone in this subreddit has dealt with it at some point. The google meets isn't working, download my totally legit video conferencing app, the test my malware laced blockchain game, npm install with a postinstall script that phishes your npm token. Aside from being a major time sink, reading up on the company, familiarizing their tech stack, canceling social engagements it leads to coordination failure in the hiring market, leading to suboptimal teams, leading to suboptimal crypto.

I was thinking that if a developer could respond to an employer with a magic link that got them to stake through a repuidable platform against the interview that we'd naturally see alot of scams retreat, alot of developer time saved and better teams in crypto.

would any devs be interested in using such a system? or real employeers stuck on cold calling that'd be happy to lead with a stake?

Hi, is there anyone willing to attend the ETH Global Lisbon hackathon?
I am looking to either form a team (Work on a project I have) or join an existing team, I am open to anything as I jast want to have a fun project ..
as for my background id ML/AI.

Hi everyone.

My name is Teja. I'm 21 from India, and honestly I feel like my life has no motion right now.

I'm a 3rd year CS student in the same lame ass college that I hate so much. I don't like this place, I don't connect with the people here, and I honestly don't like my friends either. I know it sounds harsh, but that's genuinely how I feel. It feels like I'm at the wrong place with the wrong people, and I'm trapped.

I tried a lot of times to get out of this college, but because of my family's financial situation, I can't just leave. So I kept looking for ways to make money online. I tried a lot of the things people recommend, but nothing really worked.

Then I watched Mr. Robot.

I thought hacking looked cool, so I started learning. Eventually I found Web3 security, and I completely fell in love with it.

Since then I've spent countless hours reading smart contracts, learning Solidity, using Foundry, writing PoCs, and hunting for vulnerabilities. The problem is... I still haven't been paid even once.

One of the biggest things I worked on was an ERC-4337 EntryPoint bug. I genuinely believed it was a critical issue. I spent almost 8 months researching it. I built multiple PoCs, gathered evidence, exchanged around 50 emails with one of the code authors, argued back and forth about the issue, and kept trying to prove that it was real.

I honestly thought, "This is it. This payout is going to change my life."

I thought maybe I'd finally have enough money to leave this college or even leave my country one day.

Instead, the report got marked as spam, my GitHub issue was closed, and nothing happened.

Eight months of work... and I got nothing.

After that I just kept hunting.

I got duplicate reports.

I got informative reports.

When I first started, I didn't even know how to write proper bug bounty reports, and I eventually got banned from Immunefi because of it. That was completely my fault, and I learned a lot from that mistake.

Now I mostly use HackenProof and other platforms, but sometimes they require money to submit reports or there are platform issues. There have been times where I literally couldn't report a bug because I didn't have the money or because something on the platform wasn't working.

One example was Hyperbridge.

I found 4 vulnerabilities—2 Critical and 2 High. One of them was a token inflation bug that I thought was a really big deal.

I actually had to ask my father for $5 just so I could report it.

Then HackenProof had some wallet issue where my balance wasn't showing correctly. I emailed them.

No response.

I emailed the protocol directly and explained everything.

They replied once and then later just told me to submit it through HackenProof even after I explained that I couldn't because of the platform issue.

Later I noticed that one of the bugs I had publicly documented was fixed.

Still no reward.

Still no response.

Again... I was stuck.

At that point I started feeling like bug bounties weren't enough, so I began applying for security researcher jobs.

I applied to OtterSec.

I even got to chat with one of the founders, and I was so excited because I thought maybe this was finally my chance.

Then came the interview.

It was just an intro interview, but I'm still a student, English isn't my first language, and I'm not really someone who's good at talking.

I tried my best.

I really did.

But I got rejected.

It was my first rejection, and it hurt because I felt like I had wasted such a huge opportunity.

Recently I got another opportunity.

Nethermind invited me to interview for their internship program.

I had my interview on the 16th. I think I did much better than the OtterSec interview, and now I'm waiting to hear back about the next steps.

I hope something comes from it.

During my summer holiday, I basically locked myself in my room for almost 2 months.

While my friends were going on trips and hanging out, I was sitting in front of my laptop every day hunting bugs, reading code, and trying to improve.

Sometimes I wonder if I'm wasting my life.

Sometimes I wonder if all of this effort is going to lead anywhere.

Now my holidays are over, and I'm back in the college hostel that I hate.

I honestly almost cried when I left home because I really didn't want to come back here.

I still have bugs that I haven't reported because of everything that's happened with Immunefi.

I keep posting my research on GitHub because I don't want all this work to disappear.

If anyone wants to see it, my GitHub is Tejanadh.

Right now I just don't know what to do.

I'm 21.

I'm in my 3rd year.

I feel like I'm trapped.

I don't know if I should keep focusing on bug bounties, keep applying for security jobs, build more public research, or completely change my approach.

I'm not looking for sympathy.

I just want honest advice from people

Thanks for reading.

Depending on how much risk you're willing to take you can make higher or smaller APYs for a given amount of time I'll find you the ideal project to put your money in given the fact that there is thousands if not millions of crypto projects where you can deposit your money and make some return

Most people are comfortable depositing their money in lending protocols where they earn a fixed return per year while others are more open to investing into places where the returns are way higher but there is more risk by using a platform that's not as established. So just drop your risk preferences and I'll find you the ideal project for you to put your money in

Two months ago I posted here after analyzing 78,723 Ethereum token contracts and finding 46% scored as scams. I re-ran the same query today. The table now holds 112,114 contracts, and the all-time rate rose to 59.8%.

But the average buries the story. Of the 31,172 tokens deployed since that post, 76.4% are scams, and the monthly rate just hit 82.8% in July.

Honesty check, because I got asked this directly: how much of the 46 -> 60 jump is a scammier chain vs a sharper detector? Both, and I can't cleanly separate them:

- More scams: every real-time month lands between 70% and 83% at a fixed 70+ threshold.

- Sharper detector: a scam now carries 11.06 flags on average vs 8.27 in May (+34%), new detectors landed (serial-scammer bytecode, drainer kits, hidden kill-switches). Our score floors on flag COUNT, so more flags push more contracts over the line.

- Late rugs: ~30% of the table gets re-scored a day+ later. A token clean at launch that pulls liquidity a week later flips clean -> scam with zero new scams deployed.

TL;DR

- 78,723 -> 112,114 contracts in 2 months.

- All-time scam rate 46.1% -> 59.8% (three overlapping causes, not one).

- New launches since May: 76.4% scams. July: 82.8%.

- 441,762 distinct victim wallets traced across 5.26M scam-token transactions.

Full breakdown with the monthly chart and the limits-of-our-data section:

https://rektradar.io/blog/posts/new-ethereum-tokens-76-percent-scams/?utm_source=reddit&utm_medium=post&utm_campaign=mik3fly_76pct-scams

EDIT: a few of you asked the right question, so i went and pulled it. how much of this 76% is detectable AT LAUNCH vs only later? tracking the same 24,150 launches from deploy to day 30: 48% score as scams at launch, 91% by day 30. 43% are late rugs (clean at launch, scam within a month). and 76% of the flagged ones actually got traded vs 67% of legit deploys that never trade. full writeup + chart: https://rektradar.io/blog/posts/how-many-ethereum-scams-detectable-at-launch/?utm_source=reddit&utm_medium=post&utm_campaign=mik3fly_scams-detectable-at-launch

Hey everyone,

I’m currently participating in a hackathon, and the idea for my project came from a problem I’ve seen in collaborative bug bounty work.

Sometimes you team up with researchers you don’t know well. If the report receives a bounty, the payment usually goes to one person, and everyone else has to trust that they will distribute it according to what was agreed in DMs.

That can become awkward, especially when the payout is large or the collaborators have never worked together before.

I built AuditSplit as an experiment to make that agreement explicit before submitting the report:

• The team creates a dedicated payout vault.
• Everyone agrees on the percentages.
• Every recipient accepts the agreement.
• The bounty is sent to the vault.
• Each researcher claims their share independently.

The vulnerability details remain private and never go onchain.

I’m mainly looking for honest feedback:

1. Does this solve a real problem for collaborative researchers?
2. Would the onchain step add too much friction?
3. What could go wrong in a real collaboration?

Links

• 🌐 Live app
• 💻 [GitHub] (https://github.com/alva-p/spark-buildAnything-hackaton)
• 𝕏 [Twitter post] (https://x.com/pimmpi_/status/2077141703522148723)

The hackathon also considers social engagement. If you genuinely like the idea and want to support it, a like or repost on Twitter would help.

Absolutely no pressure, honest criticism and feedback are more valuable to me than engagement.

Looking for an experienced Solidity/web3 engineer to help fix a current integration issue. Deadline is tight, so I only need someone who's genuinely done this before — not looking to train anyone up.

Just need a quick call first to walk through the problem together and see if it's a fit.

If interested, drop a comment or DM me with a bit about your background (chains/protocols you've worked with, anything relevant to integrations).

Just wrapped up building a fiat-to-onchain checkout flow for a B2B project and wanted to get some feedback on the architecture from anyone who’s built similar bridges.

The project is a transferable ERC-1155 membership pass on Base (capped at 200 total supply across three tiers) for a VR training company. Most of the buyers are traditional trades colleges and safety orgs who have zero crypto experience, so expecting them to connect a wallet at checkout was out of the question.

The contract itself is already live on Base. The hard part wasn't writing the Solidity—it was connecting PayPal to an onchain mint without leaving room for weird, asynchronous edge cases.

The basic flow is: a customer pays $300 USD via PayPal, gets an ERC-1155, a subscription entitlement mapped to their verified email, a PDF cert, and a confirmation email.

For the wallets, we split them into two paths: If they already have an address, we validate it (checksum, zero address, and known burn address checks) and mint directly to it after PayPal captures the payment. If they don't have one, we spin up an embedded Thirdweb wallet mapped to their email, mint to that address, and email them a claim link so they can export their private keys later if they want to.

The piece I spent the most time overthinking was the gap between PayPal capturing the funds and the transaction actually landing onchain. Doing it all in one synchronous request felt incredibly fragile. If PayPal succeeds but the RPC times out, you're stuck guessing if the mint landed. If the transaction reverts after payment is captured, you've taken fiat but delivered nothing.

To handle this, I treated every purchase as a simple state machine backed by a JSON sidecar file for each order. The order transitions through pending, paypal_captured, mint_submitted, mint_confirmed, emails_sent, and finally complete.

We write every state transition to disk synchronously (fs.writeFileSync). If the server crashes mid-flow, a cron job just picks up the JSON file and resumes from the last state instead of risking double-mints. If an order gets stuck in mint_submitted for more than 5 minutes, the cron checks the transaction hash. If it never hit the mempool, we rebroadcast with higher gas. If it reverted, it fires an alert for manual handling.

I know using JSON files instead of Postgres sounds a bit janky, but with the collection capped at 200 passes, I wanted something dead-simple that I could easily grep, inspect, and fix manually if needed. I definitely wouldn't do this for a high-volume drop.

One design choice I'm still wrestling with is how we handled entitlements. Even though the NFT is transferable, the actual pricing discount is tied offchain to the buyer's verified email, not the wallet address holding the token. The token is basically just a proof of purchase, while the actual service utility lives offchain. We looked into doing onchain entitlements or SBTs, but B2B clients constantly need to reassign seats and access when employees leave or organizations restructure, which is a support nightmare to manage purely onchain.

We also run the destination wallet through Chainalysis’s sanctions oracle before authorizing the PayPal checkout. PayPal does its own KYC, but we wanted to make sure we weren't minting straight to an OFAC-flagged address if someone supplied one.

Curious how other devs are tackling these hybrid flows:

1. Is there a cleaner way to handle the gap between fiat capture and mint confirmation without building out a custom state machine?
2. For NFTs tied to B2B or SaaS utility, where do you draw the line between onchain ownership and offchain permissions?
3. How much sanctions screening do you actually bother with for hybrid checkouts beyond what the payment processor already handles?

It is surprisingly hard to find solid technical discussions on this stuff since most Web3 docs just assume everyone is checking out with a browser extension.

Did the full vendor evaluation for our B2B platform last year, ended up picking cybrid but bvnk was a real contender. Writing this up because most online comparisons are either marketing fluff or thinly disguised ads, neither of these companies is paying me.

Where cybrid won for us, US and Canada money transmitter licensing is comprehensive, our origination volume is heavily north america. ACH Pull on the bank side, which means our platform can debit customer accounts directly instead of asking them to push from a bank app every time. FBO account structure was clear, the trust agreement was easy to share with our auditor. Dev experience and sandbox were solid, sandbox to production took us about 10 weeks. Support team responded fast during integration.

Where bvnk won, EU footprint is broader, if our origination volume had tilted european we likely would have picked them. Their corridor coverage in emerging markets is wider in some regions. The product is more mature on the FX management side for platforms that want more granular control over conversion economics.

Where they tied or didn't matter. Pricing was roughly comparable for our volume tier, neither was dramatically cheaper. Both have proper KYC, both handle USDC settlement, both offer the cross border speed of 10 to 30 minutes for major corridors. API design is conventional on both, neither requires exotic engineering work.

How to actually decide between them. Map your corridor volume first. If origination is primarily north america, lead with cybrid because the ACH Pull and us/canada licensing match the use case. If origination tilts european, bvnk is the stronger fit. If volume is genuinely split, talk to both and let pricing on your specific corridor mix decide.

Neither is wrong, the answer depends on where your money moves.

Lightning Labs open-sourced lightning-agent-tools

in February 2026 — a toolkit for AI agents to

transact autonomously on Lightning.

The technical stack:

lnget — like curl but Lightning-aware. Detects

HTTP 402 responses, pays the invoice, caches

the macaroon, retries. Fully automatic.

Aperture — reverse proxy that turns any API

into a pay-per-use Lightning endpoint. Full

agent-to-agent commerce loop.

Remote signing — keys live on a separate

signer machine. Agent handles payments but

never touches private keys.

Scoped macaroons — cryptographic spend limits

per agent: "max 1000 sats/hour" or

"invoices only, no payments."

MCP support — Claude Code, GPT, and custom

AI frameworks can query node state and trigger

payments via Model Context Protocol.

For node runners, this is directly relevant:

AI agent micropayments mean more routing

traffic and demand for well-connected,

liquid nodes.

Full breakdown with practical example:

https://davidebtc186.substack.com/p/ai-agents-are-starting-to-pay-in

​

I’m an economist working on an early DeFi credit concept in the lending / risk-pool space.

I’m non-technical, so I’m looking for someone with Solidity / smart contract experience who can challenge the idea from a technical perspective and potentially join as a co-founder if there is a fit.

I don’t want to disclose the full model publicly yet, but the direction is capital-efficient DeFi lending with automated risk logic.

I can handle the economic model, product thinking, documentation, research, outreach and business side.

If you’re interested in DeFi lending, credit markets or risk-pricing mechanisms, feel free to DM me.

Is anyone else tracking the architecture of newly launched EVM networks and rollups lately?

A year or two ago, every time a new L2 dropped, the native ecosystem teams would just fork Uniswap V3, spend months fighting with the codebase, and call it a day.

But look under the hood of successful hubs like Camelot, THENA, or QuickSwap now. None of them are running on custom backends anymore. They all shifted to Algebra’s modular framework instead of wasting time rewriting concentrated liquidity math from scratch.

Honestly, from a dev perspective, building your own DEX backend today feels like hosting your own physical servers instead of just using AWS. Why sink 4 months of senior Solidity hours into tick management and flash loan protection when there’s a licensed B2B infrastructure ready to go?

Plus, monolithic forks are just too rigid. If you want to add something like AI-driven dynamic fees or RWA hooks later, you have to redeploy everything and pray you don't break the core contracts. With a modular setup you just plug features in as modules without burning six figures on another top-tier code audit and stalling your roadmap for months.

Managing custom forks across 5 networks is a complete DevOps nightmare anyway. The industry is clearly shifting toward integrating proven infrastructure so teams can actually focus on their product wrapper and building a community.

For the devs or founders here - are you guys still looking at custom forks for new rollups, or is everyone pretty much moving to white-label frameworks now?

Hey everyone,

I’ve been working on a project that tries to solve one of the biggest issues in DeFi right now: unwarranted liquidations caused by temporary exchange flash-crashes and market noise.

Most traditional oracles just pass raw aggregated spot prices to smart contracts. To fix this, I built Antigravity: a First-Party Oracle powered by a Spiking Neural Network (SNN).

How it works under the hood:

• The AI: Instead of Deep Learning, I used an SNN. Because it processes discrete "spikes", it’s naturally suited for time-series data and is incredibly aggressive at filtering out short-term market anomalies in the order book before they hit the spot price.
• The Backend: The inference engine runs on a dedicated A1 ARM64 server built entirely in Rust for memory safety and ultra-low latency.
• The Blockchain Layer: I integrated it using API3's Airnode architecture. This means it’s a true first-party oracle—the data goes straight from my Rust node to the blockchain without third-party node operators acting as middlemen.

It’s currently live and tested on Optimism Sepolia, and I’ve just submitted a proposal to the API3 DAO to get it integrated into their official dAPIs for BTC/USD.

I built a small landing page explaining the architecture and demonstrating the live latency spikes: 🔗 https://oracle-landing-page-seven.vercel.app/

I would love to hear feedback from smart contract developers or AI folks here. Do you think DeFi protocols would benefit from using AI-filtered price feeds for their liquidation engines?

Any feedback is greatly appreciated!