// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IERC20 {
    // The approval function that Revoke.cash helps manage
    function approve(address spender, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
}

// When you "approve" Uniswap, this is what happens: // token.approve(uniswapRouter, 115792089237316195423570985008687907853269984665640564039457584007913129639935)
// This number = type(uint256).max = UNLIMITED

# Official website (always verify the URL)
# https://revoke.cash
# 
# Common phishing domains to AVOID: # - revokecash.com (fake)
# - revoke-cash.app (fake)
# - revok3.cash (fake)
# Always bookmark the official URL after your first visit

// Revoke.cash supports all major wallets
const supportedWallets = [
  "MetaMask",
  "WalletConnect v2",
  "Coinbase Wallet",
  "Rainbow",
  "Ledger Live",
  "Trezor (via MetaMask)",
  "Phantom (EVM mode)",
  "Trust Wallet"
];

// To "revoke" an approval, you simply approve 0 tokens
// This is the ONLY way to remove a previous approval

function revokeApproval(address token, address spender) external {
    // approve(spender, 0) overwrites the previous allowance
    IERC20(token).approve(spender, 0);
    // After this transaction, spender cannot move ANY of your tokens
}

// Alternative: approve with a specific limited amount
function setLimitedApproval(address token, address spender, uint256 amount) external {
    IERC20(token).approve(spender, amount);
    // Spender can only spend up to amount tokens
}

// Revoke.cash reads Approval events from the blockchain
const filter = {
  address: tokenAddress,           // The token contract
  topics: [
    ethers.utils.id("Approval(address,address,uint256)"),
    ethers.utils.hexZeroPad(userAddress, 32),  // Your address (owner)
    null                                       // Any spender
  ]
};

// Query all historical approval events
const approvalEvents = await provider.getLogs({
  ...filter,
  fromBlock: 0,
  toBlock: "latest"
});

// The most recent event for each (owner, spender, token) triplet
// represents the CURRENT active approval

// Direct contract call to check current allowance
const checkAllowance = async (tokenAddress, owner, spender) => {
  const token = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
  
  const allowance = await token.allowance(owner, spender);
  
  const MAX_UINT256 = ethers.BigNumber.from(
    "115792089237316195423570985008687907853269984665640564039457584007913129639935"
  );
  
  if (allowance.eq(MAX_UINT256)) {
    return { status: "UNLIMITED", risk: "CRITICAL" };
  } else if (allowance.gt(0)) {
    return { status: "LIMITED", amount: allowance.toString(), risk: "MEDIUM" };
  } else {
    return { status: "REVOKED", risk: "NONE" };
  }
};

# Complete network support as of 2026
ethereum: chain_id: 1
  rpc_required: true
  features: ["Full support", "NFT approvals", "Permit2"]

polygon: chain_id: 137
  rpc_required: true
  features: ["Full support", "Low gas revokes"]

arbitrum: chain_id: 42161
  rpc_required: true
  features: ["Full support", "Nitro compatible"]

optimism: chain_id: 10
  rpc_required: true
  features: ["Full support", "Bedrock compatible"]

base: chain_id: 8453
  rpc_required: true
  features: ["Full support", "Coinbase ecosystem"]

bnb_chain: chain_id: 56
  rpc_required: true
  features: ["Full support", "PancakeSwap approvals"]

avalanche: chain_id: 43114
  rpc_required: true
  features: ["C-Chain support", "TraderJoe approvals"]

fantom: chain_id: 250
  rpc_required: true
  features: ["Full support", "SpookySwap/SpiritSwap"]

// Revoke.cash auto-detects your current network
// Switch networks in your wallet to audit approvals on different chains

const switchNetwork = async (chainId) => {
  await window.ethereum.request({
    method: "wallet_switchEthereumChain",
    params: [{ chainId: ````0x${chainId.toString(16)}```` }]
  });
  // Revoke.cash will automatically refresh for the new chain
};

