> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rhinestone.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# 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](/wallets/embedded-wallets/accounts#initialize-the-client) and route requests to the selected account: your application's embedded wallet or a connected external wallet.

These provider, viem, wagmi, and external-wallet integrations are EVM-only. They do not expose the managed Solana wallet or a Solana provider. Use `WalletClient` directly for [managed Solana setup](/wallets/embedded-wallets/accounts#set-up-a-solana-wallet), and check [availability](/wallets/embedded-wallets/networks#availability) for its limits.

## EIP-1193 provider

```ts theme={null}
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:

```ts theme={null}
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](/wallets/embedded-wallets/external-wallets/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:

```ts theme={null}
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:

```ts theme={null}
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 endpoint URLs configured on the shared client; follow [Sponsorship setup](/transactions/sponsorship/set-up).

## wagmi

Create a connector around the same client:

```ts config.ts theme={null}
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:

```tsx theme={null}
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>;
}
```

<Note>
  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.
</Note>

## Availability

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


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.