Ecosystem

Use embedded and external wallets through EIP-1193, viem, or wagmi.

The embedded wallet SDK exposes an EIP-1193 provider and a wagmi connector. Both reuse the shared client initialization and route requests to the selected account: your application’s embedded wallet or a connected external wallet.

EIP-1193 provider

import { createWalletProvider } from "@rhinestone/wallet";
import { wallet } from "./wallet";

export const provider = createWalletProvider({
  client: wallet,
  chainId: 8453,
});

Calling eth_requestAccounts authenticates the user and returns the account address:

const accounts = await provider.request({
  method: "eth_requestAccounts",
});

if (!Array.isArray(accounts) || typeof accounts[0] !== "string") {
  throw new Error("The provider did not return an account");
}

const [accountAddress] = accounts;

To offer embedded and external wallets, call wallet_connect instead. See Connect external wallets for the connection flow.

The provider supports these common methods:

Method	Purpose
wallet_connect	Open the embedded-or-external wallet chooser.
eth_requestAccounts	Request an account without opening the external-wallet chooser.
eth_accounts	Return the connected account address.
personal_sign	Sign an EIP-191 message.
eth_signTypedData_v4	Sign EIP-712 typed data.
eth_sendTransaction	Submit one transaction.
wallet_sendCalls	Submit a batch of calls.
wallet_getCallsStatus	Read batch status.
wallet_getCapabilities	Read wallet capabilities.

Listen for standard provider events:

provider.on("accountsChanged", (accounts) => {
  if (Array.isArray(accounts)) console.log(accounts[0]);
});

provider.on("chainChanged", (chainId) => {
  console.log(chainId);
});

viem

Wrap the same provider with a viem wallet client:

import { createWalletClient, custom } from "viem";
import { base } from "viem/chains";
import { provider } from "./provider";

export const walletClient = createWalletClient({
  chain: base,
  transport: custom(provider),
});

const [accountAddress] = await walletClient.requestAddresses();

Use viem’s standard wallet actions after connection. For an external wallet, connect through wallet_connect first and wrap the same provider. Embedded-wallet transactions require the sponsorship callbacks configured on the shared client; follow Sponsorship setup.

wagmi

Create a connector around the same client:

config.ts

import { createConfig, http } from "wagmi";
import { base } from "wagmi/chains";
import { rhinestoneWallet } from "@rhinestone/wallet/wagmi";
import { wallet } from "./wallet";

export const config = createConfig({
  chains: [base],
  connectors: [rhinestoneWallet({ client: wallet, chainId: base.id })],
  transports: {
    [base.id]: http(),
  },
});

Connect and read the account with standard wagmi hooks. The connector opens the embedded-or-external wallet chooser:

import { useAccount, useConnect } from "wagmi";

export function ConnectWalletButton() {
  const { address, isConnected } = useAccount();
  const { connect, connectors } = useConnect();
  const connector = connectors.find(({ id }) => id === "rhinestone-wallet");

  if (isConnected) return <span>{address}</span>;
  if (!connector) return null;

  return <button onClick={() => connect({ connector })}>Connect wallet</button>;
}

Applications upgrading from the legacy connector need users to reconnect once because the connector ID changed. The user’s account and credentials stay the same.

Availability

These integrations expose the supported provider methods, not every method a browser extension wallet may implement. See Use and manage connected wallets for external-wallet transaction and connection behavior.