> ## Documentation Index
> Fetch the complete documentation index at: https://daehan-base.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# wallet_getCapabilities

> Get the wallet's supported capabilities for the given account

export const Button = ({children, disabled, variant = "primary", size = "medium", iconName, roundedFull = false, className = '', fullWidth = false, onClick = undefined}) => {
  const variantStyles = {
    primary: 'bg-blue text-black border border-blue hover:bg-blue-80 active:bg-[#06318E] dark:text-white',
    secondary: 'bg-white border border-white text-palette-foreground hover:bg-zinc-15 active:bg-zinc-30',
    outlined: 'bg-transparent text-white border border-white hover:bg-white hover:text-black active:bg-[#E3E7E9]'
  };
  const sizeStyles = {
    medium: 'text-md px-4 py-2 gap-3',
    large: 'text-lg px-6 py-4 gap-5'
  };
  const sizeIconRatio = {
    medium: '0.75rem',
    large: '1rem'
  };
  const classes = ['text-md px-4 py-2 whitespace-nowrap', 'flex items-center justify-center', 'disabled:opacity-40 disabled:pointer-events-none', 'transition-all', variantStyles[variant], sizeStyles[size], roundedFull ? 'rounded-full' : 'rounded-lg', fullWidth ? 'w-full' : 'w-auto', className];
  const buttonClasses = classes.filter(Boolean).join(' ');
  const iconSize = sizeIconRatio[size];
  return <button type="button" disabled={disabled} className={buttonClasses} onClick={onClick}>
      <span>{children}</span>
      {iconName && <Icon name={iconName} width={iconSize} height={iconSize} color="currentColor" />}
    </button>;
};

export const BaseBanner = ({content = null, id, dismissable = true}) => {
  const LOCAL_STORAGE_KEY_PREFIX = 'cb-docs-banner';
  const [isVisible, setIsVisible] = useState(false);
  const onDismiss = () => {
    localStorage.setItem(`${LOCAL_STORAGE_KEY_PREFIX}-${id}`, 'false');
    setIsVisible(false);
  };
  useEffect(() => {
    const storedValue = localStorage.getItem(`${LOCAL_STORAGE_KEY_PREFIX}-${id}`);
    setIsVisible(storedValue !== 'false');
  }, []);
  if (!isVisible) {
    return null;
  }
  return <div className="fixed bottom-0 left-0 right-0 bg-white py-8 px-4 lg:px-12 z-50 text-black dark:bg-black dark:text-white border-t dark:border-gray-95">
      <div className="flex items-center max-w-8xl mx-auto">
        {typeof content === 'function' ? content({
    onDismiss
  }) : content}
        {dismissable && <button onClick={onDismiss} className="flex-shrink-0 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 transition-colors" aria-label="Dismiss banner">
          ✕
        </button>}
      </div>
    </div>;
};

