kaspa-devComprehensive Kaspa blockchain development toolkit for building transactions, integrating wallets, creating dApps, block explorers, and interacting with the Kaspa network. Use when working with Kaspa blockchain development including: (1) Building and broadcasting transactions, (2) Generating addresses and managing wallets, (3) Creating dApps or block explorers, (4) Integrating Kaspa into existing applications (RainbowKit, OisyWallet, etc.), (5) Working with KRC20 tokens, (6) Setting up Kaspa nodes, (7) Using Kaspa SDKs (Rust, Go, JavaScript/TypeScript, Python, WASM). Supports Rust, Go, JavaScript/TypeScript, Python, and Motoko (Internet Computer) development.
Install via ClawdBot CLI:
clawdbot install codecustard/kaspa-devThis skill provides comprehensive support for Kaspa blockchain development across multiple programming languages and use cases. Whether you're building a simple wallet integration, a full dApp, a block explorer, or working with KRC20 tokens, this skill provides the patterns, SDK references, and boilerplate code you need.
Kaspa provides official SDKs for multiple languages:
kaspa-wasm - WebAssembly-based SDK for browser and Node.jskaspa-rpc-client and kaspa-wallet-core - Native Rust SDKgithub.com/kaspanet/kaspad - Official Go implementationkaspa package on Mops for Internet Computer integrationJavaScript/TypeScript:
import { PrivateKey, NetworkType } from 'kaspa-wasm';
const privateKey = PrivateKey.random(NetworkType.Mainnet);
const publicKey = privateKey.toPublicKey();
const address = publicKey.toAddress(NetworkType.Mainnet);
console.log('Address:', address.toString());
console.log('Private Key:', privateKey.toString());Rust:
use kaspa_wallet_core::keys::{PrivateKey, PublicKey};
use kaspa_consensus_core::network::NetworkType;
let private_key = PrivateKey::random(NetworkType::Mainnet);
let public_key = private_key.to_public_key();
let address = public_key.to_address(NetworkType::Mainnet);
println!("Address: {}", address.to_string());Go:
import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/util"
)
privateKey, _ := util.GeneratePrivateKey()
publicKey := privateKey.PublicKey()
address, _ := util.NewAddressPublicKey(publicKey.Serialize(), util.Bech32PrefixKaspaMain)
fmt.Printf("Address: %s\n", address.String())JavaScript/TypeScript:
import { Transaction, RpcClient, NetworkType } from 'kaspa-wasm';
const rpc = new RpcClient({
url: 'wss://api.kaspa.org',
network: NetworkType.Mainnet
});
await rpc.connect();
// Get UTXOs for the sender address
const utxos = await rpc.getUtxosByAddresses([senderAddress]);
// Build transaction
const tx = new Transaction({
version: 0,
inputs: utxos.map(utxo => ({
previousOutpoint: utxo.outpoint,
signatureScript: '', // Will be filled after signing
sequence: 0,
sigOpCount: 1
})),
outputs: [{
amount: amount,
scriptPublicKey: recipientScriptPublicKey
}],
lockTime: 0,
subnetworkId: '00000000000000000000000000000000'
});
// Sign transaction
const signedTx = await signTransaction(tx, privateKey);
// Broadcast
const txId = await rpc.submitTransaction(signedTx);
console.log('Transaction ID:', txId);For detailed SDK documentation and examples:
For integrating Kaspa into wallets like RainbowKit, OisyWallet, or custom wallets:
See references/wallet-integration.md for:
For setting up and operating Kaspa nodes:
See references/node-operations.md for:
When building a Kaspa dApp:
To build a block explorer:
See API reference for available endpoints.
Kaspa supports KRC20 tokens (similar to ERC20 on Ethereum). For token development:
See references/krc20-tokens.md for:
Kaspa has three network types:
kaspa:)kaspatest:)kaspadev:)Always use the correct network type for your use case.
Kaspa uses Bech32 encoding for addresses:
kaspa:qqkqkzjvr7zwxxmjxjkmxx (62 characters total)kaspatest:qqkqkzjvr7zwxxmjxjkmxxkaspadev:qqkqkzjvr7zwxxmjxjkmxxThe scripts/ directory contains utility scripts:
generate-address.py: Generate Kaspa addressesbuild-transaction.py: Build and sign transactionsmonitor-address.py: Monitor address for incoming transactionsThe assets/ directory contains boilerplate templates:
dapp-template/: React/Next.js dApp starterexplorer-template/: Block explorer starterwallet-adapter/: Wallet adapter implementationGenerated Mar 1, 2026
Develop a cryptocurrency wallet application that supports Kaspa blockchain for storing, sending, and receiving KAS tokens. This involves generating addresses, managing private keys, and broadcasting transactions using the JavaScript/TypeScript WASM SDK for browser compatibility. Ideal for fintech startups or existing wallet providers expanding to Kaspa.
Build a decentralized application (dApp) on Kaspa, such as a token swap platform or NFT marketplace, leveraging KRC20 token standards. Use the Kaspa SDKs to integrate wallet connections, handle UTXO-based transactions, and interact with smart contracts. Suitable for blockchain developers creating new DeFi or gaming applications.
Create a block explorer to visualize Kaspa network data, including blocks, transactions, and addresses. Utilize the Kaspa Developer Platform API or run a node to index and serve data via a REST/GraphQL API, with a frontend for user interaction. Useful for analytics firms or community projects.
Set up and maintain Kaspa nodes using Docker or binary installations to provide RPC services for developers and applications. This includes configuring network types, monitoring performance, and ensuring high availability for transaction processing. Ideal for infrastructure providers or enterprises needing reliable blockchain access.
Integrate Kaspa blockchain functionality into existing applications, such as e-commerce platforms or payment systems, using SDKs like Rust or Python. Implement features like address generation, transaction building, and wallet integrations (e.g., with RainbowKit) to enable Kaspa payments. Suitable for software companies enhancing their products with blockchain capabilities.
Offer a subscription-based software service providing Kaspa SDKs, APIs, and development tools to developers and businesses. Revenue comes from monthly or annual fees for access to premium features, support, and scalable infrastructure. This model targets companies building on Kaspa who need reliable development resources.
Operate a Kaspa wallet application that charges small fees for transactions, currency conversions, or premium features like enhanced security. Revenue is generated from user transaction fees and optional in-app purchases. This model appeals to individual users and small businesses using Kaspa for payments.
Provide consulting services to help businesses integrate Kaspa into their systems, develop custom dApps, or set up nodes. Revenue is earned through project-based contracts or hourly rates for expertise in Kaspa SDKs and blockchain development. This model targets enterprises and startups needing specialized Kaspa solutions.
💬 Integration Tip
Start with the JavaScript/TypeScript WASM SDK for browser-based projects due to its compatibility, and use the Kaspa Developer Platform API for quick data access without running a full node.
Connect Claude to Clawdbot instantly and keep it connected 24/7. Run after setup to link your subscription, then auto-refreshes tokens forever.
ERC-8004 Trustless Agents - Register, discover, and build reputation for AI agents on Ethereum. Use when registering agents on-chain, querying agent registries, giving/receiving reputation feedback, or interacting with the AI agent trust layer.
Autonomous crypto trading on Base via Bankr. Use for trading tokens, monitoring launches, executing strategies, or managing a trading portfolio. Triggers on "trade", "buy", "sell", "launch", "snipe", "profit", "PnL", "portfolio balance", or any crypto trading task on Base.
Deploy ERC20 tokens on Base using Clanker SDK. Create tokens with built-in Uniswap V4 liquidity pools. Supports Base mainnet and Sepolia testnet. Requires PRIVATE_KEY in config.
Query DeFi portfolio data across 50+ chains via Zapper's GraphQL API. Use when the user wants to check wallet balances, DeFi positions, NFT holdings, token prices, or transaction history. Supports Base, Ethereum, Polygon, Arbitrum, Optimism, and more. Requires ZAPPER_API_KEY.
Interact with Solana blockchain via Helius APIs. Create/manage wallets, check balances (SOL + tokens), send transactions, swap tokens via Jupiter, and monitor addresses. Use for any Solana blockchain operation, crypto wallet management, token transfers, DeFi swaps, or portfolio tracking.