r/ethdev • • Aug 26 '26

Information Glamsterdam Repricing Impact for Smart Contract Developers

Thumbnail
blog.ethereum.org
3 Upvotes

r/ethdev • • Jul 17 '24

Information Avoid getting scammed: do not run code that you do not understand, that "arbitrage bot" will not make you money for free, it will steal everything in your wallet!

55 Upvotes

Hello r/ethdev,

You might have noticed we are being inundated with scam video and tutorial posts, and posts by victims of this "passive income" or "mev arbitrage bot" scam which promises easy money for running a bot or running their arbitrage code. There are many variations of this scam and the mod team hates to see honest people who want to learn about ethereum dev falling for it every day.

How to stay safe:

  1. There are no free code samples that give you free money instantly. Avoiding scams means being a little less greedy, slowing down, and being suspicious of people that promise you things which are too good to be true.
  2. These scams almost always bring you to fake versions of the web IDE known as Remix. The ONLY official Remix link that is safe to use is: https://remix.ethereum.org/
    All other similar remix like sites WILL STEAL ALL YOUR MONEY.
  3. If you copy and paste code that you dont understand and run it, then it WILL STEAL EVERYTHING IN YOUR WALLET. IT WILL STEAL ALL YOUR MONEY. It is likely there is code imported that you do not see right away which is malacious.

What to do when you see a tutorial or video like this:

Report it to reddit, youtube, twitter, where ever you saw it, etc.. If you're not sure if something is safe, always feel free to tag in a member of the r/ethdev mod team, like myself, and we can check it out.

Thanks everyone.
Stay safe and go slow.


r/ethdev • • 3h ago

My Project We paid 25,011 x402 API calls on Base with our own USDC and recorded what came back. 6.3% settled and failed the buyer. Data with transaction hashes.

2 Upvotes

x402 is the HTTP 402 flow: request, 402 with a USDC price, sign an EIP-3009 transfer, retry, facilitator settles. Nothing in it tells the buyer whether the seller will deliver or charge the listed price, so since October we have been the paying customer of every seller we could find in the Coinbase Bazaar.

Numbers as of today (live):

  • 25,011 paid calls to 1,036 sellers, about 135 USDC in total
  • 1,587 failed the buyer: 6.3%, 95% Wilson interval 6.0% to 6.7%
  • 1,080 of those settled on-chain, then returned 4xx/5xx, an empty or wrong-typed body, or nothing within the seller's own declared timeout
  • 507 quoted a price above the one the seller lists in the Bazaar; the official client has no expected price to compare with, so it paid every one; 428 were at 2x or more
  • Of 312 sellers with at least 30 paid calls, 228 have never failed one; 27 are rated avoid
  • The top 20 sellers by 30-day on-chain inflow fail at 10.3% [9.5%, 11.1%]; a random tail at 3.6% [3.1%, 4.0%]

The protocol finding: the exact scheme has no idempotency key. We sent one intent twice with fresh signatures to 10 sellers and 5 settled both. A plain retry after a dropped connection settled a second time at 5 of 10. Each new signature is a new payment, so a client that retries after a timeout or a paid 500 pays again unless it stores the nonce per intent and replays the stored result.

Method: u/x402/fetch 2.28, exact only, no retries, caps in code before any signature (0.50 USD a call, 20 a seller a day, 100 a day). Every settlement is matched to the AuthorizationUsed log for the nonce we signed. Wrong goods are unmeasured (no per-service schemas), so every rate is a lower bound. The sample is weighted to cheap calls; the dollar-weighted rate is 18.5% with an effective n of about 3,300, so treat it with care.

Harness, MIT: https://github.com/sarmadahsan/x402-audit Data, hourly, with hashes: https://github.com/sarmadahsan/paidfor-data Method and limitations: https://paidfor.dev/methodology

Disclosure: we run paidfor.dev, which publishes these as per-seller verdicts, and maintain two buyer-side clients on the official SDK. Sellers do not pay for ratings; every seller page has a reply route and one seller has already used it to get a correction published.


r/ethdev • • 13h ago

My Project Lasso RPC v0.9.0: routing around hung endpoints, head-aware reads, and standalone builds

1 Upvotes