// Example: Switch to Polygon
await switchNetwork(137);

# Chrome Web Store: # https://chrome.google.com/webstore/detail/revokecash/revokecash-extension

# Firefox Add-ons: # https://addons.mozilla.org/firefox/addon/revokecash/

# Features: # - Warns before signing unlimited approvals
# - Alerts when approving known malicious contracts
# - Shows estimated USD value at risk
# - One-click revoke from popup

// Extension settings (configurable via popup)
const extensionConfig = {
  // Warn when approval exceeds this USD threshold
  warnThresholdUSD: 1000,
  
  // Block known phishing contracts automatically
  blockKnownScams: true,
  
  // Show risk rating for each approval
  showRiskRating: true,
  
  // Alert on Permit signatures (gasless approvals)
  warnOnPermit: true,
  
  // Dark mode
  theme: "dark"
};

// The extension monitors ethereum.request() calls
const originalRequest = window.ethereum.request;

window.ethereum.request = async (args) => {
  if (args.method === "eth_sendTransaction") {
    const tx = args.params[0];
    
    // Detect approval transactions
    if (isApprovalTransaction(tx)) {
      const spender = decodeSpender(tx.data);
      const token = tx.to;
      const amount = decodeAmount(tx.data);
      
      // Check if contract is known malicious
      if (await isKnownScam(spender)) {
        showCriticalWarning("KNOWN SCAM CONTRACT DETECTED!");
        return Promise.reject("Blocked by Revoke.cash");
      }
      
      // Warn on unlimited approvals
      if (isUnlimited(amount)) {
        showWarning("Unlimited approval detected. Consider setting a limit.");
      }
    }
  }
  
  return originalRequest(args);
};

// EIP-2612 permit: Off-chain signature becomes on-chain approval
function permit(
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
) external {
    // After this call, spender can spend value tokens
    // The user NEVER sent a transaction — only signed a message!
}

// Uniswap's Permit2 contract uses a different pattern
const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";

const checkPermit2Allowance = async (owner, token, spender) => {
  const permit2 = new ethers.Contract(PERMIT2_ADDRESS, PERMIT2_ABI, provider);
  
  const allowance = await permit2.allowance(owner, token, spender);
  
  return {
    amount: allowance.amount,
    expiration: allowance.expiration,
    nonce: allowance.nonce,
    isActive: allowance.expiration > Math.floor(Date.now() / 1000)
  };
};

// Revoking Permit2 requires a transaction to the Permit2 contract
const revokePermit2 = async (token, spender) => {
  const permit2 = new ethers.Contract(PERMIT2_ADDRESS, PERMIT2_ABI, signer);
  
  // Set amount to 0 and expiration to now
  const tx = await permit2.approve(
    token,
    spender,
    0,                                      // amount = 0
    Math.floor(Date.now() / 1000)           // expiration = now
  );
  
  await tx.wait();
  console.log("Permit2 allowance revoked!");
};

// Use multicall to revoke multiple approvals in one transaction
const multicall3Address = "0xcA11bde05977b3631167028862bE2a173976CA11";

const batchRevoke = async (revocations) => {
  const multicall = new ethers.Contract(multicall3Address, MULTICALL_ABI, signer);
  
  const calls = revocations.map(({ token, spender }) => ({
    target: token,
    allowFailure: true,
    callData: new ethers.Contract(token, ERC20_ABI).interface.encodeFunctionData(
      "approve", [spender, 0]
    )
  }));
  
  const tx = await multicall.aggregate3(calls);
  await tx.wait();
  
  console.log(````Revoked ${revocations.length} approvals in one tx!````);
};

# Strategy: Revoke during low gas periods
# - Weekends typically have lower gas
# - Early morning UTC (2AM - 6AM) is usually cheapest
# - Use https://etherscan.io/gastracker to monitor

