Quickstart

Create a smart wallet and send your first transaction. Choose 1auth for managed passkey authentication and transaction approval, or use the SDK to control the signer and account integration yourself.

1auth
SDK

Prerequisites

You need:

A browser app served over HTTPS. The hosted provider does not accept plain http://localhost; see the local HTTPS options.
A 1auth app and JWT signing credentials from the Rhinestone dashboard.
Two same-origin server endpoints that issue sponsorship tokens. Follow the fee sponsorship guide to create them.

Keep JWT signing credentials on your server. In production, authenticate these endpoints and restrict their policies, budgets, and rate limits.Install 1auth and viem:

npm install @rhinestone/1auth viem

pnpm add @rhinestone/1auth viem

bun add @rhinestone/1auth viem

Initialize 1auth

Create a client in your browser app. Replace my-app with your app’s client ID:

import { OneAuthClient } from "@rhinestone/1auth";
import { encodeFunctionData, parseAbi, parseUnits } from "viem";

const client = new OneAuthClient({
  providerUrl: "https://passkey.1auth.app",
  clientId: "my-app",
  sponsorship: {
    accessTokenUrl: "/api/sponsorship/access-token",
    extensionTokenUrl: "/api/sponsorship/extension-token",
  },
});

The access-token URL receives a GET request and returns { token }. The extension-token URL receives a POST request containing { intentOp } and returns { token }. These are endpoints in your app, not hosted 1auth endpoints. Without working app credentials, sendIntent fails with MISSING_APP_CREDENTIALS.

1auth uses app-origin passkeys by default. The WebAuthn ceremony runs on your app’s exact origin, so different origins create different passkeys and smart accounts. Learn more in Choose your WebAuthn mode.

Authenticate the user

Call authentication from a user-facing control, such as a Sign in button. Do not start authentication automatically when the page loads.The mint function below verifies authentication before reading the session address:

async function mintMusd() {
  const auth = await client.authenticate();
  if (!auth.success) {
    console.error("Authentication failed", auth.error);
    return;
  }

  const accountAddress = auth.session.accountAddress;

Mint 1 mUSD

Continue the function by submitting a sponsored mint on Base Sepolia. Invoke it from a transaction button so the user chooses when to review and approve the transaction:

  const musdBaseSepolia = "0x2f6fdE5E2AeAB6335d8f978B4d8B2a9c1129AcFb";

  const result = await client.sendIntent({
    accountAddress,
    targetChain: 84532,
    calls: [
      {
        to: musdBaseSepolia,
        data: encodeFunctionData({
          abi: parseAbi(["function mint(address to, uint256 amount)"]),
          functionName: "mint",
          args: [accountAddress, parseUnits("1", 6)],
        }),
        label: "Mint",
        sublabel: "1 mUSD",
      },
    ],
    closeOn: "completed",
  });

  if (!result.success) {
    console.error("Intent did not complete", {
      intentId: result.intentId || undefined,
      status: result.status,
      error: result.error,
    });
    return;
  }

  console.log("Completed intent", {
    intentId: result.intentId,
    status: result.status,
    transactionHash: result.transactionHash,
  });
}

sendIntent waits for the completed status because closeOn is set explicitly. A timeout is not proof that an already submitted intent failed; keep its intent ID for status tracking instead of blindly submitting it again.

Expected outcome

The authenticated smart account receives 1 mUSD on Base Sepolia and can start with a zero balance. This works because the call creates a faucet token and does not require tokens to be sourced or bridged first. Fee sponsorship does not make every transaction funding-free; transactions that need assets still require those assets to be available.

Next steps

Send crosschain

Use the mUSD you minted in a crosschain transaction.

Add React components

Add managed wallet components to a React app.

Connect viem or wagmi

Use a passkey wallet client in an existing web3 app.

Prerequisites

Run this example in a secure server-side environment. You need:

A RHINESTONE_API_KEY from the Rhinestone dashboard.
A funding account with Base Sepolia testnet ETH and its private key in FUNDING_PRIVATE_KEY. Get testnet ETH from QuickNode or Alchemy.

Keep both values in secure runtime configuration. Never expose or log API keys or private keys in browser code.Install the SDK:

npm install viem @rhinestone/sdk

pnpm add viem @rhinestone/sdk

bun add viem @rhinestone/sdk

Create an account

Create a smart account with a single ECDSA owner:

import { RhinestoneSDK } from "@rhinestone/sdk";
import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
import { baseSepolia, arbitrumSepolia } from "viem/chains";
import {
  createPublicClient,
  createWalletClient,
  encodeFunctionData,
  erc20Abi,
  type Hex,
  http,
  parseEther,
  parseUnits,
} from "viem";