[Lasso RPC](https://github.com/jaxernst/lasso-rpc) is an open source (Apache-2.0) smart proxy for aggregating EVM RPC providers. You drop in one Ethereum JSON-RPC URL with a programmable routing strategy in the path (`/rpc/fastest/ethereum`, `/rpc/load-balanced/ethereum`), and Lasso measures each provider from live traffic and routes between them.

The annoying part is that providers all fail differently with transient network issues, rate limits, and frequent latest-block lag. v0.9.0 ([release notes](https://github.com/jaxernst/lasso-rpc/releases/tag/v0.9.0)) closes a few of those gaps:

- **Hung or unstable endpoints leave rotation.** A hang isn't an error response, so a timeout didn't count against the endpoint and it kept getting traffic. Now a timeout triggers a health check, and two failed checks take it out.

- **`latest` reads always go to endpoints at the chain head.** This replaces the fixed `max_lag_blocks` setting and ensures latest blocks can be strictly monotonic (except for during reorgs). Lagging endpoints still serve historical reads.

- **Fast modes don't trust unproven endpoints.** `fastest` no longer sends traffic to failing endpoints that haven't proven themselves, and `balanced-fast` no longer locks a method onto whichever endpoint qualified first.

- **Standalone builds** for Linux (x86_64, aarch64) and macOS on Apple silicon. No Docker or Erlang needed: unpack, run `lasso/bin/lasso start`, and point your client at `http://localhost:4000/rpc/ethereum`.

Since my last post here (v0.6), Lasso also started learning provider limits from live traffic (v0.7) and pinning tx sends to providers you choose (v0.8).

**Where these fixes came from:** Bloom, an open source wallet, had a failover bug where it never reached a chain's third endpoint ([#527](https://github.com/bloom-directory/bloom/issues/527)). I built a harness that reproduces wallet failure cases like that one and posted the results on [their tracker](https://github.com/bloom-directory/bloom/issues/540). Run 1 exposed the hung endpoint problem. Run 2, on v0.9.0 meaningfully improved these results.

Still hard: a burst of txs to an endpoint that silently drops them can lose some before Lasso notices, and a lagging endpoint can serve stale reads between head checks (faster head checks are next).

I'll rerun this every release. If you've hit an RPC failure in prod that's worth testing, drop it here and I'll add it to the next run.


r/ethdev • • 1d ago

Question How do you stop Safe signers from going around a DAO vote?

3 Upvotes

Someone posted a DAO treasury prototype this week where governance votes on the mandate and a Safe executes it. They had just added a proposal, a vote and a delay before any mandate change, which is good. But the signers are still Safe owners, so they can call execTransaction and send the treasury anywhere, vote or no vote.

My first thought was a guard that only lets through calls the current mandate allows, or giving the signers a Zodiac Roles module instead of owner keys. The more I look at the guard version the less clean it gets.

setGuard is a Safe transaction too, so the owners can just remove the guard unless it also blocks calls to setGuard, enableModule, changeThreshold and the owner functions, and then a bug in the guard can lock the Safe for good, removing it included. And on 1.3 and 1.4 Safes a module goes through execTransactionFromModule, which never touches the transaction guard, so one enabled module is a way around it. 1.5 added module guards for exactly that.

So right now I lean towards the signers not being owners at all, only role holders, with the owner being something governance controls. I'm not sure that holds up once you need someone to act fast in an incident though.

If you run a treasury where the vote is supposed to bind the signers, what actually enforces it today, and what did you give up to get there?


r/ethdev • • 1d ago

Question NEW PROJECT

1 Upvotes

Hello!

I am a solo dev trying to develop a new web3 project. is anyone here from europe willing to help testing? thanks!!!


r/ethdev • • 2d ago

Information [Notice] agent-security-gate-x402: 7-Day Transition to Cloud-Native Thin Client (v3.0.0) & Legacy PyPI Yank (Nov 20 – Nov 27)

1 Upvotes

Hi r/ethdev,

We’re announcing a **7-day transition window (Nov 20 – Nov 27, 2026)** to move our Python SDK/MCP package `agent-security-gate-x402` (`v2.2.1`) from a heavy local bundle to **`v3.0.0` (Cloud-Native Thin Client & Remote Gateway)**.

### Why this matters for EVM / Agent Wallet builders

  1. **Live Threat & Drain Rules > Stale Local Packages:** ERC-20 `approve` / `increaseAllowance` / `permit` drain bypasses, prompt injections, and dangerous AST payloads evolve constantly. Centralizing inspection on our Cloud Gateway guarantees `<5ms` up-to-date defenses and EIP-712 attestation generation without waiting for manual package upgrades.
  2. **Zero-Bloat Client:** Moving away from bundling `fastapi`, `uvicorn`, `web3`, and `eth-account` locally—`v3.0.0` only needs lightweight HTTP/MCP deps (`httpx`, `mcp`) while keeping full **Polygon OMS (`SecurityGateOMSPolicy.sol`), Base AgentKit, and Arbitrum Safe/Stylus** guardrails active on the gateway.

### 7-Day Schedule (Nov 20 – Nov 27, 2026)

* **Nov 20 (Day 1):** Official 7-day transition notice published.

* **Nov 21–23 (Days 2–4):** Remote Gateway & `v3.0.0` Thin Client compatibility verification.

* **Nov 24–25 (Days 5–6):** `v3.0.0` Thin Client published to PyPI; final migration window.

* **Nov 27 (Day 7):** Legacy PyPI releases (`<= v2.2.1`) will be **yanked on PyPI**.

Existing integrations keep working smoothly during the 7-day window.

🌐 Gateway: `https://agent-security-gate-x402-212942243360.asia-northeast3.run.app` (`/docs`, `/llms.txt`, `/.well-known/agent-card.json`)


r/ethdev • • 2d ago

Information Solidity 0.8.39 released

10 Upvotes

Solidity v0.8.39 fixes a medium-severity bug that could silently corrupt storage when copying recursive structs, and warns about code size based on the new limits of the Amsterdam EVM version. It is likely the last release of the 0.8 series before 0.9.0.

Recursive struct copy bug fix

  • A struct is recursive when it can contain values of its own type, as in struct Node { Node[] children; uint256 data; }.
  • When such a struct, or an array of such structs, was copied within storage to a location that contained it, as in root = root.children[0] or roots = roots[0].children, the copy overwrote the source before it had finished reading it. The elements nested in the source were lost, and the members declared after the array came back as zero. No error was reported.
  • Versions 0.4.9 to 0.8.38 are affected with the default evmasm pipeline, and versions 0.8.13 to 0.8.38 with --via-ir. The optimizer settings and the EVM version do not matter.
  • The fix adds a runtime check to every storage-to-storage copy of a recursive struct or an array of such structs. The check costs extra gas, and copies into deeply nested targets can run out of stack space at a smaller depth than before.
  • A scan of the verified contracts on Sourcify found no deployed contract that performs an affected copy.
  • The bug was reported by cyberthirst through the Ethereum Foundation's bug bounty program.
  • The write-up has the details and explains how to check your contracts: Overlapping Recursive Storage Struct Copy Corruption Bug

Other changes

  • In the evmasm pipeline, a nested tuple assignment with a string literal could assign values to the wrong variables. For example, with bytes32 z and uint256 a, ((z, a), b) = (("x", 111), 222) assigned 111 to z and bytes32("x") to a. We do not consider this a security issue, because the pattern is unusual and unlikely to be used in practice.
  • When compiling with --evm-version amsterdam, the compiler now warns about contract code larger than 64 KiB and initcode larger than 128 KiB, the new limits from EIP-7954. For all other EVM versions, including the current default Osaka, the warnings still use the old limits.
  • The compiler now also warns about code size when it compiles standalone Yul code.
  • With --ethdebug-resources, the compiler now emits the full info/resources schema of the ethdebug format, which describes types and their layout to debuggers. ethdebug output remains experimental and requires --experimental. For an introduction to the format, see ethdebug: a shared language for debug data, in use across projects today.

Solidity 0.9.0

  • For years, we planned 0.9.0 as a large breaking release that would make the IR pipeline the default. Our plans have changed. We still plan to make the IR pipeline the default, but we no longer tie this to 0.9.0. Instead, we want to make breaking releases more often and make them smaller.
  • Most of the changes merged for 0.9.0 so far remove features that earlier 0.8 releases deprecated, such as ABI coder v1, virtual modifiers, the ABIEncoderV2 pragma, the SMTChecker's BMC engine and the EVM versions older than Constantinople.
  • We plan to publish a pre-release of 0.9.0 before the final release. A separate post will explain the new release schedule and the reasons for it.

Links


r/ethdev • • 2d ago

Question Why do some Web3 communities become inactive even when a project is still growing?

3 Upvotes

Building a community around a Web3 project is one thing. Keeping people interested and involved over time is a different challenge.

Some projects have thousands of members across Discord and Telegram, but only a small number actively participate in discussions. Others may have smaller communities where members regularly share ideas, ask questions and contribute to the project.

It makes me wonder whether community growth should be measured by the number of members or by how much people actually participate.

For those involved in Web3 communities, what do you think makes members stay active and genuinely interested in a project beyond launch announcements, giveaways and token-related discussions?


r/ethdev • • 2d ago

Information Tau bounty program just launched

1 Upvotes

Hi all,

We at Tau just launched our developer bounty program with over $10K in rewards.

Tau is all about creating new features in blockchain, made possible with a language that can formally represent and reason everything in its system.

Here are the first set of rewards: https://tau.net/bounty-program


r/ethdev • • 2d ago

My Project Got rejected by Alliance multiple times, kept building, launched fixed-rate DeFi today

1 Upvotes

Short version: DeFi still doesn't have a basic piece of finance, which is fixed rates. We spent a long time iterating on an onchain rate swap design until it worked.

Kairos lets you fix the rate on a loan you already have without moving it. Live on Ethereum and Base.

AMA about the design or the grind.

https://x.com/alliance/status/2123435204643602873


r/ethdev • • 3d ago

My Project Zean: write Zig, prove it in Lean

Thumbnail
github.com
1 Upvotes

We just open-sourced **Zean** (Zig + Lean), a toolkit for translating supported Zig functions into executable Lean models and proving their behavior. It came out of our formal verification work on [oksolc](https://github.com/okcontract/oksolc), our Solidity compiler written in Zig.

Zean works from AIR, Zig's analyzed intermediate representation. An instrumented compiler captures supported functions from AIR, and a translator emits executable Lean program definitions. Specifications and proofs live in separate handwritten Lean modules.

A verification library derives the proof obligations for memory access, initialization, permissions, arithmetic, control flow and supported calls. You write the contracts and loop invariants. If an obligation still needs a mathematical argument, you supply that too, and Lean checks the proofs. Unsupported operations are rejected, and unresolved obligations stay open.

The copy tutorial shows what that looks like:

```zig

inline fn copyWord(destination: *u32, source: *const u32) void {

destination.* = source.*;

}

pub export fn copy(destination: [*]u32, source: [*]const u32, length: usize) void {

var index: usize = 0;

while (index < length) : (index += 1) {

copyWord(&destination[index], &source[index]);

}

}

```

The caller has to establish that the source has enough initialized words and the destination has enough writable storage. For the source-preservation contract, the two ranges also have to be disjoint. Under those assumptions the proofs show there are no invalid accesses or uninitialized reads. A successful run copies the source contents into the destination and preserves memory outside it. Modeled allocation exhaustion is an explicit permitted failure, and termination is a separate property.

Change the loop bound from `< length` to `<= length` and you get an extra boundary access that the original contract can't justify. The tutorial also includes deliberately false claims that must fail verification.

When the Zig source changes, you recapture the function to regenerate the model, then replay the proofs.

This release covers memory-safety examples derived from Ziglings, buffer updates, copy loops, helper calls and a captured specialization of `std.mem.replaceScalar`. It supports restricted AIR fragments, with explicit target and layout constraints. The capture pipeline, the Zig frontend and the native backend remain trust boundaries, so the proofs don't establish correctness of the final native binary or of the whole compiler.

The idea is to keep design iteration in Zig and prove a component's contracts once it has settled.

To try it you need Zig 0.17.1 and elan:

```sh

git clone https://github.com/okcontract/zean

cd zean

elan toolchain install leanprover/lean4:v4.35.0

zig build ziglings

```

It's released under Apache 2.0. If you write Zig or Lean, I'd like to know which functions you'd want to verify with it first.

- Repo: https://github.com/okcontract/zean

- Writeup: https://okcontract.com/blog/introducing-zean-write-zig-and-prove-it-in-lean/

If you like it, leave a star on the repo. And if you'd like more updates, give us a follow: https://x.com/okcontract


r/ethdev • • 4d ago

My Project We rewrote the Solidity compiler in Zig because our builds took 12 minutes. Then we ended up writing a Lean model of the language too

Thumbnail
github.com
1 Upvotes

Our contracts took 709 seconds to build with solc. We tried tuning the build for a while, gave up, and wrote our own compiler.

oksolc is a reimplementation of solc 0.8.36 in Zig. Around 156K lines, no C++. It only does the optimized via-IR pipeline through Standard JSON, because that's what we ship with. For Foundry you just point FOUNDRY_SOLC at it.

The frontend is still sequential. The Yul optimizer and EVM codegen run per contract in a thread pool, which works because contracts barely depend on each other after the frontend.

The bigger win for day to day work is the persistent session. Each source file gets a semantic fingerprint, so editing a comment or reformatting doesn't invalidate anything. Import cycles are handled as SCCs and invalidate together. Artifacts are cached per phase in SQLite with HMAC-SHA256 on the entries, so a tampered cache can't hand you bytecode. oksolc serve --stdio keeps the whole thing warm between builds.

solc vs oksolc with 4 jobs:

Uniswap V4, full build: 59.0s vs 11.2s (5.3x) Pendle V2, incremental: 38.9s vs 1.4s (27.6x) Chainwall, full build: 709.8s vs 138.4s (5.1x)

Script is at test/benchmarks/external-compare.sh if you want to rerun them.

The thing I didn't expect going in is how much time we'd spend on what Solidity actually means. There's no formal spec. The language is whatever solc does. We run a weekly fuzz job that diffs our bytecode against solc on a public corpus, and CI builds OpenZeppelin, Uniswap v4, Pendle and Solady and pins the hashes. When the two compilers disagree, the diff shows you they differ but there's nothing that says which one is correct. We ended up with 9 places where we do something different from solc on purpose, and every one of those was an argument from the docs and from what the feature is obviously meant to do.

For most languages that's annoying. For this one it's worse, since the output can't be patched after deployment and often holds a lot of money. A compiler bug stays on chain. And fuzzing only covers the programs the fuzzer happened to generate, so at some point you want proofs, and you can't prove anything against a language with no definition.

So we started writing the definition. Solidity Spec is an executable formal model of Solidity in Lean. You can run real programs through it and compare with compiler output, and you can state properties about the semantics and get them machine checked. There's a paper, and machine-checked proofs for explicitly defined parts of the model. Coverage is still growing.

The long term goal is checking a compiler's output against a definition of the language, the way CompCert did for C and CakeML did for ML, instead of against another compiler.

If your Solidity builds are slow, try it. And if you work on semantics or verified compilers, I'd really like to know where the Lean model is wrong.

oksolc: https://github.com/okcontract/oksolc Solidity Spec: https://github.com/okcontract/solidity-spec


r/ethdev • • 5d ago

Question Does anybody know of any good decentralized email services?

Thumbnail reddit.com
3 Upvotes

r/ethdev • • 5d ago

Information Kava Lend guarded its supply-interest division against zero. The attacker left two base units: the empty-market bug, fifth time

1 Upvotes

Kava's CalculateSupplyInterestFactor (in x/hard/keeper/interest.go) divides new interest by cash + borrows − reserves, and the only guard is IsZero(). On Nov 14, someone brought the dead BUSD market's net supply down to 2 base units. One accrual pushed the supply index from about 2.76 to 671,187, and 127 loans against that inflated collateral drained about 53.9M KAVA.

This is the same shape as Hundred, Onyx, Radiant and Sonne. Those were new markets, while this one was a market being wound down with its collateral factor still above zero. The post also covers a separate, unreported 23.5k ATOM shortfall that showed up in the same module on Nov 10. I also scanned about 2,000 Aave-fork reserves and about 260 Compound comptrollers, and empty markets that still count as collateral are held shut only by caps or freeze flags. For example, Radiant's sUSDe reserve on Ethereum has zero supply, a 72% collateral factor, and a borrow cap of 1.

If you're winding down a market, set the collateral factor to zero first, then turn off borrowing, then tell depositors to leave.

Full write-up: https://nefariousplan.com/posts/kava-lend-guarded-against-zero


r/ethdev • • 6d ago

Question Why are so many opcodes used for a simple transaction?

4 Upvotes

Lets say we have this simple smart contract written in solidity:

pragma solidity ^0.8.13;
contract Counter {
    uint256 public number;
    function setNumber(uint256 newNumber) public {
        number = newNumber;
    }
}

Environment:

  • Solidity: 0.8.13
  • Optimizer: disabled
  • Foundry: 1.0.0-stable

After compilation we get this runtime code: 6080...56fe. I was curious about how this bytecode is executed for example when I send a transaction with function signature: setNumber(uint256 newNumber) and argument: 1. And I analysed by hand opcode by opcode what is happening (yes I'm crazy - leave me alone). And I wrote it this way::

6080 PUSH1 stack:80

6040 PUSH1 stack:40,80

etc.

I counted 118 opcode executions until I reached the 00(STOP) opcode. Which I think is a crazy amount of opcodes.

I'm aware that what really matters in this example is the SSTORE opcode which consumes 98% of the gas. I have these questions:

  1. Is it really that necessary to have these 118 opcodes to store a single value? At some point I just lost what happens after multiple SWAPs, POPs and JUMPs. Is it important for security reasons or rather to make bytecode more universal in case of more complex operations?
  2. When it comes to optimizing gas consumption do people really pay attention to that 2% of triggered opcodes or do they just focuse entirely on finding the locations of operational codes that actually consume gas, such as sstore?

PS After writing this post, I compiled the code with the optimizer enabled and got a completely new, more optimized bytecode, so I'm no longer sure if my original post is still relevant, but I'd still love to hear your thoughts.


r/ethdev • • 6d ago

Information I read 201 NFT contracts on Ethereum, Base, Polygon and Arbitrum. 127 let someone change the token URI. One had a freeze I could recognise

1 Upvotes

I've been surveying where NFT art lives, and the contracts were the interesting part.

From a starting set of big collections on Ethereum, Base, Polygon and Arbitrum I read 201 contracts and looked for three things: a way to change the token URI, upgradeability, and a freeze.

  • 127 have a function that lets someone change the token URI.
  • 35 are upgradeable.
  • 1 has a freeze function I could recognise.
  • 8 of the projects no longer own their domain.

Detection was pattern-based, so I may have missed freezes under other names. If you've shipped an NFT contract, how did you handle this?

Write-up: https://xtrata.xyz/a/3654

I build Xtrata, the on-chain storage layer the write-up is inscribed with, so read it knowing that.


r/ethdev • • 7d ago

Tutorial A small Ethereum log-filtering exercise, plus the free articles behind it

2 Upvotes

Hey everyone.

I shared an EVM reading path here before. This time I wanted to bring one small exercise from the same area, something you can check against actual logs.

Say you want to track an ERC-20 wallet’s incoming and outgoing transfers. In the topics filter, putting the wallet in both address positions looks reasonable:

[TransferSignature, wallet, wallet]

But that matches transfers from the wallet to itself.

Topic positions are combined with AND. To find activity in either direction, use two filters:

Outgoing: [TransferSignature, wallet]
Incoming: [TransferSignature, null, wallet]

Here, TransferSignature means the event signature hash, and wallet is the address padded to 32 bytes. These are schematic filters, not literal JSON requests.

Use the same token contract and block range for both queries. Combine the results and remove duplicates, since a self-transfer matches both. For that fixed set of logs, (blockHash, logIndex) identifies each entry.

Another useful variation:

[TransferSignature, [walletA, walletB]]

That matches transfers from either wallet. The inner array gives you OR within one position.

Try predicting the results before running the queries. It is a small exercise, but it makes the filtering rules much easier to remember.

I collect my free Ethereum articles and accompanying code examples on 0xByteBeetle. They cover EVM execution, transactions, events, deployments and proxies, with examples you can run and inspect alongside the explanations.

If you try one, I’d be interested to hear where the explanation or setup needs more detail.


r/ethdev • • 8d ago

Question Smart contract auditors, what’s the hardest part of auditing smart contracts?

6 Upvotes

Hey auditors,

I’m doing a research about the most difficult part of auditing smart contracts and would like to get your thoughts on it.

What’s the hardest part of auditing smart contracts? Is there something you spend a lot of time doing while you do your audits? Would appreciate your thoughts.

Thanks


r/ethdev • • 8d ago

Question our network our blockchain

Post image
3 Upvotes

Our network will be centralized, utilizing eight external servers (rented space). In the event of a node loss, data is immediately replicated. The design draws inspiration from Delegated Proof-of-Stake (DPoS) and early versions of Proof-of-Authority (PoA). Naturally, users also have the option to create their own assets by setting up an open observer nodes.

The goal? The rationale? Behind such a solution? To reduce network overhead for post-quantum solutions.

VillaMoney


r/ethdev • • 8d ago

My Project Nexus DAO: an open-source prototype for transparent collective investment governance

1 Upvotes

Hi everyone,

I’m sharing NexusDAO, an open-source prototype for transparent collective investment governance. It connects public proposals, snapshot-based voting, executable investment mandates, and Safe multisig validation in one workflow.

The goal is to make DAO treasury decisions more traceable and structured.

You can try the public demo here: https://vlight7432.github.io/investment-dao/

I’d really appreciate feedback on the interface, governance flow, and features you would find useful..

Adrat177


r/ethdev • • 8d ago

Information Ethereal news weekly #47 | Post quantum & post AI urgency at DEFCON 2-3, Ethlabs proposed pqai27 & withdrew quick slots from Hegotá upgrade, Glamsterdam gas repricing findings due November 16

Thumbnail
ethereal.news
1 Upvotes

r/ethdev • • 9d ago

Information Uniswap's router now sends trades through hooks. Read its routing rules before you mine your hook address

5 Upvotes

I wrote some of the Uniswap v4 guides in the official docs, so I've been following hooks since before v4 shipped.

Since 22 Oct Uniswap's router also routes through aggregator hooks, hooks that wrap Curve, Fluid or PancakeSwap so the router sees them as a v4 pool. So a hook isn't only custom logic on a pool anymore, it's a route, and the router only picks routes it trusts.

I read Uniswap's "Routing for hooked pools" page and the allowlist form. Most hooks get picked up automatically, but if yours uses beforeSwap, afterSwap, either return-delta flag or dynamic fees it goes to manual review. That's basically any hook that does something on a swap.

And most of that review is design, not paperwork. No proxy that lets you upgrade the hook. No custom calldata the router can't produce, so a signed price in hookData is out. Verified source matching the bytecode, a repo link isn't enough. Permissions live in the address bits, so you choose them once when you mine it. If your plan was an upgradeable hook, you find out at review time.

The page also says allowlisting is not a security review. It asks whether swappers can be routed through you, nothing about your LPs or your delta math, and with a hook that returns its own delta one wrong sign gets paid on every swap the router sends you.

If you've shipped a v4 hook or you're close, what was the part you were least sure about before putting it on mainnet?


r/ethdev • • 9d ago

Information Shipped in 8 days on Sigui × NexusMind: ERC-8259 spec fix merged into ethereum/ERCs, Groth16 trust-score circuit, adversarial suite green — asking for feedback before we harden further

1 Upvotes

Build-in-public update. Sigui is a security layer for autonomous AI agents that manage real capital: a 5-layer risk engine (behavior analysis, a 7B vision model trained on a 1M-sample attack dataset, memory) that returns ALLOW / BLOCK / ESCALATE in <50 ms, built on top of ERC-8259 — our on-chain standard for agent identity, tiered verification (Bronze → Silver → Gold → Platinum), trust scores and a threat registry.

Changelog, Nov 1 → 8 (every item commit-dated in the repo):

  • Nov 1 — canonical npm package erc-8259 + ERC8259Guard for Solidity: a 2-line integration with onlyVerifiedAgent and minTrustScore(700) (= 70%) modifiers for gating high-value operations. Starknet Cairo 2.8.4 contracts: 8/8 tests passing (explicitly a non-normative reference implementation).
  • Nov 2 — incident lifecycle in the spec (PR #2137 merged upstream): IncidentStatus, retractAttack / resolveAttack, T7 invariant.
  • Nov 3 — deprecated our own pre-#2137 Sepolia deployment with loud warnings + CHANGELOG. Better us than an attacker.
  • Nov 4 — internal audit found isActive unchecked in getEffectiveTier / isVerified / calculateTrustScore; fixed and merged upstream the same day (PR #2142). Added the adversarial attack test suite (phase C4).
  • Nov 6–8 — Groth16 (Circom) circuit proving trust-score computation off-chain, real prover integrated into the gateway; npm v1.3.1; docs integrity pass (removed unverifiable testnet claims — we'd rather under-claim).

Asks — this is why I'm posting:

  • Solidity/EVM devs: review the guard modifiers and the T8 trust-score expiry rule. What breaks them?
  • Anyone building AI agents (trading bots, orchestration frameworks): would pip install sigui + a 2-line guard hook fit your stack? What's missing?
  • Security folks: in a tiered-verification + threat-registry design, what do you attack first? We'll turn every answer into a GitHub issue.

Python SDK: pip install sigui · Vision model (Imina-Na-V2, 7B, LoRA r=16): https://huggingface.co/Ibonon/Imina-Na-V2 · Dataset: https://huggingface.co/datasets/Ibonon/sigui-depin-1m

Repo: https://github.com/ibonon/Sigui — every piece of harsh feedback gets an issue and a response