Account deployment - Rhinestone

A newly created smart account has a counterfactual address before it has contract code. Deployment is per chain: receiving assets at that address does not deploy it, and deployment on one chain does not deploy it everywhere. Use the account and transaction calls from Relay a transaction for the examples below.

Embedded wallet
Custom signer

Embedded wallets derive and store the account address and factory data during sign-up. Authentication does not submit an onchain deployment transaction.

Automatic deployment

Send the first real transaction with sendIntent(). If the account is undeployed on the execution chain, the wallet includes its factory setup in the intent. You do not need to construct or submit a factory call yourself.

import { baseSepolia } from "viem/chains";
import { oneAuth } from "./oneauth";

const result = await oneAuth.sendIntent({
  accountAddress,
  targetChain: baseSepolia.id,
  sourceChainId: baseSepolia.id,
  sourceAssets: [usdc],
  calls: [...calls],
  sponsorshipMode: "required",
  experimental_clear_signing: true,
  closeOn: "completed",
});

if (!result.success) {
  throw new Error(result.error?.message ?? `Intent ended as ${result.status}`);
}

This example uses the same-chain USDC transfer from Relay a transaction, including its clear-signing review. The completed intent deploys the account on Base Sepolia if necessary, then executes the calls.The deployment cost is part of the route. With sponsorshipMode: "required", your application must sponsor it. For a user-paid route, use "disabled" and fund the account with enough assets for both the calls and fees. See Sponsor fees for setup and fallback behavior.

Check deployment

Use a public RPC client for the chain you want to check. OneAuthClient does not expose an isDeployed() method:

import { createPublicClient, http } from "viem";

const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http(),
});

const code = await publicClient.getCode({ address: accountAddress });
const deployed = code !== undefined && code !== "0x";

Check the authenticated account’s address, not an account from another application or WebAuthn mode. See Accounts for the namespace boundaries.

@rhinestone/1auth does not expose a standalone deployment method. Deploy with the first real intent; the explicit deployment examples in the Custom signer tab are not embedded wallet APIs.

Use account from the Custom signer quickstart.

Automatic deployment

For a normal SDK intent, you do not need to call deploy first. When the target account is undeployed, prepareTransaction includes its setup operation in the quote. After you sign and submit that prepared intent, a relayer executes the setup and calls as part of the selected route.

import { baseSepolia } from "viem/chains";

const prepared = await account.prepareTransaction({
  chain: baseSepolia,
  calls: [...calls],
});
const signed = await account.signTransaction(prepared);
const submitted = await account.submitTransaction(signed);
const result = await account.waitForExecution(submitted);

The account is deployed only on chains where the route executes its account operations. An accepted submission is not proof of deployment; wait for completion, then call isDeployed when later behavior depends on the onchain code.

Funding a counterfactual address is safe when you preserve its exact account configuration, but receiving funds alone does not execute the factory call.

Pay deployment costs

The deployment cost is part of the prepared route:

For a user-paid transaction, the route can use the user’s available source assets according to the quote.
For a sponsored transaction, set sponsored while preparing the intent. Complete Sponsorship setup first and confirm the selected quote’s fee breakdown.

A sponsorship rejection does not fall back to the user’s funds at submission time. Prepare a new user-paid route and obtain a new signature if your application offers that fallback.

Check deployment

Pass the chain object, not a chain ID:

const deployed = await account.isDeployed(baseSepolia);

For a smart account, this checks whether contract code exists at the account address on that chain. A plain EOA is already usable and reports as deployed even though there is no smart account contract.

Deploy explicitly

Call deploy when the account must exist before its first application transaction:

const didDeploy = await account.deploy(baseSepolia);

The promise waits for the deployment path to complete. It returns true when this call performed a deployment and false when the account was already deployed or is a plain EOA.For an SDK-managed deployment through the intent path, request gas sponsorship explicitly:

const didDeploy = await account.deploy(baseSepolia, {
  sponsored: true,
});

Depending on the attached account data and SDK configuration, an explicit deployment can use a UserOperation instead of an intent—for example, an undeployed bring-your-own account whose Intent Executor is not installed, or an account configured with a custom bundler. In that case, configure the bundler and optional paymaster through ERC-4337; the relayer sponsored option does not configure UserOperation sponsorship.For EIP-7702, deploy creates the required initialization signature automatically. Normal prepareTransaction calls still require the explicit EIP-7702 flow documented in Account types: EIP-7702.

Deploy from another account

Use the public deploy action when an existing smart account should submit and pay for another account’s factory call:

import { deploy } from "@rhinestone/sdk/actions";

const newAccount = await rhinestone.createAccount({
  owners: { type: "ecdsa", accounts: [newOwner] },
});

const prepared = await sponsorAccount.prepareTransaction({
  chain: baseSepolia,
  calls: [deploy(newAccount)],
});
const signed = await sponsorAccount.signTransaction(prepared);
const submitted = await sponsorAccount.submitTransaction(signed);
await sponsorAccount.waitForExecution(submitted);

The target account derives its factory call from newAccount while sponsorAccount owns and authorizes the relay. This is separate from organization-level fee sponsorship; add sponsored to the prepared transaction only when your configured sponsorship should cover its fees.

Supported account behavior

Account configuration	Deployment behavior
Nexus, Safe, Kernel, `Startale`, or HCA	The SDK can include the provider’s factory setup in an intent or deploy the account explicitly.
EIP-7702 Nexus account	The SDK initializes and delegates the existing EOA address instead of creating a separate account address. Normal transaction preparation requires the EIP-7702 initialization signature.
Plain EOA	There is no smart account to deploy. `deploy` returns `false`.
Bring your own account	A deployed account needs no factory data. An undeployed account needs the correct address, factory, factory calldata, and Intent Executor state.

Keep the complete account configuration unchanged across chains. Provider version, owners, salt, nonce, or factory choices can change the counterfactual address. See Smart account providers and Bring your own account.

​Automatic deployment

​Check deployment

​Automatic deployment

​Pay deployment costs

​Check deployment

​Deploy explicitly

​Deploy from another account

​Supported account behavior

Automatic deployment

Check deployment

Automatic deployment

Pay deployment costs

Check deployment

Deploy explicitly

Deploy from another account

Supported account behavior