A user revokes every token approval in their wallet manager, confirms the transaction, and feels secure. But weeks later, their balance drains. The culprit was never the token approval itself—it was a second contract, registered elsewhere, that had been granted permission to move the same asset. This scenario is not rare. Token approval management tools, including those in popular wallet interfaces, address only the visible approval contract relationship. They miss the backdoor structures that drain accounts: secondary transfer permissions, allowance delegations, and contracts that execute transfers without requiring a fresh approval signature each time.

The design of Ethereum and EVM-compatible chains creates this vulnerability. An approval grants a specific contract permission to move tokens up to a certain amount. That permission is stored in the token contract itself, recorded against a spender address. But that address can be another contract, a proxy, or a router that performs the actual transfer on behalf of a user. Token approval managers show the contracts with recorded allowances, but they cannot show contracts that have found other ways to extract value—through secondary delegations, incremental pull mechanisms, or contract logic that was designed to remain hidden from standard approval interfaces. Understanding why approval managers fail is the first step toward actually securing an account.

Rabby Wallet interface showing token approval management and transaction simulation features for EVM chains

How token approval managers create the illusion of security

A standard token approval manager works by querying the balance of a specific token contract for a specific spender. In the ERC-20 standard, this is the allowance(owner, spender) function. The manager lists every address with a non-zero allowance, ranks them by risk, and allows the user to set the allowance to zero. This process is visible, straightforward, and genuinely useful for removing permissions from contracts you no longer trust. But it only works if the contract actually uses the standard approval flow.

The problem emerges when a user encounters a contract that sidesteps the normal approval mechanism. Some protocols use permit functions, which are standardized in EIP-2612 and similar specifications. A permit allows a user to grant an approval through a cryptographic signature rather than an on-chain approval transaction. The signature is submitted as part of the same transaction that executes the transfer, reducing friction and gas fees. But from an approval manager’s perspective, a permit approval appears nowhere. The user sees no spender address to revoke. The contract has received temporary permission through a signed message, not through a recorded allowance. If the user later grants the same permit again—or if the contract retains authority to execute additional transfers using the same signed authority—the approval manager cannot detect it.

A more elaborate variant involves allowance delegation. Some protocols issue wrapped or derivative tokens that represent claims to an underlying asset. The wrapper contract has been approved to move the underlying token. But the wrapper itself may then delegate permission to a router, aggregator, or liquidity contract. The approval manager sees the wrapper has permission to move the underlying asset. It does not see that the wrapper has then granted further permission downstream. Revoke the wrapper’s approval, and you have prevented direct transfers, but the delegation chain may still be intact if it was recorded separately or if the wrapper can be re-approved through other means.

The backdoor contract patterns that drain accounts

Several contract architectures allow funds to be extracted without appearing in a token approval manager’s results. The first is the proxy pattern. A contract you approved months ago may be a proxy that delegates execution to a separate implementation contract. If the implementation is upgraded, or if the proxy is configured to accept calls from multiple implementations, a user’s approval covers behavior they never authorized. Revoking the proxy’s approval does nothing if a different contract with similar logic is already authorized.

The second pattern is permit delegation with retention. A user signs a permit to allow a swap router to execute a single transaction. But if the router or an associated contract is configured to retain the signed data or to reuse the signature authority across multiple blocks, the permit can be replayed. The user approved one transaction; the contract can extract value from several. This is not always malicious—some protocols do this intentionally for batch processing—but it remains invisible to approval managers because it operates through cryptographic signatures rather than recorded allowances.

The third pattern involves secondary contract registrations. A user approves ContractA to move their tokens. ContractA’s owner then registers a second contract, ContractB, as an authorized mover within ContractA’s own configuration. ContractB never appears in the user’s approval history because the user never directly approved it. But when ContractA receives a call from ContractB, it honors the transfer. This is common in protocol upgrades: the original contract remains the user-facing approval target, but the actual execution is delegated to an updated version. If the owner becomes malicious or is compromised, or if ContractB is exploited, the user’s funds are at risk through a chain the approval manager cannot see.

The fourth pattern is the automatic renewal loop. Some contracts are designed to request a new approval before the previous allowance is exhausted. They may do this through a low-level call pattern that the user never explicitly sees. They may wait until the approval is nearly depleted, then automatically reapprove themselves using a function that the contract itself can trigger. From the approval manager’s perspective, the allowance appears high but static. In reality, the contract is autonomously extending its own permissions each time it approaches the limit.

Why Rabby safety features address only part of the problem

