wallet_getCapabilities

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

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

{
  "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
      }
    }
  }
}

{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "0x2105": {
      "auxiliaryFunds": {
        "supported": false
      },
      "atomic": {
        "supported": "unsupported"
      },
      "paymasterService": {
        "supported": false
      }
    }
  }
}

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

string

required

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

Returns

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.

Show Capabilities by chain

object

Capabilities object for a specific chain (e.g., “0x2105” for Base Mainnet).

Show Available capabilities

object

Indicates wallet access to funds beyond onchain balance verification. This capability is currently disabled.

Show auxiliaryFunds properties

boolean

Whether auxiliary funds are available for this account on this chain.

object

Indicates support for atomic batch transaction execution.

Show atomic properties

string

Atomic execution support level: “supported”, “ready”, or “unsupported”.

object

Indicates support for gasless transactions via paymaster services.

Show paymasterService properties

boolean

Whether paymaster services are supported for this account on this chain.

object

Indicates support for flow control capabilities.

Show flowControl properties

boolean

Whether flow control is supported for this account on this chain.

object

Indicates support for data callback capabilities.

Show datacallback properties

boolean

Whether data callbacks are supported for this account on this chain.

object

Indicates support for app-provided gas limit overrides on individual calls. Defined in ERC-8132. Reported for all chains (0x0).

Show gasLimitOverride properties

boolean

Whether gas limit overrides are supported.

Example Usage

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

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

{
  "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
      }
    }
  }
}

{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "0x2105": {
      "auxiliaryFunds": {
        "supported": false
      },
      "atomic": {
        "supported": "unsupported"
      },
      "paymasterService": {
        "supported": false
      }
    }
  }
}

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,
    hasGasLimitOverride: !!capabilities["0x0"]?.gasLimitOverride?.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

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

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

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

Capabilities Overview - Complete guide to using capabilities
wallet_sendCalls - Execute transactions with capabilities
wallet_connect - Connect with authentication capabilities

wallet_getCallsStatus

wallet_addSubAccount

Introduction

Quickstart

Guides

Framework Integrations

Reference

More

Basenames

Contribute

Parameters

Returns

Example Usage

Capability Detection Patterns

Check Single Capability

Check Multiple Capabilities

Conditional Transaction Building

Error Handling

Integration with Other Methods

With wallet_sendCalls

With wallet_connect

Best Practices

​Parameters

​Returns

​Example Usage

​Capability Detection Patterns

​Check Single Capability

​Check Multiple Capabilities

​Conditional Transaction Building

​Error Handling

​Integration with Other Methods

​With wallet_sendCalls

​With wallet_connect

​Best Practices

​Related Documentation

Parameters

Returns

Example Usage

Capability Detection Patterns

Check Single Capability

Check Multiple Capabilities

Conditional Transaction Building

Error Handling

Integration with Other Methods

With wallet_sendCalls

With wallet_connect

Best Practices

Related Documentation