Skip to content

Why create a Global Wallet?

Embedded wallets typically require each application to manage its own wallet setup.

Diagram showing separate embedded wallets within isolated apps

This can lead to several challenges:

  • Fragmented authentication across apps When each app manages its own authentication, you end up with duplicated logic, inconsistent session handling, and a messy user experience. OAuth2 providers struggle to maintain continuity across domains, making it difficult to track a user's identity and wallet access holistically.

  • Liquidity fragmentation kills network effects If every app generates and manages its own wallets, user assets are scattered across isolated accounts. This makes it harder to build shared economies, pooled inventories, or unified user profiles—preventing the kind of liquidity and composability that ecosystems need to thrive.

  • No interoperability across apps Different wallet implementations across apps lead to incompatibilities in how users onboard, transact, or authorize actions. Without a shared interface or contract standard, there's no guarantee that features like cross-app identity, shared balances, or seamless UX will work consistently.

How does Openfort Global Wallets solve this?

Global wallet architecture that centralizes wallet management

Switching to an ecosystem approach addresses the challenges of embedded wallets:

  • Unified authentication: A single sign-on mechanism minimizes friction and simplifies session management across apps.
  • Monitoring and user management: Manage all user permissions from a single dashboard. This empowers administrators to monitor activities and enforce security policies consistently.
  • Enhanced developer experience: One integration point means your team can focus on building features rather than managing multiple wallet configurations.
  • Consistent user experience: Provide a seamless and intuitive wallet experience regardless of which app the user interacts with.

Ecosystem SDK: Deep Dive

The Openfort Ecosystem SDK is a modular system, with each package playing a specific role in enabling secure, global wallet experiences.

@openfort/ecosystem/client

  • Announces a provider using both EIP-6963 and EIP-1193, making it compatible with popular Ethereum tooling (e.g., wagmi, viem).
  • Initiates a signer (via the SCWSigner class), which is responsible for transaction signing and secure communication.
  • All communication is based on window messaging (using postMessage), either between an iframe and the main page or between a popup and its parent.
  • The provider's request method wraps JSON-RPC requests and forwards them through the communicator, which handles the secure postMessage exchange.
  • The secure channel is established with the wallet UI (where the user interacts), following the Mobile Wallet Protocol (MWP).
  • The SCWKeyManager manages the secure key exchange and communication.

@openfort/ecosystem/core

  • Acts as the bridge between the client SDK (in the app) and the wallet UI (the user-facing component).
  • Installed in the wallet UI, it handles the other end of the communication with the client SDK via MWP.
  • Exposes helper functions for reading incoming requests and sending responses.
  • Stores session data (key pairs for Diffie-Hellman exchange) per app, based on the origin, in local storage. This allows multiple secure channels for different apps.
  • If storage is cleared, a new handshake and key exchange are required.
  • Because it's MWP-compatible, you can use platform-specific libraries (e.g., Unity) for wallet UIs.

@openfort/ecosystem/react

  • Provides React-specific helpers and a set of prebuilt components and a styling library (inspired by ConnectKit) to bootstrap wallet UIs quickly.
  • Contains React wrappers for invoking @openfort/core methods.
  • Used in the sample wallet UI at id.sample.openfort.io, which demonstrates how to build a wallet front-end using these prebuilt components.
  • The sample uses the Openfort Embedded Signer for key management, but other implementations (e.g., Safe, on-chain passkey) are possible.

@openfort/ecosystem-js

  • Re-exports everything from the above packages, providing a single entry point for all SDK functionality.

Architecture

Architectural diagram of Ecosystem SDK

Core Components

  • Client SDK (@openfort/ecosystem/client):
    The "head chef" of the wallet system, handling wallet creation, UI pop-ups, and transaction management. EIP-1193 compatible.

  • Communication module (@openfort/ecosystem/core):
    The bridge between the app and the wallet UI, handling secure communication and session management via MWP.

  • Framework prefabs (@openfort/ecosystem/react):
    Prebuilt React components and styling helpers to accelerate wallet UI development.

  • Ecosystem entrypoint (@openfort/ecosystem-js):
    A unified package that re-exports all SDK modules for convenience.