# Example gas costs for revoking: # ┌─────────────────┬──────────────┬─────────────────┐
# │ Network         │ Gas Units    │ Cost (at 20 gwei)│
# ├─────────────────┼──────────────┼─────────────────┤
# │ Ethereum        │ ~46,000      │ ~$2.30          │
# │ Polygon         │ ~46,000      │ ~$0.02          │
# │ Arbitrum        │ ~46,000      │ ~$0.50          │
# │ Optimism        │ ~46,000      │ ~$0.30          │
# │ BNB Chain       │ ~46,000      │ ~$0.10          │
# └─────────────────┴──────────────┴─────────────────┘

// Subscribe to security alerts (via browser extension or Telegram)
const subscribeToAlerts = async (address) => {
  // Methods: // 1. Browser extension (push notifications)
  // 2. Telegram bot: @RevokeCashBot
  // 3. Email alerts via revokesafe.eth
  
  const alertConfig = {
    address: address,
    alertTypes: [
      "PROTOCOL_EXPLOIT",      // When a protocol you approved gets hacked
      "NEW_UNLIMITED_APPROVAL", // When you grant an unlimited approval
      "SUSPICIOUS_CONTRACT"    // When you approve a flagged contract
    ],
    channels: ["browser", "telegram", "email"]
  };
  
  return alertConfig;
};

# WEEKLY ROUTINE: # 1. Visit revoke.cash and scan all active approvals
# 2. Revoke unlimited approvals for protocols you're not actively using
# 3. Check the "Risk" column for unknown spenders

# BEFORE EVERY MAJOR TRANSACTION: # 1. Verify the contract address on Etherscan
# 2. Check if the spender is a known protocol
# 3. If prompted for unlimited approval, set a custom limit instead

# AFTER PROTOCOL EXPLOITS: # 1. Immediately check revoke.cash if you ever used the protocol
# 2. Revoke ALL approvals with the compromised contract
# 3. Monitor your address for unauthorized transfers

// Instead of unlimited approval, set a specific amount
const setLimitedApproval = async (token, spender, humanAmount) => {
  const decimals = await token.decimals();
  const amount = ethers.utils.parseUnits(humanAmount, decimals);
  
  // Approve exactly what you need + small buffer
  const tx = await token.approve(spender, amount);
  await tx.wait();
  
  console.log(````Approved ${humanAmount} tokens for ${spender}````);
};

// Example: Only approve 1000 USDC for a swap
await setLimitedApproval(usdcContract, uniswapRouter, "1000");

// For exploring new/untested protocols: // 1. Create a separate "burner" wallet
// 2. Only transfer funds you can afford to lose
// 3. Grant approvals from the burner wallet
// 4. After use, revoke all approvals and sweep remaining funds back

const burnerStrategy = {
  maxFunds: "0.1 ETH",           // Maximum exposure
  approvalPolicy: "LIMITED_ONLY", // Never unlimited
  postUseAction: "REVOKE_ALL"     // Always cleanup after
};
````

* * *

## FAQ: Frequently Asked Questions

**Q1: Is Revoke.cash free to use?**
A: Yes, Revoke.cash is completely free. It's an open-source project (GPL-3.0) maintained by the community. You only pay the standard network gas fee for revoke transactions. The browser extension is also free.

**Q2: Can Revoke.cash steal my tokens?**
A: No. Revoke.cash is a non-custodial interface — it never holds your keys or has any special access. You sign all transactions directly through your own wallet. The code is fully open-source and auditable on GitHub.

**Q3: What's the difference between revoking and disconnecting my wallet?**
A: Disconnecting your wallet only removes the frontend connection to Revoke.cash. It does NOT remove token approvals on the blockchain. Revoking is an on-chain action that permanently removes a smart contract's permission to spend your tokens.

**Q4: Do I need to revoke approvals on every blockchain separately?**
A: Yes, token approvals are chain-specific. If you approved USDC on Uniswap on Ethereum, that approval only exists on Ethereum. You need to check and revoke approvals on each chain where you've interacted with DeFi protocols.

