Privy made it dramatically easier to embed wallets into apps. Over 1,000 teams integrated it. Seventy-five million wallets spun up. Wallet onboarding stopped being painful.

Now the whole thing lives inside Stripe.

And that changes the equation.

If Privy was your wallet layer—and Stripe now owns Privy—what exactly do you own?

Embedding Isn’t Ownership

The pitch for embedded wallets is solid: smoother onboarding, fewer dropoffs, better UX. And the reality often lives up to it.

But embedding infrastructure doesn’t make it yours. More often, it means renting someone else’s: keys, policies, recovery flows, rate limits.

That tradeoff is fine—until it isn’t.

Because when that wallet infrastructure gets acquired, your assumptions go with it. Terms can shift. Access can change. The roadmap you were relying on might suddenly point in a different direction, one optimized for a new parent company’s strategy.

Stripe is a phenomenal company. It’s also a large one. That means priorities shaped by scale, compliance, and cross-product alignment. Your wallet UX may not always be the deciding factor.

Value Was Extracted. Now It’s Consolidated.

One can guess what Stripe’s play is.

Privy became a channel—into user flows, app behavior, and onchain value. Now Stripe owns that channel.

It’s not hard to imagine what comes next: deeper integration with payments, seamless bridging between fiat and crypto, maybe even AI-optimized flows. Wallets, stablecoins, compliance—all under one stack.

That’s a logical move for Stripe. It’s also a consolidation of leverage that developers helped to create.

Because the infrastructure you helped scale now powers a platform you don’t control. Stripe didn’t do anything wrong. It just did what Stripe does.

If that feels harsh, consider the alternative: what if the wallet experience had been embedded in your app, not merely by your app?

“Don’t Be Evil” vs “Can’t Be Evil”

Privy was a wallet service. Stripe is a platform. Platforms make tradeoffs. Sometimes those tradeoffs impact you. That’s not malice; it’s math.

Which is why architectural choices matter.

Relying on goodwill works—until it doesn’t. Relying on intent is fine—until incentives shift. That’s the appeal of building with infrastructure that doesn’t require trust in the first place.

That’s what RallyProtocol is built for.

It’s permissionless and open-source. No custody layer. No admin dashboard. No “just a heads-up, we’re tightening access” email.

Wallets are generated locally on-device, encrypted by the secure enclave, and the entire UX is controlled and owned by the developer.

The Real Question: What’s Yours?

Stripe’s acquisition of Privy doesn’t break anything. But it raises a flag for developers who’ve come to depend on wallet tools that feel embedded—but aren’t actually owned.

• Who controls recovery policies?

• Who sets identity requirements?

• Who decides what’s visible, throttleable, or billable?

If the answer isn’t “you,” then the integration isn’t infrastructure—it’s exposure.

The Alternative: Own the Stack

You don’t need to rent wallet infrastructure. You can own it.

RallyProtocol lets you embed secure, on-device wallets directly into your app—without intermediaries, permissions, or vendor lock-in.

It’s not an integration. It’s your infrastructure.

About RallyProtocol

RallyProtocol is a wallet toolkit for mobile developers who want full ownership of their app’s onchain experience. It provides key management and recovery components for embedding secure, on-device wallets—no custody layers, no forced UX, and no centralized gatekeepers. Permissionless, open source, and built for vertical integration.

Your wallet. Your app. Nothing in between. Start building at rallyprotocol.com.

Composability is the ability to build your wallet stack piece by piece—choosing your own auth, onboarding, and UX. Instead of inheriting a fixed experience from a third-party service, you define it end to end.

If you’ve built with other SDKs, you know it’s fast but rigid. Composability is like building your own checkout flow—tailored to your users, optimized for your context, and fully under your control.

So why build your own when someone else offers it pre-packaged?

Because when you control the flow, you control the conversion, the UX, the brand experience—and most importantly, you keep the value you create. Third-party systems are designed to benefit the provider. Yours isn’t. Whether it's removing unnecessary steps, aligning with your app’s tone, or embedding invisible security, a custom wallet flow lets you meet users where they are—without forcing them into someone else's funnel. It’s the difference between borrowing a funnel and owning the experience.

The Layers You Should Control

Wallet UX isn't just one surface—it’s a stack. A composable wallet layer gives you control across each of these:

• Wallet Creation: Spin up wallets on-device, only when needed, anywhere in your flow.

• Auth & Onboarding: Use passkeys, biometrics, email—or skip login entirely.

• Key Custody: Store keys locally in the secure enclave—not with a provider.

• Data Ownership: Wallet usage stays in your app—not exposed to third-parties.

The Challenge with Branded Wallet Providers

Most wallet-as-a-service platforms aren’t built for composability or developer ownership. They offer convenience at the cost of control. You’re often stuck with:

• Predefined login and recovery flows (e.g., forced social logins)

• Opaque custody models

• Vendor-side tracking and analytics

You don’t just integrate the SDK—you give away the value you’re creating.

How RallyProtocol Enables Composability

RallyProtocol was designed from the ground up as an unopinionated, mobile-first wallet engine. It gives developers the primitives—key creation, storage, signing, recovery—to build their own stack. No branding. No external custody. No prescribed flows.

• Open-source and permissionless: No signup, no TOS, no gatekeeping.

• On-device custody: Keys never leave the user’s device.

• Invisible integration: Wallets live inside your app—not as overlays or modals.

• Composable SDKs: Use only what you need. Bring your own auth and UX.

Why This Matters Now

Recent failures in centralized wallet infrastructure expose the risks of outsourcing control:

• Coinbase’s social hack: Support-side breach exposed user data, enabling phishing and ~$200M in fallout.

• Loopring Wallet shutdown: Discontinued its smart wallet and app, forcing manual user migration.

When wallet infrastructure is opaque or centralized, users suffer—but developers are the ones who lose trust and retention.

Your Wallet. Your Stack. Your Rules.

RallyProtocol gives you the building blocks, not the blueprint. It’s the invisible wallet layer that adapts to your app—not the other way around.

If you believe wallets should be part of your app—not bolted on—then composability isn’t a luxury. It’s the only way forward.

About RallyProtocol

RallyProtocol is a wallet toolkit for mobile developers who want full ownership of their app’s onchain experience. It provides key management and recovery components for embedding secure, on-device wallets—no custody layers, no forced UX, and no centralized gatekeepers. Permissionless, open source, and built for vertical integration.

Your wallet. Your app. Nothing in between. Start building at rallyprotocol.com.

This isn’t a bug. It’s a feature of the current wallet infrastructure landscape.

Loopring’s exit highlights a deeper risk baked into wallet architecture: one that affects users today, but should concern developers even more. When access to wallets depends on a third party, continuity becomes fragile. This blog steps back from the shutdown itself to examine what happens when developers build on infrastructure they don’t own—and how that choice shapes the reliability, trust, and future of onchain UX

When Access Isn’t Ownership

Wallets aren’t just accounts anymore—they’re infrastructure. They manage keys, initiate transactions, and define how users create and interact with onchain value. When access to that infrastructure is abstracted behind a third-party SDK or service, developers don’t own that layer—they rent it.

When that service ends, users lose access and trust. Developers lose continuity and control. And the app’s onchain experience fractures at the wallet boundary.

Loopring’s shutdown isn’t just a matter of user inconvenience. It’s a warning: even non-custodial tooling becomes a point of failure when it’s embedded as a service, not built as infrastructure.

What Dependency Really Costs

This is where architecture matters. Wallets can be:

• Branded apps that live outside your product experience

• SaaS-style services that insert external control over custody and UX

• Embedded wallets that live inside your app, stored on-device, and fully owned by users

The first two come with dependency risk. The last one doesn’t.

