Introduction to WDK: Tether's Wallet Development Kit

By the end of this post, you'll understand what WDK is, why it was built, how it's architected, what platforms it supports, and the core concepts you need to start building with it.

Every major dev breakthrough followed the same pattern

Consider the frameworks that fundamentally changed how developers build software. React arrived in 2013 and simplified the mess of building interactive web UIs; suddenly, you didn't need to manually track DOM state or orchestrate updates. React Native came three years later and made cross-platform mobile development approachable, collapsing the division between iOS and Android. Next.js unified frontend and backend into a single framework. Hugging Face and the LLM APIs made it possible to build production AI applications without training your own models from scratch.

Each of these frameworks did the same thing: they took a domain that was painful, fragmented across incompatible tools, and accessible only to specialists, and made it approachable enough for thousands of developers to build on it. Each one created an explosion of new products, companies, and possibilities.

Wallet development is stuck in 2016. It hasn't had its breakthrough moment.

A brief history of wallet friction

Bitcoin's early wallets were command-line tools written by cryptographers, for cryptographers. Later, in 2016, wallets became browser extensions with an approachable UI. But, for the first time, non-technical users could interact without understanding key derivation or transaction construction. But that's where the progress stopped. Eight years later, wallet UX remains painful, not just for users, but especially for developers. In 2016, building around Bitcoin meant targeting essentially one dominant network, with a handful of alternatives like Ethereum just beginning to emerge. 

Today, the blockchain ecosystem evolves faster than any single team can track, developers face a radically different landscape fragmented into hundreds of incompatible chains, each with its own SDK, API conventions, transaction approach, security assumptions, signing mechanisms… and with constantly shifting standards.

The result: wallet adoption has become harder, not easier. In 2016, we made wallets usable for end users. But no one solved the developer experience. As the number of networks grew 10–30x, the complexity of building secure, multi-chain wallets grew even faster. The interface between crypto and everyday applications remains a bottleneck, not because users lack interest, but because building reliable, secure wallet infrastructure across multiple chains is still too complex and too risky.

Wallet development hasn't had its framework moment yet. WDK is it.

Why wallet development is broken

The real barrier isn't complexity, it's fear. Security and key management in crypto are genuinely hard, and the stakes are real. Developers worry about vulnerabilities. Institutions worry about liability. One mistake in how you handle private keys, one vulnerability in key derivation, one compromise in secure storage, and your users lose everything. That fear is rational. It keeps many teams from even attempting multi-chain wallets. 

And if you decide to push forward anyway, you still face the proprietary wall. Existing wallet solutions charge costly fees, lock you into their ecosystem, require their infrastructure, or force you to use closed-source code you can't audit. There's no open alternative that works everywhere.

The result is clear: most developers ship slowly, cut corners on multi-chain support, or abandon the idea entirely. The unified standard doesn't exist. The shared interface doesn't exist. Wallet adoption is hard, not because users don't want wallets, but because the developer experience is broken.

WDK exists to fix that.

What is WDK?

WDK, the Wallet Development Kit by Tether, is an open-source toolkit for building secure, multi-chain, self-custodial wallets that run anywhere. It works across Node.js backends, React Native apps, and Bare (a minimal JavaScript runtime designed for constrained environments). This lets you deploy the same wallet logic on servers, mobile devices, or embedded systems without rewriting code.

The core promise is simple: one consistent API for every blockchain. Integrate once, and it works across Bitcoin, Ethereum, Solana, TON, TRON, Spark, and more. Adding a new chain doesn’t require re-architecting your app; just plug in a module.

But WDK isn't just for traditional applications and devices; Bare is what makes this portability practical. It removes the heavy layers of Node.js, leaving a lightweight runtime that can execute wallet logic in extremely limited environments. Instead of megabytes of dependencies, you get a minimal footprint that runs on devices with tight memory constraints, enabling wallets in places where they traditionally couldn’t exist.

Tether built WDK around a clear belief: anyone should be able to build, deploy, and use a self-custodial wallet without friction, gatekeepers, or vendor lock-in. The vision extends naturally to the autonomous future world: AI agents, bots, and machine-to-machine payments. Whether it’s an agent managing its own budget or a device transacting as part of its operation, WDK treats wallets as a first-class primitive.

WDK is designed to scale to trillions of wallets across humans and machines.

Core principles

WDK is built on six foundational principles that shape every design decision. Rather than a monolithic framework that forces you to accept all its opinions, WDK is intentionally modular, open, and developer-friendly.

Runs anywhere: Whether it's a Node.js server, a React Native mobile app, or a Bare runtime on an embedded device, the same wallet code executes without modification. From smartphones to smart devices to autonomous systems.

Modular & extensible:  Pick only the wallet modules and protocols you need. Build custom modules without touching core code. The framework gets out of your way.

Developer-centric:  Strong TypeScript support. Clear, intuitive SDK design. Extensive documentation. Ready-to-use starter templates that let you ship fast.

Secure by design: Private keys never leave the user's device. Stateless and self-custodial architecture ensures private keys never leave user control. No central database to breach. No recovery backdoors. Pure self-custody.

Zero lock-in: Fully open-source and free to adopt. No vendor fees. No required cloud backend. No proprietary dependencies. You own your wallet code completely. Leave anytime, take your implementation with you.

Ecosystem-backed: Maintained and actively developed by Tether, with strong community involvement. You're not betting on a startup that might disappear. You're building on infrastructure built to last.

Architecture: the four foundations

WDK is built on four pillars that work together seamlessly. Each one solves a specific problem, so you don't have to.

