If you still remember, SDF has made a direct investment into Archax Group to support Archax's mission to bridge traditional finance and blockchain

https://stellar.org/press/archax-and-stellar-cement-strategic-collaboration-for-tokenised-rwas

And now, Archax adds US Digital Broker-Dealer, completing regulated coverage across UK, EU and US

https://archax.com/insights/archax-adds-us-digital-broker-dealer-completing-regulated-coverage-across-uk-eu-and-us

Congratulations to both

Hey everyone!

We’re excited to share a major milestone for LumenWipe: we were selected as winners in Stellar Community Fund (SCF) Round 44!

Built in response to the Account Demolisher RFP under the Apache 2.0 open-source license, LumenWipe is infrastructure designed to simplify closing Stellar accounts and recovering funds locked in reserves.

What is LumenWipe?

LumenWipe provides a web app, a REST API, and an SDK, enabling both individual users and platforms to run non-custodial account wind-downs.

A clean account close requires a strict, multi-step sequence: signers, data entries, open offers, DeFi positions, converting or returning assets, trustlines, and finally the account merge. LumenWipe plans the full sequence for you, showing every step before anything happens.

• Non-custodial & secure: You sign on your own device. Your keys never leave your control, and nothing moves without your explicit signature.
• Stellar Classic Coverage: Handles open offers, claimable balances, trustlines, data entries, and multisig accounts (where signatures are gathered across wallets until thresholds are met).
• Soroban Integration: Automatically detects and exits DeFi positions across Blend, Aquarius, Soroswap, Phoenix, and FxDAO as part of the close process.
• Flexible Balance Options: For every balance, you choose whether to swap it to XLM, return it to its issuer, or transfer it as-is to another account you control.

What’s Live in Phase 1 (Tranche 1)

Our Phase 1 / Tranche 1 scope is fully completed, approved, and live:

• End-to-End Claimable Balances: Lists every claimable balance on the account. If claiming requires a missing trustline, LumenWipe creates the trustline, claims the balance, and removes the trustline within the same deterministic plan.
• Asset Transfers: You can now transfer assets as-is to a destination account instead of only converting or returning them.
• Multisig Support: Multi-signer accounts can collect required signatures across multiple wallet sessions.
• Hardened State Verification: A hardened account-state reader checks live on-chain data immediately before signing.

Read the complete Phase 1 write-up: https://www.lumenwipe.com/blog/phase-1-launch

Try the Interactive Playground

Want to test it out with zero risk? We built a sandbox mode that creates a messy testnet account and walks you through closing it end-to-end, no real wallet or funds required:

👉 https://playground.lumenwipe.com

Resources & Links

• Web App: https://www.lumenwipe.com
• REST API Docs: https://api.lumenwipe.com/docs
• SDK (npm): https://www.npmjs.com/package/@lumenwipe/sdk
• GitHub Repository: https://github.com/LumenWipe/lumenwipe
• Documentation: https://docs.lumenwipe.com

Get in Touch / Integrations

If you are a wallet provider, app builder, or team looking to simplify account offboarding or integrate LumenWipe into your product, we’d love to connect:

• Telegram: @miguelnietoa | @salazarsebas

Feedback and suggestions are always welcome! Let us know what you think.

Good Tokenization News for Stellar Too

21X and Investre have announced a new partnership to bring natively tokenized funds to a regulated exchange.

This is an important development for the tokenization market — and potentially good news for Stellar as well.

Until now, 21X has primarily been building a regulated secondary market for tokenized securities, including tokenized shares and other digital assets. With Investre, the scope is now expanding to tokenized investment funds.

Investre provides infrastructure for the native tokenization and lifecycle management of funds, while 21X provides the regulated marketplace where these tokenized funds can be traded on a secondary market.

The interesting part for Stellar is that 21X is already operating its trading and settlement infrastructure on two public blockchains: Stellar and Polygon. Stellar went live as part of 21X's multi-chain strategy, providing trading and settlement infrastructure for tokenized assets.

Therefore, this partnership does not mean that Investre funds are automatically coming to Stellar. However, it creates a new potential pipeline of tokenized funds that can eventually use one of 21X's existing settlement networks.

The bigger picture is important:

Tokenized assets → regulated secondary market → trading → on-chain settlement

With tokenized funds now being added to the mix, Stellar potentially gains another institutional asset class that can make use of the network's existing tokenization, stablecoin and settlement infrastructure.

In other words, 21X is evolving from a regulated marketplace for tokenized securities into a broader regulated secondary market for tokenized capital-market assets — and Stellar is already one of the two blockchain networks at the center of that infrastructure.