Rabby, the open-source EVM wallet developed by the DeBank team, includes an approval manager and transaction simulation tools designed to flag risky approvals before signing. These features reduce certain categories of risk: they warn users about unlimited approvals, identify contracts that have requested unusual permissions, and simulate the likely outcome of a transaction before it is signed. For straightforward cases—revoking an old marketplace approval or preventing an unlimited allowance to a newly deployed contract—these safeguards work well. They represent a significant step beyond wallets that display no approval information at all.

However, transaction simulation in rabby wallet executes the proposed transaction in a read-only environment to estimate the outcome. That simulation can show you what will happen if you approve a contract and then immediately use it. It cannot predict what the contract will do days or weeks later, what permissions it has delegated to other contracts, or what alternative code paths exist that are triggered by different conditions. Risk alerts will catch an approval for 100 percent of your balance to an unknown contract. They will not catch a permit-based transfer, because the permit does not appear as an on-chain approval. They will not detect a secondary contract registration that occurs after the approval is made.

The address checker and permit decoding tools in Rabby provide additional transparency by showing what data a signature will authorize. But decoding a permit shows what the contract is asking permission to do in that specific transaction, not what it can do cumulatively across multiple transactions or how it might delegate that authority. A user can review the decoded permit, understand that they are approving a one-time transfer of 1,000 USDC, and sign it. If the contract retains the ability to execute additional transfers with the same signature, or if it delegates execution to a companion contract, the decoded information becomes incomplete.

The structural limits of approval detection and why they matter

Every approval manager faces the same architectural constraint: it can only query what is explicitly recorded on-chain as an allowance. The Ethereum protocol and EVM chains store approvals in the token contract’s state. A call to the allowance function returns a number. If that number is zero or very low, the token appears safe from that contract. But the token contract has no visibility into whether the spender contract has delegated permission to another address, whether it is configured to execute transfers on behalf of other authorized parties, or whether it retains rights to re-approve itself.

This is not a flaw in approval managers—it is a property of how EVM contracts work. A contract’s internal state is not automatically transparent to external callers. A contract can approve itself to move tokens again without broadcasting that intention to wallet interfaces. A contract can transfer tokens on behalf of users who have authorized it through a signature rather than an approval. These capabilities are sometimes legitimate and necessary for protocol efficiency. They are also the ideal hiding places for unauthorized fund extraction.

Examining the source code of a contract before approving it can reveal some of these patterns, but it requires technical skill and access to the compiled bytecode or verified source on a block explorer. Most users do not review contract code. Of those who do, distinguishing between intentional delegation (such as a protocol upgrade) and malicious delegation (such as a hidden drain) requires deep familiarity with the specific protocol’s architecture. A contract that delegates to another address may be doing so correctly, or it may have been compromised, or the owner may be in the process of stealing funds. The approval manager cannot tell the difference.

Real-world scenarios where approval managers fail

In 2023, several DeFi protocols experienced approval-based drains despite users believing they had removed permissions. In one case, users approved a liquidity router for a swap. The router itself was approved, but it had delegated execution to a secondary aggregation contract. When the owner of the router added the aggregator to its authorized list, it did so in a way that the approval manager did not surface. Users who checked their approvals and saw only the router thought they were safe. The aggregator was the actual contract making transfers, and users had never explicitly approved it from their perspective—yet the allowance was recorded in the token contract under the aggregator’s address.

Another example involved permit-based protocols. A user signed a permit to swap 10 USDC for ETH. The swap router retained the signed message and executed it multiple times across different blocks, extracting value on each execution. The user’s approval manager showed no allowance to the router; in its view, the user had never approved it. The permit mechanism allowed the extraction to occur through a different authorization path entirely.

A third scenario emerged with auto-compounding yield contracts. Users approved the yield contract, expecting it to move their tokens only to deposit them in an underlying protocol. The yield contract had a secondary function that allowed its owner to update the underlying protocol address. The owner changed the underlying protocol to a contract controlled by attackers. The approval remained valid; the user never revoked it. But the destination of the tokens changed, and the approval manager showed no warning because it only saw the permission level, not the contract’s internal configuration.

These are not edge cases. They represent predictable failure modes of approval-based security models. An approval manager is a useful tool for detecting and removing explicit allowances. It is not a comprehensive security solution because approvals are not the only mechanism through which contracts can move funds.

Practical steps beyond the approval manager

Users should treat an approval manager as a necessary but incomplete control. After reviewing and revoking visible approvals, examine transaction history in a block explorer to identify contracts that have moved your tokens. A contract that executed transfers may not appear in the approval list if it used permit signatures or delegated authority. Search for all outgoing token transfers from your address and verify that each one corresponds to an action you intended. If you find transfers from contracts you do not recognize or remember, that is a red flag that a secondary authorization path exists.

