> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cdp.coinbase.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Capabilities Overview

> Understand how to use Coinbase Wallet capabilities with wallet_connect and wallet_sendCalls

Coinbase Wallet 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 Discovery Pattern lines wrap expandable 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](/coinbase-wallet/reference/core/capabilities/signInWithEthereum) | `wallet_connect`   | SIWE authentication                                                      |
| [auxiliaryFunds](/coinbase-wallet/reference/core/capabilities/auxiliaryFunds)         | `wallet_sendCalls` | Access to funds beyond the visible on-chain balance (currently disabled) |
| [atomic](/coinbase-wallet/reference/core/capabilities/atomic)                         | `wallet_sendCalls` | Atomic batch transactions                                                |
| [paymasterService](/coinbase-wallet/reference/core/capabilities/paymasterService)     | `wallet_sendCalls` | Gasless transactions                                                     |
| [flowControl](/coinbase-wallet/reference/core/capabilities/flowControl)               | `wallet_sendCalls` | Flow control                                                             |
| [datacallback](/coinbase-wallet/reference/core/capabilities/datacallback)             | `wallet_sendCalls` | Data callback                                                            |
| [dataSuffix](/coinbase-wallet/reference/core/capabilities/dataSuffix)                 | `wallet_sendCalls` | Transaction attribution                                                  |
| [gasLimitOverride](/coinbase-wallet/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 Basic Connection theme={null}
// Simple connection without capabilities
const result = await provider.request({
  method: 'wallet_connect',
  params: [{
    version: '1'
  }]
});
```

### Authentication with signInWithEthereum

```typescript Authentication with signInWithEthereum lines wrap expandable 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 Basic Transaction lines wrap expandable 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 Gasless Transactions with Paymaster lines wrap expandable 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 Atomic Batch Transactions lines wrap expandable 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 Check Single Capability lines wrap expandable 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 Check Multiple Capabilities lines wrap expandable 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](/coinbase-wallet/reference/core/capabilities/signInWithEthereum) - SIWE authentication
* [auxiliaryFunds](/coinbase-wallet/reference/core/capabilities/auxiliaryFunds) - Auxiliary funding support
* [atomic](/coinbase-wallet/reference/core/capabilities/atomic) - Atomic batch transactions
* [paymasterService](/coinbase-wallet/reference/core/capabilities/paymasterService) - Gasless transactions
* [gasLimitOverride](/coinbase-wallet/reference/core/capabilities/gasLimitOverride) - Call-level gas limit overrides

## Related Methods

* [`wallet_getCapabilities`](/coinbase-wallet/reference/core/provider-rpc-methods/wallet_getCapabilities) - Discover available capabilities
* [`wallet_connect`](/coinbase-wallet/reference/core/provider-rpc-methods/wallet_connect) - Connect with capabilities
* [`wallet_sendCalls`](/coinbase-wallet/reference/core/provider-rpc-methods/wallet_sendCalls) - Execute transactions with capabilities