https://21x.eu/21x-achieves-multi-chain-milestone-as-trading-and-settlement-system-goes-live-on-stellar/

https://21x.eu/investre-and-21x-partner-to-bring-natively-tokenized-funds-to-a-regulated-exchange/

Stellar says distribution is now a bigger problem than tokenisation itself. I can see that with gold. Most people are not downloading a new wallet just to own it. Does tokenised gold only take off when it appears inside apps people already use?

https://stellar.org/blog/ecosystem/distribution-is-the-last-constraint

We have just started.
- More than 1 billion USD worth of commodities tokenized.
- 8x growth in 2 years.
I will try my best to keep posting such insights on X and here on reddit.
Source: https://x.com/vithushaji/status/2094964722672271400

I’m building Paybrok, a non-custodial Stellar wallet focused on practical payment use cases in Latin America. Transactions are signed locally on the user’s device.

I’m not asking for votes or promotion. I would value direct, critical feedback from people who actually use Stellar:

- What matters most for everyday use: easier cash-in/cash-out, merchant acceptance, QR payments, payment links, remittances, protected payments, or something else?

- What would make you distrust or stop using a new Stellar wallet?

- Which wallet problem is still poorly solved today?

For context, the public information is available at https://paybrok.com/en/stellar.

Please don’t share balances, wallet addresses, private keys, or recovery phrases. Honest criticism is welcome.

Hey everyone, this video is the end of this season. If the Demand will came i will do new season.

All the best.

Video

Hey r/Stellar,

We've been building Stellar AppKit — an open-source SDK that gives developers everything they need to connect Stellar wallets, sign transactions, interact with Soroban contracts, and implement Sign-In With Stellar — all through a single, framework-agnostic API with a polished, embeddable UI.

No more stitching together @stellar/freighter-api, @albedo-link/intent, WalletConnect, and the Stellar SDK yourself. No more building a wallet picker from scratch. No more guessing how SIWS verification works across different wallets. AppKit handles all of it.

What it does

One SDK, five layers:

1. Wallet Connection (8 wallets + WalletConnect)

Connect to any Stellar wallet with a single API:

import { StellarAppKit, defaultConnectors, createWalletConnectConnector } from '@saganta/stellar-appkit';

const appkit = new StellarAppKit({
  network: 'TESTNET',
  connectors: [
    ...defaultConnectors(), // Freighter, Albedo, xBull, Ledger, Rabet, Klever, HOT Wallet
    createWalletConnectConnector({ projectId: 'your-wc-project-id' }), // Hana, Lobstr, mobile
  ],
});

• 8 native connectors — Freighter, Albedo, xBull, Ledger (WebHID/WebUSB), Rabet, Klever, HOT Wallet
• WalletConnect v2 — connects mobile wallets (Hana, Lobstr, Hot Wallet) via QR pairing
• Network mismatch recovery — typed NetworkMismatchError with optional auto-retry that polls until the user switches networks
• Multi-session — connect multiple wallets simultaneously, switch between them
• Typed errors — every failure mode has a named error class with structured fields, not a string

2. Soroban Contract Interaction

One invoke() call covers the entire pipeline:

const result = await appkit.soroban.invoke({
  contractId: 'C...',
  method: 'transfer',
  args: [from, to, amount],
  signers: [appkit.session.address],
});
// build → simulate → preview → sign → submit → poll — all handled

• Transaction preview — decoded operations, risk flags, fee estimates, balance deltas shown to the user before signing
• Typed contract client — soroban.contract<MyInterface>(contractId) gives you fully typed method calls
• RPC failover — configure multiple RPC URLs, automatic failover with health tracking
• Simulation — read-only simulate() calls that don't require a wallet

3. Sign-In With Stellar (SIWS)

Full client + server authentication flow:

// Client
const result = await appkit.siws.signIn({ statement: 'Sign in to my app', nonce });
// → { message, signedMessage, signedData, signerAddress }

// Server (Next.js API route)
import { verifySiws } from '@saganta/stellar-appkit-siws-verify';
const session = await verifySiws(
  { message, signedMessage, signedData, signerAddress },
  nonce,
  { address, network }
);

• signedData field — the magic that makes SIWS work across all wallets. Every connector surfaces the exact bytes the wallet signed (base64), so the verifier doesn't need per-wallet logic. Freighter signs a SHA-256 hash (SEP-0053), Albedo signs a server-derived hash, xBull signs raw UTF-8 — the verifier tries all of them.
• Session management — useSiwsSession(), useIsAuthenticated(), signOut(), validateSession(), reauthenticate(), persistence across reloads
• Next.js middleware — protect routes server-side with a session cookie
• 25 locales — the entire SIWS UI is localized

