DEV Community: Kurt

Ethereum Account Abstraction (ERC-4337), Part 2: Implementation

Kurt — Tue, 30 Dec 2025 16:56:06 +0000

If you’re building on Ethereum, ERC-4337 lets you move beyond standard EOAs. In Part 2 of my series, I walk through implementing a smart account and connecting it to a frontend.

What You Build

A smart account that validates owner signatures
Executes arbitrary contract calls
Handles gas via UserOperations
Connects seamlessly to a frontend and bundler

How It Works

Encode your target contract call and wrap it in the account’s execute() function.
Estimate gas using a bundler with a special estimation signature.
Sign the UserOperation and submit it to the bundler.
EntryPoint validates and executes the operation, reimbursing the bundler from the account’s deposit.

Why It Matters

Full on-chain validation without trusting the bundler
Deterministic execution for arbitrary calls
Minimal, complete ERC-4337 workflow

For the full walkthrough with code snippets, check out my Medium article: Part 2: Implementation

Ethereum Account Abstraction (ERC-4337) Explained – Part 1

Kurt — Sun, 28 Dec 2025 17:30:07 +0000

Ethereum developers, if you’ve been curious about account abstraction, this post is for you. I’ve just published Part 1 of my Medium series on ERC-4337, and here’s a developer-friendly breakdown of the basics.

Why ERC-4337 Matters

Ethereum EOAs are rigid by design: nonces, gas payments, and validation are protocol-defined. Account abstraction lets the account itself define its behavior. ERC-4337 achieves most of this without changing Ethereum consensus.

Intent vs Transaction

Instead of sending a transaction, ERC-4337 uses UserOperations, essentially “intents”:

sender: the account address
nonce: account-specific nonce
callData: function call data
signature: proof of authorization
paymaster: optional gas sponsor
gas limits and metadata

These UserOperations stay off-chain until included by a bundler.

Key Components

Bundlers: Collect, simulate, and submit UserOperations as single transactions.
EntryPoint: A shared contract that executes UserOperations on accounts.
Paymasters: Optional contracts to sponsor gas for users.

All ERC-4337 logic flows through these components, but Ethereum itself only sees normal transactions calling the EntryPoint.

Related Standards

ERC-4337 builds on existing standards: EIP-1271 (contract signatures), ERC-165 (interface detection), ERC-7579 (modular accounts), and EIP-7702 (future directions).

For the full breakdown with architecture diagrams, sequence flows, and examples, check out the original Medium article here:
https://medium.com/@Kurt0x/account-abstraction-erc-4337-part-1-the-basics-da3dee805a24

How I Found Jobs I Might Have Missed

Kurt — Fri, 26 Dec 2025 16:49:50 +0000

I discovered over 6,000 job openings, filtered them to 100 Solidity-related positions, and applied to 20 jobs I hadn’t seen on any regular job boards.

I realized I might be missing opportunities, so I built a small web scraper to search multiple platforms like Greenhouse, Breezy, and Lever. The goal was simple: find jobs that weren’t easy to see and get a full view of the market.

I’m not sharing the code because it was for my personal use, and some sites might restrict automated scraping in their Terms of Service. The point of this article is to show what I achieved, not provide a ready-to-run tool.

Running this project taught me a lot about automation, handling inconsistent data, and overcoming web scraping challenges. A small technical tool made a real difference in my job search.

For a full breakdown of how I built the scraper, the challenges I faced, and the lessons I learned, check out my Medium article here:

https://medium.com/@Kurt0x/i-built-a-script-to-find-jobs-i-might-have-missed-053106fde7df

Sending EIP-4844 Blob Transactions with ethers.js and kzg-wasm

Kurt — Mon, 22 Dec 2025 21:19:43 +0000

EIP-4844 introduces blob transactions (Type 3) as part of Proto-Danksharding. Sending blob transactions in practice comes with constraints around tooling, RPC support, and transaction preparation.

This article summarizes hands-on experimentation with ethers.js v6 and kzg-wasm, focusing on what works, what does not, and how to get a minimal setup running.

If you just want to create a blob without diving into code, https://blobsender.xyz lets anyone write a message and submit it as a blob on Ethereum.

Current limitations

Browser wallets and connectors do not support blob transactions yet.
They must be sent from a backend or script controlling a private key directly.
RPC support is inconsistent.
Even on Sepolia, many public RPC endpoints reject blob transactions or do not support EIP-4844.

RPC support on Sepolia

RPC support was one of the main friction points. About 20 Sepolia RPC providers were tested. Many rejected blob transactions or lacked EIP-4844 support.

The following public RPC endpoints worked reliably:

https://sepolia.infura.io/v3/YOUR_API_KEY
https://ethereum-sepolia-rpc.publicnode.com
https://eth-sepolia.api.onfinality.io/public
https://0xrpc.io/sep
https://sepolia.drpc.org

This list is included in the repository to save others testing time.

Repository and code

All working examples live here:

https://github.com/0xKurt/eip-4844-ethers-examples

The repository contains two scripts:

send-blob.ts – a simple blob transaction
send-blob-contract.ts – a blob transaction combined with a contract call

Both use ethers.js v6 and kzg-wasm, and send Type 3 transactions.

At a high level, sending a blob transaction requires preparing a fixed-size blob, generating a KZG commitment and proof, and sending a transaction with type: 3.

Blobscan

Blobscan allows inspection of:

blob versioned hashes
blob gas prices
other blob-related metadata

The scripts print direct links to Blobscan using the blob versioned hash returned by ethers, making verification and inspection easy.

Full walkthrough

This post is a condensed summary. A complete step-by-step walkthrough of setup, code, and transaction flow is available in the original Medium article:

https://medium.com/@Kurt0x/sending-eip-4844-blob-transactions-using-ethers-js-and-kzg-wasm-d84224be6b81