Most wallet SDKs today simplify onboarding by centralizing hard parts—key management, gas, recovery. But in doing so, they introduce a single point of failure, whether technical or organizational. When the provider shuts down, developers scramble. When terms change, apps adapt or break. When custody shifts, users lose ownership.

That’s not infrastructure. That’s exposure.

A Path Forward: App-Owned Wallets

RallyProtocol takes a different approach. It doesn’t provision wallets for your users—it gives you the tools to embed wallets directly into your app: on-device, invisible, and developer-controlled. No third-party custody. No vendor lock-in. No shutdown notices.

With RallyProtocol:

• Keys are generated and stored on the user’s device, encrypted by the secure enclave

• Wallets are embedded directly into your mobile UX—not bolted on or handed off

• You own the flow from session to transaction, from auth to signing

When wallets live on-device and within your app, you don’t lose them when a custody provider pivots.

Own the Infrastructure

Loopring isn’t the only one. Centralized wallet layers can—and have—disappeared. It’s not always malicious. Sometimes it’s a pivot. A funding issue. A strategic exit.

The result is the same: disruption.

For mobile apps, this fragility is fatal. Users expect continuity. Developers need control. RallyProtocol is built for both. It’s wallet infrastructure that doesn’t assume trust, doesn’t require a contract, and doesn’t go dark.

About RallyProtocol

RallyProtocol is a wallet toolkit for mobile developers who want full ownership of their app’s onchain experience. It provides key management and recovery components for embedding secure, on-device wallets—no custody layers, no forced UX, and no centralized gatekeepers. Permissionless, open source, and built for vertical integration.

Your wallet. Your app. Nothing in between. Start building at rallyprotocol.com.

Lessons from the Coinbase Incident

In a recent blog post, Coinbase revealed an extortion attempt involving cybercriminals who bribed overseas customer support agents. These agents were convinced to leak user data, which was then used in targeted social engineering attacks.

Crucially, no private keys or passwords were leaked, and the company acted quickly to reimburse affected users. But the real issue here isn't just the attack—it's the reliance on a third-party custody and support layer that created a vulnerable entry point in the first place.

Centralized Custody: Still a Single Point of Failure

For all its user-friendly interfaces and institutional credibility, centralized custody introduces systemic risks:

• Support agents can be bribed or socially engineered

• Sensitive metadata (emails, balances, behavioral patterns) is exposed

• Users don’t actually control their keys or signing privileges

This undermines the core ethos of Web3—ownership without intermediaries.

Embedded Wallets: Reducing the Human Attack Surface

Embedded wallets offer a fundamentally different model: users control their keys from the start, and those keys are stored securely on their own devices. Here’s what user-owned, on-device custody via embedded wallets provides:

• No centralized customer support layer with access to user accounts

• Programmable controls for gasless transactions and session management

• Keys stored on the device or secured via passkeys, biometrics, or secure enclaves

• Reduced liability for you, the developer

Platforms like RallyProtocol offer permissionless SDKs for building mobile-first, embedded wallet flows that feel like Web2 but behave like Web3.

Why It Matters for Mobile-First Apps

If you’re building a mobile dApp, the UX needs to be seamless—no copy-pasting seed phrases or redirecting users to browser extensions. But you also need to ensure users truly own their assets.

By using open & permissionless developer tools for mobile, you can:

• Build intuitive onboarding with auto-generated wallets

• Support social logins with underlying cryptographic safety

• Avoid custodial compliance burdens (you never touch the funds)

• Design and own the entire onchain experience without compromising user custody

Final Thoughts

The Coinbase incident wasn’t about bad tech—it was about bad incentives and centralized risk. As developers, we can design systems that are resilient not just to code exploits, but to human ones.

Embedded wallets with on-device custody let us build for the future—where users hold the keys, and developers build with trust, not compromise.

About RallyProtocol

RallyProtocol is an open and permissionless onchain mobile toolkit designed to help developers build seamless, secure crypto-native experiences. With features like embedded wallets and gasless transactions, Rally enables apps to support self-custody from day one—without compromising on UX. Whether you're building in Flutter, Unity, React Native, Expo, Swift, or Kotlin, RallyProtocol gives you the tools to go onchain, mobile-first, and user-first.

Embedded wallets are something we have talked about in the past. We highly recommend checking out our previous blog posts here and here if you'd like to get an overview on what embedded wallets are and why they are important.

This post will highlight real-world examples of mobile apps leveraging embedded wallets, the UX, and why they matter—for developers looking to integrate them and for users who benefit from their seamless experience.

Orb is a mobile-only Web3 social media app built for artists, creators, degens, and everyday users, powered by Lens Chain. (Hey, we power their embedded wallets!) Orb is a great example of how social media can take advantage of embedded wallets since many interactions—such as posting, collecting content, minting, and following users—would otherwise require separate approvals outside of the app.

Pros:

• By creating an account on Orb, users automatically get an embedded wallet.

• Optionally, users can also sign in with their existing wallet - functions across multiple devices

• An experience similar to existing Social Media interactions - user familiarity.

• Fully ignores the old hassle of approving-something-every-step found in many early Web3 apps.

Cons:

• Exporting and importing keys between devices can be a hassle.

Wombat is a platform that enables users to play games, earn rewards, trade digital assets, and connect with the Web3 gaming community. By using an embedded wallet, Wombat ensures that players can collect rewards, make transactions, and interact with blockchain-based games without unnecessary friction.

Pros:

• Frictionless Gaming: Players don’t have to deal with external wallets when earning or trading in-game assets.

• Multi-Chain Support: Wombat provides access to multiple blockchains, giving users more flexibility.

• Easy Onboarding: The app abstracts away most wallet complexities, allowing non-crypto-native users to engage quickly.

• Private Key Exporting: Users can export their multi-chain private key.

Cons:

• Limited Recovery Options: Restricted to the device’s connected cloud accounts such as a user’s Google Drive.

• Limited Token Support: Only a handful of tokens are natively supported.

Immutable’s Embedded Passport, powered by Sequence wallet infrastructure, is a Web3 onboarding solution designed for gaming applications. Sequence provides the embedded wallet infrastructure for Immutable’s Embedded Passport, enabling seamless onboarding within their ecosystem.

With Embedded Passport, games can provision embedded wallets tied to their account system—including guest logins—so users can start playing right away. When players want to engage in deeper Web3 interactions, such as withdrawing funds, accessing NFT marketplaces, or sharing assets across multiple games, they can seamlessly upgrade to a full Immutable Passport wallet. While Immutable Passport itself is non-custodial, players may not have full access to private keys within the embedded version until they upgrade.

Pros:

• Seamless Player Onboarding: Gamers can enter a Web3 experience without managing a wallet manually.

• Game-Specific Wallets: Ensures smooth integration with each game’s unique ecosystem.

• Upgrade Path: Players can transition to a full Immutable Passport for broader Web3 interactions when ready.

• Non-Custodial Security: Users retain control over their assets while benefiting from a streamlined login experience.

Cons:

• Developer Integration Required: Requires developers to build Passport integration into their games, adding an extra step compared to generic wallet solutions.

• Wallet “Upgrade” Dependent: Players may not have full access to private keys within the embedded version until they migrate to the standard Immutable Passport.

Embedded wallets are transforming how users interact with blockchain applications, reducing complexity while keeping core Web3 principles intact. Whether through social apps like Orb, gaming platforms like Wombat and Immutable, or other enterprise solutions, these integrations enhance accessibility and usability across the board.

For developers, embedded wallets remove onboarding friction and create a more intuitive user experience. For users, they enable seamless interactions without the technical overhead of managing private keys. As Web3 adoption grows, expect more apps to integrate these wallet solutions to improve engagement and usability.

