Get Started
Learn about the SDK and modules architecture
The SDK is a comprehensive, modular plug-in framework designed to simplify multi-chain wallet development.
It is built on some core principles: self-custodial and stateless (private keys never leave your app and no data is stored by WDK), unified interface (consistent API across all blockchains), and cross-platform compatibility (works seamlessly from Node.js to React Native to embedded systems).
Capabilities
Multi-Chain Support: Bitcoin, Ethereum, TON, TRON, Solana, Spark, and more
Account Abstraction: Gasless transactions on supported chains
DeFi Integration: Plug-in support for swaps, bridges, and lending protocols
Extensible Design: Add custom modules for new blockchains or protocols
Modular Architecture
WDK's architecture is built around the concept of composable modules. Each module is a specialized component that handles specific functionality, allowing you to build exactly what you need without unnecessary complexity.
Each module has a single responsibility. Wallet modules handle blockchain operations, protocol modules manage DeFi interactions, and the core module orchestrates everything.
New functionality is added through modules rather than modifying core code. Also, modules are configured through simple objects, making them easy to customize for different environments and use cases.
Module Types
WDK modules are organized into five main categories, each serving a specific purpose in the blockchain application stack:
How to use the SDK
The WDK SDK uses a registration-based system where modules are added to a central orchestrator. This creates a unified interface while maintaining module independence.
Registration Flow
1. Core Module Initialization
import WDK from '@tetherto/wdk'
const seedPhrase = WDK.getRandomSeedPhrase() // or use your own seed phrase
const wdk = new WDK(seedPhrase)2. Wallet Module Registration
import WalletManagerEvm from '@tetherto/wdk-wallet-evm'
import WalletManagerBtc from '@tetherto/wdk-wallet-btc'
const wdkWithWallets = wdk
.registerWallet('ethereum', WalletManagerEvm, {
provider: 'https://eth.drpc.org'
})
.registerWallet('bitcoin', WalletManagerBtc, {
provider: 'https://blockstream.info/api'
})3. Protocol Module Registration
import SwapveloraEvm from '@tetherto/wdk-protocol-swap-velora-evm'
const wdkWithProtocols = wdkWithWallets
.registerProtocol('swap-velora-evm', SwapveloraEvm)Unified Operations
Once registered, all modules work through the same interface:
// Get accounts from different blockchains using the same method
const ethAccount = await wdkWithProtocols.getAccount('ethereum', 0)
const btcAccount = await wdkWithProtocols.getAccount('bitcoin', 0)
// Check balances using unified interface
const ethBalance = await ethAccount.getBalance()
const btcBalance = await btcAccount.getBalance()
// Send transactions with consistent API
const ethTx = await ethAccount.sendTransaction({
to: '0x...',
value: '1000000000000000000'
})
const btcTx = await btcAccount.sendTransaction({
to: '1A1z...',
value: 100000000
})
// Use DeFi protocols through the same interface
const swapResult = await wdkWithProtocols.executeProtocol('swap-velora-evm', {
fromToken: 'ETH',
toToken: 'USDT',
amount: '1000000000000000000'
})Creating Custom Modules
WDK's modular architecture makes it straightforward to add support for new blockchains or protocols. Each module type has a specific interface that must be implemented.
Wallet Module Interface
interface WalletModule {
// Account management
getAccount(index: number): Promise<Account>
getAddress(index: number): Promise<string>
getBalance(index: number): Promise<BigNumber>
// Transaction operations
sendTransaction(params: TransactionParams): Promise<TransactionResult>
estimateTransaction(params: TransactionParams): Promise<TransactionQuote>
// Key management
signMessage(message: string, index: number): Promise<string>
verifySignature(message: string, signature: string, address: string): Promise<boolean>
// Blockchain-specific operations
getTransactionHistory(index: number, limit?: number): Promise<Transaction[]>
getTokenBalance(index: number, tokenAddress: string): Promise<BigNumber>
}Protocol Module Interface
interface ProtocolModule {
// Protocol execution
execute(params: ProtocolParams): Promise<ProtocolResult>
estimate(params: ProtocolParams): Promise<ProtocolQuote>
// Supported operations
getSupportedTokens(): Promise<Token[]>
getSupportedChains(): Promise<Chain[]>
getOperationTypes(): Promise<OperationType[]>
// Protocol-specific methods
getLiquidityPools?(): Promise<Pool[]>
getLendingRates?(): Promise<Rate[]>
getBridgeRoutes?(): Promise<Route[]>
}Module Implementation Example
class CustomWalletModule implements WalletModule {
private provider: string
private chainId: number
constructor(config: { provider: string; chainId: number }) {
this.provider = config.provider
this.chainId = config.chainId
}
async getAccount(index: number): Promise<Account> {
// Implement account derivation logic
const privateKey = await this.derivePrivateKey(index)
return new CustomAccount(privateKey, this.provider)
}
async getAddress(index: number): Promise<string> {
const account = await this.getAccount(index)
return account.getAddress()
}
async getBalance(index: number): Promise<BigNumber> {
const address = await this.getAddress(index)
// Implement balance fetching logic
const balance = await this.fetchBalance(address)
return new BigNumber(balance)
}
async sendTransaction(params: TransactionParams): Promise<TransactionResult> {
// Implement transaction sending logic
const account = await this.getAccount(params.accountIndex)
const tx = await account.sendTransaction(params)
return tx
}
// Additional methods...
}Module Registration
// Register your custom module
const wdkWithCustom = wdk.registerWallet('custom-chain', CustomWalletModule, {
provider: 'https://custom-rpc-endpoint.com',
chainId: 12345
})
// Use it like any other module
const customAccount = await wdkWithCustom.getAccount('custom-chain', 0)
const balance = await customAccount.getBalance()Quick Start Paths
Ready to start building? Choose your development environment: