> ## 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.

## 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 callbacks 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.