RallyProtocol is an open and permissionless onchain mobile toolkit that features embedded wallets and gasless transactions. Our mission is to enable developers to create seamless, end-to-end onchain experiences for native mobile apps while ensuring self-custody, security, and full developer sovereignty. Whether you're building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our tools empower developers to create better onchain mobile experiences quickly and easily.

Want to learn more? Dive into our developer docs.

In this blog, we’ll break down the shortcomings of third-party developer tools and explore how a truly open and developer-first approach can onboard the next generation of mobile users onchain.

While third-party platforms promise seamless onchain integration, they often come with a hidden price that undermines the autonomy and ownership developers originally expected.

Some embedded wallet providers simplify onchain onboarding but require developers to cede user and wallet ownership—locking users into closed ecosystems. What starts as a frictionless experience can turn into a long-term dependency where the platform, not the developer, owns users and their wallets.

Building with third-party tools can feel like walking on shifting ground. Platforms alter fee structures, impose API limits, or throttle transactions as they scale.

Imagine scaling your app with a gasless transaction service, only to face sudden transaction throttling or extra fees as your app gains traction. These changes can jeopardize the core value proposition your users depend on.

Developers aim to maintain full control over their users and applications, yet many third-party platforms wedge themselves as intermediaries. They may require users to create platform-specific accounts or even sign transactions on their behalf, weakening both the developers’ and users’ own autonomy over their onchain activities.

Consider a wallet provider that “rents” smart contract wallets to developers. Instead of enabling true self-custody for users, developers are forced to rely on an intermediary that has ultimate control over user wallets with the power to extract, censor, or in the worst case-scenario, misplace them.

When developers try to reclaim control, they often find themselves constrained by vendor lock-in. A platform’s architecture might tie developers to specific chains or restrict the portability of user data and assets. Migrating users to a better alternative can become a costly and time-consuming endeavor.

For example, a wallet provider using chain-specific smart contracts might lack multi-chain support, leaving developers unable to adapt as their user needs evolve.

RallyProtocol provides a mobile-first, embedded wallet, and gasless transaction toolkit that puts developers in control.

RallyProtocol follows blockchain’s core ethos: open-source, permissionless tools that eliminate gatekeeping and unnecessary intermediaries. Developers retain full ownership of the ecosystems they build, ensuring value flows directly to the creators.

Unlike third-party platforms, RallyProtocol doesn’t extract value, impose fees, or have shifts in policy. The value you build stays with you—no arbitrary pricing models, no forced dependencies.

With RallyProtocol, you get embedded wallets and gasless transactions without ever ceding ownership. Developers can integrate onchain access directly into their stack while ensuring users have true self-custody and sovereignty.

RallyProtocol is more than a toolset—it’s a movement toward developer-owned ecosystems, mobile-first onchain applications, and frictionless onchain experiences.

Ready to take control of your Web3 stack? Start building with RallyProtocol today.

1. Externally Owned Accounts (EOAs)

2. Smart Contract Wallets (sometimes called “smart accounts”)

3. MPC (Multi-Party Computation) Wallets (often provided through Wallet as a Service)

Each approach has unique security, trust, and performance characteristics. Below, we’ll break down how these wallets work, their trade-offs, and why you might choose one over the other in 2025.

EOAs are the original account type on Ethereum and remain the only accounts that can natively initiate transactions in the EVM. Historically, most users’ first foray into Ethereum was through an EOA—if you remember the old days of MetaMask, that was an EOA experience.

• Simplicity & Self-Custody: EOAs are straightforward to set up and can be entirely self-custodied—your users control the private key or seed phrase, no third parties required.

• Native Transaction Initiation: EOAs directly submit transactions to the network without needing an additional relayer.

• Single Point of Failure: Losing the seed phrase or private key means permanently losing access to the account and any associated funds.

• User Liability: Full self-custody can be intimidating. Many users inadvertently expose their keys, or fail to back them up properly.

Recognizing these challenges, developers have spent significant effort creating solutions that preserve the performance and usability of EOAs while mitigating the catastrophic risk of losing a single key.

Developers building mobile-first dApps that prioritize speed, multi-chain compatibility, and full user ownership should consider EOAs. This model is best suited for projects that require direct blockchain interactions without added complexity. However, implementing a secure key backup and recovery system is essential to mitigate risks associated with private key loss.

A smart contract wallet is simply a smart contract that holds funds and enforces custom rules around how transactions are authorized. Although they’ve existed conceptually for years, widespread adoption only picked up recently, partly due to changes in gas economics and the emergence of EIP-4337.

• Account Abstraction: Under EIP-4337, transactions from smart contract wallets can be bundled and relayed to the network, circumventing the requirement that only EOAs can initiate transactions.

• Programmable Security: You can implement more flexible authentication schemes (e.g., social recovery, multiple signers, rate limits) that go beyond traditional ECDSA signatures.

• Lower Costs on L2s: With most transaction volume moving to cheaper, faster L2s, the additional gas overhead of a smart contract wallet has decreased, making them more viable.

• Deployment on Multiple Chains: In a multi-chain environment, you must deploy your wallet contract on each chain you wish to support. This is both costly and introduces complications around deterministic deployment.

• Higher Overhead: Despite recent improvements, smart contract wallets generally incur higher gas costs than simple EOAs.

• Ownership: Often, the smart contract wallets are wholly owned by the provider and are only ‘rented’ out to developers. The EOAs that control smart contract wallets are predominantly custodied by third party providers.

Developers seeking programmable security features, such as social recovery and multi-signature authorization, should consider smart contract wallets. However, they must carefully assess provider dependency, ownership limitations, and wallet and transaction fees as they scale. While smart contract wallets effectively address many UX and security challenges of EOAs, they introduce additional complexity, particularly for developers looking to enable seamless cross-chain interactions from day one.

MPC wallets operate similarly to EOAs but split the underlying private key among multiple parties. In this scheme, no single party possesses the entire private key.

• Cross-Chain Compatibility: Because they still appear on-chain as a standard EOA, you can reuse the same address on multiple chains without additional contracts or deployments.

• Key Recovery: Splitting the key among multiple parties (e.g., the user, a trusted provider, and perhaps another backup) allows for more robust recovery options in case of a lost share.

• Trust in the MPC Provider: You rely on the provider to be honest and to have implemented the cryptographic protocols correctly.

• Continued dependence on MPC Providers: All onchain activities route through the MPC provider, which means that users and wallets can be throttled or even censored.

• Proprietary Implementations: Many MPC solutions are not open source, so you’re trusting a “black box” for critical cryptographic functions.

MPC wallets are ideal for developers who need cross-chain compatibility without deploying smart contract wallets on every chain. However, like smart contract wallets, they come with trade-offs—developers must trust the provider’s security model, uptime, and overall control over the wallet. When evaluating an MPC solution, it’s crucial to assess the provider’s reputation, technical expertise, and commitment to transparency—especially if their code is not open for independent audits.

With so many custody models—each having its own benefits and drawbacks—it might seem that a “perfect” solution is still out of reach. Ideally, we’d all use hyper-secure EOAs that:

1. Don’t require a separate wallet per chain

2. Offer robust back up and recovery options

3. Can leverage modern hardware security

At RallyProtocol, we’ve taken major steps toward that vision by developing an EOA-centric solution that incorporates hardware-backed security and cloud-based backups.

By 2025, virtually all mobile devices (iOS and Android) come equipped with a secure compute element—a tamper-resistant chip that can securely generate, store, and handle cryptographic keys. We use this hardware to:

• Encrypt EOAs on-device

• Backup Encrypted Keys to the Cloud

If a user loses their phone, the encrypted key can be restored from the cloud but remains unusable without the secure enclave found on modern devices. This significantly reduces the risk of losing access.

For larger balances, you could still employ a hybrid model:

