Boost performance with 4x smaller SDKs, manage multiple wallets with Shield V2's Keychain, and get started faster with Marti's video guide.

Openfort SDK size reduction and Shield V2 keychain announcement

4x size reduction in Openfort JS



It’s been three months since we introduced our [chain abstraction](https://www.openfort.io/blog/chain-abstraction) framework. Today, we’re sharing a changelog of our progress and a look at how we’re making cross-chain interactions native for every ecosystem.

## What is Openfort Chain Abstraction?

Chain abstraction is a framework that allows users to interact with any blockchain using a single, unified balance. Instead of bridging funds manually, users can keep their assets in a "Source Chain" vault, while our system handles the liquidity and "repayment" on the "Destination Chain" automatically. Openfort’s approach empowers ecosystems to act as their own liquidity providers, sharing value with their users instead of external solvers.


## Our vision: Community as Value-Sharing Liquidity Providers

At Openfort, we've taken a unique approach to chain abstraction. While many solutions in the market rely on third-party solvers or fillers who compete to front liquidity on destination chains in exchange for fees, we've placed ecosystems at the center of our model.

Our vision grants ecosystems the power to become liquidity providers for their own users. Instead of value being captured by external solvers, ecosystems deploy tailor-made 4337 chain abstraction infrastructure that allows them to share this value directly with their users.

This fundamental shift transforms the relationship between ecosystems and their users. Ecosystems now have the tools to provide a unified balance that's instantly accessible across all their applications, regardless of the underlying blockchain. Users gain a seamless, friction-free experience without sacrificing security or control over their assets.

## The evolution of Openfort chain abstraction: From v0.1 to today

Our chain abstraction framework has undergone significant evolution since its inception. What started as a proof of concept has grown into a "almost" production-ready system that addresses real-world requirements for secure, efficient cross-chain transactions.

### Core components and their evolution

- **Time-Locked Vaults**
Our system centers around tokenized vaults that securely store user funds with configurable locking periods. These vaults serve as counterparty guarantees for Paymasters, ensuring that funds are only used as intended. Unlike traditional locked assets, these vaults can be yield-bearing, allowing users to earn returns while their assets serve as security.

We've simplified the "locking" process to be as user-friendly as possible - users simply send a transaction from their EOA to their Smart Contract Account, and a backend watcher automatically transfers the funds to a time-locked vault using a pre-approved session key.

- **Invoice Manager**
A critical advancement in our system is the implementation of the Invoice Manager, which:
- Manages the settlement of invoices between chains
- Prevents double-repayment of invoices with state proof verification
- Authorizes paymasters and paymaster verifiers

This component has been crucial in protecting users against double-repay scenarios, a key requirement we've successfully implemented.

- **Ecosystem Paymasters**
Our 4337-compatible Chain Abstraction Paymasters (CABPaymasters) front funds on destination chains for users with sufficient locked balances. Each ecosystem owns its Paymaster, giving them direct control over the experience while maintaining a non-custodial architecture.

- **Paymaster Verifiers**
We've implemented permissionless verification of remote events and storage proofs, allowing for trustless verification of invoices across chains.

### Production requirements met

Since our initial release, we've successfully implemented several critical production requirements:

- **Protected users against double-repay**: Through state-proofs and our InvoiceManager, we've ensured that invoices cannot be repaid multiple times, protecting both users and ecosystems.

- **Execution at destination chain speed**: Transactions execute at the native speed of the destination chain, with repayment happening asynchronously on the source chain.

- **Proving system fallbacks**: Beyond Polymer's fast proving system (thanks to the V2), we've integrated Hashi as a fallback proving mechanism, ensuring that the system can continue to operate even if primary proving services are unavailable.

- **Native token sponsorship**: We've implemented native token sponsorship with refund rates agreed upon at transaction signing, not at repayment time. This protects users from token volatility during the transaction lifecycle.

Our system now leverages cross-L2 execution proofs from Polymer, eliminating the need for users to trust Openfort or the Ecosystem. Repayment only occurs with verified execution proof from the destination chain, and the InvoiceManager tracks all invoices on-chain to prevent double-refunds.

## What sets our approach apart

Our chain abstraction framework differs fundamentally from other solutions in the market:

### Ecosystem-Centric vs. Solver Networks

While many approaches rely on third-party solvers or fillers to compete for providing liquidity, we empower ecosystems to be their own liquidity providers. This allows ecosystems to capture and share value that would otherwise go to external parties.

### Yield-Bearing Security

Our time-locked vaults allow users to earn yields on their locked assets, transforming what would typically be idle capital into productive investments. This represents a significant improvement over traditional security models where locked assets generate no returns.

### True Abstraction Across Applications

Our solution unifies user liquidity across apps within an ecosystem, providing a single balance that's instantly spendable regardless of which chain an application runs on. This creates a seamless experience where users don't need to think about which chain they're interacting with.

## Looking Ahead: Completing the Chain Abstraction Vision

While we've made significant progress, several key components of our production roadmap are still in active development:

- **Transaction Sequencing Enhancements**

We're working on advanced transaction sequencing mechanisms to prevent double-spending of counterparty resources, further enhancing the security of our system.

- **Non-Custodial Security Architecture for Paymasters**

Although our current implementation provides strong security guarantees, we're advancing our integration with secure enclaves (via lit, turnkey, and nitro) with custom policies to ensure that Openfort never has custody of ecosystem funds.

- **Intelligent Liquidity Path Selection**

We're developing systems to automatically select the cheapest refund liquidity path for each transaction. Users will approve these paths by signing an EIP-712 message, ensuring transparency and control over how their transactions are processed.

- **L2 Reorg Resistance**

To address the challenges of layer-2 reorganizations, we're implementing additional safeguards to ensure transaction finality even in cases of network reorganizations.

- **External Liquidity Fallbacks**

We're building fallback mechanisms to external liquidity sources, ensuring transaction execution even in cases where ecosystem liquidity might be constrained.

As we continue to develop and refine our chain abstraction solution, we invite developers, ecosystems, and users to join us on this journey. Together, we can build a future where blockchain interactions are as simple and intuitive as traditional web experiences, unlocking the full potential of onchain technology for everyone.


Our newest updates and progress on the chain abstraction project and how it will link with our ecosystem SDK

Chain abstraction framework updates and cross-chain improvements

Improving our Chain Abstraction implementation


Our implementation of the Mobile Wallet Protocol (MWP) for Unity is now publicly available. This allows any game developer to connect their in-game wallets to external onchain applications securely and without complex manual integrations.

## What is the Mobile Wallet Protocol (MWP)?

The Mobile Wallet Protocol is an open-source communication standard that allows mobile applications to interact securely with wallet apps using deep links and end-to-end encryption. In Unity, MWP enables a "handshake" between a game and an external wallet, allowing players to sign transactions or connect their accounts without needing to rely on web-based intermediaries. At Openfort, we’ve optimized this protocol specifically for gaming environments to ensure sub-second response times and a native feel.


> You can start using our MWP implementation in Unity right away. Check out our [comprehensive documentation](https://www.openfort.io/docs/products/cross-app-wallet/usage/unity) and [sample project](https://github.com/openfort-xyz/mobile-wallet-protocol-unity-client) to get started.


## Why Mobile Wallet Protocol Matters for Gaming

The gaming industry has long faced challenges when connecting in-game experiences to external onchain applications. Traditional approaches often required complex integrations, multiple SDK implementations, or clunky user experiences. With MWP in Unity, we're eliminating these barriers by providing a standardized, secure protocol for communication between games and external applications.


Mobile Wallet Protocol was originally developed as an open-source communication standard that helps wallets communicate securely with applications. At Openfort, we've adapted this technology specifically for gaming environments, enabling Unity developers to leverage ecosystem wallets without the complexity.

## How Mobile Wallet Protocol Works in Unity

At its core, MWP is a two-step process that creates a secure communication channel between applications. Let's break down how this works in the gaming context, where your Unity game can securely connect to external wallets or applications:

![mwp-scheme.png](/images/blog/mwp_scheme_e160faedf4.png)

### Session Establishment
The communication between a client application and a wallet application begins with session establishment. This process involves several key steps:

1. The client game configures the MWP SDK with essential parameters including callbackURL, CustomScheme (for Unity).

2. When the user initiates an action requiring wallet interaction, the client app triggers a request through the SDK.

3. The SDK prepares this request, typically including encryption to ensure secure communication.

4. The request is sent to the wallet app using platform-specific deep linking mechanisms.

The deep linking mechanism is central to the protocol's architecture, enabling direct app-to-app communication without requiring web-based intermediaries.

### Request Processing and Response Handling
Once a request reaches the wallet application, several steps occur:

1. The wallet app receives and processes the incoming request.

2. For operations requiring user approval (such as signing transactions), the wallet presents appropriate interfaces to the user.

3. After processing (and potential user interaction), the wallet generates a response.

4. This response is encrypted for security and returned to the client app via the previously configured callback URL.

5. The client app's deep link handler captures this incoming URL and passes it to the SDK's handleResponse function.

6. The SDK decrypts and processes the response, then provides the result to the client app for further action.

This request-response pattern supports various operations, including connecting to wallets, signing transactions, and making batch requests.

## Benefits for Game Developers

Our Unity implementation of MWP offers several key advantages:

- **End-to-end encryption** to prevent unauthorized access to messages exchanged between the client app and wallet.

- **Secure key exchange** mechanisms for establishing encrypted communication channels.

- **Decentralized identity verification** using well-known URI standards, eliminating the need for centralized verification services.

- **Batch request support** to minimize the number of security-sensitive interactions required.

- **Cross-Platform Support**: Works across desktop, mobile, and console gaming environments.

## Real-World Applications

![unity_screenshot.png](/images/blog/unity_screenshot_fd75385137.png)

- **NFT Marketplace Integration**: List in-game items directly on marketplaces like OpenSea without requiring players to use external wallets.

- **Cross-Game Asset Transfer**: Move assets between different games securely.

- **External Wallet Connections**: Allow players to connect their favorite wallets to your game ecosystem.

A standout example is our OpenSea integration demo, where players can list their in-game NFTs directly to the marketplace without leaving the game environment. This seamless connection between gaming and NFT marketplaces demonstrates the power of MWP in creating unified onchain experiences.


## A Public Good for the Gaming Ecosystem

By bringing MWP to Unity, we're contributing to the broader gaming ecosystem and promoting interoperability between games and Web3 applications. This implementation represents our commitment to creating open standards that benefit the entire industry.

We believe that standardized protocols like MWP are essential for the growth of blockchain gaming. By making our implementation available to all developers, we're helping to create a more connected and seamless experience for players across the on-chain gaming landscape.


We can't wait to see what you build with Mobile Wallet Protocol in Unity. Connect with us on [X](https://twitter.com/openfort_hq).


This powerful feature is now available to all game developers, enabling seamless connections between in-game wallets and the broader Web3 ecosystem.

Mobile Wallet Protocol integration for Unity game development

Mobile Wallet Protocol for Unity, a public good

- [What is Openfort Shield V2?](#what-is-openfort-shield-v2)
- [Nearly 4x smaller package size for lightning-fast applications](#nearly-4x-smaller-package-size-for-lightning-fast-applications)
- [Unified multi-wallet management under a single user identity](#unified-multi-wallet-management-under-a-single-user-identity)
- [Video: Openfort Kit quickstart](#video-openfort-kit-quickstart)

Nearly 4x smaller package size for lightning-fast applications

Unified multi-wallet management under a single user identity

Our third major update of Launch Week 2 is here: a 4x reduction in SDK size and the introduction of Shield V2. These updates are designed to make your applications faster and your users' credentials more secure.

[What is Openfort Shield V2?](#what-is-openfort-shield-v2)

Shield V2 is a security upgrade for our SDK that includes a new "Keychain" system for managing multi-wallet identities. Similar to how Apple’s Keychain stores passwords and keys securely across devices, Shield V2 allows users to manage multiple wallets under a single identity with a familiar and trusted security model. By combining this with our new treeshakable JavaScript SDK, developers can now build high-performance on-chain apps that load faster while maintaining enterprise-grade safety.

[Nearly 4x smaller package size for lightning-fast applications](#nearly-4x-smaller-package-size-for-lightning-fast-applications)

We've dramatically reduced our SDK footprint by almost 4x, resulting in significantly faster loading times and improved performance for your applications. This massive improvement means:

: Quicker application startup and smoother interactions

**Faster User Experiences**: Quicker application startup and smoother interactions

: Less bandwidth consumption for your users

**Reduced Data Usage**: Less bandwidth consumption for your users

: Particularly crucial for gaming applications on mobile devices

**Better Mobile Performance**: Particularly crucial for gaming applications on mobile devices

![beforetreesh.png](/images/blog/beforetreesh_2b97c6edcf.png)

How did we achieve this? By implementing treeshakable JavaScript for both our 

 implementations. This allows you to import only the specific functionality you need, eliminating unused code from your final bundle.

How did we achieve this? By implementing treeshakable JavaScript for both our [embedded JS](https://socket.dev/npm/package/@openfort/openfort-js) and [ecosystem JS](https://socket.dev/npm/package/@openfort/openfort-js) implementations. This allows you to import only the specific functionality you need, eliminating unused code from your final bundle.

![aftertreesha.png](/images/blog/aftertreesha_ebb1113cc5.png)

[Unified multi-wallet management under a single user identity](#unified-multi-wallet-management-under-a-single-user-identity)

Users can now seamlessly manage multiple wallets under one secure identity, eliminating the friction of juggling separate credentials across different applications or chains. This enhancement delivers:

: One identity to manage multiple wallets

**Simplified User Experience**: One identity to manage multiple wallets

: Reduced risk through centralized authentication management

**Increased Security**: Reduced risk through centralized authentication management

: Consistent wallet access across your entire application ecosystem

**Cross-App Compatibility**: Consistent wallet access across your entire application ecosystem

 with Keychain functionality. Similar to Apple's intuitive 

, our implementation provides a familiar and trusted model for secure credential management in the on-chain space.

This breakthrough comes through our new [Shield V2](https://github.com/openfort-xyz/shield/) with Keychain functionality. Similar to Apple's intuitive **Keychain system**, our implementation provides a familiar and trusted model for secure credential management in the on-chain space.

[Video: Openfort Kit quickstart](#video-openfort-kit-quickstart)

To help you get started with the fastest and most responsive components in the market, our team member Marti has created a comprehensive 

To help you get started with the fastest and most responsive components in the market, our team member Marti has created a comprehensive [video tutorial on Openfort Kit](https://youtu.be/h__PUjSlkP4). This video features:

This rapid onboarding is now possible thanks to a new comprehensive video tutorial created by our team member Martí.

4x size reduction in Openfort JS

Table of Contents

Switch to Openfort

Table of Contents

Switch to Openfort

What is Openfort Shield V2?

Nearly 4x smaller package size for lightning-fast applications

Unified multi-wallet management under a single user identity

Video: Openfort Kit quickstart

Keep Reading

Mobile Wallet Protocol for Unity, a public good

Improving our Chain Abstraction implementation

Try Openfort Free