Create seamless dApp connections with Wagmi and EIP-1193

Ethereum dApp users expect wallet connections to feel instant and familiar. Injected wallets like MetaMask created that expectation by appearing automatically inside a browser and exposing a standard interface that every dApp understands. WalletConnect expanded this pattern by letting users connect wallets running on another device, such as a mobile app, through QR codes or deep links.

Turnkey reaches the same level of simplicity without requiring extensions, seed phrases, or external wallet apps. Instead of asking users to install a browser extension or scan a QR code, Turnkey embeds a secure, non-custodial wallet directly into an application. Users authenticate with passkeys, email, or social login, and their private keys remain sealed inside secure enclaves.

This article explains how Turnkey provides a smooth connect wallet experience across dApps and how developers can integrate this behavior through Wagmi.

Why embedded wallets matter for dApp connectivity

If you’re just getting started with embedded wallets, let’s first define them before launching into how they’re used to connect to Ethereum dApps.

Injected wallets depend on browser extensions and local key storage. They work well for seasoned crypto users but create friction when onboarding new audiences or supporting mobile users who do not run desktop extensions.

Embedded wallets remove that friction entirely. A user can authenticate through a familiar UI, and a wallet is created instantly inside the app. Because Turnkey manages keys inside secure enclaves, no seed phrases or manual setup steps are required.

From the user’s perspective, the connection still feels the same. They pick an account, the dApp recognizes it, and interaction begins. The difference is that the entire flow becomes more accessible and more secure.

How Turnkey becomes recognizable to dApps

The key to Turnkey’s seamless dApp connectivity is compatibility with EIP-1193. Turnkey provides this interface through its Wagmi integration, making its embedded wallets appear to dApps just like a traditional provider.

What is EIP-1193?

EIP-1193 is an Ethereum improvement proposal that defines the standard interface dApps use to communicate with wallets. It describes how a dApp requests accounts, sends RPC calls, and receives responses in a consistent way.

Key ideas:

• Wallets expose the same request method and event structure.
  
  
• dApps can connect to any compatible wallet without custom code.
  
  
• Wagmi, Viem, and ethers.js automatically recognize EIP-1193 providers.

EIP-1193 is the shared language that allows wallets and dApps to work together across the entire Ethereum ecosystem.

Because Turnkey provides an EIP-1193 connection, any dApp built with Wagmi, Viem, or ethers.js automatically recognizes a Turnkey wallet, the same way they detect an injected wallet like MetaMask.

How Wagmi works with EIP-1193

Wagmi is a React library that simplifies how applications connect to wallets and interact with blockchains. Instead of manually wiring up providers, RPC calls, and connection state, developers use Wagmi hooks like useConnect, useAccount, and useSendTransaction to handle these concerns inside React components.

Under the hood, Wagmi relies on the EIP-1193 provider standard. EIP-1193 defines a common interface that wallets expose to dApps, including a request method for JSON RPC calls and events for account and network changes. Injected wallets like MetaMask, as well as embedded wallets that implement EIP-1193, all present themselves through this same provider shape.

When you plug a wallet into Wagmi, you do it through a connector. Each connector tells Wagmi how to obtain an EIP-1193 compatible provider for that wallet. 

Once the provider is available, Wagmi sends all connection requests, signing calls, and reading operations through the standard request interface. That means Wagmi does not need to know the details of how a specific wallet stores keys or signs transactions. It only needs the EIP-1193 interface.

This is where Turnkey fits in. By exposing an EIP-1193 provider, Turnkey can register as a connector in Wagmi just like MetaMask or other wallets. 

From the dApp’s perspective, the Turnkey provider behaves like any other wallet: it returns accounts, supports signing, and emits events when state changes. From the user’s perspective, the difference is that the wallet is embedded directly in the app and backed by secure enclaves instead of a browser extension.

Because Wagmi is built around EIP-1193, it becomes a neutral layer that can work with injected wallets, mobile wallets, and embedded wallets such as Turnkey. 

As long as the wallet implements the standard provider interface, Wagmi can connect to it and give developers a consistent, React-friendly way to integrate it into their applications.

What Turnkey’s connection experience looks like

When a user clicks Connect Wallet, the dApp asks for accounts through a standard provider interface. Turnkey surfaces a familiar connection prompt that allows the user to authenticate and select a wallet address. Unlike WalletConnect, which requires a separate wallet app and a QR code or deep link, Turnkey handles the entire connection inside the application with no external steps.

See the Berakin wallet example in Turnkey docs on how to build an embedded wallet pop-up and wire it to a Wagmi connector. 

Once the user is verified, Turnkey returns the approved account and chain ID to the dApp. The connection is established, and the user can immediately interact with contracts and interfaces.

The crucial detail is that this happens without extensions, seed phrases, or cryptographic prompts that interrupt the flow. The dApp receives the same information it would from an injected wallet, but the onboarding is far more approachable.

How Turnkey enables smooth signing across dApps

After connecting, users can sign messages or approve transactions across any Ethereum dApp. Signing requests follow the same pattern they would with an injected wallet, but Turnkey routes them through the embedded wallet’s authenticated session.

The user reviews the request in a clean, app-controlled UI. If they approve, Turnkey signs the message or transaction inside its secure enclave and returns the result to the dApp.

This creates a predictable, smooth signing experience that works across the entire web3 ecosystem. Developers avoid managing private keys, and users stay inside a consistent, familiar interface.

Why developers benefit from this approach

Turnkey gives developers the ease of custom MetaMask-style connectivity without requiring them to build or maintain wallet infrastructure. Integrating Turnkey into Wagmi’s connection flow is a straightforward step that makes embedded wallets discoverable by any EIP-1193-aware dApp.

Because private keys never touch the application or device, developers also eliminate a major security burden. The architecture becomes simpler, safer, and easier to scale.

This approach also broadens the user base. Mobile users, beginners, and mainstream audiences can access the dApp without extension requirements or seed phrase onboarding.

To polish the connection experience, developers may introduce helpful enhancements, such as persisting sessions so users stay connected, validating message origins for security, and handling network switching under the hood.

Connect your application to Turnkey

Turnkey offers a seamless, MetaMask-style “connect wallet” experience while removing the barriers of extensions and seed phrases. By exposing a standard EIP-1193 provider through Wagmi, it fits directly into existing dApp ecosystems and allows users to authenticate and sign with minimal friction.

For developers, this unlocks a secure and scalable way to onboard users while preserving the familiar patterns that dApps already rely on. The result is a smoother, more accessible wallet experience that extends across the entire web3 landscape.

Connect with Turnkey today. 

‍