• Use an EOA (secured by hardware + cloud backups) for day-to-day transactions.

• Pair it as one signer in a smart contract wallet for additional security measures (e.g., multi-signature, third-party backups).

Because these are still EOAs, there’s no need to deploy new contracts each time you expand to a different L2 or sidechain. That means your app can go cross-chain on day one without incurring additional contract deployment costs or complications.

By removing third-party reliance, developers gain full control over their app, users, and data—ensuring they, not third parties, retain the value they create.

By 2025, the choice of custody solution for EVM-based dApps is broader than ever:

• EOAs remain the simplest, fastest way to interact with EVM chains—especially with hardware-backed, native cloud-restored solutions.

• Smart Contract Wallets offer programmable security and account abstraction, at the cost of higher deployment complexity.

• MPC Wallets promise EOA-like performance with shared key management but depend heavily on trusting the MPC provider.

At RallyProtocol, we believe a robust, hardware-enabled EOA strategy strikes the best balance between security, usability, and flexibility—especially in a multi-chain world. By leaning on secure enclaves and encrypted cloud backups, we’ve dramatically reduced the most significant risks to EOA-based self-custody.

If you’re building a next-generation dApp, consider how you can leverage these evolving custody approaches to deliver a more secure, seamless experience for your users.

RallyProtocol is an open and permissionless onchain mobile toolkit that features embedded wallets and gasless transactions. Our mission is to enable developers to create seamless, end-to-end onchain experiences for native mobile apps while ensuring self-custody, security, and full developer sovereignty. Whether you're building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our tools empower developers to create better onchain mobile experiences quickly and easily.

Want to learn more? Dive into our developer documentation here.

In our initial design, we aimed to shield developers from the complexities of web3 entirely. To handle transaction-building logic, we performed numerous RPC calls to fetch details like:

• Token decimals

• EIP-712 version, salt, etc.

This approach worked well to simplify the process for a theoretical developer with no web3 familiarity. However, it came with significant trade-offs, particularly for mobile, which is a core focus of our SDK. In addition to the technical tradeoffs, developers without interest in web3 never proved to be a valid archetype, so the need for all web3 to be hidden was unnecessary.

Mobile environments are inherently more resource-constrained than desktop or server setups. Our reliance on RPC calls introduced several issues:

• Higher Latency: Each additional RPC call increases the time it takes to construct a transaction.

• Increased Failure Rates: Mobile networks are less reliable, making repeated calls more prone to timeouts or errors.

• Resource Consumption: RPC calls require more bandwidth and processing power, which can be taxing for mobile devices and degrade the user experience.

While these trade-offs might be acceptable in some environments, they are particularly problematic for mobile end users, where performance and handling unreliability networks are critical.

Recognizing these challenges, we decided to pivot our approach. Instead of dynamically fetching transaction configuration details through RPC calls, we now pre-bake this data at build or compile time. By embedding necessary transaction configuration directly into the SDK, we dramatically reduced the number of required RPC calls. This shift provides several key benefits:

• Improved Performance: With fewer RPC calls, transactions are constructed faster, improving the user experience.

• Increased Reliability: Reducing dependency on external calls minimizes the risk of network-related failures.

• Optimized for Mobile: Lower resource consumption makes our SDK more efficient for mobile devices, where every byte and millisecond counts.

Importantly, this change does not introduce additional risk. Blockchain contracts are immutable, meaning that values like token decimals or contract-specific configurations are static and will not change unexpectedly. This ensures that the pre-baked configuration remains valid across deployments.

While most developers are comfortable managing web3 configurations, we recognize that some might still need assistance. To support these users, we’ve built a suite of web tools that help generate the required configuration objects for their specific tokens, contracts, and other parameters. These tools provide the best of both worlds: enabling developers to dive deep into web3 when needed while maintaining the simplicity and efficiency of our SDK.

This journey has been an invaluable learning experience. By initially optimizing for accessibility and later iterating based on real-world feedback, we’ve refined our SDK to better serve the needs of our users. Our new approach balances simplicity with performance, ensuring that developers can build powerful mobile web3 applications without compromising on speed, reliability, or resource efficiency. We’re excited to see what the community builds with this improved SDK and look forward to continuing to iterate and evolve based on your feedback. Let us know your thoughts and how we can further enhance your development experience!

RallyProtocol is an open and permissionless onchain mobile toolkit that features embedded wallets and gasless transactions. Our mission is to enable developers to create seamless, end-to-end onchain experiences for native mobile apps while ensuring self-custody, security, and full developer sovereignty. Whether you're building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our tools empower developers to create better onchain mobile experiences quickly and easily.

Want to learn more? Dive into our developer documentation here.

Developers integrating embedded wallets for mobile apps have several options, each with distinct benefits and trade-offs. Here’s a quick TL;DR:

Smart Contract Wallets: Embedded wallets with built-in support for ERC-4337 features.

• Pros: Simplifies user experience with features like embedded wallets, gasless transactions, and gas fee optimization in one package.

• Cons: Relies on third-party key custody, fees for deploying and maintaining active wallets, cross-chain support requires additional wallets to be deployed.

WaaS (Wallet as a Service): Managed solutions for onboarding users with just a username or email, utilizing MPC.

• Pros: Easy integration into your app and simplifies recovery for users by leveraging trusted third-party services for transaction signing and recovery.

• Cons: Shares many limitations of third-party custody, including fees, data lock-in, and potential censorship.

Direct Self-Custody: Equips users with embedded wallets via EOAs (Externally Owned Accounts) directly on their device—RallyProtocol’s approach.

• Pros: Permissionless, full developer-sovereignty, cost-free, and cross-chain compatible. Users own their keys, and wallets are created on-device.

• Cons: Requires a small additional setup to enable ERC-4337 features like gasless transactions.

For mobile-first developers, the choice of custody has a significant impact—not only on user experience but also on control, cost, and scalability.

Using third parties for key management through Smart Contract Wallets or WaaS may be convenient for both developers and users, but there are potential drawbacks developers should consider:

1. Loss of Control: Neither developers nor users own the keys to the wallet. The third-party that custodies the keys has the power to close or restrict wallets without developer or user consent.

2. Reliance on Centralized Services: Any outage or security breach at the third-party level affects your app and users—even if your own stack is secure.

3. Recurring Costs: Wallet providers often charge for active wallets, and additional fees for premium features could be introduced in the future.

4. Data Ownership Issues: Developers do not own their users’ wallet data or the associated social graphs. The third party effectively "owns" the wallets created through their service.

In contrast, enabling direct self-custody ensures both developers and users retain full control over their wallets and data. With embedded wallets powered by EOAs and secured by device-level encryption, developers unlock several advantages:

1. Full User Sovereignty: Users—and only users—own their wallets and keys on-device encrypted by the secure enclave. Developers don’t need to rely on third-party custody services.

2. Permissionless Control: Developers can create wallets instantly without requiring third-party accounts or permissions, enabling frictionless scaling.

3. No Hidden Costs: Unlike Smart Contract Wallets or WaaS, there are no ongoing fees for wallet creation or use.

4. Data Ownership: Developers retain access to user wallet data and social graphs. Builders who create value can fully own it by leveraging permissionless, open-source tools.

With RallyProtocol’s approach, developers can provide embedded wallets directly from their apps, taking full control of the user experience while eliminating third-party dependencies. Here’s how RallyProtocol aligns with the needs of mobile-first developers:

• Built for Mobile Developers: Designed natively for mobile, embedded wallets integrate seamlessly into onchain mobile apps, removing the need for external wallet apps or extensions.

• Gasless Transaction Support: While self-custody wallets require some setup for advanced features like gasless transactions, RallyProtocol provides tools to streamline implementation, empowering you to own your gasless transaction stack.

