Ecosystem

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 { createOneAuthProvider } from "@rhinestone/1auth"
import { oneAuth } from "./oneauth"

export const provider = createOneAuthProvider({
  client: oneAuth,
  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 { oneAuth as oneAuthConnector } from "@rhinestone/1auth/wagmi"
import { oneAuth } from "./oneauth"

export const config = createConfig({
  chains: [base],
  connectors: [oneAuthConnector({ client: oneAuth, 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 === "1auth")

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

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

Availability

These examples use the public @rhinestone/1auth 0.10.2 release. The 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.

Getting started

Authentication

External wallets

Signing

Integration

Security

EIP-1193 provider

viem

wagmi

Availability

​EIP-1193 provider

​viem

​wagmi

​Availability

EIP-1193 provider

viem

wagmi

Availability