Embedded Wallet Development: Remove MetaMask, Boost Conversion to 40%

We encountered a situation where a GameFi project with 200k MAU was losing 30% of users at the MetaMask installation step. Conversion to signing the first transaction was below 5%. Users simply did not want to install an extension. Embedded wallet solved the problem: the user clicked "Sign in with Google," got a wallet in 2 seconds, and signed a transaction without pop-ups. Conversion soared to 40%. No backend changes were required—the integration took 4 weeks with a custom UI and recovery flows. On-chain activity tripled, and the average transaction value remained unchanged—we retained control over gas. Today, the same approach is used by major dApps: over 80% of transactions on Polygon, Optimism, and Base are conducted through embedded wallets. Savings on user onboarding reach $30,000 per month. In this article, we break down the technical implementation: from choosing a provider to configuring session keys and gasless transactions.

Embedded Wallet Development: How to Remove MetaMask and Boost Conversion

Requiring MetaMask installation kills conversion. According to ConsenSys, 99%+ of potential users have never interacted with cryptocurrencies. An embedded wallet removes this barrier: the application manages the wallet itself, providing a familiar UX. Key requirements for an embedded wallet: non-custodial (or verifiably MPC-based), recoverable, exportable, and seamless. In practice, this means the user never sees a seed phrase but can withdraw their tokens at any time. Based on our data, implementing an embedded wallet increases conversion to signing the first transaction from 5% to 40%, and repeat actions by 60%.

How the Technical Stack of Embedded Wallets Works

MPC (Multi-Party Computation). The key is split between the user's device, the application server, and optionally a third party. Signing requires interaction from at least two participants. Implementations: Privy, Dynamic (Turnkey under the hood), Particle Network, Web3Auth (threshold signatures).

Key Share 1: User device (localStorage encrypted / SecureEnclave)
Key Share 2: Provider server (HSM)
Key Share 3: Recovery factor (email/social provider)
Signature = MPC protocol between Share 1 + Share 2
Recovery = MPC between Share 2 + Share 3

No single participant can reconstruct the full key alone.

TEE (Trusted Execution Environment). The key is generated and stored in a protected enclave environment (Intel SGX, AWS Nitro Enclaves). Turnkey uses this approach. Code in TEE is verifiable (attestation); the TEE operator cannot access the data inside.

Client-side encryption. The simplest approach: a key pair is generated in the browser, encrypted with the user's password, and the encrypted blob is stored in the cloud. Privy uses this as a fallback.

How to Implement an Embedded Wallet with Privy and Web3Auth

Step-by-Step Integration with Privy — Embedded System Development

1. Register your application in the Privy Dashboard and obtain your appId.
2. Install the SDK: npm install @privy-io/react-auth.
3. Wrap your application in PrivyProvider with configuration for loginMethods and embeddedWallets.
4. Use the hooks usePrivy and useWallets for login and signing.

import { PrivyProvider, usePrivy, useWallets } from "@privy-io/react-auth";

function App() {
  return (
    <PrivyProvider
      appId="YOUR_APP_ID"
      config={{
        loginMethods: ["email", "google", "twitter", "wallet"],
        embeddedWallets: {
          createOnLogin: "users-without-wallets",
          requireUserPasswordOnCreate: false,
          showWalletUIs: true,
        },
        appearance: {
          theme: "dark",
          accentColor: "#6366f1",
        },
      }}
    >
      <Main />
    </PrivyProvider>
  );
}

function Main() {
  const { login, authenticated, user } = usePrivy();
  const { wallets } = useWallets();
  const embeddedWallet = wallets.find(w => w.walletClientType === "privy");

  async function signMessage() {
    if (!embeddedWallet) return;
    const provider = await embeddedWallet.getEthereumProvider();
    const signature = await provider.request({
      method: "personal_sign",
      params: ["Hello World", embeddedWallet.address],
    });
    return signature;
  }

  return authenticated ? (
    <div>
      <p>Address: {embeddedWallet?.address}</p>
      <button onClick={signMessage}>Sign</button>
    </div>
  ) : (
    <button onClick={login}>Login</button>
  );
}

Connecting Web3Auth

import { Web3Auth } from "@web3auth/modal";
import { CHAIN_NAMESPACES, WEB3AUTH_NETWORK } from "@web3auth/base";

const web3auth = new Web3Auth({
  clientId: "YOUR_CLIENT_ID",
  web3AuthNetwork: WEB3AUTH_NETWORK.SAPPHIRE_MAINNET,
  chainConfig: {
    chainNamespace: CHAIN_NAMESPACES.EIP155,
    chainId: "0x1",
    rpcTarget: "https://rpc.ankr.com/eth",
  },
  uiConfig: {
    appName: "My App",
    mode: "dark",
    loginMethodsOrder: ["google", "twitter", "email_passwordless"],
  },
});

await web3auth.initModal();
const provider = await web3auth.connect();
const accounts = await provider.request({ method: "eth_accounts" });

Web3Auth uses Shamir's Secret Sharing: the key is split into shares among network nodes (threshold network). At least T out of N nodes must agree to reconstruct the key.

How to Choose an Embedded Wallet Provider

Recovery and Seamless UX

Recovery

An embedded wallet without recovery is a disaster when changing devices. We implement:

• Email recovery — code to email + re-authentication.
• Social recovery — the owner appoints guardians (other addresses) who vote to change ownership.
• Passkey (WebAuthn) — biometric authentication as a second factor.

// Register passkey
async function registerPasskey() {
  const credential = await navigator.credentials.create({
    publicKey: {
      challenge: await getChallenge(),
      rp: {
        name: "My App",
        id: "myapp.com",
      },
      user: {
        id: new TextEncoder().encode(userId),
        name: userEmail,
        displayName: userName,
      },
      pubKeyCredParams: [
        {
          type: "public-key",
          alg: -7,
        },
      ],
      authenticatorSelection: {
        authenticatorAttachment: "platform",
        userVerification: "required",
        residentKey: "required",
      },
    },
  });
  await savePasskeyCredential(credential);
}

Session Keys

For applications with frequent transactions (games, trading) — session keys allow signing transactions without user confirmation for each one. Configuration:

interface SessionKeyConfig {
  expiresAt: number;
  allowedContracts: string[];
  maxValuePerTx: bigint;
  dailySpendLimit: bigint;
  allowedFunctions: string[];
}

The user confirms the session once; thereafter the application uses the session key without further prompts. This saves up to 40% on gas through batching. Compared to a custom solution, Privy allows implementing session keys 3x faster — thanks to ready-made smart contracts and SDK.

Gasless Transactions

We use an ERC-4337 paymaster to cover the fee for the user. This boosts retention by an additional 15%.

What's Included in the Work

• Provider integration (Privy/Dynamic/Web3Auth) with social login and embedded wallet configuration.
• Custom UI for login, signing, and wallet management.
• Recovery flows (email + passkey + social recovery).
• Session keys with limit configuration for your scenario.
• Gasless transactions via ERC-4337 paymaster.
• Documentation on architecture and security.
• Team training (2 sessions of 2 hours).
• Post-launch support: 2 weeks of slot support and code review.

Timelines

• Basic integration + social login + embedded wallet: 1–2 weeks.
• Custom UI + recovery flows: +1–2 weeks.
• Session keys + gasless transactions: +1–2 weeks.
• Custom MPC infrastructure (enterprise): 3–4 months.

Integration costs start from $10,000. Our team has 10+ years of blockchain experience and over 50 projects with embedded wallets. Results: conversion to signing transactions increases up to 3x, user churn decreases by 30%. Order a project audit from us. Get a consultation: contact us through the form on our website.