​
Common Implementation Issues

Quick reference for resolving EIP-7702 implementation questions:
IssueCauseSolution
”Y parity is required”Wallet doesn’t return yParity in signatureUse viem or compatible wallet library
”Invalid signature”Using signTypedData() instead of signMessage()Use UserOperation hash signing for Kernel accounts
”UserOperation hash mismatch”Incorrect BigInt conversion or EntryPoint versionEnsure all numeric fields are BigInt and use EntryPoint 0.7

​
Multi-Chain Operation Errors

IssueCauseSolution
”Missing origin chain signatures”Forgot to sign origin chain operationsSign all operations in quote.originChainsOperations[]
”Transaction failed on origin chain”Origin chain delegation or UserOp signature missingCheck that both delegation and UserOp are signed for each origin chain

​
Delegation Errors

IssueCauseSolution
”Nonce too low”Outdated delegation nonceOneBalance handles this automatically; retry the request
”Already delegated”EOA already delegated to this contractNormal - no delegation object will be returned
”Contract not found”Using wrong Kernel v3.3 addressUse the contract address returned by OneBalance

​
Account Configuration Errors

IssueCauseSolution
”Account type not supported”Wrong account type configurationMust use type: "kernel-v3.3-ecdsa" and deploymentType: "EIP7702"
”Address mismatch”Different signer and account addressesBoth signerAddress and accountAddress must be the same EOA address
Critical: Kernel v3.3 accounts require different signing patterns than role-based accounts. Always use UserOperation hash signing (signMessage()) instead of typed data signing (signTypedData()).

​
Multi-Input Limitation

OneBalance’s EIP-7702 implementation has one architectural limitation for all operations (swaps, transfers, contract calls): it can only handle single-transaction execution when you have assets on ≤1 source chain different from the destination chain. This limitation exists because OneBalance relies on external routing providers that don’t yet support EIP-7702 authorization tuples in their multi-input APIs. Learn more about how OneBalance works.

​
When You Need the Workaround

Your AssetsDestinationResult
USDC on OptimismArbitrum✅ Single transaction
USDC on Optimism + ArbitrumArbitrum✅ Single transaction
USDC on Optimism + BaseArbitrum⚠️ Needs workaround
USDC on 3+ different chainsAny destination⚠️ Needs workaround
This affects approximately 20% of operations. Most users will use the single-transaction flow without issues.

​
Manual Delegation Workaround

When you encounter the multi-input limitation, you need to manually delegate your EOAs before using OneBalance:
1

Manually Delegate on Required Chains

Submit EIP-7702 delegations directly to each chain where you have assets
2

Use Standard OneBalance Flow

Once delegated, use the normal OneBalance integration flow
3

Handle Interruptions

If the process is interrupted, you may need to manually complete transactions

​
Manual Delegation Process

This requires a wallet library that supports EIP-7702 signAuthorization method, such as viem.
import { createWalletClient, http } from 'viem';
import { optimism, base } from 'viem/chains';

// Submit delegation manually on each required chain
async function submitDelegation(chainId: number) {
  const walletClient = createWalletClient({
    chain: chainId === 10 ? optimism : base,
    transport: http()
  });

  const authorization = await walletClient.signAuthorization({
    contractAddress: "0xd6CEDDe84be40893d153Be9d467CD6aD37875b28", // Kernel v3.3
    nonce: 0 // Get current nonce from chain
  });

  const hash = await walletClient.sendTransaction({
    authorizationList: [authorization],
    data: "0x",
    to: walletClient.account.address,
  });
  
  return hash;
}

​
Best Practices

  • Optimize for the 80%: Most users will use the single-transaction flow without issues
  • Detect automatically: Route users based on their asset distribution
  • Provide clear messaging: Explain when and why the workaround is needed
  • Handle errors gracefully: Implement proper error handling and recovery
  • Monitor success rates: Track how often the workaround is needed
Consider implementing a fallback that automatically detects when the single-transaction flow fails and offers the manual delegation alternative.
Most errors are automatically handled by OneBalance. The main issue you’ll encounter is the multi-input limitation, which affects about 20% of operations. Learn more about transaction lifecycle.

​
Next Steps

Getting Started

Learn the basic implementation flow

API Reference

Complete API documentation