• Developer-Centric Tools: RallyProtocol empowers developers to build truly open and permissionless applications, ensuring flexibility and scalability without compromise. Check out our github.

For example, a developer creating an onchain mobile game can use RallyProtocol to instantly equip users with embedded wallets under the hood, have users claim NFTs gaslessly, and never lose control of the app’s onchain user experience—all without relying on third parties.

For developers who prioritize having full control, cost efficiency, and mobile-first experiences, direct self-custody is the way forward. RallyProtocol simplifies the process, giving you the tools to innovate while retaining the value that you create. By aligning custody decisions with the principles of permissionless and open development, developers can create better user experiences while maintaining control over their ecosystems.

RallyProtocol is an open and permissionless onchain mobile toolkit that features embedded wallets and gasless transactions. Our mission is to enable developers to create seamless, end-to-end onchain experiences for native mobile apps while ensuring self-custody, security, and full developer sovereignty. Whether you're building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our tools empower developers to create better onchain mobile experiences quickly and easily.

Want to learn more? Dive into our developer documentation here.

Onchain Onboarding: Challenges and Solutions

Onchain onboarding has faced significant hurdles over the years. Creating and connecting an external wallet often forces users to navigate confusing interfaces and manage complex setup requirements—all before they can even begin engaging with your app. This cumbersome process deters many new users, resulting in high bounce rates and stalled adoption.

Embedded wallets have emerged as a powerful solution, enabling seamless, in-app wallet creation for onchain onboarding.

Much like the advancements in desktop onboarding, mobile onchain onboarding has also evolved. Embedded wallets are crypto wallets integrated directly into a mobile app. They allow developers to equip users with wallets instantly within the app, eliminating the need to switch apps to connect an external wallet.

Before embedded wallets, developers had to rely on end users to complete the round trip of connecting a wallet outside of an application, resulting in a total loss of control over the user journey. For inexperienced onchain users without an existing wallet, the journey to create and connect a wallet was often daunting and complex, leading to high bounce rates.

Embedded wallets lower entry barriers to crypto by enabling developers to create simple, secure, and fast wallet experiences for users. Here is an example of equipping a user with an embedded wallet in just one tap:

Embedded wallets do more than simply equip a user with a wallet; they provide a seamless way to enable onchain activity without friction:

While wallets are the entry point to onchain experiences, asking the average consumer to create and connect one presents a significant hurdle. Embedded wallets enable developers to equip users with wallets behind the scenes, allowing them to start the app experience without going through the complexities of crypto onboarding.

With modern embedded wallet UX, developers can create wallets for users instantly in just a few steps. Embedded wallets eliminate the guesswork of relying on users to leave the app to connect an external wallet, creating a seamless, uninterrupted user experience that keeps users in-app.

Embedded wallets support gasless transactions, where developers or third parties sponsor gas fees on behalf of users. This combination makes the web3 experience feel entirely invisible to end-users.

While embedded wallets are transforming the onchain experience, developers must carefully evaluate their needs when selecting an embedded wallet provider. Here are some key considerations:

Embedded wallets leveraging technologies like MPC or Account Abstraction can simplify onboarding but often come with trade-offs in custody. For example, MPC solutions typically only grant users a minority share of their keys, while Account Abstraction services typically custody the EOA themselves or rely on a custody partner. These compromises reduce user control and introduce risks, such as potential censorship or the inability to secure funds.

Some providers continue to manage wallets, transaction data, and onchain activities even after the initial wallet creation. This reliance on third-party services can limit developer autonomy and prevent full control over the user experience.

Many third-party services charge ongoing fees tied to transaction volume or active wallet counts. As your app scales, these costs can grow quickly, impacting your budget and limiting your flexibility to adapt as needed.

RallyProtocol provides a permissionless, open toolkit for onchain mobile developers. We believe in providing tools that are simple, accessible, and free.

Keys are always stored locally on the user’s native device and encrypted by the secure enclave, similar to a hardware wallet. There is no partial key ownership or obscured custody of EOAs, ensuring that no third party can own, censor, or seize a user’s wallet.

RallyProtocol eliminates the need for third parties by stepping back after the embedded wallet creation process. These embedded wallets use non-proprietary wallet generation, along with native device security and storage, to help developers bring users onchain without requiring a third party to facilitate transactions. We believe that developers should have full sovereignty over their users and their wallets.

Our tools are freely accessible to all developers without requiring an account. We provide the essential building blocks that empower developers to create fully customizable onchain experiences. This is achieved without compromises or surrendering control to end-users or third parties.

RallyProtocol is an open and permissionless onchain mobile toolkit that features embedded wallets and gasless transactions. Our mission is to enable developers to create seamless, end-to-end onchain experiences for native mobile apps while ensuring self-custody, security, and full developer sovereignty. Whether you're building an iOS or Android app in Flutter, Unity, React Native, or Expo, our tools empower developers to create better onchain mobile experiences quickly and easily.

Ready to bring your mobile users onchain with embedded wallets? Explore RallyProtocol’s documentation here.

Building on our success on Polygon—where we helped developers create over a million embedded wallets for mobile users, enabled over 70% of gasless transactions, and integrated with SocialFi leader Orb: Social Network on Lens—we're now ready to empower the next generation of builders.

Base has become the go-to blockchain for developers building real consumer applications, thanks to its established and rapidly growing ecosystem of apps and engaged onchain users. Furthermore, the high volume of stablecoin transactions on Base indicates that apps are creating genuine engagement and utility for the average consumer.

Base makes it easier than ever to bring users onchain, and now, with RallyProtocol’s open and permissionless onchain mobile toolkit, we’re excited to amplify this vision by empowering developers to create onchain mobile apps quickly, simply, and with full sovereignty.

Our core principles focus on giving developers full control and sovereignty over their apps, users, and onchain experiences. While embedded wallet services like Wallet-as-a-Service (WaaS) and Account Abstraction (AA) are valuable for simplifying onchain onboarding, we believe there are simpler, more developer-friendly solutions that don’t rely on smart contracts, APIs, or third-party subscriptions.

Warpcast's onboarding experience, with its smooth embedded wallet creation that doesn’t require integration with a third-party wallet service, exemplifies what every developer should have access to. Our vision for Base is to provide permissionless and open tools that empower all developers to build onchain mobile apps securely, quickly, and autonomously.

RallyProtocol is designed for mobile developers who want to bring users onchain quickly, easily, and without the reliance on third-party services. Here are the features RallyProtocol provides:

Embedded wallets

Create self-custodied wallets embedded on users’ devices, encrypted by the device’s secure enclave. Developers have full sovereignty, meaning wallet facilitation belongs exclusively to them. They maintain complete ownership and control over wallets, social graphs, and data, without any third-party intermediaries.

Gasless transactions

Streamline user onchain experiences by completely eliminating gas fees for users without ever needing smart contract wallets. Build your own stack using our open-source code, or try our stack and let us handle the heavy lifting.

RallyProtocol’s vision is to bring mobile users onchain by providing developers with tools that are simple, non-prescriptive, and aligned with blockchain principles:

• Permissionless & Open: Start creating embedded wallets without needing a developer account or requiring your users to log in with socials.

• Decentralized: Our stack is built with core onchain features that anyone can create and use.

• Self-custodial and secure: Keys are always stored directly on the user’s native device and encrypted by the hardware’s secure enclave.

• Full sovereignty: Full control is given to the developers to decide their UX. No need for permissions or services to facilitate your relationship with your users.

• Censorship-resistant: User wallets can never be censored, revoked, or lost by a third party because they are fully stored only on the user’s device.

RallyProtocol is an open and permissionless onchain mobile toolkit that features embedded wallets and gasless transactions. Our mission is to enable developers to create seamless, end-to-end onchain experiences for native mobile apps while ensuring self-custody, security, and full developer sovereignty. Whether you're building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our tools empower developers to create better onchain mobile experiences quickly and easily.

