wdk-skill

Install and integrate Tether's Wallet Development Kit (WDK) into any project. Supports Node.js, React Native, and browser environments. Use when the user wants to build self-custodial wallets, integrate multi-chain cryptocurrency support, or perform blockchain operations like sending transactions, token swaps, cross-chain bridges, or DeFi lending.

SKILL.md

---
name: wdk-skill
description: Install and integrate Tether's Wallet Development Kit (WDK) into any project. Supports Node.js, React Native, and browser environments. Use when the user wants to build self-custodial wallets, integrate multi-chain cryptocurrency support, or perform blockchain operations like sending transactions, token swaps, cross-chain bridges, or DeFi lending.
license: Apache-2.0
compatibility: Requires Node.js 18+ or compatible JavaScript runtime. Network access required for blockchain operations.
metadata:
  author: wdk-skill
  version: "1.0.0"
  wdk-version: "latest"
---

# WDK Skill - Wallet Development Kit Integration

This skill helps you integrate Tether's Wallet Development Kit (WDK) into any project. WDK is an open-source toolkit for building secure, multi-chain, self-custodial wallets.

## What This Skill Does

1. **Installation Wizard** - Set up WDK from scratch in any project
2. **Integration Helper** - Add WDK capabilities to existing projects
3. **Operations Guide** - Help with ongoing blockchain operations

## Supported Platforms

- **Node.js / TypeScript** - Server-side and CLI applications
- **React Native / Expo** - Mobile wallet applications
- **Browser** - Web-based wallet interfaces

## Supported Blockchains

- Ethereum (EVM)
- Polygon
- Arbitrum
- TON
- Bitcoin
- TRON
- Solana
- ERC-4337 (Gasless)

## Supported Services

- **Swaps** - Token exchanges via ParaSwap
- **Bridges** - Cross-chain transfers via USDT0
- **Lending** - DeFi lending via Aave

---

## Quick Start

### Step 1: Install WDK

```bash
npm install @tetherto/wdk
```

### Step 2: Initialize WDK

```typescript
import { WDK } from '@tetherto/wdk';

// Initialize with a 12-word seed phrase
const seed = 'your twelve word seed phrase here ...';
const wdk = new WDK(seed);
```

### Step 3: Register Wallets

```typescript
import { WalletManagerEvm } from '@tetherto/wdk-wallet-evm';
import { WalletManagerTon } from '@tetherto/wdk-wallet-ton';

wdk
  .registerWallet('ethereum', WalletManagerEvm, { rpcUrl: 'https://...' })
  .registerWallet('ton', WalletManagerTon, { rpcUrl: 'https://...' });
```

### Step 4: Use Accounts

```typescript
// Get account by index
const ethAccount = await wdk.getAccount('ethereum', 0);

// Get account by BIP32 path
const tonAccount = await wdk.getAccountByPath('ton', "1'/2/3");

// Send transaction
await ethAccount.sendTransaction({
  to: '0x...',
  value: '1000000000000000000', // 1 ETH in wei
});
```

---

## Installation Wizard

When the user wants to set up WDK, follow these steps:

### 1. Detect Project Type

Check the project to determine the environment:

```
- package.json exists? → Node.js/React project
- app.json or expo exists? → React Native/Expo
- index.html without package.json? → Browser/Vanilla JS
- No project files? → Create new project
```

### 2. Install Dependencies

**For Node.js/TypeScript:**
```bash
npm install @tetherto/wdk
# Install wallet modules as needed:
npm install @tetherto/wdk-wallet-evm    # For Ethereum/Polygon/Arbitrum
npm install @tetherto/wdk-wallet-ton    # For TON
npm install @tetherto/wdk-wallet-btc    # For Bitcoin
npm install @tetherto/wdk-wallet-tron   # For TRON
npm install @tetherto/wdk-wallet-sol    # For Solana
```

**For React Native/Expo:**
```bash
npx expo install @tetherto/wdk
npx expo install @tetherto/wdk-wallet-evm
# Additional wallet modules as needed
```

**For Browser:**
```html
<script src="https://unpkg.com/@tetherto/wdk/dist/wdk.browser.js"></script>
```

### 3. Create Configuration

Create a `wdk.config.ts` file:

```typescript
import { WDK } from '@tetherto/wdk';
import { WalletManagerEvm } from '@tetherto/wdk-wallet-evm';

export function createWDK(seed: string) {
  const wdk = new WDK(seed);

  wdk.registerWallet('ethereum', WalletManagerEvm, {
    rpcUrl: process.env.ETH_RPC_URL || 'https://eth.llamarpc.com',
    chainId: 1,
  });

  return wdk;
}
```

### 4. Set Up Environment Variables

Create `.env` file:
```
ETH_RPC_URL=https://eth.llamarpc.com
POLYGON_RPC_URL=https://polygon.llamarpc.com
# Add other RPC URLs as needed
```

---

## Integration Patterns

### Adding to Existing Express/Node.js App