Verify the source code of contracts you approve, particularly if they are new or updated. GitHub repositories and verified contracts on Etherscan can show whether a contract delegates to other addresses, how it handles approvals, and whether any recent changes have been made. This is time-consuming, but it is the most reliable way to detect delegation chains and secondary permissions before approving.

Use hardware wallets such as Ledger or Trezor to sign approvals. Hardware wallets do not prevent you from approving dangerous contracts, but they ensure that only you can authorize the approval—malware on a computer cannot sign without you pressing the hardware device’s button. They also often display the contract address and amount on their screen, giving you a second location to verify the details.

Limit approvals to the specific amount you intend to spend, not unlimited balances. If you are swapping 100 USDC for ETH, approve exactly 100 USDC, not your entire USDC balance. Some protocols may charge fees or require slightly more allowance than the swap amount, but unlimited approvals are rarely necessary and dramatically increase the damage if a contract behaves unexpectedly.

Regularly revoke approvals for protocols you no longer use. Set a reminder to review your active approvals quarterly. This reduces the window of exposure for contracts that may become compromised or change ownership.

The longer-term solution: Permit2 and intent-based architectures

The Ethereum ecosystem has begun addressing these problems through alternative approval mechanisms. EIP-4337 and similar standards propose intent-based architectures where users can express their desired transaction outcome without pre-approving contracts. Instead of approving a contract to move tokens and hoping it does what was promised, a user would sign an intent to swap A for B, and a network of executors would compete to fulfill that intent at the best price. If the fulfillment fails or deviates from the stated intent, the user’s assets remain protected because no standing approval was granted.

Permit2, another emerging standard, consolidates approvals into a single well-audited router contract that users approve once. Instead of approving every swap protocol, yield contract, or lending contract individually, users approve Permit2 and then use signed messages to authorize specific transfers. This reduces the number of contracts with standing allowances and consolidates the risk to a single auditable contract. However, Permit2 is still newer, and not all protocols have adopted it.

In the interim, users must assume that approval managers will miss secondary transfer permissions and that vigilance is required. The tool is useful, but the responsibility for security remains with the user. A wallet like rabby wallet can warn you about approving an unlimited balance to an unknown contract, but it cannot warn you about a contract that was already approved six months ago and just delegated to a thief. It cannot prevent you from signing a permit that a contract retains and reuses.

Choosing wallets and protocols based on transparency and auditability

When evaluating a protocol to approve, prefer those that have undergone security audits from established firms and published the results. Audits do not guarantee that a contract is safe, but they increase the probability that simple delegation tricks or reentrancy vulnerabilities have been caught. Check whether the protocol is a widely used EVM protocol with a long track record, or a newer experimental contract.

Prefer protocols that use Permit2 or similar consolidated approval mechanisms over protocols that request individual approvals to each contract. Prefer protocols that publish their contract upgrades and changes in advance, so you can assess whether a delegation or configuration change affects your existing approvals. Prefer wallets that default to showing all active approvals and make revocation simple, even if they cannot detect all secondary permissions.

Understand that self-custody wallets give you full control over your private keys and approvals, but that control includes responsibility for understanding what you are approving. A wallet interface that simplifies the approval process is useful, but simplification can also hide complexity. The goal is not to have the wallet make decisions for you, but to make information available so that you can make informed decisions before signing.

Frequently asked questions

Why does revoking all my token approvals not prevent my balance from draining?

Approval managers only show allowances recorded directly in the token contract. They miss secondary permissions granted through permit signatures, contracts that delegate authority to other contracts, and automatic re-approval loops. Revoking visible approvals removes one layer of risk but does not address these backdoor transfer mechanisms. You should also audit your transaction history to identify contracts that have moved your tokens and verify their code before they were approved.

Can Rabby Wallet’s transaction simulation and risk alerts protect me from all approval-based drains?

Rabby Wallet’s simulation and risk alerts are valuable tools that flag unlimited approvals and unusual contract permissions before you sign. However, they can only detect what is visible at the time of the transaction. They cannot predict how a contract will behave weeks later, whether it has delegated permission to secondary contracts, or whether it will execute additional transfers through permit signatures. The wallet provides an important safeguard, but approval security also depends on reviewing contract source code, auditing your transaction history, and limiting approvals to specific amounts.

How can I verify that a contract does not have hidden secondary permissions before I approve it?

Check the verified source code on a block explorer or GitHub to see whether the contract delegates authority to other addresses, retains the ability to re-approve itself, or uses permit-based signatures. Look for contract upgrades and ownership changes that might indicate the contract has been modified. Review your transaction history to see if the contract has already executed transfers from your address. Use a hardware wallet to sign the approval so that only you can authorize it. Prefer protocols that have undergone security audits and have a long track record on major EVM chains.