kaspa-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,148 @@
+# Kaspa MCP
+
+MCP server for sending KAS on the Kaspa blockDAG.
+
+## About Kaspa
+
+[Kaspa](https://kaspa.org) is a fast, scalable Layer-1 cryptocurrency built on proof-of-work (PoW) and powered by the GHOSTDAG protocol — a novel consensus mechanism that extends Nakamoto's original design. Unlike traditional blockchains that discard competing blocks, GHOSTDAG allows parallel blocks to coexist and orders them within a Directed Acyclic Graph (blockDAG), enabling high throughput while preserving decentralization and security.
+
+**Key Features:**
+- **10 blocks per second** with sub-second finality (Crescendo upgrade, May 2025)
+- **Proof of Work** using kHeavyHash algorithm
+- **Fair launch** - no premine, no ICO, no token allocations
+- **Decentralized** - runs on standard hardware
+
+## Installation
+
+```bash
+npm install
+npm run build
+```
+
+## Configuration
+
+Set these environment variables:
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `KASPA_MNEMONIC` | Yes* | BIP39 mnemonic phrase (24 words) |
+| `KASPA_PRIVATE_KEY` | Yes* | Hex-encoded private key (alternative to mnemonic) |
+| `KASPA_NETWORK` | No | Network: `mainnet`, `testnet-10`, `testnet-11`. Defaults to `mainnet` |
+| `KASPA_ACCOUNT_INDEX` | No | BIP44 account index when using mnemonic. Defaults to `0` |
+
+*Either `KASPA_MNEMONIC` or `KASPA_PRIVATE_KEY` must be set.
+
+## Usage with Claude Desktop
+
+Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "kaspa": {
+      "command": "npx",
+      "args": ["kaspa-mcp"],
+      "env": {
+        "KASPA_MNEMONIC": "your twenty four word mnemonic phrase here ...",
+        "KASPA_NETWORK": "mainnet"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+### `get_my_address`
+Get the Kaspa address derived from your configured private key or mnemonic.
+
+**Returns:** `{ address: string }`
+
+### `get_balance`
+Get balance for a Kaspa address.
+
+**Parameters:**
+- `address` (optional): Address to check. Defaults to your wallet address.
+
+**Returns:** `{ address: string, balance: string, utxoCount: number }`
+
+### `get_fee_estimate`
+Get current fee estimates from the network.
+
+**Returns:** `{ priorityFee: string, normalFee: string, lowFee: string }`
+
+### `send_kaspa`
+Send KAS tokens to a recipient.
+
+**Parameters:**
+- `to`: Recipient Kaspa address (must match wallet network)
+- `amount`: Amount in KAS as string (e.g., "10.5", max 8 decimal places)
+- `priorityFee` (optional): Priority fee in sompi
+
+**Returns:** `{ txId: string, fee: string }`
+
+**Validations:**
+- Address format and network prefix validation
+- Amount must be a valid positive decimal number
+- Maximum 8 decimal places (1 sompi = 0.00000001 KAS)
+- Insufficient balance check before broadcast
+
+### `get_transaction`
+Get transaction details including inputs and outputs.
+
+**Parameters:**
+- `txId`: Transaction ID
+
+**Returns:**
+```typescript
+{
+  txId: string,
+  accepted: boolean,
+  blockHash?: string,
+  blockTime?: number,
+  inputs: Array<{ transactionId: string, index: number }>,
+  outputs: Array<{ index: number, amount: string, address: string }>
+}
+```
+
+## Example
+
+![Demo of kaspa-mcp in Claude Code](assets/demo.png)
+
+```
+"Send 5 KAS to kaspa:qz..."
+```
+
+The MCP will:
+1. Validate the recipient address matches your network
+2. Check your balance is sufficient
+3. Build the transaction with KIP-9 compliant fees
+4. Sign with your private key
+5. Broadcast to the network via public nodes
+6. Return the transaction ID
+
+## Technical Details
+
+- Uses [kaspa-wasm](https://github.com/aspect-build/aspect-cli) for cryptographic operations
+- Connects to public nodes via Resolver for automatic node discovery
+- Implements BIP44 derivation path `m/44'/111111'/account'` for mnemonic wallets
+- Transaction building uses Generator for KIP-9 compliant UTXO management
+
+## Security
+
+- Private keys and mnemonics are only used locally for signing
+- Keys are never sent to any external service
+- Error messages are sanitized to prevent secret leakage
+- All transactions require explicit user action via MCP tools
+
+## Networks
+
+| Network | Address Prefix | API Endpoint |
+|---------|---------------|--------------|
+| `mainnet` | `kaspa:` | api.kaspa.org |
+| `testnet-10` | `kaspatest:` | api-tn10.kaspa.org |
+| `testnet-11` | `kaspatest:` | api-tn11.kaspa.org |
+
+## License
+
+ISC

package/dist/e2e.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/e2e.test.js

@@ -0,0 +1,184 @@
+// ABOUTME: End-to-end tests for Kaspa MCP server
+// ABOUTME: Tests the MCP server tool handlers with real wallet operations
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+// Valid test mnemonic (24 words)
+const TEST_MNEMONIC = 'matter client cigar north mixed hard rail kitten flat shrug view group diagram release goose thumb benefit fire confirm swamp skill merry genre visa';
+async function wrapToolHandler(handler) {
+    try {
+        const result = await handler();
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true,
+        };
+    }
+}
+describe('End-to-End Tests', () => {
+    const mockFetch = vi.fn();
+    const originalFetch = globalThis.fetch;
+    const originalEnv = process.env;
+    beforeAll(() => {
+        process.env = {
+            ...originalEnv,
+            KASPA_MNEMONIC: TEST_MNEMONIC,
+            KASPA_NETWORK: 'mainnet',
+        };
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    beforeEach(() => {
+        globalThis.fetch = mockFetch;
+        mockFetch.mockReset();
+        vi.resetModules();
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    describe('wrapToolHandler', () => {
+        it('wraps successful result in MCP format', async () => {
+            const handler = async () => ({ address: 'kaspa:qptest' });
+            const response = await wrapToolHandler(handler);
+            expect(response.isError).toBeUndefined();
+            expect(response.content).toHaveLength(1);
+            expect(response.content[0].type).toBe('text');
+            const parsed = JSON.parse(response.content[0].text);
+            expect(parsed.address).toBe('kaspa:qptest');
+        });
+        it('wraps error in MCP format with isError flag', async () => {
+            const handler = async () => {
+                throw new Error('Test error');
+            };
+            const response = await wrapToolHandler(handler);
+            expect(response.isError).toBe(true);
+            expect(response.content).toHaveLength(1);
+            expect(response.content[0].text).toContain('Error:');
+            expect(response.content[0].text).toContain('Test error');
+        });
+    });
+    describe('MCP Server Tool Registration', () => {
+        it('can create MCP server with tool capabilities', () => {
+            const server = new McpServer({ name: 'test-kaspa-mcp', version: '0.1.0' }, { capabilities: { tools: {} } });
+            expect(server).toBeDefined();
+        });
+        it('can register get_my_address tool', async () => {
+            const server = new McpServer({ name: 'test-kaspa-mcp', version: '0.1.0' }, { capabilities: { tools: {} } });
+            const { getMyAddress } = await import('./tools/get-my-address.js');
+            server.tool('get_my_address', 'Get the Kaspa address derived from the configured private key', async () => wrapToolHandler(() => getMyAddress()));
+            expect(server).toBeDefined();
+        });
+        it('can register get_balance tool with schema', async () => {
+            const server = new McpServer({ name: 'test-kaspa-mcp', version: '0.1.0' }, { capabilities: { tools: {} } });
+            const { getBalance } = await import('./tools/get-balance.js');
+            server.tool('get_balance', 'Get balance for a Kaspa address', {
+                address: z.string().optional().describe('Kaspa address to check'),
+            }, async (params) => wrapToolHandler(() => getBalance({ address: params.address })));
+            expect(server).toBeDefined();
+        });
+        it('can register send_kaspa tool with required params', async () => {
+            const server = new McpServer({ name: 'test-kaspa-mcp', version: '0.1.0' }, { capabilities: { tools: {} } });
+            const { sendKaspa } = await import('./tools/send-kaspa.js');
+            server.tool('send_kaspa', 'Send KAS tokens', {
+                to: z.string().describe('Recipient address'),
+                amount: z.string().describe('Amount in KAS'),
+                priorityFee: z.number().optional().describe('Priority fee in sompi'),
+            }, async (params) => wrapToolHandler(() => sendKaspa({
+                to: params.to,
+                amount: params.amount,
+                priorityFee: params.priorityFee,
+            })));
+            expect(server).toBeDefined();
+        });
+    });
+    describe('Full Tool Flow E2E', () => {
+        it('get_my_address returns valid mainnet address', async () => {
+            const { getMyAddress } = await import('./tools/get-my-address.js');
+            const response = await wrapToolHandler(() => getMyAddress());
+            expect(response.isError).toBeUndefined();
+            const result = JSON.parse(response.content[0].text);
+            expect(result.address).toMatch(/^kaspa:/);
+        });
+        it('get_balance returns formatted balance', async () => {
+            mockFetch
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ balance: '10000000000' }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve([{ utxo: 1 }, { utxo: 2 }, { utxo: 3 }]),
+            });
+            const { getBalance } = await import('./tools/get-balance.js');
+            const response = await wrapToolHandler(() => getBalance({}));
+            expect(response.isError).toBeUndefined();
+            const result = JSON.parse(response.content[0].text);
+            expect(result.balance).toBe('100');
+            expect(result.utxoCount).toBe(3);
+        });
+        it('get_fee_estimate returns all fee tiers', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    priorityBucket: { feerate: 2.0 },
+                    normalBuckets: [{ feerate: 1.5 }],
+                    lowBuckets: [{ feerate: 1.0 }],
+                }),
+            });
+            const { getFeeEstimate } = await import('./tools/get-fee-estimate.js');
+            const response = await wrapToolHandler(() => getFeeEstimate());
+            expect(response.isError).toBeUndefined();
+            const result = JSON.parse(response.content[0].text);
+            expect(result.priorityFee).toBe('2');
+            expect(result.normalFee).toBe('1.5');
+            expect(result.lowFee).toBe('1');
+        });
+        it('get_transaction returns transaction status', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    transaction_id: 'txid123',
+                    is_accepted: true,
+                    block_hash: ['hash1'],
+                    block_time: 1234567890,
+                    inputs: [{ previous_outpoint_hash: 'prev_tx', previous_outpoint_index: 0 }],
+                    outputs: [{ amount: '10000000000', script_public_key_address: 'kaspa:qptest' }],
+                }),
+            });
+            const { getTransaction } = await import('./tools/get-transaction.js');
+            const response = await wrapToolHandler(() => getTransaction({ txId: 'txid123' }));
+            expect(response.isError).toBeUndefined();
+            const result = JSON.parse(response.content[0].text);
+            expect(result.txId).toBe('txid123');
+            expect(result.accepted).toBe(true);
+            expect(result.outputs).toHaveLength(1);
+            expect(result.outputs[0].address).toBe('kaspa:qptest');
+        });
+        it('send_kaspa validation error returns isError', async () => {
+            const { sendKaspa } = await import('./tools/send-kaspa.js');
+            const response = await wrapToolHandler(() => sendKaspa({ to: 'invalid', amount: '1' }));
+            expect(response.isError).toBe(true);
+            expect(response.content[0].text).toContain('Invalid Kaspa address');
+        });
+    });
+    describe('Error Handling E2E', () => {
+        it('API timeout is handled gracefully', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('Network timeout'));
+            const { getFeeEstimate } = await import('./tools/get-fee-estimate.js');
+            const response = await wrapToolHandler(() => getFeeEstimate());
+            expect(response.isError).toBe(true);
+            expect(response.content[0].text).toContain('Network timeout');
+        });
+        it('missing txId parameter returns error', async () => {
+            const { getTransaction } = await import('./tools/get-transaction.js');
+            const response = await wrapToolHandler(() => getTransaction({ txId: '' }));
+            expect(response.isError).toBe(true);
+            expect(response.content[0].text).toContain('Transaction ID (txId) is required');
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './kaspa/setup.js';

package/dist/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// ABOUTME: MCP server entry point for Kaspa transactions
+// ABOUTME: Registers all tools and starts the stdio transport
+import './kaspa/setup.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { getMyAddress } from './tools/get-my-address.js';
+import { getBalance } from './tools/get-balance.js';
+import { getFeeEstimate } from './tools/get-fee-estimate.js';
+import { sendKaspa } from './tools/send-kaspa.js';
+import { getTransaction } from './tools/get-transaction.js';
+async function wrapToolHandler(handler) {
+    try {
+        const result = await handler();
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+        return {
+            content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+const server = new McpServer({
+    name: 'kaspa-mcp',
+    version: '0.1.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.tool('get_my_address', 'Get the Kaspa address derived from the configured private key', async () => wrapToolHandler(() => getMyAddress()));
+server.tool('get_balance', 'Get balance for a Kaspa address (defaults to your wallet address)', {
+    address: z.string().optional().describe('Kaspa address to check (optional, defaults to your address)'),
+}, async (params) => wrapToolHandler(() => getBalance({ address: params.address })));
+server.tool('get_fee_estimate', 'Get current fee estimates from the Kaspa network', async () => wrapToolHandler(() => getFeeEstimate()));
+server.tool('send_kaspa', 'Send KAS tokens to a recipient address', {
+    to: z.string().describe('Recipient Kaspa address'),
+    amount: z.string().describe('Amount to send in KAS'),
+    priorityFee: z.number().optional().describe('Priority fee in sompi (optional)'),
+}, async (params) => wrapToolHandler(() => sendKaspa({
+    to: params.to,
+    amount: params.amount,
+    priorityFee: params.priorityFee,
+})));
+server.tool('get_transaction', 'Get transaction status and details', {
+    txId: z.string().describe('Transaction ID'),
+}, async (params) => wrapToolHandler(() => getTransaction({ txId: params.txId })));
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Kaspa MCP server started');
+}
+main().catch((error) => {
+    // Log only the message to prevent secret leakage in stack traces
+    const safeMessage = error instanceof Error ? error.message : 'Unknown error';
+    console.error('Fatal error:', safeMessage);
+    process.exit(1);
+});

package/dist/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/integration.test.js

@@ -0,0 +1,159 @@
+// ABOUTME: Integration tests for Kaspa MCP tools
+// ABOUTME: Tests tool flows with real kaspa-wasm but mocked network calls
+import { describe, it, expect, vi, beforeEach, afterEach, beforeAll, afterAll } from 'vitest';
+// Valid test mnemonic (24 words)
+const TEST_MNEMONIC = 'matter client cigar north mixed hard rail kitten flat shrug view group diagram release goose thumb benefit fire confirm swamp skill merry genre visa';
+describe('Integration Tests', () => {
+    const mockFetch = vi.fn();
+    const originalFetch = globalThis.fetch;
+    const originalEnv = process.env;
+    beforeAll(() => {
+        process.env = {
+            ...originalEnv,
+            KASPA_MNEMONIC: TEST_MNEMONIC,
+            KASPA_NETWORK: 'mainnet',
+        };
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    beforeEach(() => {
+        globalThis.fetch = mockFetch;
+        mockFetch.mockReset();
+        vi.resetModules();
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    describe('get-my-address tool', () => {
+        it('returns wallet address derived from mnemonic', async () => {
+            const { getMyAddress } = await import('./tools/get-my-address.js');
+            const result = await getMyAddress();
+            expect(result.address).toMatch(/^kaspa:/);
+            expect(result.address).toHaveLength(67);
+        });
+    });
+    describe('get-balance tool', () => {
+        it('returns balance for wallet address', async () => {
+            mockFetch
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ address: 'kaspa:test', balance: '5000000000' }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve([
+                    { address: 'kaspa:test', outpoint: { transactionId: 'tx1', index: 0 }, utxoEntry: { amount: '5000000000' } },
+                ]),
+            });
+            const { getBalance } = await import('./tools/get-balance.js');
+            const result = await getBalance({});
+            expect(result.address).toMatch(/^kaspa:/);
+            expect(result.balance).toBe('50');
+            expect(result.utxoCount).toBe(1);
+        });
+        it('returns balance for specified address', async () => {
+            const testAddress = 'kaspa:qptest123456789abcdef';
+            mockFetch
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ address: testAddress, balance: '1000000000' }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve([]),
+            });
+            const { getBalance } = await import('./tools/get-balance.js');
+            const result = await getBalance({ address: testAddress });
+            expect(result.address).toBe(testAddress);
+            expect(result.balance).toBe('10');
+            expect(result.utxoCount).toBe(0);
+        });
+    });
+    describe('get-fee-estimate tool', () => {
+        it('returns formatted fee estimates', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    priorityBucket: { feerate: 1.5, estimatedSeconds: 10 },
+                    normalBuckets: [{ feerate: 1.0, estimatedSeconds: 30 }],
+                    lowBuckets: [{ feerate: 0.5, estimatedSeconds: 60 }],
+                }),
+            });
+            const { getFeeEstimate } = await import('./tools/get-fee-estimate.js');
+            const result = await getFeeEstimate();
+            expect(result.priorityFee).toBe('1.5');
+            expect(result.normalFee).toBe('1');
+            expect(result.lowFee).toBe('0.5');
+        });
+    });
+    describe('get-transaction tool', () => {
+        it('returns transaction details', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    transaction_id: 'abc123def456',
+                    is_accepted: true,
+                    block_hash: ['blockhash1'],
+                    block_time: 1234567890,
+                    inputs: [],
+                    outputs: [],
+                }),
+            });
+            const { getTransaction } = await import('./tools/get-transaction.js');
+            const result = await getTransaction({ txId: 'abc123def456' });
+            expect(result.txId).toBe('abc123def456');
+            expect(result.accepted).toBe(true);
+            expect(result.blockHash).toBe('blockhash1');
+        });
+        it('throws for missing transaction', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+                text: () => Promise.resolve('Not found'),
+            });
+            const { getTransaction } = await import('./tools/get-transaction.js');
+            await expect(getTransaction({ txId: 'notfound' })).rejects.toThrow('Transaction not found: notfound');
+        });
+    });
+    describe('send-kaspa tool validation', () => {
+        it('validates recipient address format', async () => {
+            const { sendKaspa } = await import('./tools/send-kaspa.js');
+            await expect(sendKaspa({ to: 'invalid', amount: '1' })).rejects.toThrow('Invalid Kaspa address');
+        });
+        it('validates amount format', async () => {
+            const { sendKaspa } = await import('./tools/send-kaspa.js');
+            // Use a valid mainnet address format for this test
+            const validMainnetAddress = 'kaspa:qpamkvhgh0kzx50gwvvp5xs8ktmqutcy3dfs9dc3w7lm9rq0zs76vf959mmrp';
+            await expect(sendKaspa({ to: validMainnetAddress, amount: 'abc' })).rejects.toThrow('Amount must be a valid decimal number');
+        });
+        it('validates network mismatch', async () => {
+            // Create a testnet wallet to get a valid testnet address
+            const { KaspaWallet } = await import('./kaspa/wallet.js');
+            const testnetWallet = KaspaWallet.fromMnemonic(TEST_MNEMONIC, 'testnet-10');
+            const validTestnetAddress = testnetWallet.getAddress();
+            const { sendKaspa } = await import('./tools/send-kaspa.js');
+            // Wallet is on mainnet (from beforeAll), so sending to testnet address should fail
+            await expect(sendKaspa({ to: validTestnetAddress, amount: '1' })).rejects.toThrow('Address network mismatch');
+        });
+    });
+    describe('wallet consistency', () => {
+        it('generates same address from same mnemonic', async () => {
+            const { getMyAddress } = await import('./tools/get-my-address.js');
+            const result1 = await getMyAddress();
+            const result2 = await getMyAddress();
+            expect(result1.address).toBe(result2.address);
+        });
+    });
+    describe('API error handling', () => {
+        it('handles API errors gracefully', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                text: () => Promise.resolve('Internal server error'),
+            });
+            const { getFeeEstimate } = await import('./tools/get-fee-estimate.js');
+            await expect(getFeeEstimate()).rejects.toThrow('API error 500');
+        });
+    });
+});

