An NFT collector discovers what appears to be a legitimate offer to trade a rare digital asset. The interface looks professional. The smart contract address resembles the one from a known marketplace. But when the transaction is submitted, the contract executes a hidden function that drains not just the NFT in question, but every token and asset held in the connected wallet. By the time the user realizes what happened, the funds are irretrievable. The exploit worked because the transaction signature approved far more than the visible action suggested.
This scenario has played out thousands of times across Ethereum and other EVM networks. NFT theft is not always a matter of compromised seed phrases or phishing emails. Often it is a direct result of signing a transaction without understanding what the contract will actually do. The attacker relies on the mismatch between what a user sees on screen and what the blockchain will execute. A self-custodial NFT wallet cannot prevent bad contracts from existing, but it can show a user exactly what will happen before they sign, turning opacity into clarity.
The mismatch between user intention and contract execution
When someone clicks “list NFT for sale” on a marketplace, they expect to authorize a transfer of that specific NFT. The smart contract call required to enable that transfer is usually an approval function. In ERC-721 and ERC-1155 standards, an approval grants permission for a third party (the marketplace contract) to move the token on behalf of the owner. The problem arises when a malicious contract or a compromised legitimate interface includes additional code that executes simultaneously.
A well-designed NFT marketplace contract will only transfer the asset the user selected. A deceptive or compromised version might include a secondary function call—one that moves all ERC-20 tokens from the wallet, or sweeps a balance of a different NFT collection, or delegates voting rights to an attacker’s address. The user’s browser may display only the primary action. The blockchain, however, executes all functions within the transaction. If the user signs without reviewing the complete transaction, they have approved all of them.
The technical reason this works is that Ethereum transactions are opaque to the end user by default. A transaction’s data field contains bytecode—a series of hex characters representing contract function calls. A user seeing a marketplace interface does not automatically see this bytecode. They see a button that says “Approve” or “List NFT.” The wallet extension or application is responsible for translating that bytecode into human-readable language. If the application does not perform that translation, or if it only partially translates it, the user may sign something they do not understand.
This is where transaction simulation becomes critical. Instead of showing only the button label or the primary action, a wallet can decode the transaction data, execute it against a test blockchain state, and report exactly what will change. The user sees not just the intent, but the actual outcome: which assets will be transferred, to which addresses, in what amounts. When that simulation reveals something unexpected, a user can refuse to sign before any irreversible action occurs on the mainnet.
Real-world examples of hidden contract behaviors
One common attack uses “approve and call” patterns where a user approves a token transfer to Contract A, but that contract immediately calls a function on Contract B, which then calls Contract C. Each step performs an unannounced action. An attacker might craft a contract that asks for approval to transfer a specific NFT, then during the same transaction sweeps a connected DeFi lending pool balance, claiming collateral that was supposed to be locked. The user sees only the first step advertised.
Another variant involves fake marketplace contracts that clone the interface and address naming of legitimate platforms like OpenSea or Blur. When a user attempts to list an NFT, they are approving not the real marketplace, but a contract controlled by the attacker. The signature may appear valid in a standard wallet view because it shows the expected NFT and a reasonable-looking contract address. A simulation, however, would reveal that the receiving contract immediately triggers unexpected transfers or delegate calls.
Permit-based attacks are increasingly common because they bypass the two-step approve-then-transfer pattern. Instead, a single signature grants permission for multiple actions. A user might sign what they believe is authorization for a token swap, but the permit function is constructed to allow unlimited transfers of that token over an extended time. The victim has not just moved one asset; they have given a contract the ability to drain them repeatedly until the permit expires or is revoked.
A fourth category involves NFT metadata manipulation. An attacker creates a contract that mimics the appearance of a valuable NFT by claiming to represent the same metadata or image. When displayed in a wallet, it might show the cover art or name of a sought-after collection. The contract itself, however, contains code that triggers a secondary transaction when anyone tries to transfer it or approve it. The user believes they are moving a worthless asset; the contract hijacks the signature to perform a different action entirely.
How transaction interpretation prevents approval attacks
A wallet that implements transaction interpretation decodes contract function calls and displays them in structured language before the user signs. Rather than showing raw bytecode or a vague “approve” prompt, the wallet shows: “Contract Uniswap V3 Router wants to swap 10 USDC for approximately 0.005 ETH. Fee: 0.3%. Slippage tolerance: 1%.” The user can verify each parameter matches their intent.
For NFT operations, the interpretation is even more specific. Instead of “Approve Contract 0x1234…” the wallet shows “OpenSea wants permission to transfer any ERC-721 token from your collection ‘Cool Cats’ (contract 0x1a92f7381b9c…). This allows listing or selling on OpenSea.” If the contract address shown does not match the real OpenSea address, or if the collection is not Cool Cats, the mismatch is immediately visible.
When a transaction contains multiple function calls, a well-designed interpretation surfaces all of them. If the user is approving a token for a swap but the contract is also calling a secondary function—say, setting a delegate or transferring a different asset—both appear in the preview. This eliminates the scenario where a user approves the primary action and only later discovers a hidden secondary effect.
The interpretation also includes balance change prediction. The wallet calculates what the user’s balances will look like after the transaction executes, showing expected increases and decreases for each asset. If a user approves a swap expecting to send 100 USDC and receive 0.05 ETH, but the simulation shows they will also lose 50 USDT or all of their NFT holdings, the preview makes that visible before signing. This is the difference between trusting an interface and verifying reality.
Pre-sign security checks and risk alerts
Beyond transaction interpretation, a robust security framework includes automated risk detection. Certain patterns are statistically associated with theft or loss. These include: approvals with unlimited token amounts (often written as 2^256 – 1 in hex), approvals to unknown or newly created contracts, approvals to contracts that have been flagged in community databases as malicious, and transactions that combine approval with an immediate transfer in a way that suggests a flash loan attack or reentrancy exploitation.
A wallet can check each transaction against security checking databases and heuristics. If the destination contract has been reported to security services as the source of NFT theft, the wallet can display a warning: “This contract has been flagged by multiple security services as malicious. Do not proceed unless you are certain of the source.” Similarly, if an approval request uses unlimited allowance when the intended transaction requires only a specific amount, the wallet can alert the user to that mismatch and suggest a more restrictive approval.
Rabby’s approach includes both real-time contract analysis and community-sourced risk data. When a user attempts to sign a transaction, the wallet checks the contract’s code for common attack patterns, verifies the contract against known malicious address lists, and displays any warnings in a prominent position before the signature is requested. The alerts are not meant to make every transaction feel dangerous; they are meant to highlight genuine red flags that should trigger a pause and verification.
The most effective additional control is hardware wallet integration. When a Rabby wallet is connected to a Ledger, Trezor, or other hardware device, the transaction preview and security checks occur on the connected computer, but the actual signature is generated by the hardware device’s isolated processor. Even if the computer is compromised or the website is malicious, the hardware wallet can refuse to sign a transaction if the user rejects it on the physical device. This creates two independent decision points rather than one.
Differentiating between approval scams and genuine risks
Not every smart contract that requests an approval is malicious. DeFi protocols, marketplaces, and swapping services all require approvals to function. The challenge is distinguishing between a legitimate approval needed for a service the user intended to use and an approval requested as part of an attack. The key factors are context, source, and amount.
Context means the approval request should appear during the action the user initiated. If someone clicks “Swap tokens on Uniswap,” it makes sense that Uniswap’s router contract will request approval. If someone navigates to an NFT marketplace to list a single item and is suddenly asked to approve unlimited transfers of all ERC-20 tokens in their wallet, that is contextually wrong. The preview should display this mismatch clearly.
Source refers to whether the contract address requesting approval actually belongs to the service advertised. An attacker might clone the UI of Opensea but direct approvals to a different contract address. A user comparing the contract address displayed in the wallet preview to the verified address published on OpenSea’s official documentation can spot the mismatch. Many users skip this step, assuming the interface is trustworthy. The wallet’s job is to make the comparison obvious by showing the full address and, ideally, the contract’s verified source code or known name.
Amount is the third control. A legitimate approval for a single transaction should typically request permission to transfer only the amount needed, plus a small margin for slippage or rounding. An unlimited approval (2^256 – 1) is sometimes necessary for convenience—a user might want to approve a decentralized exchange once and then use it repeatedly without re-approving. However, this convenience carries a risk: if the contract becomes compromised or the user later interacts with a different service that exploits the standing approval, funds can be stolen. A wallet’s security check can suggest revoking old unlimited approvals and replacing them with limited ones.
The process of installing a trustworthy wallet and verifying authenticity
The transaction preview and security checking features only protect a user if they are running the genuine wallet software. Fake versions exist on unauthorized websites and third-party app stores, designed to steal seed phrases or private keys before any transaction preview can occur. The first security decision is not about smart contracts or blockchain transactions. It is about downloading the correct software from the correct source.
Rabby is available as a browser extension for Chrome, Brave, Edge, and other Chromium-based browsers, as well as native Android applications. The official source is rabby.io. Any other domain claiming to host Rabby is suspicious. Similarly, the official app stores are the Chrome Web Store for the extension and Google Play for Android. Third-party stores, especially those requiring payment or unusual permissions, should be avoided.
Before downloading, a user should verify the official sources through a known reference. Searching “Rabby Wallet download” in a search engine may return sponsored links or clone sites. A safer approach is to navigate directly to the official domain by typing the URL, or to read more about installation from verified sources. If using the browser extension, check that the developer listed is Rabby. If using Android, verify that the application publisher is Rabby and check the number of downloads and recent review ratings.
Once installed, the wallet should be initialized securely. If importing an existing seed phrase, the user should confirm they are typing it into the wallet window, not copying it through the clipboard or pasting it into a text editor that might sync to the cloud. If generating a new wallet, the recovery phrase should be written on paper, stored physically in a safe location, and never typed into a web browser, email, or cloud storage. The backup process is the most sensitive moment because the recovery phrase grants complete control of the wallet’s funds.
Using watch-only and hardware wallet features to reduce signing exposure
A user does not always need to sign transactions from their main wallet. For monitoring or planning purposes, a watch-only account can display balances and transaction history without requiring a private key or recovery phrase to be entered. This is useful for observing NFT holdings, tracking portfolio value, or planning future transactions without exposing the signing capability to the browser extension.
Similarly, hardware wallet integration allows a user to keep the actual private key on a separate, air-gapped device. Rabby can display the wallet balance, compose transactions, and show the security preview, but the final signature is generated by the hardware device. If the computer running Rabby is compromised by malware, the malware cannot steal the private key or forge a signature without physical access to the hardware wallet and the user’s PIN. This is the strongest practical configuration for managing significant NFT collections or token balances.
MetaMask import functionality allows existing users to migrate their accounts into Rabby without creating entirely new wallets. The process generates a new recovery phrase for Rabby and imports the accounts associated with the old MetaMask seed. This is useful for adopting a wallet with better transaction interpretation without losing access to established accounts. However, the migration should be done on a clean, offline computer or air-gapped device if possible, since the import process temporarily exposes the seed phrase to the browser.
After migration, the old MetaMask wallet should remain in place for a period of observation. This allows verification that all accounts and assets are accessible from Rabby before the old backup is destroyed. If something goes wrong in the migration—if a typo or UI misunderstanding causes a recovery phrase to be entered incorrectly—the original wallet remains available to restore funds.
Real-time decision-making when facing an unfamiliar transaction
A user receives an offer to participate in an NFT swap or a token sale. The interface looks professional. The terms seem reasonable. But when they attempt to approve the transaction, Rabby’s preview shows something unexpected: the approval amount is unlimited, or the contract address does not match the advertised service, or the simulation reveals a secondary transfer to an unknown address. At this moment, the user must make a decision: trust the interface and proceed, or stop and investigate further.
The correct response is to investigate. Even if the offer seems time-limited or socially urgent, proceeding with a transaction that the wallet has flagged as suspicious is likely to result in loss. A legitimate service will explain why the approval is unlimited or why the contract address differs from expectations. An attacker will pressure for quick action and attempt to dismiss the user’s questions as technical confusion. If no clear explanation is available, the transaction should be abandoned.
Investigation might include searching for the contract address on a blockchain explorer like Etherscan, where the contract source code may be visible and the transaction history may reveal whether it has been used to drain other users’ wallets. It might include checking a security aggregator or community site to see if the contract or associated address has been reported as malicious. It might include asking in a community forum with a screenshot of the preview, with sensitive information redacted. The time investment is small compared to the potential loss.
A good practice is to make a small test transaction first. If offering to buy an NFT, ask if the seller will accept a smaller preliminary transfer to confirm the wallet and contract are legitimate. This allows verification of the transaction path and confirmation that funds actually arrive as expected, before committing the full purchase amount. A legitimate counterparty will usually accept this. An attacker often will not, since the purpose is to steal the first large transaction.
Ongoing wallet maintenance and approval hygiene
Over time, a user may accumulate approvals to many different contracts. Each standing approval represents a potential risk if the contract is later compromised. Periodic review and revocation of unnecessary approvals reduces that exposure. Rabby can display all active approvals for a connected wallet, showing which contracts have permission to transfer which tokens and the amounts allowed.
An audit might reveal that a user approved Uniswap several years ago with an unlimited allowance, but has not used Uniswap since moving to Curve. The old approval can be revoked by sending a zero-amount approval transaction to the same contract, which costs a small amount of gas but removes the standing permission. Similarly, approvals to deprecated or unknown contracts might be candidates for revocation.
This maintenance is not urgent or continuous. A user is not at immediate risk from an old, unused approval. However, scanning the approval list every few months and removing the ones that are clearly no longer necessary is a reasonable hygiene practice. It reduces the surface area of potential exploitation and clarifies which contracts currently have access to the wallet’s assets.
The larger point is that NFT security is not a one-time decision. A user cannot simply “be careful” once and then assume all future transactions are safe. Instead, security is a process of verification, skepticism, and ongoing attention. A wallet that makes verification easy—by showing complete transaction previews, running automated risk checks, and integrating hardware devices—removes friction from the security process. The result is that security becomes less burdensome and therefore more likely to be followed consistently.
Frequently asked questions
What does “transaction simulation” actually do, and does it prevent all NFT scams?
Transaction simulation executes the transaction against a copy of the blockchain state before the user signs, showing exactly which assets will be transferred, to which addresses, and in what amounts. This reveals hidden contract behaviors and prevents approval attacks. However, it does not protect against scams where the user intentionally sends an asset to an attacker in exchange for something that is not delivered, or where the contract itself is a fake version of a legitimate service. Simulation shows what will happen; it cannot determine user intent or whether the counterparty is trustworthy.
Is it safe to approve unlimited token amounts for convenience?
Unlimited approvals allow a contract to transfer any amount of a token without requiring re-approval on each transaction, which is convenient for repeated use on decentralized exchanges or marketplaces. However, if the contract is compromised or if the user later uses a malicious contract that exploits the standing approval, the attacker can drain the entire balance. For high-value holdings, a limited approval (allowing only the amount needed for the current transaction plus a reasonable margin) or a hardware wallet signature requirement reduces this risk in exchange for slightly more friction per transaction.
How do I verify that I downloaded the genuine Rabby Wallet and not a fake?
Download only from the official rabby.io domain or verified app stores: the Chrome Web Store for the browser extension, or Google Play for Android. Verify the developer name is Rabby. Do not download from unauthorized websites, third-party app stores, or links in social media posts. If unsure, navigate directly to the domain by typing the URL, rather than clicking a link or using a search result.






