Share on XShare on LinkedInShare on Telegram
Security Decisions/ Before launchWeb3 Security

Base Sub Accounts Security: Auditing Spend Permissions

Understand Base App wallet security and how Sub Accounts and Spend Permissions protect delegated crypto transactions. Explore how allowance limits, spender permissions, funding modes, and permission-tier changes create potential security risks. Learn from the 2026 Bankr exploit and discover essential audit checklists and best practices to secure Base wallet integrations and protect user funds.

Author
QuillAudits Team
•November 3, 2026
Base Sub Accounts Security: Auditing Spend Permissions
Share on XShare on LinkedInShare on Telegram

The decision · answer in brief

Understand Base App wallet security and how Sub Accounts and Spend Permissions protect delegated crypto transactions. Explore how allowance limits, spender permissions, funding modes, and permission-tier changes create potential security risks. Learn from the 2026 Bankr exploit and discover essential audit checklists and best practices to secure Base wallet integrations and protect user funds.

What Is Base App Wallet Security? Your Spend Permissions Guide

Base app wallet security has a new primitive to account for: Sub Accounts, the app-specific wallets that Base Account issues under a user's main wallet, governed by Spend Permissions with named, onchain-enforced parameters (spender, allowance, period, end). This guide treats that primitive as its own audit surface rather than folding it into generic wallet-safety advice, using the May 2026 Bankr/Grok permission-escalation incident on Base as the concrete cautionary precedent for what delegated spend authority gets wrong when nobody checks the scope.

What Are Sub Accounts and Spend Permissions?

A Sub Account is a hierarchical smart account that an app creates and controls, sitting underneath a user's universal Base Account. Base's own engineering team describes the design as combining "hierarchical smart account ownership, Spend Permissions, and a new wallet_addSubAccount RPC method," using Remote Procedure Call (RPC), the standard mechanism an app uses to request an action from a wallet, so the app-specific account feels integrated with the user's main wallet instead of bolted on beside it.

Base didn't start here. The team first tried a pure Session Keys design, then abandoned it: existing onchain state, like a user's standing USDC approval to a Uniswap contract, could be exploited by a malicious session key that never needed a fresh signature to act within that pre-existing approval. The team's own framing of the pivot was blunt: "What if we relaxed this constraint and embraced app accounts?" Sub Accounts, paired with Spend Permissions, were the answer.

A Spend Permission is a struct with specific fields, not a vague "approved" flag: account, spender, token, allowance, period (in seconds), start, end, salt, and extraData. Those fields let a spender pull funds from a Smart Wallet, but only within the bounds the struct defines. Accounting is stored fully onchain, in a single storage slot keyed by the hash of the permission's struct values, and the allowance automatically resets to zero once the current time passes the end of the last recorded period. That's a meaningfully narrower grant than an open-ended token approval, and it's auditable in the literal sense: you can read the struct and know exactly what an app can do.

One default worth flagging before you integrate anything: Auto Spend Permissions is enabled by default for Sub Accounts. It lets a sub account draw from its parent wallet's balance when its own balance runs short, with no fresh approval prompt for the user to see. Developers can turn this off by setting funding to manual in the SDK config, but the out-of-the-box behavior is silent top-ups, not silent denials. For teams new to Base's broader account-abstraction (AA) model, QuillAudits' overview of getting started with Base is a useful primer before you get into permission-specific detail.

Where Delegated Spend Authority Threatens Base App Wallet Security

Is the Base wallet safe to use? The underlying Base Account and Spend Permissions design is sound and onchain-enforced, but "safe" depends on how an individual app configures and requests permissions, not on the primitive alone. The attack surface isn't the smart contract. It's the request: what scope an app asks for, what a user approves without reading, and what happens to that approval after launch.

The clearest real-world illustration is the Bankr incident on Base. On May 4, 2026, an attacker drained roughly $150,000 to $200,000 in DRB tokens from Bankr, an AI agent wallet operating on Base, by first acquiring a Bankr Club Membership NFT. That NFT silently upgraded the wallet's permission tier from read-only to transfer-and-swap, without the attacker ever exceeding a spend cap or defeating an allowlist. The exploit worked because the permission tier itself, not the per-transaction limit, was the thing that moved. Coincub later reported the loss at approximately $170,000, with 80 to 88 percent of the funds eventually recovered.

That incident maps directly onto what a Spend Permission audit has to check beyond the allowance number. A cap of $500 per day means nothing if a separate mechanism, like an NFT-gated membership tier, can re-point the spender field or widen what the spender is allowed to call. Dren Hima, Coincub's Head of Research, put the underlying principle plainly: "A cap enforced at the wallet's API layer cannot be argued with by injected text, where a cap living in a model's context can be." The enforcement has to live in the wallet's own logic, not in a policy an app or an agent prompt is merely supposed to follow.

This isn't unique to AI agent wallets, but it's sharper there. An autonomous agent acting on a Spend Permission doesn't pause to notice that its permission tier just changed out from under it. QuillAudits' broader look at agentic wallet security covers the related session-key and ERC-7715/7710 scoped-permission patterns in more depth; Sub Accounts solve a different piece of the same problem by moving the escape hatch Base found in pure session keys, pre-existing onchain approvals, into a struct the wallet itself enforces.

