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 teh Ecosystem demo with Rapidfire sample. 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 the 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 Rapid Fire ecosystem (TM).

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 security page.

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!