{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "wallet_getCapabilities",
  "params": ["0x407d73d8a49eeb85d32cf465507dd71d507100c1"]
}

{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "0x2105": {
      "auxiliaryFunds": {
        "supported": true
      },
      "atomic": {
        "supported": "supported"
      },
      "paymasterService": {
        "supported": true
      },
      "flowControl": {
        "supported": false
      },
      "datacallback": {
        "supported": false
      }
    },
    "0x14A34": {
      "auxiliaryFunds": {
        "supported": false
      },
      "atomic": {
        "supported": "ready"
      },
      "paymasterService": {
        "supported": true
      }
    }
  }
}
Defined in EIP-5792
Returns the wallet’s capabilities for a given account. Capabilities indicate what additional functionality the wallet supports beyond standard RPC methods, such as atomic batch transactions, gasless transactions, auxiliary funds, and authentication features.

​
Parameters

​
account
string
required
The account address to check capabilities for. Pattern: ^0x[0-9a-fA-F]{40}$

​
Returns

​
result
object
An object where each key is a chain ID (as a hexadecimal string) and each value is an object containing the capabilities supported on that chain.

​
Example Usage

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "wallet_getCapabilities",
  "params": ["0x407d73d8a49eeb85d32cf465507dd71d507100c1"]
}

{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "0x2105": {
      "auxiliaryFunds": {
        "supported": true
      },
      "atomic": {
        "supported": "supported"
      },
      "paymasterService": {
        "supported": true
      },
      "flowControl": {
        "supported": false
      },
      "datacallback": {
        "supported": false
      }
    },
    "0x14A34": {
      "auxiliaryFunds": {
        "supported": false
      },
      "atomic": {
        "supported": "ready"
      },
      "paymasterService": {
        "supported": true
      }
    }
  }
}

​
Capability Detection Patterns

​
Check Single Capability

async function checkAuxiliaryFunds(userAddress: string): Promise<boolean> {
  try {
    const capabilities = await provider.request({
      method: 'wallet_getCapabilities',
      params: [userAddress]
    });

    return capabilities["0x2105"]?.auxiliaryFunds?.supported || false;
  } catch (error) {
    console.error('Failed to check capabilities:', error);
    return false;
  }
}

​
Check Multiple Capabilities

async function getWalletCapabilities(userAddress: string) {
  const capabilities = await provider.request({
    method: 'wallet_getCapabilities',
    params: [userAddress]
  });

  const baseCapabilities = capabilities["0x2105"] || {};

  return {
    hasAuxiliaryFunds: baseCapabilities.auxiliaryFunds?.supported || false,
    hasAtomicBatch: baseCapabilities.atomic?.supported === "supported",
    hasPaymaster: !!baseCapabilities.paymasterService?.supported,
    hasFlowControl: !!baseCapabilities.flowControl?.supported,
    hasDataCallback: !!baseCapabilities.datacallback?.supported
  };
}

​
Conditional Transaction Building

async function buildTransaction(userAddress: string, calls: any[]) {
  const capabilities = await provider.request({
    method: 'wallet_getCapabilities',
    params: [userAddress]
  });

  const baseCapabilities = capabilities["0x2105"] || {};
  
  const txParams: any = {
    version: '1.0',
    chainId: '0x2105',
    from: userAddress,
    calls
  };

  // Add gasless capability if supported
  if (baseCapabilities.paymasterService?.supported) {
    txParams.capabilities = {
      paymasterService: {
        url: "https://paymaster.base.org/api/v1/sponsor"
      }
    };
  }

  // Use atomic execution if supported and multiple calls
  if (calls.length > 1 && baseCapabilities.atomic?.supported === "supported") {
    txParams.atomicRequired = true;
  }

  return txParams;
}

​
Error Handling

CodeMessageDescription
-32602Invalid paramsInvalid account address format
4100Method not supportedWallet doesn’t support wallet_getCapabilities
4200Wallet not availableWallet is not installed or available
Capabilities are chain-specific and account-specific. Always check capabilities for the specific chain and account combination you’re targeting.
Not all wallets support all capabilities. Use capability detection to provide progressive enhancement rather than blocking functionality when capabilities aren’t available.

​
Integration with Other Methods

​
With wallet_sendCalls

Use capabilities to enhance transaction execution: 
const capabilities = await provider.request({
  method: 'wallet_getCapabilities',
  params: [userAddress]
});

// Use capabilities in wallet_sendCalls
const result = await provider.request({
  method: 'wallet_sendCalls',
  params: [{
    version: '1.0',
    chainId: '0x2105',
    from: userAddress,
    atomicRequired: capabilities["0x2105"]?.atomic?.supported === "supported",
    calls: [{
      to: '0x...',
      value: '0x0',
      data: '0x...'
    }],
    capabilities: {
      paymasterService: capabilities["0x2105"]?.paymasterService?.supported ? {
        url: "https://paymaster.base.org/api/v1/sponsor"
      } : undefined
    }
  }]
});

​
With wallet_connect

Capabilities detection doesn’t affect wallet_connect, but you can use the results to inform your authentication flow: 
const capabilities = await provider.request({
  method: 'wallet_getCapabilities',
  params: [userAddress]
});

// signInWithEthereum is always available with wallet_connect
const { accounts } = await provider.request({
  method: 'wallet_connect',
  params: [{
    version: '1',
    capabilities: {
      signInWithEthereum: { 
        nonce: generateNonce(), 
        chainId: '0x2105'
      }
    }
  }]
});

​
Best Practices

  1. Always Check First: Call wallet_getCapabilities before using advanced features
  2. Cache Results: Capabilities typically don’t change frequently, consider caching
  3. Graceful Fallbacks: Implement fallback behavior when capabilities aren’t supported
  4. Chain-Specific: Check capabilities for each chain your app supports
  5. Progressive Enhancement: Use capabilities to enhance UX, not gate basic functionality