A user connects their wallet to a DeFi protocol promising high yield farming returns. The browser extension shows a permission prompt. The interface is clean, the protocol is well-known, and the user has seen similar requests a hundred times. They approve without reading the details—and unknowingly grant unlimited token spending authority to a contract that may drain their balance within seconds. This scenario plays out regularly because most wallet users do not understand what permission requests actually authorize, what risks each type carries, or how to distinguish a reasonable request from a dangerous one.
Rabby Wallet is built specifically to address this gap. Unlike many extension wallets that display opaque contract function calls, Rabby uses transaction simulation and readable formatting to show users exactly what a smart contract interaction will do before they sign. The wallet’s permission system goes further by breaking down token approvals, contract interactions, and dApp connections into legible components, with warnings for known high-risk patterns. Understanding how these prompts work and what they mean in practice is essential for anyone managing meaningful amounts of value on Ethereum or compatible blockchains.
The distinction between connection and authorization
When a user visits a decentralized application and clicks “connect wallet,” they are not yet authorizing any transaction or smart contract action. Connecting a wallet to a dApp is a read-only disclosure of the wallet address. The dApp learns which address it is interacting with; the wallet does not automatically approve any spending or contract function calls. This is an important boundary because it means connection itself carries minimal risk—the dApp cannot move funds, alter settings, or execute functions based on connection alone.
What happens after connection is the critical part. Once connected, the dApp can request that the user sign specific transactions. These requests fall into several categories, each with different implications. A token approval request grants spending authority. A contract function call may execute arbitrary logic. A message signature proves ownership of an address without moving funds. A transaction sending ETH moves the native currency directly. Understanding these categories is the foundation for evaluating whether any given request is appropriate for what the user is trying to do.
Rabby Wallet’s approach to connection and authorization is to keep both steps visible. Rather than hiding contract details behind generic “approve” buttons, the wallet shows what each interaction will actually do. This means a user can see that connecting to a farming protocol is safe, but the subsequent request to approve token spending for that protocol requires closer examination. The separation is not just a philosophical point; it translates into practical security because it forces at least a moment of deliberation between clicking a dApp button and committing to an irreversible transaction.
A common mistake is treating all permission requests as equivalent. They are not. Approving an address as a recipient of a message signature carries nearly zero financial risk; the signature proves you own the address but cannot transfer any assets. Approving unlimited token spending to a contract, by contrast, can empty your entire balance of that token if the contract is compromised or malicious. The risk profile differs by orders of magnitude. Wallet design that makes this distinction explicit reduces casual approval of dangerous requests.
Token approval requests and the unlimited spending problem
The most common high-stakes permission request is the token approval. When a user interacts with a DeFi protocol—swapping on a decentralized exchange, lending tokens, or providing liquidity—the protocol needs permission to move tokens from the user’s wallet. Technically, the user is approving a smart contract to call the transferFrom function on an ERC-20 token contract, up to a specified amount. This amount is critical because it defines the upper bound on what the contract can spend without requesting a new approval.
Many dApps request unlimited approvals, which means they ask for authorization to spend an essentially infinite amount of the token. The marketing rationale is convenience: the user does not need to approve again if they want to trade more of that token with the same protocol in the future. The security consequence is that if the protocol is hacked, the attacker can drain the entire balance of that token from every wallet that approved it. This is not a hypothetical scenario. Hundreds of millions of dollars have been lost in incidents where a compromised dApp or contract had unlimited approval from users.
Rabby Wallet addresses this by flagging unlimited approvals prominently. The transaction simulation will show “Unlimited approval” as a distinct warning, helping users recognize when they are accepting this concentrated risk. More importantly, Rabby allows users to modify the approval amount before signing. A user can see that a dApp is requesting unlimited access to, say, USDC, but then change the approval to only the amount needed for the current transaction—or perhaps a reasonable amount for a few future transactions. This single feature eliminates most of the practical risk from token approvals because the damage surface is now bounded.
The secondary risk in token approvals is that older approvals accumulate. A user may have granted unlimited approval to a DeFi protocol months or years ago, using the official rabby wallet or another interface. If that protocol is later compromised, the user’s funds remain exposed through the old approval. Rabby provides a token allowance manager that shows all active approvals across all connected dApps and protocols, along with the ability to revoke them individually. This is not a feature that prevents attacks; it is a feature that makes the consequences of past approvals visible and manageable.
Smart contract interactions and function calls
Token approvals are straightforward once you understand them: you are authorizing a contract to move tokens up to a limit. Smart contract function calls are more varied and potentially more complex. When a user interacts with a decentralized application, they are typically calling a function on a smart contract. This function might swap tokens, deposit funds into a lending protocol, claim rewards, mint an NFT, or execute any other logic the contract was programmed to perform.
The problem is that contract functions are often not transparent to users. A wallet that receives a transaction to send to a contract address might display it as “Unknown function call” or show the raw hexadecimal data. This is where transaction simulation becomes essential. Rabby decodes the function call and explains what it will do in readable language. For example, instead of showing hex data, Rabby might display: “Swap 10 USDC for WETH via Uniswap” or “Deposit 1 ETH into Aave and receive aETH.” This readable output is the difference between approving blindly and understanding what you are authorizing.
Some contract functions are inherently risky because they give the contract broad authority. A function that says “claim rewards” is relatively safe; it should only move tokens that the user is entitled to. A function labeled “call” or that takes arbitrary data as a parameter is much more suspicious because it could execute any logic. Similarly, if a smart contract interaction requires the user to approve unlimited token spending first, followed by a function call, the combination is more dangerous than either step alone. Rabby’s transaction simulation should highlight these patterns, showing the full sequence of operations so the user can see both the approval and the function call together.
Rug pulls and exit scams often follow a predictable pattern: the dApp requests unlimited approval of a token, executes a function call that transfers funds from the user’s wallet to an attacker-controlled address, and disappears. New users are most vulnerable because they do not yet recognize the pattern. More experienced users sometimes still fall for this if the protocol is well-designed, has credible marketing, or operates for weeks or months before stealing. Rabby cannot prevent sophisticated social engineering, but by making the full transaction chain visible before signing, it removes the surprise element.
Message signing and authentication requests
Many dApps ask users to sign a message to prove they own a particular address. This is often used for authentication on web2 systems that want to verify a user’s wallet ownership without moving any funds. The user sees a message, signs it with their private key, and the dApp verifies that the signature is mathematically valid for that address. This proves the user controls the address without any financial transaction.
The security model for message signing is much safer than token approvals or contract interactions because no assets move. However, it is not risk-free. A malicious dApp could request a message that, if signed, has meaning in another context—such as signing a message that could authorize a transaction elsewhere. More commonly, signing a message authorizes the dApp to create an account in its system associated with the user’s address. This is not financial risk, but it is a form of identity linkage that the user should be aware of.
Rabby displays the full text of any message requested for signing, so the user can read it before approving. Some dApps try to obscure what a message means by using technical jargon, long hex strings, or references to standards that sound official but are not. The readable display in Rabby makes it harder for dApps to hide the true meaning of a signature request. Users should still be skeptical of signing messages from unfamiliar sources, but at least the text itself is transparent.
Permission revocation and ongoing exposure
A critical and often overlooked aspect of permissions is that they do not expire. Once you approve a dApp to spend tokens, it can do so indefinitely until you explicitly revoke the approval. This means that old approvals from protocols you no longer use remain active, representing ongoing risk exposure. If a protocol is hacked months or years after you stopped using it, and you forgot that you approved it, your funds can still be stolen through that approval.
The practical consequence is that wallet security is not a one-time event. It is a continuous process of monitoring and revoking permissions you no longer need. Rabby makes this manageable by listing all active token approvals in an easy-to-access interface. A user can see at a glance which dApps have permission to spend which tokens, and for how much. More importantly, they can revoke individual approvals directly from the wallet without visiting the original dApp. This is a genuine security improvement because many protocols become impossible to access (the website goes down, the domain lapses) but the approvals remain active on the blockchain.
Revocation itself costs gas fees on Ethereum or equivalent fees on other EVM chains. This means that indiscriminately revoking every approval can be expensive. The strategic approach is to identify which approvals represent genuine risk—usually unlimited approvals to protocols you no longer use—and revoke those first. Approvals with limited amounts to active protocols you still use are lower priority. Rabby supports this decision-making by allowing users to sort and filter approvals, making it easy to identify the highest-risk ones.
Recognizing phishing and fake permission requests
Phishing attacks in the wallet space often target the permission system itself. A user is directed to a fake website that looks identical to a legitimate protocol. They connect their wallet, which shows the real Rabby extension prompting for connection. At this point, the attack looks legitimate because the wallet interface is genuine. The dApp connection itself is safe, but the next step is where the attack lands: a request for unlimited token approval or a suspicious contract call.
Common phishing red flags include dApps that request token approvals before asking what the user wants to do, dApps that request approvals for tokens the user never intended to use on that platform, or requests that pressure the user to act quickly without time to review. Legitimate dApps generally request approvals only when needed, for the specific tokens involved in the transaction, and with amounts that match the user’s intended action. A protocol that asks for unlimited USDC approval before any specific transaction is a warning sign.
Rabby’s built-in protections against phishing are primarily informational rather than absolute barriers. The wallet does not block suspicious requests because sometimes legitimate protocols have patterns that look suspicious to automated analysis. Instead, Rabby highlights unusual requests with clear warnings. A request for an approval that is 10,000 times larger than any amount you have used before will be flagged. A contract call to an address that is not the expected protocol contract will be flagged. These warnings give users a chance to double-check before approving, rather than blocking them entirely and risking false positives.
The strongest defense against phishing is still user awareness. Users should verify that they are on the correct website, that the Rabby extension is showing the request (not a fake overlay), and that the approval amount matches their intention. For high-value transactions, visiting the protocol through a bookmarked link rather than a search result or ad can reduce the chance of landing on a phishing site. Checking the contract address on a blockchain explorer before approving large permissions is also worthwhile for significant funds.
EVM-specific permission models and cross-chain implications
Rabby’s permission system is designed specifically for Ethereum and EVM-compatible blockchains, which means it only works directly on networks where contracts follow the Ethereum standard. This includes Arbitrum, Optimism, Base, Polygon, BNB Smart Chain, and dozens of others—essentially any blockchain that implements the EVM specification. The implication is that Rabby’s security model and readable transaction simulation apply consistently across all these networks because they all use the same contract interface standards.
However, this also means that if a user wants to interact with Bitcoin, Solana, or other non-EVM blockchains, they need different tools. Rabby does not support non-EVM chains natively, so the permissions architecture described here does not apply to those networks. A user managing crypto across both EVM and non-EVM chains should not assume that Rabby’s security model extends beyond the EVM ecosystem. Different blockchains have different permission models, different signature schemes, and different security vulnerabilities. Using the appropriate wallet for each blockchain is more important than trying to consolidate everything into one tool.
Within the EVM ecosystem, permissions granted on one chain do not affect other chains automatically, but they can represent similar risks. A user might grant unlimited approval on both Polygon and Ethereum to the same DeFi protocol, doubling the exposure surface. Rabby displays approvals separately for each chain, so this is visible, but the user must actively revoke approvals on each chain independently. The risk is not cross-chain contamination but rather the cognitive burden of managing multiple parallel approval lists. Treating each EVM chain as a separate permission surface, even when using the same protocol, is the safer mental model.
Hardware wallet integration and permission flow
Rabby supports hardware wallets including Ledger and Trezor, which adds another layer to the permission system. When using a hardware wallet, every transaction requires physical approval on the device. This includes token approvals, contract calls, and message signatures. The permission flow is the same—the dApp requests, Rabby shows the readable details, and the user must approve—but the final authorization step requires interaction with the hardware device rather than just a click in the extension.
This hardware confirmation step is a genuine security improvement because it means an attacker who compromises the user’s computer cannot execute transactions without physical access to the hardware wallet. However, it does not eliminate the need to understand what you are approving. A user must still read the details shown on the hardware device screen and verify that the amount, recipient, and function match their intention. Hardware wallets generally show less detail than Rabby’s simulation—they cannot display the full context of a DeFi transaction the same way a desktop interface can—so the user should verify the basic parameters (amount and address) on the hardware device and trust the desktop simulation for more complex details.
The workflow when using Rabby with a hardware wallet is therefore slightly slower than with a software wallet. Every approval requires a device confirmation, and switching between devices, updating firmware, and recovering from lost devices adds complexity. For users managing substantial funds, this friction is a feature rather than a bug. The slight inconvenience is a built-in brake on impulsive approvals. A user is much less likely to grant unlimited approval to a new protocol if it requires pulling out a hardware device and confirming the transaction on a separate screen.
Frequently asked questions
What is the difference between connecting a wallet to a dApp and approving a transaction?
Connecting a wallet to a dApp discloses your address and allows the dApp to see your balances, but it does not authorize any spending or contract execution. Approval comes later, when you sign a specific transaction—such as a token approval, contract function call, or message signature. Rabby keeps these steps separate so you can review what you are actually authorizing before signing.
Why is unlimited token approval dangerous?
Unlimited approval allows a smart contract to spend any amount of a token from your wallet, up to your entire balance. If the contract is hacked or compromised, an attacker can drain all of that token without needing a new approval. Rabby lets you reduce unlimited approvals to specific amounts before signing, limiting your maximum exposure.
How can I see and revoke old approvals I no longer need?
Rabby’s token allowance manager displays all active approvals granted to dApps, including the amount and which token. You can revoke individual approvals directly from the wallet without visiting the original dApp. This is essential because old approvals remain active indefinitely and represent ongoing risk if the protocol is later compromised.
