We're excited to announce a major upgrade to **Global Wallets**: built-in funding capabilities. This makes it simpler than ever to add onramps to your apps, letting users fund their wallets directly — whether from another wallet or straight from fiat.  

With this update, anyone using Global Wallets via the **Ecosystem SDK** can set up funding flows with just a single RPC method. No more piecing together third-party integrations or handling complex state yourself.  

![funding_example.svg](https://strapi-oube.onrender.com/uploads/funding_example_caf6e59a8f.svg)

Today, we're rolling out:  
- **Wallet-to-wallet funding** for seamless transfers  
- **Fiat-to-crypto onramps** built right in  

These features are designed to reduce friction in your user onboarding, so your app can go from zero to funded in minutes. We've built this on top of our existing wallet infrastructure, ensuring it's secure, scalable, and developer-friendly.  

If you'd like early access or want to beta test these funding flows, sign up [here](https://dashboard.openfort.io/auth/login).

This is the first step toward making Global Wallets a complete end-to-end solution for on-chain interactions. Soon, you'll be able to trace funding events, analyze transaction performance, and troubleshoot issues all within Openfort.  

## Wallet-to-Wallet Funding  
Transferring funds between wallets has always been a core part of crypto, but integrating it smoothly into your app often meant custom code and error-prone handling. Now, with Global Wallets, you can enable **wallet-to-wallet funding** with one straightforward RPC call.  

This lets users:  
- Send assets from an external wallet to their Global Wallet  
- Handle confirmations and updates automatically  
- Get real-time status notifications  


The SDK manages the transaction lifecycle, including gas estimation and retries, so you can focus on your app's UX instead of blockchain plumbing.  

## Built-in Fiat-to-Crypto Onramps  
Bringing new users into crypto means making fiat entry points as easy as possible. We've embedded **fiat-to-crypto onramps** directly into Global Wallets, powered by trusted providers under the hood.  

Users can:  
- Fund their wallet using credit cards, bank transfers, or other fiat methods  
- Convert to crypto in a single flow  
- See funds reflected instantly in their Global Wallet balance  

No need to redirect to external sites or manage KYC yourself — it's all handled via the same RPC method.  


This integrates seamlessly with your app's flow, whether you're building a mobile dapp, game, or DeFi tool. We've also added support for multiple currencies and tokens to keep things flexible.  


## TL;DR  
The new funding capabilities in **Openfort Global Wallets** bring:  
- 🚀 **Wallet-to-wallet transfers** via a single RPC  
- 💳 **Fiat-to-crypto onramps** built-in  
- 🔧 Easy setup through the Ecosystem SDK  

This makes it simpler than ever to add onramps to your apps, letting users fund their wallets directly — whether from another wallet or straight from fiat.  

Funding.svg

Introducing Funding in Global Wallets

We’ve just released the **Openfort Swift SDK**, bringing seamless wallet integration and account abstraction **natively** to iOS. You 

With this update, you can:

- ✅ Manage **multiple accounts** effortlessly  
- ✅ Use **developer‑friendly Swift APIs** to interact with wallets  
- ✅ Integrate **native Apple and Google authentication flows**  
- ✅ Build faster with a ready‑to‑run sample app  

This launch is part of our mission to make **Openfort a first‑class citizen on every platform**. Now, iOS developers get the same high‑level features as our web and React Native SDKs — but written for Swift.

- [Documentation](https://www.openfort.io/docs/products/embedded-wallet/swift)
- [Sample](https://github.com/openfort-xyz/swift-example)

![swift_example.svg](https://strapi-oube.onrender.com/uploads/swift_example_850008c342.svg)


## Multi‑Account Support  
Managing more than one wallet in a mobile app used to be tedious — juggling state, switching active accounts, and updating UI.  
The Swift SDK now ships with **multi‑account support built‑in**.

Your users can:  
- Connect multiple wallets to their profile  
- Switch between them instantly  
- Have session state fully persisted

The SDK takes care of persistence, so you can focus on building features, not state management.

## Swift‑First Wallet APIs  
We’ve mirrored the philosophy of our web and React Native hooks, but designed for Swift.  

The APIs handle:  
- Connecting and disconnecting  
- Retrieving wallet metadata  
- Executing transactions  
- Handling errors gracefully

All type‑safe, leveraging Swift’s strong typing to prevent runtime issues.

## Native Apple & Google Auth  
Authentication flows are fully **native** — no webviews or redirects.  

- **Apple Sign‑In** is deeply integrated with the SDK for smooth onboarding on iOS.  
- **Google Sign‑In** works natively on iOS with a guided setup.

This gives you:  
- Instant, familiar login for users  
- A shorter path from auth → wallet actions  
- Fewer platform edge cases to debug


## Example iOS App You Can Run Today  
We’ve published a sample project to get you going immediately.  
It demonstrates:  
- Setting up the SDK in a Swift project  
- Connecting multiple wallets  
- Integrating Apple / Google auth  
- Switching active accounts  

📂 [Openfort Swift Auth Sample](https://github.com/openfort-xyz/swift-example)


### TL;DR  
**Openfort Swift SDK** gives you:  
- 🚀 Multi‑account wallet management  
- 🔗 Native Swift APIs for wallet actions  
- 🍏 / 🤖 Native auth flows (Apple + Google)  
- 📦 Example iOS app to start building today


We’ve just released the Openfort Swift SDK, bringing seamless wallet integration and account abstraction natively to iOS.

swift_sdk.svg

Introducing Swift SDK

We’ve just released the **Openfort React Native SDK**, making it easier than ever to integrate wallet functionality and account abstraction into your mobile apps — all with a smooth native experience on both iOS and Android.

With this update, you'll be able to:  

- ✅ Manage **multiple accounts** in the same app  
- ✅ Use **react-native-ready hooks** to interact with wallets  
- ✅ Enable **native Apple and Google authentication flows**  
- ✅ Build faster with examples and a starter repo ready to clone  

This release is part of our ongoing mission to make **Openfort work seamlessly on every platform** — and mobile is a big part of that.  

- [Documentation](https://www.openfort.io/docs/products/embedded-wallet/react-native)
- [Sample](https://github.com/openfort-xyz/react-native-auth-sample)

## Multi‑Account Support  
In the past, working with more than one wallet per user required a lot of manual state handling. The new SDK ships with **multi‑account support** out of the box.  
This means your users can:  

- Connect multiple wallets  
- Easily switch between them  
- Keep everything in sync across sessions  

Behind the scenes, the SDK manages the account list and session state for you — no custom Redux boilerplate required.


## Wallet Hooks for React Native  
We’re bringing over all the best hooks you’ve come to love from our web SDK, now optimized for React Native.  

For example:  

```ts
const { connectWallet, disconnectWallet, wallets } = useWallet();
```

These hooks handle:  

- Connection  
- Disconnection  
- Retrieval of wallet metadata  
- Transaction execution  

They’re fully typed with TypeScript, so you'll get completion hints and error checking as you build.

## Native Apple & Google Auth  
Authentication on mobile should *feel* native — so instead of browser redirects and awkward webviews, the SDK integrates directly with **Apple Sign‑In** (iOS) and **Google One Tap** (Android & iOS).  

That means:  

- Faster login times  
- Better UX for your users  
- Fewer auth edge cases to handle  

And because auth is deeply integrated with Openfort’s session system, you can go straight from sign‑in to wallet actions without extra round trips.


## Example App You Can Clone  
To get you started quickly, we’ve published a complete example:  

[Openfort React Native Auth Sample](https://github.com/openfort-xyz/react-native-auth-sample)  

It covers:  

- Setting up the SDK  
- Handling wallet connections  
- Implementing Apple / Google native auth  
- Switching between accounts  

Just clone it, install dependencies, and run it on your simulator or device.

## Next Steps  
You can check out the full documentation here: **[openfort.io/docs](https://openfort.io/docs)**

We see this release as the foundation for **mobile-first account abstraction**. We're already working on:  

- In-app transaction signing flows  
- Offline session support  
- Deeper React Native hook integration  


We’ve just released the Openfort React Native SDK, making it easier than ever to integrate wallet functionality

reactnative_sdk.svg

Introducing React Native SDK

Today, we're releasing **Multi Accounts**, a new capability that lets your users create and manage **multiple wallets under the same identity**.
These accounts can live on the same chain or across different chains, giving end users and developers more flexibility in how they organize and interact with on-chain assets.

This feature was one of the most requested by our community, and it’s now built directly into the **Openfort React SDK** — no extra setup required.

## Why Multi Accounts

In many applications, a single wallet per user can be limiting. Different contexts call for different accounts:

* **Separation of purposes** — for example, a *savings account* for long-term holdings and a *personal account* for day-to-day transactions.
* **Specialized trading strategies** — such as running independent buy and sell operations without risk of cross-contamination.

By enabling multiple accounts under the same identity, developers can offer cleaner user experiences, keep activities organized, and help users manage risk more effectively.

## How it Works

Multi Accounts is supported natively in the React SDK. Creating and switching between accounts is straightforward:

```javascript
// Create a new account for the active user
createAccount();

// Switch the active account in your session
setActiveAccount(accountId);
```

The SDK handles the underlying state, ensuring that each account maintains its own transaction history, balances, and chain context.

## Updated Documentation

We’ve fully updated our documentation with guidance, examples, and integration patterns for Multi Accounts.
You’ll find sections on:

* Creating accounts programmatically
* Switching active accounts in the UI
* Persisting and restoring account sessions
* Multi-chain account management best practices

These accounts can live on the same chain or across different chains, giving end users and developers more flexibility in how they organize and interact with on-chain assets.

multi-accounts.svg

Introducing Multi Accounts Support

Today, we're releasing the Openfort React SDK, which provides tools for managing authentication UI elements from the Openfort kit, along with React hooks and TypeScript types for embedded wallets.

This SDK is designed for React applications that need to handle user authentication and wallet interactions. **It includes optional UI components, but can also be used in a headless mode without them.** Additionally, it comes with [Playground](https://playground.openfort.io), a development toolkit that offers suggestions for methods, status updates, and response previews in a single interface.

- [Open-source React SDK](https://github.com/openfort-xyz/openfort-react)
- [Documentation](https://www.openfort.io/docs/products/embedded-wallet/react)
- [Sample](https://github.com/openfort-xyz/create-openfort)

## Openfort in React Applications
Openfort provides building blocks for authentication and embedded wallets. The core kit handles user sessions, logins, and wallet integrations with blockchain networks.

With React being a common choice for frontend development, we've created this SDK to better support it. It includes UI components for elements like login forms and wallet connectors, which can be customized or omitted entirely for a headless setup. This flexibility allows developers to choose between pre-built UI or fully custom implementations.

The SDK also introduces React hooks, such as useWallet, useAuthSession, and useTransaction, for managing state, errors, and updates. These are typed with TypeScript to help catch issues early. For embedded wallets, the hooks simplify tasks like initialization, funding, and interactions, while following security practices.

Overall, this can lead to cleaner code and more efficient development in React environments.

## Limitations of Traditional Approaches
Integrating authentication and wallets in React has often involved combining various libraries, handling state manually (e.g., with Redux), or working with untyped APIs that risk errors at runtime. This can create inconsistencies and potential security issues, especially for sensitive tasks like wallet operations.

Embedded wallets require precise handling to protect private keys and session data. Without tailored tools, developers might build custom solutions, which can vary across projects.

The React SDK offers a consistent layer over the Openfort kit, aligned with React conventions like hooks and context. It supports async operations and includes testing features like mocking.

Compared to our existing JavaScript SDK, this version is optimized for React: it leverages hooks for better state management, provides TypeScript types for improved reliability, and integrates more naturally with React's ecosystem. The JavaScript SDK remains a solid general-purpose option, but the React SDK reduces boilerplate and enhances usability for React-specific workflows. It builds on lessons from tools like React Query and Wagmi, adapted for Openfort.

### Start Using the React SDK Today  
The Openfort React SDK is available now as a public package. You can install it via npm or yarn and start integrating it into your projects immediately. No major overhauls required – it's designed to complement your existing Openfort setup.  

We've made the onboarding process straightforward and reversible, so you can experiment without risking your current workflows. 

 Add it to your project with a simple command:  
 
   ```bash  
   npm install @openfort/react  
   ```

This pulls in all the necessary dependencies, including UI components and hooks. These hooks include TypeScript types for props and returns, making your code more predictable.  

## Exploring with Playground

![react-playground.svg](https://blog-cms.openfort.io/uploads/react_playground_d23ceb036d.svg)

Playground is a toolkit for working with the React SDK and Openfort APIs. It provides an interface for method suggestions (e.g., recommending useTransaction after wallet connection), real-time status, and response views.

Accessible from the Openfort dashboard, it supports component previews and is useful for prototyping or troubleshooting. It's based on community feedback and can be used independently of the SDK.

## Maximizing the SDK's Value
The React SDK helps create more maintainable code by reducing custom implementations and improving integration. It's compatible with other Web3 libraries and frameworks like Next.js.

For those using the JavaScript SDK, transitioning to the React version can simplify wallet management through hooks, especially in React apps. We plan to add features like UI theming and more specialized hooks based on ongoing feedback. Explore the documentation for detailed examples.

This new SDK brings seamless integration with Openfort Kit (authentication UI elements), along with dedicated React hooks and TypeScript types for handling embedded wallets.

Introducing Funding in Global Wallets

Introducing Funding in Global Wallets

Introducing Swift SDK

Introducing React Native SDK

Introducing Multi Accounts Support

Introducing React SDK

Product

Industries

Resources

Company

Openfort blog

Introducing Funding in Global Wallets

Introducing Funding in Global Wallets

Introducing Swift SDK

Introducing React Native SDK

Introducing Multi Accounts Support

Introducing React SDK