Product Changelog

Openfort CLI — Now in Public Beta

The Openfort CLI is live. Manage wallets, smart accounts, and signing operations directly from your terminal. This week added sessions, triggers, list smart-accounts, list delegated-accounts, rotate-key, and hash-message commands. Comes with a full README, supply-chain-secured dependencies (pinned commit hashes), and an interactive login flow connected to the dashboard.

Solana Support in the React SDK

Full Solana support lands in @openfort/openfort-react. Includes a headless Solana-only sample app, auto wallet creation on network switch to Solana, and recipe updates across Aave, LiFi, Morpho, and the agent-permissions template. The Solana Kit dependency was simplified — no longer required in consumer apps.

Test Account Auth Provider for App Store Review

New auth provider in the dashboard specifically for automated testing and App Store / Play Store review flows. Lets QA teams and reviewers log in with test credentials without affecting production users.

Dashboard: CLI Login Page

The dashboard now surfaces a dedicated login page for CLI authentication, making it easier to connect openfort CLI sessions to your organization.

• CLI: README rewritten with cleaner structure, ASCII art fixed, supply chain security via pinned action hashes in CI
• React SDK: connectOnLogin option added — control whether the wallet auto-connects on user login
• React SDK: Autoconnect now prefers embedded wallet before external wallets, reducing friction for embedded-first apps
• Dashboard: OAuth scopes list UI updated with cleaner display
• Documentation: React SDK migration guides updated for the new SDK API surface
• Documentation: Improved React config examples with explicit QueryClientProvider wrapper
• Documentation: Gas sponsorship guide naming and ETH sendTransaction examples fixed
• Documentation: New Build with CLI page and Test Accounts guide added
• openfort-node: Dependency updates and code formatting pass

• Fixed auto-create wallet failing on Solana network switch
• Fixed an unguarded wagmi import causing build failures in strict package environments
• Fixed biome linter now running against locked package names (was silently skipping)
• Fixed connectOnLogin: false not being respected in certain auth flows
• Fixed broken documentation links across gas sponsorship and embedded wallet pages

EIP-1193 Provider Events & Wallet State Observer

The JavaScript SDK now supports standard EIP-1193 provider events and a new watchEmbeddedState observer, making it easier to track wallet state changes in real time.

Delegated Accounts API

New endpoint to retrieve delegated accounts by chain for backend wallets, enabling more flexible multi-chain wallet management.

Unified Backend Transaction Sending

The Node SDK now supports sending transactions via backend wallets through a unified sendTransaction interface.

Policy V2 Session Key Support

Session key registration and revocation now fully support V2 policies, including improved validity checks.

Customers Page

Launched a new /customers landing page showcasing case studies and customer success stories.

• React SDK: Added retry logic to useWallets connector and improved fallback behavior for wallet operations, including private key export support
• React Native: Added native platform version verification for passkey PRF support on Android 14+ and iOS 18+
• Dashboard: Added argument constraints UI for Policy V2 criteria and improved backend wallets management page
• Dashboard: Consolidated billing fees into a single surcharge display with improved operation usage card
• Documentation: Updated x402 recipe with backend wallet support, added wallet permissions recipe, and improved gasless transaction guides
• Auth: Added rate limiting to authentication endpoints and no-cache headers for improved security

• Fixed wallet recovery failing when no password was set
• Fixed a race condition in the React SDK when fetching wallet connectors during social login
• Fixed an error during headless social login flows
• Fixed anonymous account linking being triggered during token refresh instead of only at explicit auth endpoints
• Enforced player ownership checks when viewing transaction intents
• Added URL validation for OAuth provider configurations to prevent SSRF
• Replaced unsafe query patterns with parameterized queries in the analytics layer

Policy engine V2

Today: our policy engine gets an upgrade to take care of both the gas policies and the transaction autoamtions. Now with Policies v2, you can:

• Create policies per entire project, not only at the transaction level.
• Automatically provides sponsorship with stablecoins, no more checking prices of gas tokens, and other middleware in between.
• Introduced programmable wallet policies for backend wallets, giving developers fine-grained control over transaction permissions and spending limits

Read more here.

• Account responses now include custody details, providing clearer visibility into how each account's keys are managed

Documentation

• Added new webhooks documentation with detailed event descriptions
• Added backend wallet policies documentation
• Updated bundler and paymaster wording for clarity

Bundler & Paymaster

• Updated the ERC-4337 bundler for improved transaction processing
• Added EntryPoint v0.9 support for the bundler

• Fixed an issue where deleting users in the dashboard would throw an error
• Improved error handling when selecting API keys
• Fixed external links across the website that were causing unnecessary redirects
• Resolved a compatibility issue with the v0.9 paymaster

Passkey Support for React Native

• Added native passkey authentication to the React Native SDK
• Developers can now integrate WebAuthn passkeys directly in mobile applications, providing users with passwordless, biometric-secured login

RPC Bundler for External Accounts

• New API capability allows using the bundler with any EVM account, not just Openfort accounts
• Expands flexibility for developers integrating external account types

Documentation

• Added comprehensive Passkey authentication guide for React Native
• Added OpenSigner vs Openfort differentiation documentation to clarify product architecture
• Improved MCP (Model Context Protocol) documentation with correct URLs

SDK Updates

• openfort-node: Fixed EVM account methods for better compatibility
• openfort-react-native: Added passkey support with improved error handling
• openfort-js: Enhanced passkey error messages for better debugging

