Wallet Call API

22export class EOA7702 extends BaseAccount {...177  isSponsorable(): boolean {178    return this.network.chainId === 100n179  }180181  getAtomicStatus(): 'unsupported' | 'supported' | 'ready' {182    return this.accountState.isSmarterEoa ? 'supported' : 'ready'183  }184185  getNonceId(): string {186    // 7702 accounts have an execution layer nonce and an entry point nonce187    return `${this.accountState.eoaNonce!.toString()}-${this.accountState.erc4337Nonce.toString()}`

284export const handleProviderRequest = ({285  inpageMessenger,286}: {287  inpageMessenger: Messenger;288}) =>289  rnbwHandleProviderRequest({...403    }) => {...424      console.warn('Chain Id not supported', {425        proposedChainId,426        host,427      });428    },429    getCapabilities: async ({ address, chainIds }) => {430      if (!getEip5792Enabled()) {431        throw createProviderError(432          'METHOD_NOT_SUPPORTED',433          'EIP-5792 methods are not enabled',434        );435      }436      const delegationAvailability = getDelegationAvailable(address);437      if (!delegationAvailability.available) {438        // Non-compliant: spec expects a capabilities object (e.g. atomic: unsupported) rather than an error.439        // We throw here because some dapps (e.g. revoke.cash) interpret any non-error response from440        // wallet_getCapabilities as full EIP-5792 support and immediately call wallet_sendCalls.441        // Since Rainbow only executes batches atomically via delegation, returning unsupported capabilities442        // would mislead those dapps into attempting a flow that will always fail.443        throw createProviderError(444          'METHOD_NOT_SUPPORTED',445          `Delegation not available: ${delegationAvailability.reason}`,446        );447      }448449      // Pre-warm delegation cache: getDelegations fetches WalletStatus (all chains450      // in one request). Both getDelegationStatus and getChainDelegationStatus451      // share the same cache keyed by { address }, so subsequent452      // supportsDelegation/willDelegate calls hit cache. Without this, each chain453      // would trigger a separate NetworkStatus request.454      await getDelegations({ address });455456      const results = await Promise.all(457        chainIds.map(async (chainId) => {458          try {459            const { supported } = await supportsDelegation({460              address,461              chainId,462            });463            if (!supported) {464              throw new Error('Delegation not supported');465            }466            const { willDelegate: needsAuth } = await willDelegate({467              address,468              chainId,469            });470            return [471              chainId,472              {473                atomic: {474                  status: needsAuth ? 'ready' : 'supported',475                },476              },477            ] as const;478          } catch {479            return [chainId, { atomic: { status: 'unsupported' } }] as const;480          }481        }),482      );483      return Object.fromEntries(results);484    },485    getBatchByKey: (params) => {486      if (!getEip5792Enabled()) {487        throw createProviderError(488          'METHOD_NOT_SUPPORTED',

18export type ExecuteSendCallsBatchResult =19  | { success: true; nonces: number[] }20  | { success: false; error: string };2122/**23 * Execute a wallet_sendCalls batch via delegation SDK.24 * Errors out if delegation is not supported or execution fails.25 */26export async function executeSendCallsBatch({27  sendParams,28  from,29}: {30  sendParams: SendCallsParams;31  from: Address;32}): Promise<ExecuteSendCallsBatchResult> {33  const chainId = Number(sendParams.chainId);3435  const calls: BatchCall[] = sendParams.calls.map((call) => ({36    to: call.to ?? from,37    value: toHex(BigInt(call.value ?? '0x0')),38    data: call.data ?? '0x',39  }));4041  if (!calls.length) {42    return { success: false, error: 'No calls to execute' };43  }4445  const totalValue = calls.reduce(46    (sum, c) => sum + BigInt(c.value ?? 0),47    BigInt(0),48  );4950  const delegationEnabled = getDelegationEnabled();51  const { supported } = await supportsDelegation({ address: from, chainId });52  const walletClient = await getViemWalletClient({ address: from, chainId });5354  if (!delegationEnabled || !supported || !walletClient) {55    return {56      success: false,57      error: 'Delegation not supported for this wallet or chain',58    };59  }6061  const gas = useGasStore.getState().selectedGas.transactionGasParams;62  const maxFee = (gas as { maxFeePerGas?: string }).maxFeePerGas;

125export class SafeWalletProvider {...135  private async makeRequest(request: RpcRequest, appInfo: AppInfo): Promise<unknown> {...138    switch (method) {...180      case 'eth_getTransactionReceipt': {181        return this.eth_getTransactionReceipt(...(params as [string]))182      }183184      // EIP-5792185      // @see https://eips.ethereum.org/EIPS/eip-5792186      case 'wallet_sendCalls': {187        return this.wallet_sendCalls(...(params as [SendCallsParams]), appInfo)188      }

24export async function handleWalletGetCapabilities(25  address: string,26  chainIds?: `0x${string}`[],27  accountOverride?: Account,28): Promise<Record<string, any>> {...53  if (account?.type === "bankr") {54    emitSupportedChains(...57      shouldEmit,58    );59  }6061  if (62    account?.type === "privateKey" ||63    account?.type === "seedPhrase"64  ) {65    const candidateSet = new Set<number>(ALLOWED_CHAIN_IDS);66    for (const chain of getResolvedChains(networksInfo)) {67      if (68        !chain.hidden &&69        hasDefaultDelegateForChain(chain.chainId)70      ) {71        candidateSet.add(chain.chainId);72      }73    }74    const optedInDelegates = await getAllDelegatesForAccount(account.id);75    for (const chainIdValue of Object.keys(optedInDelegates)) {76      const chainId = Number(chainIdValue);77      if (Number.isFinite(chainId)) candidateSet.add(chainId);78    }7980    const candidateChainIds = [...candidateSet].filter((chainId) => {81      const hexChainId = toHexChainId(chainId);82      return shouldEmit(chainId, hexChainId);83    });84    const probeResults = await Promise.all(85      candidateChainIds.map(async (chainId) => {86        const resolved = await getStoredResolvedChainById(chainId);87        if (!resolved?.rpcUrl) return { chainId, atomic: false };88        try {89          const result = await resolveActiveDelegate({90            accountId: account.id,91            accountAddress: account.address as `0x${string}`,92            chainId,93            rpcUrl: resolved.rpcUrl,94          });95          return { chainId, atomic: !!result.delegate };96        } catch {97          return { chainId, atomic: false };98        }99      }),100    );101    for (const { chainId, atomic } of probeResults) {102      if (atomic) capabilities[toHexChainId(chainId)] = {103        ...ATOMIC_SUPPORTED_CAP,104      };105    }106  }107108  // View-only accounts advertise batching so dapps surface a review screen;109  // all signing paths still reject this account type.

1/**...7 *     authorize, and whether an authorization tuple needs to be bundled in.8 *   - Account Settings "Smart Account" section UI: shows current onchain9 *     delegation + custom override + what would be used on the next batch.10 *11 * Resolution order (per account × per chain):12 *   1. Probe onchain: eth_getCode(EOA) → parse 0xef0100 prefix → current delegate13 *   2. If active delegate exists AND supports ERC-7821 batch mode → use silently14 *   3. Else if the chain has WalletChan's default delegate deployed15 *      (built-in Pectra chain or KNOWN_CHAINS entry) → use WalletChan default16 *      with a bundled authorization in the first batch tx.17 *   4. Else → null (caller falls back to existing auto-sequential PK/SP path)18 *19 * "Silently" in (2) means we DON'T need to include an authorization tuple in20 * the tx — the EOA is already delegated onchain to that contract. This is the21 * common case after the first batch on a given chain.

271export const handleProviderRequestApp = ({ messenger, data, meta }: { messenger: Messenger; data: any; meta: any }) => {...336  }) => {...339    if (supportedChainId) {...346      console.warn('PROVIDER TODO: TODO SEND NOTIFICATION');347    }348  };349350  handleProviderRequest({351    providerRequestTransport,352    isSupportedChain,353    getFeatureFlags,354    messengerProviderRequest,355    onAddEthereumChain,356    checkRateLimit,357    onSwitchEthereumChainNotSupported,358    onSwitchEthereumChainSupported,359    getProvider,360    getActiveSession,361    getChainNativeCurrency: chainId => useBackendNetworksStore.getState().getChainsNativeAsset()[chainId],362  });363364  messenger.dispatch({ data, meta });365};

157class ProviderController extends BaseController {...351  }) => {...398    delete approvalRes.sig;399    delete approvalRes.$account;400401    let is1559 = is1559Tx(approvalRes);402    const is7702 = is7702Tx(approvalRes);403404    if (is7702) {405      // todo406      throw new Error('not support 7702');407    }408409    if (410      is1559 &&411      approvalRes.maxFeePerGas === approvalRes.maxPriorityFeePerGas

80<sub>Reviewed 2026-09-24. Sources: [chain list](../core/crates/primitives/src/chain.rs), [feature configuration](../core/crates/primitives/src/chain_config.rs), [Squid chain coverage](../core/crates/swapper/src/squid/mod.rs), [address-history contract](../core/crates/chain_traits/src/lib.rs), [simulation implementations](../core/crates/gem_evm/src/provider/simulation.rs), [Solana](../core/crates/gem_solana/src/provider/simulation.rs), [Sui](../core/crates/gem_sui/src/provider/simulation.rs), [TON](../core/crates/gem_ton/src/provider/simulation.rs), [Tron](../core/crates/gem_tron/src/provider/simulation.rs), [WalletConnect chain configuration](../core/gemstone/src/config/wallet_connect.rs), and [WalletConnect request handlers](../core/crates/gem_wallet_connect/src/request_handler/mod.rs).</sub>8182The Cetus package-version guard is not a stub: it turns one on-chain failure into a message the swap screen can show, and it clears itself when the built-in version catches up.8384## WalletConnect8586The status is based on both the chains returned by Core configuration and the methods accepted by the Core request dispatcher. Method-set links open the chain-specific handler.8788In this section, `➖` means WalletConnect does not publish an ecosystem method-set reference for that Gem chain; it is not an implementation TODO. Bitcoin is `🏗️` because WalletConnect does publish a `bip122` method set and Core does not implement it.8990### Supported method sets9192| Method set | Namespace | Core-supported methods | Published methods missing in Core | WalletConnect reference |93| --- | --- | --- | --- | --- |94| Bitcoin (TODO) | `bip122` | None | `getAccountAddresses`<br>`signMessage`<br>`signPsbt`<br>`sendTransfer` | <sub>[spec](https://docs.walletconnect.network/wallet-sdk/chain-support/bitcoin)</sub> |95| [EVM](../core/crates/gem_wallet_connect/src/request_handler/ethereum.rs) | `eip155` | `eth_chainId`<br>`personal_sign`<br>`eth_signTypedData`<br>`eth_signTypedData_v4`<br>`eth_signTransaction`<br>`eth_sendTransaction`<br>`wallet_addEthereumChain`<br>`wallet_switchEthereumChain` | `eth_sign`<br>`eth_sendRawTransaction` | <sub>[spec](https://docs.walletconnect.network/wallet-sdk/chain-support/evm)</sub> |96| [Solana](../core/crates/gem_wallet_connect/src/request_handler/solana.rs) | `solana` | `solana_signMessage`<br>`solana_signTransaction`<br>`solana_signAndSendTransaction`<br>`solana_signAllTransactions` | `solana_getAccounts`<br>`solana_requestAccounts` | <sub>[spec](https://docs.walletconnect.network/wallet-sdk/chain-support/solana)</sub> |97| [Sui](../core/crates/gem_wallet_connect/src/request_handler/sui.rs) | `sui` | `sui_getAccounts`<br>`sui_signPersonalMessage`<br>`sui_signTransaction`<br>`sui_signAndExecuteTransaction` | ➖ | <sub>[spec](https://docs.walletconnect.network/wallet-sdk/chain-support/sui)</sub> |98| [TON](../core/crates/gem_wallet_connect/src/request_handler/ton.rs) | `ton` | `ton_sendMessage`<br>`ton_signData` | ➖ | <sub>[spec](https://docs.walletconnect.network/wallet-sdk/chain-support/ton)</sub> |99| [Tron](../core/crates/gem_wallet_connect/src/request_handler/tron.rs) | `tron` | `tron_signMessage`<br>`tron_signTransaction`<br>`tron_sendTransaction` | `tron_getBalance` (optional) | <sub>[spec](https://docs.walletconnect.network/wallet-sdk/chain-support/tron)</sub> |100101Core's session-wide method list, consumed by both platform approval paths and by the one-click-auth namespace, advertises only the methods the request handler accepts. A method the handler cannot serve is absent from the method enum, so an incoming request for it reads as unsupported. `solana_signAllTransactions` is advertised and served for a single transaction; a batch is answered with an unsupported error rather than dropped from the session.102103### Chain coverage104105| Chain | Status | Namespace | Supported methods |

15pub enum WalletConnectionState {...17    Active,18    Expired,19}2021#[derive(Debug, Serialize, Deserialize)]22pub enum WalletConnectionMethods {23    #[serde(rename = "eth_chainId")]24    EthChainId,25    #[serde(rename = "personal_sign")]26    PersonalSign,27    #[serde(rename = "eth_signTypedData")]28    EthSignTypedData,29    #[serde(rename = "eth_signTypedData_v4")]30    EthSignTypedDataV4,31    #[serde(rename = "eth_signTransaction")]32    EthSignTransaction,33    #[serde(rename = "eth_sendTransaction")]34    EthSendTransaction,35    #[serde(rename = "wallet_switchEthereumChain")]36    WalletSwitchEthereumChain,37    #[serde(rename = "wallet_addEthereumChain")]38    WalletAddEthereumChain,39    #[serde(rename = "solana_signMessage")]40    SolanaSignMessage,41    #[serde(rename = "solana_signTransaction")]42    SolanaSignTransaction,