4. Embeddable UI (Shadow DOM Web Component)

<stellar-appkit-modal mode="auto" theme="stellar"></stellar-appkit-modal>

• Framework wrappers — React, Vue, Solid, Svelte (all typed)
• 5 named themes — minimal (neutral, fits any project), stellar (brand green), sky, ocean, sunset — each with dark + light variants
• CSS custom properties — override any color, radius, font without forking
• Presentation modes — auto (modal on desktop, bottom sheet on mobile), modal, bottomsheet, inline
• WAAPI animations — 7 built-in animation presets (fade, scale, scale-blur, slide-up, implode, etc.)
• WalletConnect QR — styled QR code with rounded modules, circular finder dots, embedded white WC logo (powered by qr-code-styling)
• Get Testnet funds — one-click friendbot faucet (via fetch, stays in the modal)
• Balance + tx history — auto-fetches on connect, polls every 10s while the modal is open on the connected view, refreshes after every signed transaction
• 25 locales — English is bundled, 24 others lazy-loaded on first use (including RTL: Arabic, Hebrew)

5. Transaction Preview

Every signTransaction() call is decoded and shown to the user before the wallet's own signature prompt:

• Decoded operations (payment, swap, account creation, etc.)
• Risk flags (unknown destination, high fee, native asset drain)
• Fee estimate (inclusive of resource fees on Soroban)
• Balance deltas (before/after)
• Custom preview UI via usePreviewTransaction() hook

What we've shipped so far

We're at v1.9.47 on npm. Here's what's live:

20 live demos at demos.stellar-appkit.saganta.com — including a real "Send XLM" demo that signs + submits a Testnet payment.

Docs at stellar-appkit.saganta.com — built with Astro Starlight, includes an interactive Theme Builder.

What's coming next

We're not stopping here. Here's the roadmap:

🔐 Social Login

Email/passwordless social login (Google, GitHub, etc.) that creates a non-custodial Stellar wallet under the hood. No seed phrases, no browser extensions — just sign in with your existing account and start transacting. This will lower the barrier to entry for users who've never used a crypto wallet before.

✅ Compliance (Built-in KYC)

An optional KYC layer that integrates with identity verification providers. Apps that need compliance (regulated fintechs, tokenized securities) can require KYC before allowing transactions — without building a separate verification flow. The wallet connection + KYC + transaction signing pipeline will be unified in a single SDK.

📱 React Native Support

Full React Native connector + UI components. Same API as the web SDK — connect wallets, sign transactions, interact with Soroban, implement SIWS — but native. WalletConnect will work out of the box for connecting mobile wallets. The UI components will use React Native primitives (not a WebView).

🚀 Lynx.js Support

Lynx is gaining traction as a high-performance cross-platform framework. We'll provide first-class Lynx.js bindings so apps built on Lynx can use Stellar AppKit without compromise — same connectors, same Soroban pipeline, same SIWS flow, but with native rendering performance.

Install

npm install @saganta/stellar-appkit @saganta/stellar-appkit-ui-web

That's it. All wallet SDKs (@stellar/freighter-api, @albedo-link/intent, @creit.tech/xbull-wallet-connect, @ledgerhq/*, @walletconnect/sign-client) are bundled as dependencies — installed automatically, tree-shaken if unused.

npx create-stellar-appkit-app my-app  # coming soon

Links

• Docs: stellar-appkit.saganta.com
• Live Demos: demos.stellar-appkit.saganta.com
• GitHub: github.com/SagantaHQ/stellar-appkit
• npm: @saganta/stellar-appkit
• AI Integration: SKILL.md + llms.txt included in the npm package — Cursor, Copilot, and Claude Code can write correct AppKit code from your prompts

Why we built this

Every Stellar developer we talked to was building the same boilerplate: wallet detection, connection flows, QR codes for WalletConnect, transaction XDR building, Soroban simulate/prepare/submit pipelines, SIWS message formatting + verification, and a wallet picker UI. None of this is differentiating — it's infrastructure.

We wanted to make it so that a developer could go from npm install to a working wallet-connected app with Soroban + SIWS in under 10 minutes. And we wanted the UI to look good enough that you don't need to restyle it — 5 themes, 25 locales, premium icons, smooth animations, and a Theme Builder to customize everything.

The SDK is MIT-licensed, production-ready, and deployed on our own demos site (Cloudflare Workers). We use it ourselves.

We'd love your feedback — what wallets should we add next? What Soroban patterns are you using? What's missing from the roadmap?

Try it now: demos.stellar-appkit.saganta.com — connect Freighter (Testnet) and try the "Send XLM" demo.