Capabilities Overview

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

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

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

// 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...'
    }]
  }]
});

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

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

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

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