feat: remove fee sponsoring on nibi (NibiruChain#2530)

Author: matthiasmatt

.gitignore

@@ -363,3 +363,6 @@ AGENTS.md
 precompile.test
 tx_log.json
 passkey-bundler/.tmp
+evm-e2e/.nibid-*/
+evm-e2e/.passkey-*-privkey.txt
+evm-e2e/.passkey-*-wallet.json

evm-e2e/passkey-sdk/src/local-bundler.ts

@@ -47,7 +47,6 @@ const provider = new JsonRpcProvider(RPC_URL)
 const wallet = new Wallet(PRIVATE_KEY, provider)
 const ENTRY_POINT_ABI = [
   "function handleOps((address sender,uint256 nonce,bytes initCode,bytes callData,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,bytes paymasterAndData,bytes signature)[] ops, address payable beneficiary)",
-  "function depositTo(address) payable",
 ]
 const FACTORY_ABI = [
   "function createAccount(bytes32 _qx, bytes32 _qy) returns (address account)",
@@ -157,8 +156,6 @@ async function handleRpcRequest(
       return createResult(payload.id, handleGetUserOpReceipt(payload.params ?? []))
     case "passkey_createAccount":
       return createResult(payload.id, await handleCreatePasskeyAccount(payload.params ?? []))
-    case "passkey_fundAccount":
-      return createResult(payload.id, await handleFundAccount(payload.params ?? []))
     case "passkey_getLogs":
       return createResult(payload.id, handleGetLogs(payload.params ?? []))
     default:
@@ -183,16 +180,7 @@ async function handleSendUserOperation(params: any[], chainId: bigint): Promise<
     nonce: rpcUserOp.nonce,
   })
 
-  let bundlerNonce = await provider.getTransactionCount(wallet.address, "pending")
-
-  // Simple pre-fund: deposit the required amount into EntryPoint for this sender.
-  const requiredPrefund =
-    (userOp.callGasLimit + userOp.verificationGasLimit + userOp.preVerificationGas) * userOp.maxFeePerGas
-  if (requiredPrefund > 0n) {
-    console.log(`Prefunding sender ${rpcUserOp.sender} with ${requiredPrefund} wei in EntryPoint`)
-    const prefundTx = await entryPoint.depositTo(rpcUserOp.sender, { value: requiredPrefund, nonce: bundlerNonce++ })
-    await prefundTx.wait()
-  }
+  const bundlerNonce = await provider.getTransactionCount(wallet.address, "pending")
 
   const tx = await entryPoint.handleOps([userOp], wallet.address, {
     gasLimit: userOp.callGasLimit + userOp.verificationGasLimit + userOp.preVerificationGas + 200000n,
@@ -268,18 +256,6 @@ async function handleCreatePasskeyAccount(params: any[]): Promise<{ account: str
   return { account, txHash: tx.hash }
 }
 
-async function handleFundAccount(params: any[]): Promise<{ txHash: string }> {
-  const to = params[0] as string | undefined
-  const amount = params[1] ? BigInt(params[1] as string) : 1_000_000_000_000_000_000n
-  if (!to) {
-    throw new Error("passkey_fundAccount requires target address")
-  }
-  const tx = await wallet.sendTransaction({ to, value: amount })
-  const receipt = await tx.wait()
-  console.log(`Funded ${to} with ${amount} wei from bundler wallet (tx ${receipt?.hash ?? tx.hash})`)
-  return { txHash: receipt?.hash ?? tx.hash }
-}
-
 function readBody(req: IncomingMessage): Promise<string> {
   return new Promise((resolve, reject) => {
     let data = ""

evm-e2e/passkey-sdk/src/passkey-e2e.ts

@@ -64,11 +64,6 @@ async function main() {
   await txCreate.wait()
 
   const account = new Contract(predictedAccount, ACCOUNT_ABI, provider)
-  const entryPointContract = new Contract(
-    ENTRY_POINT,
-    ["function depositTo(address account) payable", "function balanceOf(address account) view returns (uint256)"],
-    wallet,
-  )
 
   // 3) Fund the PasskeyAccount.
   const fundTx = await wallet.sendTransaction({
@@ -102,20 +97,6 @@ async function main() {
     maxPriorityFeePerGas: maxPriority,
   }
 
-  const requiredPrefund =
-    (userOp.callGasLimit + userOp.verificationGasLimit + userOp.preVerificationGas) * userOp.maxFeePerGas
-  console.log("Depositing prefund:", formatEther(requiredPrefund), "NIBI")
-  const depositTx = await entryPointContract.depositTo(predictedAccount, {
-    value: requiredPrefund,
-    nonce: deployerNonce++,
-  })
-  await depositTx.wait()
-  console.log(
-    "EntryPoint deposit before bundling:",
-    formatEther(await entryPointContract.balanceOf(predictedAccount)),
-    "NIBI",
-  )
-
   const chainId = BigInt((await provider.getNetwork()).chainId)
   const userOpHash = getUserOpHash(userOp, ENTRY_POINT, chainId)
   const { r, s } = signUserOpHash(userOpHash, nodePasskey.privKey)
@@ -146,10 +127,8 @@ async function main() {
   // 6) Confirm nonce + balance changes on-chain.
   const nonceAfter = (await account.nonce()) as bigint
   const balanceAfter = await provider.getBalance(predictedAccount)
-  const depositAfter = await entryPointContract.balanceOf(predictedAccount)
   console.log("Nonce after:", nonceAfter.toString())
   console.log("Account balance after:", formatEther(balanceAfter), "NIBI")
-  console.log("EntryPoint deposit after:", formatEther(depositAfter), "NIBI")
 
   if (nonceAfter === onChainNonce + 1n && balanceAfter < balanceBefore) {
     console.log("✅ Passkey ERC-4337 flow completed successfully")

passkey-app/README.md

@@ -8,7 +8,7 @@ now talks to an ERC-4337 bundler (not a custom RPC method) for passkey-signed us
 
 ```bash
 # From nibiru/ root
-just passkey-demo        # starts localnet (if needed), deploys EntryPoint + PasskeyAccountFactory, writes .env.local, starts bundler on :4337 (logs in logs/passkey-bundler.log), funds bundler from guard-cream dev key
+just passkey-demo        # starts localnet (if needed), deploys EntryPoint + PasskeyAccountFactory, writes .env.local, starts bundler on :4337 (logs in logs/passkey-bundler.log)
 
 # Then launch the UI
 cd passkey-app && npm install && npm run dev
@@ -29,9 +29,9 @@ Open http://localhost:5173. The connection panel is prefilled from `.env.local`
 bundler URL if needed (defaults to http://127.0.0.1:4337). Flow:
 
 1) Create/load a passkey (WebAuthn).  
-2) Click “Create passkey account” — this asks the bundler to call `createAccount(qx,qy)` on the factory (gas paid by the
-   bundler dev key), then auto-sets `from` from the `AccountCreated` event.  
-3) Fund that address from the localnet validator if needed (e.g. `nibid tx bank send validator <passkey_addr> 1000000000000000000unibi --yes --fees 750000unibi --gas 300000 --chain-id nibiru-localnet-0 --node http://localhost:26657`).  
+2) Click “Create passkey account” — this asks the bundler to call `createAccount(qx,qy)` on the factory, then auto-sets
+   `from` from the `AccountCreated` event.  
+3) Bundler sponsorship is disabled. Fund that address manually if needed (e.g. `nibid tx bank send validator <passkey_addr> 1000000000000000000unibi --yes --fees 750000unibi --gas 300000 --chain-id nibiru-localnet-0 --node http://localhost:26657`).  
 4) Use “Send NIBI (prefilled)” for a quick native transfer, or “Open custom transaction” for calldata trades.  
 5) Deposit flow uses `PerpVaultEvmInterface.deposit`; fill vault address, collateral ERC20, and wasm msg if needed.
 

passkey-app/src/App.tsx

@@ -7,13 +7,12 @@ import { makePublicClient } from './lib/passkeyClient'
 import { clearPasskey, loadPasskey, savePasskey } from './lib/storage'
 import { derivePasskeyAddress } from './lib/passkeyAddress'
 import { encodeExecute, PASSKEY_ACCOUNT_ABI } from './lib/passkeyAccount'
-import { createPasskeyAccount, fundAccount, fetchBundlerLogs, sendUserOperation } from './lib/bundler'
+import { createPasskeyAccount, fetchBundlerLogs, sendUserOperation } from './lib/bundler'
 import { defaultUserOp, getUserOpHash, toRpcUserOperation } from './lib/userop'
 import { fromBase64Url } from './lib/base64'
 import { getBundlerHealth, getRpcHealth } from './lib/health'
 import { Sidebar } from './components/Sidebar'
 import { Step } from './components/Step'
-import { fundFromDevAccount } from './lib/faucet'
 
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
 const envRpc = import.meta.env.VITE_RPC_URL as string | undefined
@@ -51,7 +50,6 @@ function App() {
   const [balance, setBalance] = useState<string>('0')
   const [bundlerBalance, setBundlerBalance] = useState<string>('0')
   const [bundlerLogs, setBundlerLogs] = useState<BundlerLogEntry[]>([])
-  const [isFunding, setIsFunding] = useState(false)
   const [isDeployed, setIsDeployed] = useState(false)
   const [serviceHealth, setServiceHealth] = useState<{ rpc: ServiceHealth; bundler: ServiceHealth }>({
     rpc: { status: 'checking' },
@@ -468,54 +466,27 @@ function App() {
 
         <Step
           number={3}
-          title="Fund Account"
+          title="Funding (Optional)"
           description={
             <>
               <p>
-                Smart contract accounts need gas to pay for transactions (unless using a Paymaster).
+                Bundler fee sponsorship is disabled.
               </p>
               <p>
-                We'll use the Bundler's faucet to send some testnet NIBI to your new account.
+                If this account needs native tokens for non-gasless flows, fund it directly from a wallet or CLI.
               </p>
             </>
           }
           isActive={isDeployed}
           isCompleted={BigInt(balance) > 0}
         >
-          <button
-            onClick={async () => {
-              if (!fromAddress || fromAddress === ZERO_ADDRESS) return
-              try {
-                setIsFunding(true)
-                const desiredAmount = 100000000000000000n // 0.1 NIBI
-                const bundlerBal = BigInt(bundlerBalance || '0')
-                if (bundlerBal < desiredAmount + 20000000000000000n) {
-                  updateStatus('Bundler is underfunded. Top up the bundler signer first.')
-                  return
-                }
-
-                updateStatus(`Requesting transfer of ${desiredAmount} wei from bundler dev account...`)
-                const txHash = await fundFromDevAccount(config, fromAddress, desiredAmount)
-                updateStatus(`Funded tx: ${txHash}`)
-              } catch (err: any) {
-                console.error(err)
-                updateStatus(err?.message ?? 'Funding failed')
-              } finally {
-                setIsFunding(false)
-              }
-            }}
-            disabled={isFunding || !isDeployed}
-          >
-            {isFunding ? 'Funding…' : 'Fund from Dev Account'}
-          </button>
-          {BigInt(balance) === 0n && (
-            <div style={{ marginTop: '12px', fontSize: '14px', color: '#64748b' }}>
-              <p>If the faucet fails, send NIBI manually to:</p>
-              <code style={{ background: '#f1f5f9', padding: '4px 8px', borderRadius: '4px', wordBreak: 'break-all' }}>
-                {fromAddress}
-              </code>
-            </div>
-          )}
+          <div style={{ marginTop: '12px', fontSize: '14px', color: '#64748b' }}>
+            <p>No bundler funding RPC is available.</p>
+            <p>Fund manually if needed:</p>
+            <code style={{ background: '#f1f5f9', padding: '4px 8px', borderRadius: '4px', wordBreak: 'break-all' }}>
+              {fromAddress}
+            </code>
+          </div>
         </Step>
 
         <Step
@@ -534,7 +505,7 @@ function App() {
               </ol>
             </>
           }
-          isActive={isDeployed && BigInt(balance) > 0}
+          isActive={isDeployed}
         >
           <div className="grid">
             <div style={{ border: '1px solid #e2e8f0', padding: '16px', borderRadius: '8px' }}>

passkey-bundler/README.md

@@ -1,18 +1,16 @@
 # Passkey Bundler
 
 Lightweight ERC-4337 bundler focused on passkey-backed accounts on Nibiru, aligned with `bundler-prd.md`. It exposes
-JSON-RPC on port `4337` by default, performs validation, prefunding, and queue-based submission to the configured
-EntryPoint, and ships with health and metrics endpoints for operations.
+JSON-RPC on port `4337` by default, performs validation and queue-based submission to the configured EntryPoint, and
+ships with health and metrics endpoints for operations.
 
 ## Features
 - JSON-RPC: `eth_chainId`, `eth_supportedEntryPoints`, `eth_sendUserOperation`, `eth_getUserOperationReceipt`.
-- Passkey helpers: `passkey_createAccount(qx,qy,factory?)`, `passkey_fundAccount(address,amountWei)`,
-  `passkey_getLogs(limit)`.
+- Passkey helpers: `passkey_createAccount(qx,qy,factory?)`, `passkey_getLogs(limit)`.
 - Validation: entry point and chain ID enforcement, userOp schema checks, rate limiting, optional API key auth
   (`x-api-key` or `Authorization: Bearer <key>`).
 - Queue + retries: in-memory FIFO queue (tie-breaker `maxPriorityFeePerGas`), configurable concurrency, retries with
   gas bumping and nonce management.
-- Prefunding: optional EntryPoint `depositTo` top-ups with configurable ceiling.
 - Observability: `/healthz`, `/readyz`, `/metrics` (Prometheus), structured logs kept in a rolling buffer.
 - Storage: in-memory receipt/log store with configurable retention (intended to be swapped for SQLite/Postgres later).
 
@@ -54,8 +52,6 @@ node dist/index.js
   `FINALITY_BLOCKS` (default `2`).
 - `VALIDATION_ENABLED`: run `simulateValidation` before enqueue (defaults to `true` in testnet mode).
 - `ENABLE_PASSKEY_HELPERS`: enable `passkey_*` helper RPC methods (defaults to `false` in testnet mode).
-- `PREFUND_ENABLED` (default `true` in dev, `false` in testnet), `MAX_PREFUND_WEI` (default `5e18`),
-  `PREFUND_ALLOWLIST` (comma-separated sender addresses; required if `PREFUND_ENABLED=true` in testnet mode).
 - `RECEIPT_LIMIT` (default `1000`), `RECEIPT_POLL_INTERVAL_MS` (default `5000`).
 
 Health: `GET /healthz` (process + RPC reachability), `GET /readyz` (RPC synced, signer nonce). Metrics: `GET /metrics`

passkey-bundler/src/config.ts

@@ -28,9 +28,6 @@ const baseSchema = z.object({
   validationEnabled: z.boolean().default(false),
   gasBumpPercent: z.number().nonnegative().default(15),
   gasBumpWei: z.bigint({ coerce: true }).optional(),
-  prefundEnabled: z.boolean().default(true),
-  maxPrefundWei: z.bigint({ coerce: true }).default(5_000_000_000_000_000_000n), // 5 ETH
-  prefundAllowlist: z.array(hexAddress).default([]),
   submissionTimeoutMs: z.number().int().positive().default(45_000),
   finalityBlocks: z.number().int().positive().default(2),
   receiptLimit: z.number().int().positive().default(1000),
@@ -49,7 +46,6 @@ export function loadConfig(): BundlerConfig {
     config = {
       ...config,
       authRequired: merged.authRequired ?? true,
-      prefundEnabled: merged.prefundEnabled ?? false,
       enablePasskeyHelpers: merged.enablePasskeyHelpers ?? false,
       validationEnabled: merged.validationEnabled ?? true,
     }
@@ -60,9 +56,6 @@ export function loadConfig(): BundlerConfig {
     if (config.authRequired && config.apiKeys.length === 0) {
       throw new Error("Testnet mode requires API keys (set BUNDLER_API_KEYS) or disable authRequired")
     }
-    if (config.prefundEnabled && config.prefundAllowlist.length === 0) {
-      throw new Error("Testnet mode with prefundEnabled requires PREFUND_ALLOWLIST (comma-separated sender addresses)")
-    }
   }
 
   return config
@@ -105,11 +98,6 @@ function envOverrides(): RawConfig {
     validationEnabled: toBool(process.env.VALIDATION_ENABLED),
     gasBumpPercent: process.env.GAS_BUMP ? Number(process.env.GAS_BUMP) : undefined,
     gasBumpWei: toBigInt(process.env.GAS_BUMP_WEI),
-    prefundEnabled: toBool(process.env.PREFUND_ENABLED),
-    maxPrefundWei: toBigInt(process.env.MAX_PREFUND_WEI),
-    prefundAllowlist: process.env.PREFUND_ALLOWLIST
-      ? process.env.PREFUND_ALLOWLIST.split(",").map((v) => v.trim()).filter(Boolean)
-      : undefined,
     submissionTimeoutMs: toInt(process.env.SUBMISSION_TIMEOUT_MS),
     finalityBlocks: toInt(process.env.FINALITY_BLOCKS),
     receiptLimit: toInt(process.env.RECEIPT_LIMIT),

passkey-bundler/src/entryPoint.ts

@@ -5,7 +5,6 @@ const USER_OP_TUPLE =
 
 export const ENTRY_POINT_V06_ABI = [
   `function handleOps(${USER_OP_TUPLE}[] ops, address payable beneficiary)`,
-  "function depositTo(address account) payable",
   "function balanceOf(address account) view returns (uint256)",
   `function simulateValidation(${USER_OP_TUPLE} userOp)`,
   `function simulateHandleOp(${USER_OP_TUPLE} op, address target, bytes targetCallData)`,
@@ -31,4 +30,3 @@ export function extractRevertData(err: unknown): string | undefined {
     undefined
   )
 }
-

passkey-bundler/src/index.ts

@@ -245,9 +245,6 @@ async function handleRpcRequest(payload: any, ctx: RpcRequestContext): Promise<o
       case "passkey_createAccount":
         if (!config.enablePasskeyHelpers) return createError(payload.id, -32601, `Method ${method} not found`)
         return createResult(payload.id, await handleCreatePasskeyAccount(payload.params ?? [], wallet))
-      case "passkey_fundAccount":
-        if (!config.enablePasskeyHelpers) return createError(payload.id, -32601, `Method ${method} not found`)
-        return createResult(payload.id, await handleFundAccount(payload.params ?? [], wallet))
       case "passkey_getLogs":
         if (!config.enablePasskeyHelpers) return createError(payload.id, -32601, `Method ${method} not found`)
         return createResult(payload.id, await handleGetLogs(payload.params ?? [], store))
@@ -395,15 +392,6 @@ async function handleCreatePasskeyAccount(params: any[], wallet: Wallet): Promis
   return { account, txHash: receipt?.hash ?? tx.hash }
 }
 
-async function handleFundAccount(params: any[], wallet: Wallet): Promise<{ txHash: string }> {
-  const to = params[0] as string | undefined
-  const amount = params[1] ? BigInt(params[1] as string) : 1_000_000_000_000_000_000n
-  if (!to) throw new Error("passkey_fundAccount requires target address")
-  const tx = await wallet.sendTransaction({ to, value: amount })
-  const receipt = await tx.wait()
-  return { txHash: receipt?.hash ?? tx.hash }
-}
-
 async function handleGetLogs(params: any[], store: BundlerStore) {
   const limit = Number(params?.[0] ?? 100)
   if (!Number.isFinite(limit) || limit <= 0) return []

passkey-bundler/src/metrics.ts

@@ -6,8 +6,6 @@ export class Metrics {
   readonly rpcFailures: Counter
   readonly userOpSuccess: Counter
   readonly userOpFailed: Counter
-  readonly prefundAttempts: Counter
-  readonly prefundFailures: Counter
   readonly queueDepth: Gauge
   readonly submissionDuration: Histogram
 
@@ -42,18 +40,6 @@ export class Metrics {
       labelNames: ["reason"],
     })
 
-    this.prefundAttempts = new Counter({
-      name: "bundler_prefund_attempts_total",
-      help: "Prefund attempts performed before handleOps",
-      registers: [this.registry],
-    })
-
-    this.prefundFailures = new Counter({
-      name: "bundler_prefund_failures_total",
-      help: "Prefund attempts that failed",
-      registers: [this.registry],
-    })
-
     this.queueDepth = new Gauge({
       name: "bundler_queue_depth",
       help: "Current queue depth for pending user operations",