SDK: a unified API that your application code talks to. Whether you're registering a wallet module, fetching balances, or executing a transaction, you use the same SDK, but you choose which fully open-source modules you want to use. No context switching between different libraries.

Indexer API: reliable access to blockchain data for Bitcoin and Tether tokens (USDt, XAUt, USAt) without the headache. Balances, transactions, historical data, and real-time updates, all abstracted behind a consistent interface. No need to figure out which RPC endpoint to query or how to parse chain-specific responses.

UI Kit: reusable React Native components for building wallet interfaces. Covers the most common wallet screens so you ship faster. Use them, customize them, move on.

Examples & starters: production-ready wallet templates that work out of the box. Clone a starter, register your modules, and deploy. No blank canvas paralysis. No hours spent on boilerplate.

The module system

Inside the SDK, everything is built around composable modules. Rather than a monolithic package, WDK lets you assemble only what you need. The Core Module (@tetherto/wdk) acts as the central orchestrator; it registers and manages your wallet and protocol modules through a unified interface.

Here's how it works in practice:

• Instantiate the Core: Create a WDK instance with a seed phrase
• Register wallet modules: Add the blockchains you want to support
• Register protocol modules Layer on DeFi capabilities (swaps, bridges, lending)
• Use a single API: All interactions happen through the Core, regardless of which blockchain you're targeting

The Core Module handles all the coordination behind the scenes. Account management, transaction signing, and state tracking. You use the Core's unified interface for everything.

Wallet modules handle blockchain-specific operations, generating addresses, signing transactions, and reading balances, for each supported chain. Protocol modules sit on top and add DeFi capabilities, such as swaps, bridges, lending, fiat on- and off-ramps, etc. The architecture keeps modules independent while maintaining a cohesive experience.

For the complete guide on the Core Module's capabilities, see the official Core Module documentation.

Module naming conventions

All official packages follow a consistent pattern under the @tetherto scope on npm. This consistency is intentional — it makes the ecosystem discoverable and makes it easy for anyone to create and contribute modules.

Core:

@tetherto/wdk                              # Core orchestrator

Wallet modules:

@tetherto/wdk-wallet-<chain>               # Chain wallet modules

Protocol modules:

@tetherto/wdk-protocol-<type>-<n>-<chain>    # Protocol modules

Extending WDK: Build your own modules

The naming convention isn't just a style guide; it's an invitation. If you need to support a blockchain that WDK doesn't yet have, or build a DeFi integration for a protocol that isn't covered, you can create your own module following these patterns. Implement the standard WDK module interface, follow the naming convention, and you have a module that works seamlessly with the ecosystem.

The WDK community has already started building. Check out the Community Modules documentation to see what's available or learn how to contribute your own.

Creating a wallet in code

Most wallet SDKs force you to learn each blockchain's unique APIs, security models, and quirks. WDK inverts that: you write code once, and it works across every supported chain. The developer experience feels like Web2, a simple, predictable API that abstracts complexity without hiding control. 

Here's the real WDK API in action:

import WDK from '@tetherto/wdk'
import WalletManagerEvm from '@tetherto/wdk-wallet-evm'
import WalletManagerTron from '@tetherto/wdk-wallet-tron'
import WalletManagerBtc from '@tetherto/wdk-wallet-btc'
import SwapVeloraEvm from '@tetherto/wdk-protocol-swap-velora-evm'

// Generate a secure seed phrase for the wallet
const seedPhrase = WDK.getRandomSeedPhrase()

// Create the wallet and register the chains and protocols you need
const myWallet = new WDK(seedPhrase)
  .registerWallet('ethereum', WalletManagerEvm, { /* config */ })
  .registerWallet('tron', WalletManagerTron, { /* config */ })
  .registerWallet('bitcoin', WalletManagerBtc, { /* config */ })
  .registerProtocol('swap-velora-evm', SwapVeloraEvm, { /* config */ })

What's happening here:

1. First, you import the core WDK orchestrator '@tetherto/wdk' and the specific modules you need, in this case three network modules '@tetherto/wdk-wallet-evm', '@tetherto/wdk-wallet-tron', and '@tetherto/wdk-wallet-btc', and one protocol module '@tetherto/wdk-protocol-swap-velora-evm'.
2. Next, you generate a seed phrase (BIP-39 compliant, by default 24 words), or you could also import an existing one.
3. Finally, it’s as easy as instantiating the WDK with that seed phrase, then chain .registerWallet() calls for each blockchain you want to support. Each registration tells WDK: "on this chain, use this wallet module with these settings."
4. Add DeFi protocols, the same way, .registerProtocol() for swaps, bridges, lending, whatever you've imported.

The result is a fully functional, multi-chain wallet with DeFi capabilities. That's one unified wallet object that understands Bitcoin, Ethereum (or any EVM-compatible layer with the correct module configuration), TRON, and can execute swaps on EVM networks. All in less than 15 lines of code.

Extending later is frictionless. Adding a new chain means registering a new module. Six months in, do you need to add support for Solana? Import the Solana wallet module and add one line: .registerWallet('solana', WalletManagerSolana, { /* config */ }). The rest of your code doesn't change. The wallet already knows how to coordinate with new modules. This is the power of the modular, registration-based design.

What's next

In this post, we covered the what and the why of WDK; its purpose, vision, core principles, and architecture.

In the next article, Wallet Fundamentals: Build, Sign, and Send Your First Transaction in WDK, we'll get hands-on with WDK: installing it, registering your first wallet module, generating an address, and sending a test transaction.

Ready to explore?

• Node.js Quickstart →
• React Native Quickstart →
• Key Concepts Reference →
• GitHub →
• Discord Community →