• Fixed account linking for anonymous users, ensuring proper session handling
• Fixed an issue where deleted anonymous user IDs could not be reused
• Improved sponsorship policy naming in dashboard for clarity

Gasless Solana Transactions

• Added support for gasless transactions on Solana network via new paymaster integration
• Solana users can now enjoy sponsored transactions similar to EVM chains

User Wallet Endpoint

• New API endpoint to retrieve wallet addresses associated with a user
• Simplifies wallet management and lookup for applications

User ID Support in Transaction Intents

• Transaction intents now support userId parameter for simplified wallet identification
• Developers can reference users directly without specifying wallet addresses

SDK Updates

• openfort-node: Updated to latest version with new user wallet methods
• openfort-csharp: Updated to latest version with SDK improvements
• openfort-swift: Updated to latest version with enhanced functionality
• openfort-js: Updated to latest version with improved user management

API Enhancements

• Added user ID parameter support across transaction intent endpoints
• Improved wallet address resolution from user identifiers

Documentation

• Added Solana gasless transaction documentation
• Updated migration guides for v1 to v2 API transition
• Improved paymaster configuration documentation for Solana

• Fixed authentication header handling in certain edge cases
• Fixed user deletion functionality in dashboard
• Fixed session creation issues for new accounts
• Improved error handling for wallet operations

OTP (One-Time Password) Authentication

• Added OTP-based authentication flow for Shield, providing an additional secure authentication method
• Dashboard now supports OTP Shield configuration for project setup
• Comprehensive OTP authentication documentation added

User Management Improvements

• New filtering options on the Users API endpoint (v2) for easier user management
• Dashboard now supports OAuth-based user filtering from configuration

Solana Support

• Added Solana fee sponsorship documentation and paymaster workflow guides
• Improved Solana paymaster documentation with clearer integration steps

ERC-7702 Paymaster Modes

• New ERC20 paymaster modes with multiple fee configurations:
  • Constant fee mode
  • Recipient mode
  • Pre-fund mode
  • Combined modes with various options

API & Security

• Improved API key security for backend wallet generation
• Fixed app origin validation for better security
• Anonymous users can now link social accounts to their profiles
• Anonymous email addresses are no longer exposed to clients

SDK Updates

• openfort-js: Updated to latest version with improved logout handling for React Native
• react-native SDK: Updated to latest version with SDK improvements
• Shield OTP sample integration added

Dashboard

• Improved error text overflow handling
• Standardized variable naming for Shield publishable keys

Documentation

• Added viem integration guide for backend wallets
• Added paymaster signature validity duration tip
• Standardized encryption session endpoint documentation
• Improved recipes documentation alignment with example files

• Fixed social account linking to anonymous users
• Fixed API key revocation functionality
• Fixed contacts check during OTP flow
• Improved error messages returned during OTP flow
• Fixed Shield OTP sample implementation
• Fixed error text overflow in React components

Features

• Two-Factor Authentication (2FA) Support
  • Added a new endpoint to enable 2FA in the Shield service and exposed the corresponding method in the Shield JS SDK . This update allows for enhanced security workflows directly from the client libraries.
• Third-Party Authentication in React Native
  • Introduced a thirdPartyAuth configuration parameter to the createOpenfortClient function in the React Native SDK. This allows developers to initialize the client with specific third-party authentication settings, addressing previous limitations where this configuration was missing .

Improvements

• API Client Synchronization
  • Updated the generated API clients across Openfort JS and Openfort Node to match the latest Swagger/OpenAPI definitions. This ensures the SDKs are fully aligned with the most recent backend API changes.
• Enhanced Validation & Error Handling
  • Improved session validation logic and error handling within the Openfort JS SDK to provide more robust authentication flows .
• Pregenerate V2
  • Refined the pregenerate functionality in the Node SDK to strictly operate through account endpoints, streamlining the account creation process .

Fixes

• React Native SDK Fixes
  • Fixed issues related to third-party authentication and updated internal SDK versioning to ensure compatibility .
• Initialization & Cleanup
  • Resolved an issue with Node.js SDK initialization .
  • Removed the deprecated list user accounts functionality from Openfort JS to clean up the API surface.

Features

• Solana (SVM) Support
  • React Native SDK: Added support for creating SVM accounts, significantly expanding blockchain compatibility for mobile applications .
  • React Native SDK: Enhanced the flow for SVM and email-based account creation to streamline user onboarding .
• Shield & Security
  • Shield Service: Added a new "resend provider" functionality, likely to support retrying or managing authentication provider messages .
  • React Native SDK: Integrated OTP Shield support, bolstering security for mobile authentication flows .
  • Shield JS SDK: Added a reference parameter to the getEncryptionMethodsByOwnerIdDetailed method, allowing for more precise queries when retrieving encryption details .
  • Shield API: Exposed a matching reference parameter in the /shares/encryption/user/bulk endpoint .
• Storage Isolation
  • Openfort JS: implemented "isolated storage by key," which improves how session data is managed and segregated on the client side .

Improvements

• Developer Experience
  • React Native SDK: Improved JSDoc documentation for better type hinting and developer guidance .
  • Openfort JS: Refined sample code to provide clearer usage examples for developers .

Fixes

• React Native SDK Fixes
  • Fixed the signout process to ensure sessions are cleared correctly .
  • Resolved issues with wallet types definitions .
  • Fixed EOA (Externally Owned Account) creation logic .
  • Corrected storage initialization and cleanup routines .