const rhinestoneApiKey = process.env.RHINESTONE_API_KEY;
if (!rhinestoneApiKey) {
  throw new Error("RHINESTONE_API_KEY is not set");
}

const fundingPrivateKey = process.env.FUNDING_PRIVATE_KEY;
if (!fundingPrivateKey) {
  throw new Error("FUNDING_PRIVATE_KEY is not set");
}

const sourceChain = baseSepolia;
const targetChain = arbitrumSepolia;

const privateKey = generatePrivateKey();
const account = privateKeyToAccount(privateKey);

const rhinestone = new RhinestoneSDK({
  apiKey: rhinestoneApiKey,
});
const rhinestoneAccount = await rhinestone.createAccount({
  owners: {
    type: "ecdsa",
    accounts: [account],
  },
});
const address = rhinestoneAccount.getAddress();
console.log(`Smart account address: ${address}`);

Store the owner key securely if you need to access this account again. Generating a new owner key creates a different account address.You’ll see a deterministic address printed:

Smart account address: 0x...

Nothing is onchain yet: the account is deployed lazily on first use, on each chain it touches.

Fund the account

Send ETH to the smart account on the source chain. This is the only token you fund:

const publicClient = createPublicClient({
  chain: sourceChain,
  transport: http(),
});
const fundingAccount = privateKeyToAccount(fundingPrivateKey as Hex);
const fundingClient = createWalletClient({
  account: fundingAccount,
  chain: sourceChain,
  transport: http(),
});

const txHash = await fundingClient.sendTransaction({
  to: address,
  value: parseEther("0.001"),
});
await publicClient.waitForTransactionReceipt({ hash: txHash });

Send a crosschain transaction

Transfer USDC on the target chain, sourced from the ETH you funded on the source chain:

const usdcAmount = parseUnits("0.1", 6);
const usdc = "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d"; // USDC on Arbitrum Sepolia

const prepared = await rhinestoneAccount.prepareTransaction({
  sourceChains: [sourceChain],
  targetChain,
  calls: [
    {
      to: usdc,
      value: 0n,
      data: encodeFunctionData({
        abi: erc20Abi,
        functionName: "transfer",
        args: ["0xd8da6bf26964af9d7eed9e03e53415d37aa96045", usdcAmount],
      }),
    },
  ],
  tokenRequests: [
    {
      address: usdc,
      amount: usdcAmount,
    },
  ],
});
const signed = await rhinestoneAccount.signTransaction(prepared);
const transaction = await rhinestoneAccount.submitTransaction(signed);
console.log("Transaction", transaction);

const transactionResult = await rhinestoneAccount.waitForExecution(transaction);
console.log("Result", transactionResult);

submitTransaction returns an intent handle; waitForExecution polls until every chain’s operation reaches a terminal state:

Transaction {
  type: 'intent',
  id: '0x9c…',
  traceId: '…',
  sourceChains: [ 84532 ],
  targetChain: 421614
}
Result {
  status: 'COMPLETED',
  accountAddress: '0x5fA3…42c1',
  operations: [
    { chain: 84532, status: 'COMPLETED', txHash: '0x…', timestamp: 1750000000 },
    { chain: 421614, status: 'COMPLETED', txHash: '0x…', timestamp: 1750000002 }
  ]
}

Your ETH on Base Sepolia landed as USDC on Arbitrum Sepolia in a single atomic operation: no bridging, swapping, or gas tokens to manage.

Building a browser app? Use the Reown + Rhinestone example to get wallet connection working with MetaMask or any WalletConnect-compatible wallet.

Expected outcome

Your account is deployed on Base Sepolia and Arbitrum Sepolia, with 0.1 USDC transferred on the target chain from the ETH funded on the source chain.

Next steps

Sponsor fees

Cover gas, bridging, and swap fees for your users across any chain.

Smart account setup

Configure signers: passkeys, embedded wallets, multisig, and more.

Smart Sessions

Add session keys for one-click UX and automated transactions.

Tutorials

Smart account setup

Gas & fee sponsorship

Smart Sessions

More features

Configuration

Module development

SDK Reference

Prerequisites

Expected outcome

Next steps

Send crosschain

Add React components

Connect viem or wagmi

Prerequisites

Expected outcome

Next steps

Sponsor fees

Smart account setup

Smart Sessions

​Prerequisites

​Expected outcome

​Next steps

Send crosschain

Add React components

Connect viem or wagmi

​Prerequisites

​Expected outcome

​Next steps

Sponsor fees

Smart account setup

Smart Sessions

Prerequisites

Expected outcome

Next steps

Prerequisites

Expected outcome

Next steps