```typescript
// src/services/wallet.ts
import { WDK } from '@tetherto/wdk';
import { WalletManagerEvm } from '@tetherto/wdk-wallet-evm';

let wdkInstance: WDK | null = null;

export function getWDK(seed: string): WDK {
  if (!wdkInstance) {
    wdkInstance = new WDK(seed)
      .registerWallet('ethereum', WalletManagerEvm, {
        rpcUrl: process.env.ETH_RPC_URL,
      });
  }
  return wdkInstance;
}

export async function getBalance(seed: string, accountIndex: number) {
  const wdk = getWDK(seed);
  const account = await wdk.getAccount('ethereum', accountIndex);
  return account.getBalance();
}
```

### Adding to React Native App

```typescript
// src/hooks/useWallet.ts
import { useState, useEffect } from 'react';
import { WDK } from '@tetherto/wdk';
import { WalletManagerEvm } from '@tetherto/wdk-wallet-evm';
import * as SecureStore from 'expo-secure-store';

export function useWallet() {
  const [wdk, setWdk] = useState<WDK | null>(null);
  const [account, setAccount] = useState(null);

  useEffect(() => {
    async function init() {
      const seed = await SecureStore.getItemAsync('wallet_seed');
      if (seed) {
        const instance = new WDK(seed)
          .registerWallet('ethereum', WalletManagerEvm, {
            rpcUrl: 'https://eth.llamarpc.com',
          });
        setWdk(instance);
        const acc = await instance.getAccount('ethereum', 0);
        setAccount(acc);
      }
    }
    init();
  }, []);

  return { wdk, account };
}
```

### Adding to Browser/React Web App

```typescript
// src/lib/wdk.ts
import { WDK } from '@tetherto/wdk';
import { WalletManagerEvm } from '@tetherto/wdk-wallet-evm';

export function initWDK(seed: string): WDK {
  return new WDK(seed)
    .registerWallet('ethereum', WalletManagerEvm, {
      rpcUrl: 'https://eth.llamarpc.com',
    })
    .registerWallet('polygon', WalletManagerEvm, {
      rpcUrl: 'https://polygon.llamarpc.com',
      chainId: 137,
    });
}
```

---

## Common Operations

### Send Transaction

```typescript
const account = await wdk.getAccount('ethereum', 0);

const txHash = await account.sendTransaction({
  to: '0xRecipientAddress',
  value: '1000000000000000000', // Amount in wei
  // Optional: data, gasLimit, gasPrice
});

console.log('Transaction sent:', txHash);
```

### Token Swap (ParaSwap)

```typescript
import { SwapProtocolParaswap } from '@tetherto/wdk-swap-paraswap';

// Register the swap protocol
wdk.registerProtocol('paraswap', SwapProtocolParaswap, {
  apiKey: process.env.PARASWAP_API_KEY,
});

// Execute swap
const account = await wdk.getAccount('ethereum', 0);
const swap = account.getSwapProtocol('paraswap');

await swap.swap({
  srcToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
  destToken: '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT
  amount: '1000000000', // 1000 USDC (6 decimals)
  slippage: 1, // 1%
});
```

### Cross-Chain Bridge (USDT0)

```typescript
import { BridgeProtocolUSDT0 } from '@tetherto/wdk-bridge-usdt0';

wdk.registerProtocol('usdt0', BridgeProtocolUSDT0, {});

const account = await wdk.getAccount('ethereum', 0);
const bridge = account.getBridgeProtocol('usdt0');

await bridge.bridge({
  destChain: 'polygon',
  amount: '1000000000', // Amount to bridge
  recipient: '0xRecipientOnPolygon',
});
```

### DeFi Lending (Aave)

```typescript
import { LendingProtocolAave } from '@tetherto/wdk-lending-aave';

wdk.registerProtocol('aave', LendingProtocolAave, {
  poolAddress: '0x...',
});

const account = await wdk.getAccount('ethereum', 0);
const lending = account.getLendingProtocol('aave');

// Supply assets
await lending.supply({
  asset: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
  amount: '1000000000',
});

// Borrow assets
await lending.borrow({
  asset: '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT
  amount: '500000000',
});
```

### Get Network Fee Rates

```typescript
const feeRates = await wdk.getFeeRates('ethereum');
console.log('Current gas prices:', feeRates);
```

---

## Security Best Practices

1. **Never hardcode seed phrases** - Use environment variables or secure storage
2. **Use secure storage on mobile** - expo-secure-store, react-native-keychain
3. **Validate all addresses** - Check format before sending
4. **Set transaction limits** - Implement safeguards in your app
5. **Use testnets first** - Test on Sepolia, Mumbai before mainnet

---

## Troubleshooting

### "Module not found" errors
Ensure all wallet modules are installed:
```bash
npm install @tetherto/wdk-wallet-evm @tetherto/wdk-wallet-ton
```

### RPC connection issues
Check your RPC URL is valid and the network is accessible. Consider using a dedicated RPC provider.

### Transaction failures
- Check account has sufficient balance for gas
- Verify the recipient address format
- Check network congestion and gas prices

---

## Resources

- **Documentation**: https://docs.wallet.tether.io/
- **GitHub**: https://github.com/tetherto/wdk-core
- **Discord**: https://discord.gg/arYXDhHB2w

---

## Reference Files

For detailed documentation, see:
- `references/getting-started.md` - Detailed setup guide
- `references/api-reference.md` - Complete API documentation
- `references/platforms/` - Platform-specific guides
- `references/operations/` - Detailed operation guides
- `templates/` - Ready-to-use code templates