• Minting & Assets
  • Openfort JS: Fixed backend minting logic and smart contract calls for minting NFTs .
  • Openfort JS: Resolved issues with the wallet_getAssets method to ensure accurate asset reporting .
• General Fixes
  • Openfort JS: improved error propagation during the initialization phase .
  • Openfort Node: Fixed verification logic (likely related to webhooks or signatures) .
  • Shield: Fixed Docker image builds in the CI environment .

This week was focused on making Openfort more production-ready out of the box: better wallet UX, clearer asset visibility, faster transaction feedback, modular orchestration, and vendor-neutral key management.

Here’s everything we shipped:

Day 1 — Wallet widget becomes a money console

We upgraded the wallet widget from a passive balance viewer into an actionable surface where users can fund, send, and receive — all inside your app.

What’s new

• Send assets directly from the wallet modal
• Receive from external wallets in the same flow
• Deposit via on-ramp (Coinbase / Stripe)

**Read the article

Day 2 — Asset discovery powered by ERC-7811

We made it easier for apps and support teams to know what users actually own across chains, without stitching together indexers or custom token lists.

What’s new

• Ask the wallet directly for assets via wallet_getAssets
• Unified view of tokens + NFTs across supported chains
• Fewer mismatched balances and support tickets

View Docs

Day 3 — Faster RPCs with EIP-7966

We added support for a new RPC method that reduces transaction round-trips and simplifies production UX — no more custom polling loops.

What’s improved

• One call returns confirmed, pending, or error
• Lower latency for high-throughput apps
• Cleaner integration for wallets, games, agents & paymasters

Deep Dive

Day 4 — Orchestration platform

Originally an internal debugging dashboard, Orchestration is now a full control plane for signers, smart accounts, and contract-based execution.

What’s new

• Monitor and coordinate activity across any signer & contract
• Compatible with 7702-style delegator contracts
• Keep your stack modular and vendor-neutral

Learn How it Works

Day 5 — OpenSigner: open-source key management

We released OpenSigner — the key management layer powering Openfort — now open-source and self-hostable.

What’s new

• Create Ethereum & Solana wallets
• Sharded key storage: device / hot / cold
• Hosted or self-hosted with recovery flows built in

Check the site Check the repo

Extra — LLM leaderboard

Not a product release — but a useful benchmark for teams using AI to speed up Openfort integrations.

What it includes

• Side-by-side model comparisons (auth, wallets, hooks, actions)
• Practical scores based on real Openfort code
• Helps pick the fastest model for developer workflows

Check the results

This cycle was about making performance predictable, giving apps more flexible fee options, and carrying EIP-7702 all the way down the stack so you can keep EOAs while unlocking smart features when it actually matters. Think: fewer cold starts, fewer “which chain am I on?” moments, and more ways to sponsor UX without painting yourself into a corner.

Wallets

Published new performance benchmarks for Wallets v2. We’ve been stress-testing wallet creation, first action time, and batched operations across typical app paths (auth → wallet init → first write). The goal isn’t “synthetic wins” but predictable P95s you can design around. If you’re shipping high-volume onboarding, this helps you decide when to pre-warm, when to sponsor, and when to borrow smart features (via 7702) rather than deploy a contract per user. Benchmarks live in the docs with methodology and harness config so you can reproduce them in your CI.

New Paymaster v3 We've splitted the responsabilities with owner, manager and signer. This means better security and access control to the contract. We also upgraded the validation logic to enable bundler whitelist and incorporated ERC20 modes to enable project to monetize on fees as well.

Backend

Implemented EntryPoint v8 and added EIP-7702 support. We’ve aligned the service layer with the latest EntryPoint v8 semantics (cleaner validation, better gas accounting edge-cases), and wired 7702 so an EOA can “mount” smart capabilities for a scoped session—no contract deployment per user. That means your backend can enforce policy like: “batch at most N actions” or “sponsor if the basket includes only allow-listed contracts”.

Why this matters: You keep EOA compatibility (wallet portability, broad tool support) while getting 4337-like ergonomics only when the UX needs it—checkout, multi-step actions, or recoveries.

React SDK

Fixed chain-switching edge cases. A handful of apps hit “stuck between chains” after optimistic switches or custom connectors. We hardened the switch lifecycle (request → confirm → rehydrate state), so providers, caches, and UI all converge on the same network reliably. Result: fewer invisible mismatches where reads and writes disagree.

Improved passkey recovery flows. We tightened the prompts and recovery checks so users know exactly what’s happening, and apps can gate actions until recovery is finalized. You also get clearer error objects for analytics (“why did the user drop here?”) and better hooks for retry UX.

Monitoring & observability upgrades. We added structured events around init, chain switch, signer changes, and 7702 session lifecycles. Pipe them to your logger of choice; they’re cardinally safe (no secrets), so you can chart success/failure funnels without worrying about leakage.

Swift SDK

Exposed new methods + minor bug fixes. The iOS side now mirrors the React mental model more closely—cleaner init, explicit session management, and better error surfaces. If you’re building a cross-platform app, you can share flows and docs without “Swift-only oddities”.

Developer Experience

Expanded and refined documentation. We reorganized quickstarts and deep-dives so you can choose a path by job-to-be-done: “first write in 5 minutes”, “add gas sponsorship”, “ship recovery without seed phrases”. Fewer cross-tabs, more copy-paste blocks.

Introduced a one-click backend deployment flow. If “getting infra running” was your last blocker, this gives you a golden, reproducible stack (pinned Node/Go, CI templates, default policies) so you can test end-to-end without yak shaving. It’s opinionated, not restrictive—you can eject piece-by-piece later.

QoL across the toolchain. Tighter type surfaces, clearer error codes, smaller Docker images, and saner defaults. It’s the unglamorous stuff that makes week two (and week twenty) smoother than day one.

We spent this cycle on two themes: make EOAs feel smart (7702) and tighten every bolt in the toolchain so teams can scale safely without yak-shaving. Below is what changed, why we did it, and how it helps you ship faster.

Openfort JS SDK

Headline: 7702 lands. Tooling grows up. Tests stop flaking.

New

• 7702 authorization support (new component + deps). Why it matters: keep users as EOAs but “borrow” smart account powers—batching, sponsored gas, safer recovery—only when needed. No contract deployments per user; pay only when you use it.

Improvements

• Migrated to pnpm + Biome; a deep modularity refactor. Why: faster, deterministic installs; consistent formatting/linting; easier sub-package reuse.
• Raised Node.js engine & refreshed deps. Why: align with modern runtimes and security fixes.
• CI/CD hardened (least-privilege perms, node pinning, audit gates). Why: protect your supply chain and keep builds reproducible.

Fixes

• Patched a critical SSRF in the Coinbase onramp API path. Impact: closes a sneaky exfil path; thanks to everyone running bug bounties with us.
• Stabilized E2E by making UI selectors deterministic and tightening configs. Impact: fewer “works on my machine” moments.
• Fixed the external link in SignTypedDataButton.
• Trimmed redundant type checks; tuned static upload & Playwright steps. Impact: smaller builds, snappier CI.

Wallet Iframe

Headline: More predictable identity, safer creation path.

New

• Explicit UUID format functions. Why: predictable, testable identifiers across SDKs and services.

Improvements

• Creation flow now generates the signer UUID first and stores a share in Shield. Why: resilience—if anything fails later, recovery is straightforward and auditable.
• Streamlined npm auth/registry; dependency refresh; CI hardening & Node version control. Why: fewer publishing hiccups, repeatable builds.

Fixes

• Stopped deployment config from being tracked.
• Dockerfile fixes for slimmer, faster images.

Dashboard

Headline: Safer dependencies, stricter types, fewer foot-guns.

New

• CI workflow to audit dependencies (pnpm). Why: catch vulnerabilities before they catch you.

Improvements

• Adopted zod for runtime validation. Why: schema-first safety nets on inputs and API edges.
• Updated ABI types; bumped Node.js, pnpm, and openfort-node. Why: keep typegen and runtime in lock-step.

Fixes

• Correct OAuth embedded-wallet callback URL in ProviderForm.
• Added missing @radix-ui/react-slot so composition works as intended.

Backend APIs

Headline: Better observability and clearer errors for account lifecycles.

New

• Account-creation stats segmented by network type and account type (castle endpoints + buffers protobufs). Why: make growth and ops reviews data-driven.
• New error codes: “account already exists” and a generalized Castle error. Why: fewer mysteries, faster retries.

Improvements

• Validate existing accounts and standardize address storage. Why: no more drift between services.
• Upgraded Go base image; service version bumps (API, CastleV2, Runekeeper). Why: security and performance headroom.

Create-Openfort (CLI)

Headline: Cleaner scaffolds, honest telemetry, better DX.

New

• Opt-out telemetry (project name & template only) and a --version flag. Why: transparency and easier debugging.

Improvements

• Moved away from degit; improved logging, error handling, and cleanup. Why: fewer edge-case failures on cold networks.
• Stronger input validation & clearer wording. Why: smoother first-run experience.

Fixes

• Correct telemetry status reporting in the CLI.
• Fixed env var handling in build/publish. Impact: consistent CI across environments.

Quickstarts, SDK Init & Guides (Docs/Examples)

Headline: Shorter time-to-first-success.

• New UI quickstart; all quickstarts are now standalone. Why: copy → paste → run, without hunting cross-links.
• Reworked SDK initialization flow with better debug logging. Why: see what’s wired where when it misbehaves.
• React Native auth guides aligned with React. Why: one mental model across platforms.
• Added Firebase integration example. Why: bring your own auth without ceremony.
• Style/ORM naming cleanups; removed obsolete doc workflows. Why: less noise, more signal.

Authentication & Wallets

• Added OTP error handling for Shield-JS (2FA support)
• Apple OAuth now supported
• Improved email login flow with new UI components

React & React Native SDKs

• New React guides: wallet actions, passkey, password recovery
• Improved React Native docs for auth & wallet management
• Standardized docs and TSDoc comments across hooks/components
• Updated React SDK to v0.0.13 with improved UI (modal, connector list, logos)

Theme Builder & Dashboard

• Search bar added to theme builder
• Support for custom auth providers & recovery methods in theme export
• Updated dashboard navigation & links (sponsor policies, provider settings)
• Standardized capitalization for “Wallet Actions”

Documentation & Examples

• Rebuilt quickstart examples with better structure and commands
• Added direct GitHub links to recipe hub references
• Updated ERC-20 examples with testnet disclaimers
• Lots of link fixes, typo corrections, and content rephrasing

Infra & Services

• Bumped iframe service (v0.4.29), walletiframe (v0.4.29), Shield (v0.2.22)
• Improved Opensigner docs, config, and README (with new banner)
• Added GitHub Actions workflow for dependency review

Bug fixes

• Fixed broken links in docs and embedded wallet guides
• Fixed outdated wallet recovery & OAuth hook docs
• Resolved React build issues in OpenfortProvider
• Corrected localization strings and README image paths

We’re excited to introduce Recipes – a curated collection of ready-to-use repositories that come with embedded wallets powered by Openfort and extra functionality for the workflows you care about.

Our first set of Recipes includes examples for:

• Yield with Aave
• Yield with Morpho
• Stablecoin transfers
• Hyperliquid integration

Whether you’re building DeFi apps, stablecoin flows, or trading experiences, Recipes help you move faster by giving you working code out of the box.

Stay tune for new recipes coming soon!

We've enabled a third method to recover your wallet with Openfort. Now apart from automatic recovery and password recovery you can also recover using Passkeys. Secure and with less dependencies.

Minor

• Improve the documentation on Swift and React Native
• Updates on onbaording flows
• Updates on dashboard for better error handling and account information

• Add support for create and recover embedded signer for multiple accounts
• Fix personal_sign for smart account
• Fix timeout with iframe when doing getEthereumProvider
• Support signature verifications for un-deployed accounts
• Fix third party auth logout

• Rebuild documentation with built-in samples and interactions
• Faster navigation across sdks (React, React Native, etc.) and product lines: Now embedded wallets and global wallets

Dashboard

• v2 deployed with better navigation and setups
• Added global search bar
• Added better transaction lifecyle
• Sped up page loads by 2-3x
• Lots of random bugs fixed (10+)

Transaction management

• Moved our stack to eRPC and load balancing system across bundlers and RPCs
• Coupled with Rindexer and our legacy indexing as a fallback

iframe

• Deployed our v2 that solved issue with network and key regeneration
• Added cross-origin security and other security related improvements
• Lots of random bugs fixed

We've been now working for more than 6 months on building a top-tier wallet infrastructure for people to launch wallets without burden. Our next step has been to open up the infrastructure to key partners in the space, like Safe accounts and passkeys with Rhinestone and bring new functionality to our community.

→ Check our demo

Other updates

1. We've improved the onboarding experience on the dashboard, so now you can create an app with the CLI directly.
2. Improved the transaction status response to incorporate further information on the transaction lifecycle.

Today, we're excited to announce that Openfort supports EIP7702 across the infrastructure. The EIP 7702 allows you to create Smart EOAs and simplify the way you create and manage embedded wallets.

→ Check our demo to see the capabilities of the account delegated. Powered by Openfort.

If you want to learn more about the Openfort delegator check the following blog post.

NEW: CLI tool to ship your React app with Openfort Kit

We’ve made it even easier for developers to integrate Openfort Kit into their React apps. With a single command, you can now spin up a project with all the embedded wallet capabilities pre-configured:

That’s it—your app is ready to go!

UPDATE: Apple authentication is now available for embedded wallets

You can now enable Sign in with Apple for embedded wallets on both React Native and web. This makes onboarding seamless for iOS users. Up next, we’re adding support for ecosystem wallets!

Check the documentation

UPDATE: Easier authentication provider migration

Migrating from another authentication provider? We've built a no-hassle migration tool that lets you import user data from third-party solutions—either gradually or all at once.

Start migrating today!

Stay tuned—more updates coming soon!

We have added Sentry to the Openfort Client Libraries for better error monitoring.

Social account improvements:

• Line: now returns the account email link to Line.
• X: now returns the account email link to X.
• Apple: authenticateWithThirdParty issue in React Native is now resolved.
• Android: configureEmbeddedSigner issue in React Native is now resolved.

We fix the Reset Password deeplink when user logs in with email in React Native.

We have enabled email/password authenticaton to the Ecosystem SDK as a new method to onboard users.

Day 1: Ecosystem v3 - New UI Without Popup Windows

We're excited to introduce Ecosystem v3, featuring a completely redesigned UI that eliminates the need for popup windows, creating a more seamless user experience.

What's new?

• Integrated iframe-based interactions replace disruptive popup windows
• Smoother wallet connection flow with fewer interruptions
• Enhanced user experience with simplified navigation and interface

→ Start building today!

Day 2: Connecting Games to Wallets with Open Communication Protocol

We've implemented Mobile Wallet Protocol (MWP) in Unity, bridging the gap between games and wallets with a secure, standardized communication system.

Key highlights:

• Secure encrypted communication between games and wallet applications
• Seamless wallet connectivity for Unity game developers
• Standardized protocol ensuring compatibility across platforms

→ Check the docs

Day 3: Smaller JS Packages and Multi-Wallet Per User

We've optimized our JavaScript packages and introduced multi-wallet support to enhance developer flexibility and user experience.

What does this mean for you?

• Reduced package sizes for faster load times and better performance
• Support for multiple wallets per user, enabling specialized wallet usage
• Streamlined integration process with lighter dependencies

→ Read the update

Day 4: New Updates on Chain Abstraction Architecture

We've made significant advancements in our Chain Abstraction architecture, bringing true cross-chain functionality closer to reality.

Major improvements:

• Implemented double-spend controls
• Added fault-proof fallback system with Hashi
• Updated to Polymer V2

