Skip to main content

Run Without Candide

A wallet built on Candide should pass the walkaway test: if Candide disappears or misbehaves, the wallet keeps working, and someone else can step in without our approval. This page shows how to check that for your integration. It lists every Candide service, what stops if it goes away, and how to replace it.

The short version: accounts and funds are onchain and don't depend on Candide. What depends on Candide is convenience: sponsored gas, a hosted bundler, coordinated recovery and automatic deposit forwarding. Each one has a replacement.

What Never Depends on Candide​

  • Accounts and funds. Safe accounts, their modules and EIP-7702 accounts are contracts on each chain. Candide has no admin key over them and can't upgrade, pause or move them.
  • Signing. Passkeys live on the user's device and are bound to your app's domain, not to Candide's. Keys in a user's own wallet stay there.
  • AbstractionKit. The SDK runs inside your app and is open source under the MIT license. You can keep using the version you have, or fork it.

Service by Service​

Candide serviceIf it goes awayReplacement
BundlerUserOperations sent to Candide's endpoint aren't submittedAny ERC-4337 bundler that serves your EntryPoint version, or Voltaire run by you
Paymaster (sponsorship and ERC-20 gas)Gas is no longer sponsored or paid in tokens through CandideAnother ERC-7677 paymaster, or users pay gas in the native token
Gas policies and dashboardPolicies stop applyingNothing to replace: they only control Candide's paymaster
Recovery ServiceSignature collection, the email/SMS guardian and alerts stopGuardians sign and submit to the recovery module directly. The email/SMS guardian can't sign, so the other guardians must meet the threshold.
Forwarding Address relayerDeposits are no longer forwarded and stay at the addressThe recipient withdraws directly from the forwarding address contract on the source chain
Solana PaymasterFees are no longer paid in stablecoins through CandideAny Kora node, including one you run, or users pay fees in SOL

Bundler​

A UserOperation is a signed message. Any bundler that serves the same EntryPoint version can submit it, so switching is a change of URL:

// Before: Candide's endpoint. After: any ERC-4337 bundler, or your own Voltaire.
const bundlerUrl = process.env.BUNDLER_URL as string;

let userOperation = await smartAccount.createUserOperation(transactions, nodeUrl, bundlerUrl);
// ...sign...
await smartAccount.sendUserOperation(userOperation, bundlerUrl);

Voltaire, the bundler Candide runs, is open source. The installation guide shows how to run it with Docker against your own node.

As a last resort, no bundler is needed at all. The EntryPoint is a public contract: any address can call handleOps with a signed UserOperation, pay the transaction's gas, and be refunded from the account.

Paymaster​

Without a paymaster, the account pays its own gas in the native token. Remove the paymaster step and make sure the account holds enough to cover gas.

To keep sponsoring gas, point Erc7677Paymaster at another provider's ERC-7677 endpoint. The class is built for this: it speaks the standard methods, not a Candide-specific API.

import { Erc7677Paymaster } from "abstractionkit";

// Any ERC-7677 paymaster endpoint
const paymaster = new Erc7677Paymaster(process.env.PAYMASTER_URL as string);

CandidePaymaster and Candide's gas policies are Candide-specific. If you use them, plan how your app falls back to the native token or to another paymaster.

Recovery​

The Social Recovery Module is a contract on each chain, and the Recovery Service only coordinates around it. Without the service:

  • Guardians sign the recovery request and anyone submits it to the module, then finalizes it after the grace period.
  • The open-source SafeCover frontend does this from a browser. You can use recovery.candide.dev or host SafeCover yourself.
  • The email/SMS guardian is a key Candide holds, so it can't sign without Candide. This is why it should be one guardian among several, never the only one: with two personal guardians in a 2-of-3 setup, recovery still works.
  • Recovery alerts stop. The account owner can still cancel a recovery during the grace period, but has to watch for one another way.

Forwarding Address​

A forwarding address is a contract on each source chain. The relayer watches for deposits and forwards them, and without it deposits stay where they landed:

  • The recipient can withdraw from the forwarding address contract on the source chain at any time, with no timelock.
  • If you set a company recovery wallet (custodialWithdrawer), it can withdraw after the timelock.
  • Both withdrawals are ordinary contract calls. Any tool that sends transactions can make them.
  • The relayer deploys a forwarding address on its first deposit. If an address was never deployed on a source chain, it has to be deployed there before anyone can withdraw from it, which needs its full deployment parameters (see What to Store).

See The custodialWithdrawer Role for how the two withdrawal paths work.

What to Store​

Walking away is only possible if you kept what you need to find and control the accounts. Store:

  • Each account's address and setup: the address itself, plus its owners, threshold and the class it was created with. Recomputing the address takes the same creation inputs, including any non-default c2Nonce, factory or singleton override, so store those too. The stored address is the reference, and the setup is the fallback that lets you rebuild the account object with any copy of AbstractionKit.
  • Passkey public keys and credential IDs. The account needs them to verify signatures, and an undeployed account can't be used without them.
  • Guardian addresses and the threshold, so guardians can be contacted and recovery can be run without the Recovery Service.
  • Forwarding address deployment parameters. Recipient, recovery wallet, destination chain and salt are not a complete backup: the address also depends on the factory, singleton, allowed relayer and proxy creation code. While the API is available, save the full result of forwarding_getDeployParamsByAddress for each address. You need all of it to deploy the address and withdraw from it.

Check Your Integration​

Ask these about your app:

  1. Can a user move their funds if every Candide endpoint is down?
  2. Can a user recover their account without the Recovery Service?
  3. Are endpoint URLs configuration, so switching provider needs no code change?
  4. Do you store everything in What to Store?

If any answer is "no", that is where your app depends on Candide. See Principles for why this matters to us.