> ## 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.

# Capabilities Overview

> Understand how to use Base Account capabilities with wallet_connect and wallet_sendCalls

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>;
};

Base Account supports various capabilities that extend functionality beyond standard wallet operations. Capabilities are feature flags that indicate what additional functionality a wallet supports for specific chains and accounts.

## Core Concepts

Capabilities are discovered using `wallet_getCapabilities` and utilized through `wallet_connect` and `wallet_sendCalls` methods. Each capability is chain-specific and may have different availability depending on the account type.

### Discovery Pattern

```typescript theme={null}
// Check what capabilities are available
const capabilities = await provider.request({
  method: 'wallet_getCapabilities',
  params: [userAddress]
});

// Check specific capability for Base mainnet
const baseCapabilities = capabilities["0x2105"]; // Base mainnet chain ID
```

## Available Capabilities

| Capability                                                                         | Method             | Description                                                              |
| ---------------------------------------------------------------------------------- | ------------------ | ------------------------------------------------------------------------ |
| [signInWithEthereum](/base-account/reference/core/capabilities/signInWithEthereum) | `wallet_connect`   | SIWE authentication                                                      |
| [auxiliaryFunds](/base-account/reference/core/capabilities/auxiliaryFunds)         | `wallet_sendCalls` | Access to funds beyond the visible on-chain balance (currently disabled) |
| [atomic](/base-account/reference/core/capabilities/atomic)                         | `wallet_sendCalls` | Atomic batch transactions                                                |
| [paymasterService](/base-account/reference/core/capabilities/paymasterService)     | `wallet_sendCalls` | Gasless transactions                                                     |
| [flowControl](/base-account/reference/core/capabilities/flowControl)               | `wallet_sendCalls` | Flow control                                                             |
| [datacallback](/base-account/reference/core/capabilities/datacallback)             | `wallet_sendCalls` | Data callback                                                            |
| [dataSuffix](/base-account/reference/core/capabilities/dataSuffix)                 | `wallet_sendCalls` | Transaction attribution                                                  |
| [gasLimitOverride](/base-account/reference/core/capabilities/gasLimitOverride)     | `wallet_sendCalls` | Call-level gas limit overrides                                           |

## Using with wallet\_connect

The `wallet_connect` method supports capabilities for connection and authentication:

### Basic Connection

```typescript theme={null}
// Simple connection without capabilities
const result = await provider.request({
  method: 'wallet_connect',
  params: [{
    version: '1'
  }]
});
```

### Authentication with signInWithEthereum

```typescript theme={null}
// Generate nonce for security
const nonce = window.crypto.randomUUID().replace(/-/g, '');

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

// Extract authentication data
const { address } = accounts[0];
const { message, signature } = accounts[0].capabilities.signInWithEthereum;

// Verify signature on your backend
await fetch('/auth/verify', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ address, message, signature })
});
```

## Using with wallet\_sendCalls

The `wallet_sendCalls` method supports transaction-related capabilities:

### Basic Transaction

```typescript theme={null}
// Simple transaction without capabilities
const result = await provider.request({
  method: 'wallet_sendCalls',
  params: [{
    version: '1.0',
    chainId: '0x2105',
    from: userAddress,
    calls: [{
      to: '0x...',
      value: '0x0',
      data: '0x...'
    }]
  }]
});
```

### Gasless Transactions with Paymaster

```typescript theme={null}
await provider.request({
  method: 'wallet_sendCalls',
  params: [{
    version: '1.0',
    chainId: '0x2105',
    from: userAddress,
    calls: [{
      to: contractAddress,
      value: '0x0',
      data: encodedFunctionCall
    }],
    capabilities: {
      paymasterService: {
        url: "https://paymaster.base.org/api/v1/sponsor"
      }
    }
  }]
});
```

### Atomic Batch Transactions

```typescript theme={null}
await provider.request({
  method: 'wallet_sendCalls',
  params: [{
    version: '1.0',
    chainId: '0x2105',
    from: userAddress,
    atomicRequired: true, // Require atomic execution
    calls: [
      {
        to: tokenAddress,
        value: '0x0',
        data: approveCallData
      },
      {
        to: dexAddress,
        value: '0x0',
        data: swapCallData
      }
    ]
  }]
});
```

## Capability Detection Patterns

### Check Single Capability

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

    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(address: string) {
  const capabilities = await provider.request({
    method: 'wallet_getCapabilities',
    params: [address]
  });

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

  return {
    hasAuxiliaryFunds: baseCapabilities.auxiliaryFunds?.supported || false,
    hasAtomicBatch: baseCapabilities.atomic?.supported === "supported",
    hasPaymaster: !!baseCapabilities.paymasterService?.supported,
    canAuthenticate: true // signInWithEthereum is always available with wallet_connect
  };
}
```

## Capability-Specific Guides

For detailed information on each capability:

* [signInWithEthereum](/base-account/reference/core/capabilities/signInWithEthereum) - SIWE authentication
* [auxiliaryFunds](/base-account/reference/core/capabilities/auxiliaryFunds) - Auxiliary funding support
* [atomic](/base-account/reference/core/capabilities/atomic) - Atomic batch transactions
* [paymasterService](/base-account/reference/core/capabilities/paymasterService) - Gasless transactions
* [gasLimitOverride](/base-account/reference/core/capabilities/gasLimitOverride) - Call-level gas limit overrides

## Related Methods

* [`wallet_getCapabilities`](/base-account/reference/core/provider-rpc-methods/wallet_getCapabilities) - Discover available capabilities
* [`wallet_connect`](/base-account/reference/core/provider-rpc-methods/wallet_connect) - Connect with capabilities
* [`wallet_sendCalls`](/base-account/reference/core/provider-rpc-methods/wallet_sendCalls) - Execute transactions with 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>
)}
/>