Want to learn more? Dive into our developer documentation here.

In the rapidly evolving landscape of Web3, the intersection of mobile technology and blockchain is becoming a focal point for innovation. At the final session of RallyProtocol’s Mobile Onchain Summit, Ian LeViness, head of grants and PR at Push Protocol, provided valuable insights into how mobile apps are shaping the future of onchain social interactions.

Mobile: The Gateway to Mass Adoption

As Ian pointed out, mobile devices are the most ubiquitous technology today. Their potential to onboard millions into the Web3 space cannot be overstated. Mobile-first design is no longer a luxury—it's a necessity. This shift is evident as platforms like Push Protocol expand their offerings to cater specifically to mobile users. With a growing suite of products, Push Protocol is pioneering wallet-to-wallet communication, a feature that not only enhances user interaction but also promotes decentralization by giving users more control over their data.

Wallet-to-Wallet Chat: A New Dimension

One of the standout points Ian made during the session was the importance of wallet-to-wallet communication. This feature, which allows users to chat directly through their digital wallets, is a game-changer. It represents a shift from traditional, centralized communication platforms to decentralized alternatives that are native to the blockchain ecosystem. The implications are profound: as more users embrace Web3, the need for secure, private, and decentralized communication tools will only grow.

Expanding the Ecosystem

Push Protocol isn't just stopping at wallet-to-wallet chat. The protocol is designed to support a wide range of communication needs, from community engagement to business applications. By integrating these capabilities into mobile platforms, Push Protocol is helping to create a more connected and interactive Web3 environment. Ian emphasized that as the ecosystem grows, so too will the demand for mobile-friendly solutions that can meet the diverse needs of users.

Moreover, Push Protocol's focus on interoperability ensures that it can seamlessly integrate with other protocols and platforms within the Web3 space. This interoperability is crucial for building a cohesive decentralized infrastructure, allowing users and developers to leverage a unified communication system across various dApps and services.

Looking Ahead

The conversation at the Mobile Onchain Summit underscored a critical truth: the future of Web3 is mobile. As blockchain technology continues to mature, the need for mobile integration will become even more pressing. Platforms like Push Protocol are at the forefront of this movement, building the tools and infrastructure necessary to support the next generation of decentralized applications.

In conclusion, the session highlighted the pivotal role that mobile technology will play in the evolution of onchain social interactions. With leaders like Ian LeViness and Push Protocol driving innovation, the future of mobile in Web3 looks promising indeed.

Watch the Providing Infrastructure for Mobile Developers panel here.

RallyProtocol is an all-in-one Web3 mobile toolkit that enables developers to create seamless, end-to-end onchain experiences for native mobile apps, featuring embedded wallets and gasless transactions. Whether you’re building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our mission is to give developers the power to create user-friendly mobile UX with fewer taps and zero web3 touchpoints. Want to learn more? Dive into our developer documentation here.

The Future of Blockchain: How Consumer Applications are Leading the Mobile Revolution

Blockchain technology is on the brink of a significant shift, driven by the growing possibilities of mobile applications that can be used by the average consumer. As more users access the internet through mobile devices, the importance of blockchain applications tailored for mobile cannot be overstated. This evolution isn’t just about technological innovation; it’s about creating accessible and meaningful experiences that resonate with consumers.

For years, blockchain development has been dominated by a focus on infrastructure—building the foundational layers that enable decentralized networks to function. However, the conversation is shifting. The real power of blockchain lies in its ability to deliver consumer-facing applications that hide the complexities of the technology and provide real value to users.

This transition is particularly evident in the work being done by Ava Labs, the team behind the Avalanche blockchain network. Matthew Schmenk, a member of the business development team at Ava Labs, emphasizes the need to prioritize consumer applications over additional infrastructure. While the technical aspects, like data availability and staking mechanisms, are crucial, they often don’t resonate with the average user. Instead, the focus should be on applications that directly benefit users—such as those in social finance (SocialFi) and gaming—by abstracting away the blockchain elements and delivering intuitive, user-friendly experiences.

One of the most promising areas for blockchain’s consumer applications is gaming. The concept of decentralization is particularly powerful in this space, where players can finally take true ownership of their in-game assets. Matthew Schmenk highlights the potential of blockchain to transform gaming by enabling players to retain control over digital items like skins and weapons, which are traditionally at the mercy of game publishers.

This shift towards player ownership is a game-changer. No longer can publishers alter or revoke items that players have invested time and money into. With blockchain, these assets are securely owned by the players themselves, ensuring that the effort they put into their gaming experiences is preserved. This is just one example of how blockchain technology can be harnessed to create more equitable and engaging experiences for users.

Beyond gaming, the potential for blockchain to revolutionize payments is immense. Imagine a Venmo-like application built on the Avalanche network, capable of supporting multiple currencies and stablecoins. By leveraging tools like the Hyper SDK, developers can create payment platforms that are not only fast and secure but also flexible enough to handle a variety of currencies.

Such a platform could provide a compelling alternative to existing payment systems, especially as traditional platforms like Venmo begin charging businesses for transactions. By integrating blockchain technology, these new payment systems could offer lower fees, faster transactions, and greater transparency—benefits that are increasingly important in today’s digital economy.

As blockchain technology continues to evolve, the shift towards mobile platforms is inevitable. The key to success in this new era will be the ability to deliver applications that are not only powerful and secure but also intuitive and user-friendly. This is where the real value of blockchain lies—not in the underlying infrastructure, but in the applications that bring this technology to life for consumers.

The future of blockchain is bright, and its potential is vast. By focusing on consumer applications and embracing the mobile revolution, blockchain developers have the opportunity to redefine how we interact with digital services, making them more accessible, equitable, and engaging than ever before.

Watch the Providing Infrastructure for Mobile Developers panel here.

RallyProtocol is an all-in-one Web3 mobile toolkit that enables developers to create seamless, end-to-end onchain experiences for native mobile apps, featuring embedded wallets and gasless transactions. Whether you’re building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our mission is to give developers the power to create user-friendly mobile UX with fewer taps and zero web3 touchpoints. Want to learn more? Dive into our developer documentation here.

Unlocking the Future of Web3 on Mobile: Opportunities and Challenges

The web3 ecosystem holds immense potential for transforming user experiences across various platforms, especially mobile. However, realizing this potential requires addressing several technical, developmental, and business challenges. In this blog post, we explore the key insights from a recent panel discussion among web3 experts, highlighting the hurdles and opportunities in the journey toward seamless web3 integration on mobile devices.

Watch the Providing Infrastructure for Mobile Developers panel here.

Developers play a crucial role in shaping user experiences in the web3 space. With the rise of mobile dapps, creativity in ideating new use cases is equally important, especially for the average consumer. This creativity must first be unlocked by having web3 tools and infrastructure readily available for app developers. Only then can app developers have full control over their UX to create the best app experience.

One of the most compelling ideas brought up by Yash from Web3Auth was the concept of a "Universal Profile." This profile would function similarly to a Google account, aggregating user data across different games and ecosystems powered by context-specific data revelation, enabling users to see relevant content based on their current activity, avoiding clutter from unrelated games or applications. 

Human verification remains a pain point for users, with captchas and other verification methods often being intrusive and repetitive. The panel discussed the potential for web3 to provide a universal human verification protocol. Such a solution would streamline the verification process using blockchain technology, making it more user-friendly while maintaining security and authenticity.

The ability to manage an identity is a high-value proposition of the web3 experience. Nick from RallyProtocol highlighted the need for a comprehensive identity management system that focuses on internet identity control, allowing for single or even multiple personas. Such a system would enable users to manage their identities across different platforms securely and efficiently. This "meta account" for web3 could revolutionize how users interact with digital services.