package/dist/kaspa/api.d.ts

@@ -0,0 +1,11 @@
+import type { UtxoResponse, BalanceResponse, FeeEstimateResponse, TransactionResponse } from '../types.js';
+export declare class KaspaApi {
+    private baseUrl;
+    constructor(network?: string);
+    private fetch;
+    getBalance(address: string): Promise<BalanceResponse>;
+    getUtxos(address: string): Promise<UtxoResponse[]>;
+    getFeeEstimate(): Promise<FeeEstimateResponse>;
+    getTransaction(txId: string): Promise<TransactionResponse>;
+}
+export declare function getApi(network: string): KaspaApi;

package/dist/kaspa/api.js

@@ -0,0 +1,49 @@
+// ABOUTME: REST API client for Kaspa REST APIs
+// ABOUTME: Handles UTXO queries, balance checks, fee estimates - supports mainnet and testnet
+const API_ENDPOINTS = {
+    mainnet: 'https://api.kaspa.org',
+    'testnet-10': 'https://api-tn10.kaspa.org',
+    'testnet-11': 'https://api-tn11.kaspa.org',
+};
+export class KaspaApi {
+    baseUrl;
+    constructor(network = 'mainnet') {
+        this.baseUrl = API_ENDPOINTS[network] || API_ENDPOINTS.mainnet;
+    }
+    async fetch(path, options) {
+        const url = `${this.baseUrl}${path}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+            },
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`API error ${response.status}: ${text}`);
+        }
+        return response.json();
+    }
+    async getBalance(address) {
+        return this.fetch(`/addresses/${address}/balance`);
+    }
+    async getUtxos(address) {
+        return this.fetch(`/addresses/${address}/utxos`);
+    }
+    async getFeeEstimate() {
+        return this.fetch('/info/fee-estimate');
+    }
+    async getTransaction(txId) {
+        return this.fetch(`/transactions/${txId}`);
+    }
+}
+let apiInstance = null;
+let apiNetwork = null;
+export function getApi(network) {
+    if (!apiInstance || apiNetwork !== network) {
+        apiInstance = new KaspaApi(network);
+        apiNetwork = network;
+    }
+    return apiInstance;
+}

package/dist/kaspa/api.test.d.ts

@@ -0,0 +1 @@
+export {};