Defined in [EIP-5792](https://eips.ethereum.org/EIPS/eip-5792)

<Info>
  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.
</Info>

## Parameters

<ParamField body="account" type="string" required>
  The account address to check capabilities for.
  Pattern: `^0x[0-9a-fA-F]{40}$`
</ParamField>

## Returns

<ResponseField name="result" type="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.

  <Expandable title="Capabilities by chain">
    <ResponseField name="[chainId]" type="object">
      Capabilities object for a specific chain (e.g., "0x2105" for Base Mainnet).

      <Expandable title="Available capabilities">
        <ResponseField name="auxiliaryFunds" type="object">
          Indicates wallet access to funds beyond on-chain balance verification. This capability is currently disabled.

          <Expandable title="auxiliaryFunds properties">
            <ResponseField name="supported" type="boolean">
              Whether auxiliary funds are available for this account on this chain.
            </ResponseField>
          </Expandable>
        </ResponseField>

        <ResponseField name="atomic" type="object">
          Indicates support for atomic batch transaction execution.

          <Expandable title="atomic properties">
            <ResponseField name="supported" type="string">
              Atomic execution support level: "supported", "ready", or "unsupported".
            </ResponseField>
          </Expandable>
        </ResponseField>

        <ResponseField name="paymasterService" type="object">
          Indicates support for gasless transactions via paymaster services.

          <Expandable title="paymasterService properties">
            <ResponseField name="supported" type="boolean">
              Whether paymaster services are supported for this account on this chain.
            </ResponseField>
          </Expandable>
        </ResponseField>

        <ResponseField name="flowControl" type="object">
          Indicates support for flow control capabilities.

          <Expandable title="flowControl properties">
            <ResponseField name="supported" type="boolean">
              Whether flow control is supported for this account on this chain.
            </ResponseField>
          </Expandable>
        </ResponseField>

        <ResponseField name="datacallback" type="object">
          Indicates support for data callback capabilities.

          <Expandable title="datacallback properties">
            <ResponseField name="supported" type="boolean">
              Whether data callbacks are supported for this account on this chain.
            </ResponseField>
          </Expandable>
        </ResponseField>

        <ResponseField name="gasLimitOverride" type="object">
          Indicates support for app-provided gas limit overrides on individual calls. Defined in [ERC-8132](https://github.com/ethereum/ERCs/pull/1485). Reported for all chains (`0x0`).

          <Expandable title="gasLimitOverride properties">
            <ResponseField name="supported" type="boolean">
              Whether gas limit overrides are supported.
            </ResponseField>
          </Expandable>
        </ResponseField>
      </Expandable>
    </ResponseField>
  </Expandable>
</ResponseField>

## Example Usage

<RequestExample>
  ```json Request theme={null}
  {
    "id": 1,
    "jsonrpc": "2.0",
    "method": "wallet_getCapabilities",
    "params": ["0x407d73d8a49eeb85d32cf465507dd71d507100c1"]
  }
  ```

  ```typescript SDK Usage theme={null}
  import { createBaseAccountSDK } from '@base-org/account';

  const provider = createBaseAccountSDK().getProvider();

  // Get capabilities for a user address
  const capabilities = await provider.request({
    method: 'wallet_getCapabilities',
    params: ['0x407d73d8a49eeb85d32cf465507dd71d507100c1']
  });

  // Check specific capabilities
  const baseCapabilities = capabilities["0x2105"]; // Base Mainnet
  const hasAuxiliaryFunds = baseCapabilities?.auxiliaryFunds?.supported;
  const supportsAtomic = baseCapabilities?.atomic?.supported === "supported";
  const hasPaymaster = baseCapabilities?.paymasterService?.supported;
  const hasGasLimitOverride = capabilities["0x0"]?.gasLimitOverride?.supported;

  console.log('Capabilities:', {
    hasAuxiliaryFunds,
    supportsAtomic,
    hasPaymaster,
    hasGasLimitOverride
  });
  ```
</RequestExample>

<ResponseExample>
  ```json Full Capabilities Response theme={null}
  {
    "id": 1,
    "jsonrpc": "2.0",
    "result": {
      "0x2105": {
        "auxiliaryFunds": {
          "supported": true
        },
        "atomic": {
          "supported": "supported"
        },
        "paymasterService": {
          "supported": true
        },
        "flowControl": {
          "supported": false
        },
        "datacallback": {
          "supported": false
        }
      },
      "0x0": {
        "gasLimitOverride": {
          "supported": true
        }
      },
      "0x14A34": {
        "auxiliaryFunds": {
          "supported": false
        },
        "atomic": {
          "supported": "ready"
        },
        "paymasterService": {
          "supported": true
        }
      }
    }
  }
  ```

  ```json Limited Capabilities Response theme={null}
  {
    "id": 1,
    "jsonrpc": "2.0",
    "result": {
      "0x2105": {
        "auxiliaryFunds": {
          "supported": false
        },
        "atomic": {
          "supported": "unsupported"
        },
        "paymasterService": {
          "supported": false
        }
      }
    }
  }
  ```
</ResponseExample>

## Capability Detection Patterns

### Check Single Capability

```typescript theme={null}
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

```typescript theme={null}
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,
    hasGasLimitOverride: !!capabilities["0x0"]?.gasLimitOverride?.supported
  };
}
```

### Conditional Transaction Building

```typescript theme={null}
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

| Code   | Message              | Description                                    |
| ------ | -------------------- | ---------------------------------------------- |
| -32602 | Invalid params       | Invalid account address format                 |
| 4100   | Method not supported | Wallet doesn't support wallet\_getCapabilities |
| 4200   | Wallet not available | Wallet is not installed or available           |

<Warning>
  Capabilities are chain-specific and account-specific. Always check capabilities for the specific chain and account combination you're targeting.
</Warning>

<Info>
  Not all wallets support all capabilities. Use capability detection to provide progressive enhancement rather than blocking functionality when capabilities aren't available.
</Info>

## Integration with Other Methods

### With wallet\_sendCalls

Use capabilities to enhance transaction execution:

```typescript theme={null}
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:

```typescript theme={null}
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

## Related Documentation

* [Capabilities Overview](/base-account/reference/core/capabilities/overview) - Complete guide to using capabilities
* [wallet\_sendCalls](/base-account/reference/core/provider-rpc-methods/wallet_sendCalls) - Execute transactions with capabilities
* [wallet\_connect](/base-account/reference/core/provider-rpc-methods/wallet_connect) - Connect with authentication capabilities

<BaseBanner
  id="privacy-policy"
  dismissable={false}
  content={({ onDismiss }) => (
<div className="flex items-center">
  <div className="mr-2">
    We're updating the Base Privacy Policy, effective July 25, 2025, to reflect an expansion of Base services. Please review the updated policy here:{" "}
    <a
      href="https://docs.base.org/privacy-policy-2025"
      target="_blank"
      className="whitespace-nowrap"
    >
      Base Privacy Policy
    </a>. By continuing to use Base services, you confirm that you have read and understand the updated policy.
  </div>
  <Button onClick={onDismiss}>I Acknowledge</Button>
</div>
)}
/>