In the realm of identity management, privacy-preserving applications are essential. These applications should allow users to prove identity-related facts, such as age or attendance, without revealing personal details. This balance between functionality and privacy is critical for gaining user trust and widespread adoption.

Pedro from WalletConnect stated that a significant technical hurdle for web3 adoption in mobile applications is the lack of hardware support for specific cryptographic curves used by blockchains. Currently, most hardware supports the p256 curve for passkeys but not the K1 curve used by many blockchains. This limitation is more about policy than technology, as hardware can technically support these curves with minor adjustments. Addressing this issue could open the door to more seamless integration of web3 technologies in mobile apps.

The web3 industry lacks unified advocacy. Establishing strong business development relationships with traditional tech giants like Apple and Samsung is crucial to the success of web3. By helping these companies understand the benefits of supporting web3 technologies, they can realize how it benefits their own ecosystems.

The future of web3 on mobile is filled with exciting possibilities, but it also comes with significant challenges. By addressing technical limitations, fostering strong business development relationships, and innovating in identity management and user experiences, the web3 community can unlock its full potential. Collaboration and advocacy will be key to driving these changes, ultimately creating a more integrated and user-friendly digital ecosystem.

Watch the Providing Infrastructure for Mobile Developers panel here.

RallyProtocol is an all-in-one web3 mobile toolkit that enables developers to create frictionless, end-to-end onchain experiences for native mobile apps. Whether you’re building an iOS or Android app in Flutter, Unity, React Native, Swift, or Kotlin, through instant embedded wallet creation and gasless transactions, our mission is to give developers the power to create user-friendly mobile UX with fewer taps and zero web3 touchpoints. Want to learn more? Dive into our developer documentation here.

Leveling Up The Gaming Experience

Onchain gaming leverages blockchain technology to enable experiences previously impossible in traditional gaming. Key benefits include true ownership of in-game assets and transparency. This transition fosters a new era of player empowerment, engagement, and rewards that didn’t exist before. Erica Cheever from VividGamingGG is a prominent figure in this space, bringing awareness to onchain gaming and reflecting a growing community of gamers and developers exploring blockchain's potential to create more immersive and rewarding experiences for everyday consumers.

Aligning Incentives for Both Developer and Players 

Welly Sculley from SuperLayer and Unite, with a decade of crypto experience, focuses on how blockchain can revolutionize game monetization for all participants. He discusses the potential shift from traditional monetization models to innovative and unexplored strategies that  benefit not only developers but also players and the community directly.

Empowering Game Developers With Onchain Tools

Renz Chong, CEO of BreederDAO, highlights a critical need in the blockchain gaming ecosystem: tools to help developers build on-chain games. By providing tailored in-game asset creation tools, BreederDAO is paving the way for developers to create gaming universes unique to their brand and community.

NFTs, More Than Just Digital Assets

No onchain game is complete without the mention of NFTs. NFTs are not merely digital collectibles; for some games, they form the backbone of blockchain gaming. Mobile games like Pirate Nation and Guild of Guardians demonstrate how NFTs can enhance gameplay by providing players with unique, tradable assets that carry real-world value. This enriches the gaming experience and introduces new economic dynamics within games.

Current Challenges for Mobile Onchain Apps

Despite its potential, one of the hurdles mobile onchain gaming faces is the challenging app store policies. However, the increasing number of onchain games being released regularly is a positive sign. Another hurdle is the need for better user experiences; users unfamiliar with Web3 should not have to go through the hassle of creating a wallet. More effort spent on ensuring a seamless transition for players new to the blockchain space through technologies such as embedded wallets and gasless transactions would be beneficial for everyone.

The Future Is Bright For Mobile

The journey into mobile onchain gaming is just beginning. Blockchain technology is transforming how we play, interact with digital worlds, and perceive ownership and value in gaming. This shift towards a more rewarding, empowering, and innovative ecosystem brings new challenges and endless possibilities for players and developers. The rise of decentralized platforms, developer tools & SDKs for mobile, and the love of gaming is setting the stage for a new world of digital interaction and creativity. 

Watch to the Whole Panel Here

Watch the Future of Onchain Gaming Powered by Mobile panel here.

About RallyProtocol

RallyProtocol is an all-in-one Web3 mobile toolkit that enables developers to create seamless, end-to-end onchain experiences for native mobile apps, featuring embedded wallets and gasless transactions. Whether you’re building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our mission is to give developers the power to create user-friendly mobile UX with fewer taps and zero web3 touchpoints. Want to learn more? Dive into our developer documentation here.

Over the past 12 months if you talk to anyone about gasless transactions, improved UX, secure recovery and general user onboarding the conversation inevitably gravitates towards account abstraction and more specifically ERC 4337. ERC4337 is amazing, so is EIP 3074 and Vitalik's recent EIP 7702. All of these proposals give developers and users more flexibility around account management making interacting with any EVM chain easier and more secure.

The Essential Role of EOAs in Account Abstraction

Something that is often lost in conversations about account abstraction is the role that EOAs will continue to play under any currently proposed form of account abstraction. The EVM allows for both EOAs and smart contracts to execute transactions, but only EOAs can initiate a transaction and in cases where transactions are relayed by a downstream, managed EOA (e.g. meta transactions, 4337 tx bundling) a signature from the initiating EOA is still required to authorize the transaction. Another super power of EOAs is that you can also use them cross-chain out of the box! In all cases EOAs remain paramount to using the EVM.

Secure EOAs on Mobile Devices

As a team fully focused on bringing crypto developers and users out of the browser and onto their phones, we've spent a lot of time thinking about and implementing secure, performant EOAs on mobile devices. It turns out most modern phones have similar security properties to hardware wallets, they have a segregated, secure computing environment where cryptographic keys can be generated, stored and used without being exposed to any external actors. Properly using this secure computing environment in conjunction with secure cloud backup gives users an EOA that is similar to what they use on a hardware wallet with the added benefit of cloud backup.

The Progressive Wallet Journey: From EOAs to Smart Contract Accounts

A secure, on device EOA is the first step in a user's progressive wallet journey. This EOA allows a user to onboard quickly and without cost. You can also send gasless transactions from these accounts! These accounts can be used for things like identity in a social app or small transactions without huge financial implications. In some cases users will hit a point where it makes sense for them to graduate to a smart contract wallet for additional security, more granular control over their transactions or any of the other awesome 4337 features being imagined. If this proggressive approach to account managament on mobile excites you, stay tuned! We are currently working on rolling out progressive 4337 support in the Rally Protocol SDK and will have some fun announcements over the next couple of weeks and at the Rally Mobile Summit at Consensus.

About RallyProtocol

RallyProtocol is an all-in-one Web3 mobile toolkit that enables developers to create seamless, end-to-end onchain experiences for native mobile apps, featuring embedded wallets and gasless transactions. Whether you’re building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our mission is to give developers the power to create user-friendly mobile UX with fewer taps and zero web3 touchpoints. Want to learn more? Dive into our developer documentation here.

Requiring wallet creation upfront often disrupts users' end-to-end experience within a single application. Whether they encounter third-party pop-ups for authentication or switch apps to connect an external wallet, these disruptions lead to drop-offs and unnecessary taps during mobile onboarding.

While users are accustomed to downloading and launching an app and immediately accessing its features, the world of web3 imposes additional requirements, creating a dissonance from the seamless, in-app experiences mobile users have come to expect.

The RallyMobile SDK aims to solve this problem by providing developers with tools to create an embedded wallet under the hood within their native mobile app. With RallyMobile SDK, developers can generate embedded wallets on-demand on the user's device, eliminating the requirement to create a wallet upfront. The SDK offers developers the flexibility to display keys, balances, and the option to export/import keys for their users, allowing them to showcase web3 features or abstract away from users as needed.