→ Check the latest upgrades

Day 5: Openfort Launches Solana Support

Today, we're thrilled to announce the launch of Openfort for Solana, expanding our wallet infrastructure beyond EVM chains to one of the fastest growing blockchain ecosystems.

What's included in this initial launch:

• Seamless non-custodial Solana wallet creation for your users
• Simplified transaction and message signing capabilities
• Developer-friendly APIs requiring minimal code for integration

→ Check the sample

Today, we're excited to announce Openfort kit. It's a new way to build beautiful, responsive, and cross-platform wallets using React.

→ Start building today!

The gates are open to everyone!

We've removed the waitlist process for developers. The team has worked relentlessly to launch the public version of Openfort. Start using the wallet capabilities in your project, no cap.

[BETA] Launching Mobile Wallet Protocol (MWP) in Unity

Mobile Wallet Protocol (MWP) is an open-source communication protocol from Coinbase that helps wallets communicate securly with apps. At Openfort we've been working to bring this standard to other verticals like gaming and we're soft launching the beta version to help game developers leverage ecosystem wallets in Unity.

How to make guest onboarding with Unity

We are committed to the best developer experience and continue to iterate so we can constantly improve. Here's a guide at how to build a guest login for your Unity game in under 10 minutes.

→ Start building

We're excited to announce several major improvements to our platform, including expanded website coverage, enhanced documentation, and new wallet features. Here's what's new:

Dashboard Enhancements

We've resolved several critical dashboard issues to improve your development experience:

• Enhanced email configuration system to ensure reliable communication
• Fixed webhook testing functionality for better API integration testing

Wallet Updates

Embedded Wallet

The embedded wallet now features network switching capabilities, giving users more flexibility in managing their blockchain interactions.

Ecosystem Wallet

We've introduced a more accessible authentication system with:

• Email and password login support
• Improved user experience for wallet management

Network Expansions

We're thrilled to announce our deployment on two new networks:

• XAI Network: Expanding our presence in the gaming and AI blockchain space
• B3se: Adding support for this emerging blockchain platform

Day 1: Ecosystem customization tool

We’re thrilled to introduce a brand-new dashboard designed to simplify the management and configuration of Ecosystem Wallets.

What’s new?

• Customize your wallet SDK with themes tailored to your project’s branding.
• Streamline wallet creation and management directly from an intuitive interface.

This update puts even more control in your hands, enabling a seamless setup process.

Day 2: Ecosystem SDK Goes Permissionless

The Ecosystem SDK has been rebuilt to be entirely permissionless, empowering developers like never before.

What does this mean for you?

• Deploy your ecosystem wallet independently—no need for a client API to get started.
• Faster, easier integration to accelerate your development workflow.

We’re excited to see how this change unlocks new possibilities for your projects!

Day 3: Unity SDK with Ecosystem Wallet Compatibility

Game developers, this one’s for you! We’ve launched a new Unity SDK that seamlessly integrates Ecosystem Wallet capabilities into your favorite games.

Key highlights:

• Bring the power of ecosystem wallets to Unity with minimal setup.
• Enable a next-level gaming experience for your players.

Start building immersive, Web3-powered games today with our Unity SDK!

Day 4: Guest mode and new Ecosystem demo

We've introduced guest login method on our JS SDK. This means faster onboarding with the possibility to later on register yoru users and link their wallet. Fasterr onbaording means faster ways to get to the 'aha' moment.

We've also improved and revamped the Ecosystem demo. Check it out.

Day 5: First Chain Abstraction Demo with Proofs on Optimistic Chains

We’re proud to announce our first chain abstraction demo, showcasing proofs on optimistic chains.

Why it matters:

• A significant step towards a chain-abstracted future, enabling multichain transaction functionality.
• Simplified with a wrap API call for easy integration into your applications.

This breakthrough will allow you to offer multichain support effortlessly and bring Web3 one step closer to seamless interoperability.

These updates are designed to make building on Openfort faster, easier, and more powerful than ever before. As always, your feedback is invaluable—don’t hesitate to share your thoughts or reach out with questions. Happy building! 🚀

You can now configure Trusted Forwarder Contracts directly in the Openfort Dashboard, enabling a customizable backend wallet setup for gasless transactions.

Why this matters:

• Provides developers the flexibility to integrate their own gasless transaction infrastructure.
• Supports a broader range of use cases for wallet customization and optimization.

New demo app with Rapidfire Ecosystem

We’ve replaced the old demo game on the Openfort homepage with a fresh example that highlights the full potential of Ecosystem Wallets.

Explore how ecosystem wallets can enhance user experiences in your project through the Giftquest platfrom.

We’re excited to announce improvements to the onboarding experience for embedded wallets and ecosystem wallets! You can now choose between these two options directly within the dashboard, making it easier to tailor Openfort to your specific project needs.

What’s new?

• A simplified onboarding wizard guides you step-by-step, helping you set up your wallet type seamlessly.
• Enhanced tutorials provide in-depth guidance to get started quickly, regardless of your wallet architecture preference.

Session Key Support for zkSync Smart Accounts

We’re introducing Session Keys for zkSync smart accounts, unlocking a more secure and flexible way to manage short-lived keys for specific operations.

What are Session Keys?

• Temporary keys that allow fine-grained access to certain smart contract functions without exposing your main account keys.
• Ideal for time-limited tasks, enhancing both security and usability.