Base-specific account abstraction carries its own bundler and paymaster considerations too, which is why auditing a Base integration shouldn't reuse an Ethereum mainnet checklist wholesale; QuillAudits has argued for treating Base's AA stack as its own audit target rather than assuming Ethereum-style assumptions carry over cleanly. The cost of getting wallet and permission design wrong is also measurable at the macro level: wallet and key-compromise incidents averaged $13 million per incident in the first half of 2026, compared with under $1 million for pure smart contract code exploits. Permission and custody design, not contract logic alone, is the larger loss vector right now.

Auditing an App's Spend Permission Request

Before approving or shipping a Spend Permission request, check it against this list:

  • Spender address. Confirm it's the specific contract the app says it is, not a proxy or router that can be redirected later without the user's knowledge.
  • Token and allowance. The allowance should match the app's actual stated use case. A swap app asking for unlimited approval of every token in a wallet is a scope mismatch, not a convenience.
  • Period and reset behavior. Since the allowance automatically zeroes out once the current time passes the end of the last recorded period, confirm the period length matches the app's real billing or usage cadence, not an arbitrarily long window chosen for fewer re-approval prompts.
  • Start and end timestamps. An end far in the future, or none at all within the app's intended lifecycle, extends the attack window indefinitely.
  • Auto Spend Permissions / funding mode. Check whether the sub account's funding is set to auto or manual. Auto pulls from the parent wallet's balance without a fresh prompt; manual keeps top-ups visible to the user.
  • Session re-authorization. Since wallet_addSubAccount must be called again in each new session before a previously created Sub Account can be used, confirm the app isn't caching or replaying a stale session in a way that bypasses that re-authorization step.
  • Tier-change triggers. As the Bankr incident showed, check for any separate mechanism, an NFT, a role, a membership flag, that can widen what the spender is allowed to do without generating a new, user-visible Spend Permission request.

Checklist Before You Integrate Sub Accounts

Teams building on Sub Accounts should treat the following as pre-launch gates, not post-launch fixes:

  1. Set funding to manual unless the app has a specific, documented reason to rely on Auto Spend Permissions, and disclose that choice to users.
  2. Scope the allowance, period, and end fields as tightly as the app's actual usage pattern allows, and revisit them every time the app's feature set changes.
  3. Treat any mechanism that can change a wallet's permission tier, including NFT-gated roles, as part of the Spend Permission attack surface, and require it to trigger a new, visible permission request rather than a silent upgrade.
  4. Get the Spend Permissions contract integration itself reviewed, not just the app's general smart contract code. A generic audit scope can miss a misconfigured struct field entirely.
  5. Monitor the permission's live state after launch. A one-time audit catches the configuration at launch; it doesn't catch a scope change introduced in a later update.

On that last point: QuillAudits' service pages list a Wallet Audit alongside its Smart Contract Audit, with explicit support for Base among the chains it covers, and a dApp Penetration Testing Audit that reaches the app-integration layer where Spend Permission requests actually get configured, not just the underlying contract. Worth saying plainly: those pages don't list an audit track specific to Sub Accounts or account-abstraction primitives by name, so a team integrating this feature should confirm directly with any auditor, QuillAudits included, that Base's Spend Permissions contracts specifically are in scope, not assumed to be covered by a general wallet review. And because a pre-launch audit can't catch a permission parameter changed six months later, ongoing monitoring matters as much as the initial review for any app that keeps touching its spend permission configuration.

Final Thoughts

Is Base Wallet owned by Coinbase? Base Account (formerly Coinbase Smart Wallet) is Coinbase's wallet product, built on the Base network that Coinbase operates, and Sub Accounts and Spend Permissions are features of that same stack, not a separate third-party add-on. That lineage is part of why the primitive is worth taking seriously: it's maintained infrastructure, with a documented design history, not an experimental patch.

Sub Accounts and Spend Permissions give Base app wallet security something concrete to check: named fields, onchain enforcement, and a documented default (Auto Spend Permissions) that shifts risk toward convenience unless a developer turns it off. The Bankr incident is a reminder that the allowance number was never the only thing an attacker needs to move. The permission tier around it matters just as much, and it rarely gets the same scrutiny. Treat a Spend Permission request the way you'd treat any other access-control change in a contract: read every field, question the default, and get the integration itself checked before real funds sit behind it.

Explore more Security Decisions

Contents

Tell Us About Your Project
Subscribe to Newsletter
hashing bits image
Loading...

WE SECURE EVERYTHING YOU BUILD.

From day-zero risk mapping to exchange-ready audits, QuillAudits helps projects grow with confidence. Smart contracts, dApps, infrastructure, compliance: secured end to end.

QuillAudits Logo


ISO 27001Circle Alliance Program
Uniswap FoundationAethiropt-collectivePolygon SPNBNB Chain Kickstart

All Rights Reserved. © 2026. QuillAudits - LLC