While RallyMobile SDK does not require authentication, developers can choose to implement it at the app level if necessary for their specific use case. This approach grants developers complete control and flexibility over the onboarding process and a single-application experience. 

The impact of RallyMobile SDK's pop-upless wallet creation is evident in apps like DeepDiveRewards by Taki. It utilizes RallyMobile SDK to seamlessly create embedded wallets during the initial app launch without requiring any user input. With the elimination of web3 onboarding, users can start playing the game with just one tap.

By enabling embedded wallet creation under the hood, RallyMobile SDK significantly improves the mobile web3 user experience:

1. Seamless In-App Experience: Users can create an embedded wallet and start using the app immediately, without being redirected to other apps or going through multiple sign-in steps. This singular, uninterrupted in-app experience keeps users in your app. 

2. Reduced Onboarding Friction: Eliminating mandatory user authentication at the SDK level streamlines the onboarding process. Users can dive straight into using the app without facing the usual web3 onboarding hurdles.

3. Increased User Retention: A simplified, pop-upless onboarding flow reduces drop-off rates. Users are more likely to complete the onboarding process and continue using the app when it's seamless and friction-free.

4. Developer Flexibility: RallyMobile SDK gives developers the freedom to design the onboarding experience that best fits their app. They can add user authentication at the app level if needed, but it's not a one-size-fits-all requirement

5. Fewer Taps, Better UX: Reduce the number of taps required for onchain onboarding to get started with your app.

RallyProtocol is an all-in-one Web3 mobile toolkit that enables developers to create seamless, end-to-end onchain experiences for native mobile apps, featuring embedded wallets and gasless transactions. Whether you’re building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our mission is to give developers the power to create user-friendly mobile UX with fewer taps and zero web3 touchpoints. Want to learn more? Dive into our developer documentation here.

In this post, we’ll dive into the need for gasless solutions and how RallyProtocol's Gasless Transactions offering is helping developers create better web3 mobile experiences and leading gasless transactions on Polygon.

Gas fees are a necessary component of blockchain networks, they secure the network and incentivize validators, but they introduce significant user experience hurdles that hinder adoption, especially for mobile apps.

For developers building onchain mobile apps, gas fees are a major pain point causing user drop-off. New users are unfamiliar with gas fees and the multi-step process of acquiring tokens to pay for them. This journey involves creating exchange accounts, completing KYC verification, purchasing tokens with credit cards, and transferring them to on-chain wallets – a stark contrast to the seamless onboarding flows of web2 apps.

Moreover, developers face challenges with volatile gas fees that fluctuate based on token prices and network congestion. Users frequently encounter failed or stuck transactions, leading to frustration and churn.

Gas-free onchain transactions are a powerful way to enable developers to create onchain app experiences free from the complexities of web3. With just one tap, users can perform essential on-chain operations like claiming NFTs, transferring tokens, or deploying smart contracts directly from native mobile apps—no gas required.

By abstracting away gas fees, developers are able to craft non-interrupted, engaging app experiences. Users remain immersed in the curated app journey, without the friction of fulfilling on-chain requirements externally.

RallyProtocol provides a comprehensive suite of tools and services, drastically reducing development, operational, and security overheads associated with implementing gasless transactions. Developers can focus on creating value through their app, rather than grappling with the complexities of building in-house gasless solutions.

With its mobile-first approach, RallyProtocol streamlines the integration of gasless transactions into native mobile apps. Developers no longer need to piece together fragmented software or rely on costly wallet services. It's is versatile enough to support gasless transaction across tools and platforms whether you’re building an iOS or Android app in React Native, Flutter, Swift, or Kotlin. It can also be leveraged from your backend servers or web app.

Gasless transactions are enabled using user-custodied embedded EOA wallets, rather than relying on smart accounts. This provides greater flexibility and optionality for developers and end-users alike.

The platform offers seamless compatibility with RallyProtocol's natively embedded wallet solution and supports integrations with any third-party wallet developers choose. This modularity frees developers to utilize streamlined APIs for easy gasless transaction integration or build their infrastructure if preferred.

Polygon has become the go-to network for teams building low-cost onchain solutions, with millions of active wallets and transactions daily. Within Polygon, RallyProtocol has emerged as the leading provider of gasless transactions.

Over the last 180 days, teams using Rallyprotocol contributed to over 70% of all Gas Station Network (GSN) transactions on Polygon. These transactions come from some of the top teams in web3 building mobile applications, like Taki Games, Trophy Network, Unite, and the Superlayer.

If you're a developer aiming to create delightful onchain experiences, we provides the tools to make it happen. Explore our docs to learn more about easily integrating gasless transactions into your app. 

RallyProtocol is an all-in-one Web3 mobile toolkit that enables developers to create seamless, end-to-end onchain experiences for native mobile apps, featuring embedded wallets and gasless transactions. Whether you’re building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our mission is to give developers the power to create user-friendly mobile UX with fewer taps and zero web3 touchpoints. Want to learn more? Dive into our developer documentation here.

Amoy GSN Core Contract Addresses

About RallyProtocol

RallyProtocol is an all-in-one Web3 mobile toolkit that enables developers to create seamless, end-to-end onchain experiences for native mobile apps, featuring embedded wallets and gasless transactions. Whether you’re building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our mission is to give developers the power to create user-friendly mobile UX with fewer taps and zero web3 touchpoints. Want to learn more? Dive into our developer documentation here.

GSN was not deployed to Amoy yet so we took it upon ourselves to do so and get the first relayer set up. When we started testing we noticed the following error on every attempt to relay a transaction:

insufficient funds for gas * price + value: address 0x0000000000000000000000000000000000000000 have 2170300023505000000 want 900000000000000000000 (supplied gas 600000000)

We initially assumed it was a misconfiguration from our GSN deploy or one of our clients. It’s easy to miss a setting. Oddly everything worked on our integration test infra. Our integration tests use a hardhat node forking off of the testnet networks before every run. So something is different between sending transactions to hardhat vs sending transactions to Amoy.

The above error message is specific to the Polygon bor client. The same error message in geth is “insufficient balance to pay for gas” after googling around for “0x0000000000000000000000000000000000000000” and “insufficient balance to pay for gas” we found this issue in the geth repo. Aha! So sending an eth_call with a gas price set has different behavior in different node clients! Now we had something to look for.

Digging in to the GSN relayer codebase we uncovered this line:

await this.relayHubInstance.calculateCharge( maxPossibleGasFactorReserve, relayTransactionRequest.relayRequest.relayData, { gasPrice: relayTransactionRequest.relayRequest.relayData.maxFeePerGas } )

Getting rid of that pesky gasPrice was all it took and caused the same behavior across the board and we were up and running on Amoy.

We are happy to support our developer community in building onchain mobile apps by getting RallyTransact up on Amoy but we wish a few things had been easier in this migration:

It seems there are different versions of bor running on Amoy vs Polygon PoS mainnet. This makes the utility of a testnet a bit diminished as we can’t fully trust apples to apples comparisons between the two networks.

I really did miss etherscan functionality when trying to work with the Oklink explorer. Once again, differences between mainnet and testnets makes things harder for the dev community.

About RallyProtocol

RallyProtocol is an all-in-one Web3 mobile toolkit that enables developers to create seamless, end-to-end onchain experiences for native mobile apps, featuring embedded wallets and gasless transactions. Whether you’re building an iOS or Android app in Flutter, Unity, React Native, Expo, Swift, or Kotlin, our mission is to give developers the power to create user-friendly mobile UX with fewer taps and zero web3 touchpoints. Want to learn more? Dive into our developer documentation here.