**Q5: What are Permit2 approvals and how are they different?**
A: Uniswap's Permit2 system allows gasless approvals through off-chain signatures. These don't appear as regular on-chain transactions but still grant spending permissions. Revoke.cash can detect and revoke Permit2 allowances through a dedicated interface.

**Q6: Should I revoke ALL approvals, even from trusted protocols?**
A: Not necessarily. For protocols you use regularly (like Aave or Uniswap), maintaining an approval is convenient and the risk is low for established protocols. Focus on revoking: (1) unlimited approvals, (2) approvals for protocols you no longer use, and (3) approvals to unknown contracts.

**Q7: Can someone steal my NFTs through approvals?**
A: Yes! ERC-721 and ERC-1155 token approvals work similarly to ERC-20. If you've approved an NFT marketplace or random contract, they can transfer your NFTs. Revoke.cash supports revoking NFT approvals as well — look for the "NFT" tab on the dashboard.

**Q8: What happens if I don't revoke approvals?**
A: Your tokens remain at risk indefinitely. If the approved contract gets exploited, hacked, or turns malicious, your entire approved balance can be drained in a single transaction. Many high-profile hacks (like the $600M Poly Network exploit) were possible because of lingering approvals.

* * *



## Recommended Hosting & Infrastructure

Before you deploy any of the tools above into production, you'll need solid infrastructure. Two options dibi8 actually uses and recommends: - **[DigitalOcean](https://m.do.co/c/eca87ac14ee0)** — $200 free credit for 60 days across 14+ global regions.
- **[HTStack](https://my.htstack.com/aff.php?aff=27187)** — Hong Kong VPS with low-latency access from mainland China. This is the same IDC that hosts dibi8.com.

*Affiliate links — they don't cost you extra and they help keep dibi8.com running.*

## Conclusion: Make Revoke.cash Part of Your Security Routine

In DeFi, security isn't a one-time setup — it's an ongoing practice. Revoke.cash, with its **2,500+ GitHub stars**, **browser extension**, and **multi-chain support**, provides the simplest yet most effective way to audit and manage your token approvals.

With over **$1 billion in protected assets** and regular security alerts for exploited protocols, Revoke.cash has proven itself as an essential tool in every crypto user's security stack. Make it a weekly habit — spend 5 minutes on revoke.cash and potentially save your entire portfolio.

**Looking for a secure place to trade? [Sign up on Binance](https://www.bsmkweb.cc/register?ref=DIBI8) — the world's largest crypto exchange with industry-leading security, lowest fees, and insurance fund protection.**

* * *

*Disclaimer: This article is for informational purposes only and does not constitute financial or security advice. Always verify contract addresses, use hardware wallets for significant holdings, and practice good operational security. This post contains affiliate links — we may receive compensation at no cost to you when you use our partner links.*


{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "revoke-crypto-permission-manager",
  "datePublished": "2026-05-20",
  "dateModified": "2026-05-20",
  "author": {
    "@type": "Organization",
    "name": "Dibi8"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Dibi8",
    "logo": {
      "@type": "ImageObject",
      "url": "https://dibi8.com/logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://dibi8.com/resources/revoke-crypto-permission-manager"
  }
}
</script>
## Frequently Asked Questions (FAQ)

**问：量化交易的风险有多大？**

取决于策略设计、资金管理、市场波动。建议先用模拟账户测试。

**问：如何选择适合的交易策略？**

根据风险承受能力、时间投入、资金规模选择。高频需要技术，低频需要分析。

**问：回测结果可信吗？**

回测有局限性，需警惕过拟合、前视偏差、忽略滑点和手续费。

**问：需要编程基础吗？**

基础策略可使用低代码平台，高级策略需要Python/C++编程能力。

**问：交易系统的维护成本？**

包括服务器费用、数据订阅、算法更新、以及监控维护时间。