We've enabled wildcard policies that allow you to sponsor any interactions with any smart contracts within a policy and without registering them previously

We've added more capabilities into Openfort JS that showcases:

• Walletconnect support to connect your embedded wallet outside the app itself.
• Onramp support to enable your users to onramp funds with Moonpay, Coinbase Onramp or via external wallets.

We've built a lot in the dashboard too to make it feel more intuitive and snappier:

• Better gas policy configuration.
• More details on the transaction page.
• Added event configuration page.

Ecosystem Wallet Sample

One month ago we’ve introduced the Ecosystem Wallet sample to help you easily explore our product. The Ecosystem Wallet serves as a framework for managing permissions on the web, moving away from traditional wallet app permissions. Check our ecosystem wallet sample to explore.

Seamless login with Telegram

Check out our guide on building a mini-app on Telegram using Openfort.

Unreal Engine

• Added support for third-party authentication providers.
• Updated the Unreal Engine SDK for compatibility with version 5.4.

EIP7702

We launched a proof of concept of an EIP-7702 wallet utilizing ERC-4337 smart accounts. See the demo here

Dashboard improvements

• Added new login providers
• Added more transaction details
• Fixed bug with the gas balance display
• Fixed bugs with the ecosystem settings

New chains

• Added suport for opBNB
• Added suport for Tiktrix
• Added support for Soneium
• Added support for DOS Chain

Great news this week! It looks like we've made significant improvements to your authentication options and documentation structure.

1. New Authentication Methods: Telegram & Line.

2. Updated Documentation Structure. Resources are now split into three main categories: React Embedded wallets, JS Embedded Wallets & Global Wallets.

We've updated the UE5 SDK now to accomodate native onbaording with our auth systems, session keys and onchain actions. Get started with the UE5 SDK and blueprints here.

We've also started to rollout our ZKsycn support with selected partners. Feel free to connect with us if you want to use it in your project.

Introducing Identity Linking: You can now connect email, Oauth providers and wallets under one single user identity. Link your user's identity here

We've also spent part of this August incresing the throughput of the overall system to accomodate our enterprise partners. Now with our new architecture we've make it 3x faster to send transactions onchain with average time of ~3sec. The efforts include: further load balancing mechanisms, circuit breakers, new indexer and database migration.

We're happy to announce that we've audited our SSS library in Go and publish the report for more people in the space to use and contribute.

You can see the full announcement here.

Migrated codebase to Viem you can now use Viem or Ethers direcly too. New guides on how to use web3 library connectors.

This past couple of weeks at Openfort we've been working on improving the infrastructure speed

• New: Export Private Key.
• New: Ecosystem SDK sample.
• New Sample: Now featuring Wagmi sample.

Improvements

• Stability improvements for openfort JS.
• Improved edge cases for embedded wallets on JS where user could not logged in after logging out.
• Fixed a bug that was clocking the CPU

The emergence of new chains also means games are being onboarded into different ecosystems and environments.

New Features

1. Cross-Chain Game Management

   • Unified infrastructure for managing games across multiple blockchains
   • Support any new EVM rollup you request
   • Embedded gaming wallet functionality

2. Ecosystem Policies

   • Centralized policy management (e.g., gas limits) applicable across all games in an ecosystem

3. White-Label Dashboard

   • Customizable interface for ecosystem administration
   • Project-specific views for individual game developers and ecosystem managers

4. Authentication System

   • Customizable authentication clients
   • Single Sign-On (SSO) support for consistent wallet experience across ecosystem
   • Enhanced security through abstracted private key handling

Technical Improvements

• API extensions for ecosystem-wide operations
• Enhanced SDK support for multi-game environments
• Improved data aggregation for cross-game analytics

Developer Tools

• New documentation for Ecosystems integration
• Updated SDKs with ecosystem management capabilities

Compatibility

• Backward compatible with existing Openfort integrations
• New endpoints added for ecosystem-specific operations

For detailed API changes and integration guidelines, please refer to the full documentation

This update includes several improvements and new features:

Enhanced Authentication

• Added new login methods: Discord and Epic Games.
• Ability to create server session keys and store them in your gaming backend to make automatic actions.

Documentation Improvements

• Restructured documentation into two main sections:
  • Identity: Covers authentication and embedded signer.
  • Cloud: Focuses on onchain actions.

Unity SDK Updates

• Refactored Unity SDK with:
  • Improved support for WebGL.
  • Improved native flows for authentication.

Improvements in Openfort Auth

• New password recovery setup.
• New Social Logins: Fascebook and X(Twitter) -If you need new ones let us know!.
• Added PKCE login for Android, iOS and macOS clients.

Improvements on the Openfort-JS

• Added signTypedData.
• Fixed Openfort URI and constructor when inid library.
• Export 1669 provider.

• Improved the perfomance of our network of RPCs. Incorporated circuit breaker and load balancer that helped us decrease redundancy issues and throughput across the transaction cloud.
• We've added orderbook support to instantly list any asset across Seaport protocol based marketplaces. Starting with Beam subnet support with more coming soon
• Added support for loading the library as a JS script
• 74% size reduction for openfort-js SDK
• Token Swap Module added support for Degen chainx

• Pre-generate embedded wallets associated with a given account, like an email address, without requiring the user to login, all from the backend.

Updated NodeJS and C# SDKs available.

• We've deployed the improvement around webhooks. You can now subscribe to receive webhook notifications on successful, failed, cancelled and broadcasted transactions.

• Improved iframe communication and new endpoints to sign types of transaction from Shield.

Announcing two new endpointto exhange tokens:

• /v1/exchange endpoint, designed to facilitate faster and more efficient token swaps on our decentralized exchange (DEX). This feature allows you to initiate token swaps directly, ensuring that your transactions are executed with optimal speed and precision.
• /v1/exchange/quote endpoint, which provides real-time quotations for token swaps. This allows developers to fetch potential swap details, including fees and slippage, before executing the transaction.

Check the exchange endpoint in the API reference docs.

Also, we're happy to share that Openfort is now Paymaster agnostic. This means you can define custom logic to select the paymaster (if any) to use with the accounts you control. This allows you to use your own paymaster or even use multiple paymasters in different scenarios.

Creating a self-custodial wallet is one of the key onboarding flows. Shield brings a powerful new way to manage the recovery key. This highly requested feature allows the most advance games to self-host the Shield server themselves in order to add further resilinece in their system. With shield you can:

• Onboard user's by automatically encrypting the recovery share.
• Onbaord users and ask them to provide a passcode to encrypt the share.

Shield is an open-source key management solution that together with our SSS Library allows us safely and transaprently manage the user's wallets. It's the main reason why Openfort has less vendor lock-in than other wallet infrastructure solutions.

Openfort Identity is built on a novel combined architecture of smart wallet technology and a secure enclave signing service.

By design our solution is fully equipped with:

• OpenID Connect and OAuth2 support, designed in a non-custodial framework, making it simple to connect any OAuth2 provider for seamless wallet access.
• Custom auth support, so you can use your preferred auth and gaming baxkend solution.
• Built with verifiable and opensource server called Shield.
• Ability to self-host the Shield and the iframe.

→ Try on Unity. → Try on browser.

Read the full announcement blog.

You can now integrate in-app purchases safeliy in your web3 game and start monetizing players regularly (all within the compliance boundaries o Apple and Google).

Here is how we're using in-app purchases in our sample:

• Buy soft-currencies (not crypto).
• Buy NFTs directly with IAP or your soft-currency.
• Sell NFTs for your game token (hard currency).

Read more about IAP in web3.

After deploying one of the first versions of smart accounts compliant with the ERC4337. We've finally pushed the envolope in auditing it with CertiK. Both the Smart contract accounts as well as the Paymasters were part of the scope.

We take security of our contracts very seriously and we constantly thinking ways to better explain the thread model and security decision we take internally. To read more about the security at Openfort you can find go to the documentation.

You can read the audit here.

Use backend wallets as you develop your game in order to scale and customize any onchain interaction between the players and your game.

For example:

• Send NFTs to users purchasing a pre-minted NFT instead of minting directly from the smart contract.
• Airdrop users tokens.
• Escrow user's assets until the outcome is decided (i.e. competition)

Backend wallets can be configured to either use relayers in order to execute transactions or simply with the wallets native network token. his feature allows your app to sponsor gas for your users to transfer NFTs, list items on marketplaces, and more.

Today's fragmented solutions and their gaps—in the areas of throughput, nonce management, reorg detection, transaction retries, and more—force developers to DIY their own transaction, wallet, key, and gas management infrastructure.

Our Transaction Cloud addresses all of the challenges above and more. It abstracts the complexities of writing to blockchains through simple HTTP REST APIs—enabling developers to manage the entire transaction lifecycle with unprecedented ease and scale.

- High-Performance REST APIs: Achieve thousands of requests per second with simple HTTP APIs that eliminate the need for private keys, wallets, or gas management. Integrate transactions effortlessly with one line of code, ensuring scalability and reliability.

- Nonce Management and Idempotency: Automatically ensure transactions are unique and executed in order, preventing double spends and saving engineering time.

- Dropped/Reorg Detection and Auto-Resubmission: Our system automatically retries transactions in case of failures, reducing the need for manual monitoring and enhancing product reliability.

- Horizontally-Scalable Transaction Wallets: Utilize auto-scaling wallets for fast, consistent performance under any load, supporting your growth without architectural changes.

- Auto-Managed Gas with USD Billing: We handle all aspects of gas management, including fluctuations and accounting, allowing you to focus on core operations.

- Real-Time Transaction Lifecycle Management: Get instant updates on transaction statuses from initiation to confirmation, with alerts for any anomalies.

Cross-Chain Signing and Attestations: Facilitate secure interactions across different blockchains with EIP-712 signing and signature-based updates and attestations, reducing complexity and enhancing security.

Gas policies allow you to customize the user experience in your application. The combination of gas policies and rules lets you set control on transactions you want to sponsor and transactions you want the user to charge with.

You can now select policy strategies:

• Sponsor transactions by paying the gas on behalf of the user.
• Let users pay with the in-game token (ERC20) with a dynamic rate (live quote of the token).
• Let users pay with the in-game token (ERC20) with a fixed rate.

Also, you could define policy rules:

• Sponsor interactions with smart contracts.
• Sponsor interactions with the smart account.
• Limit the amount of gas or number of transactions over an interval.

Above and beyond

• When using the Openfort policies, you will now receive email alerts automatically when you are close to hitting your sponsorship limits. Never see unexpected failed sponsorship again.
• You can now buy gas credits directly in your dashboard to increase your sponsorship limits in seconds with a credit card - no need to manage native tokens and no limits on sponsorship!