Hey there! I totally get where you're coming from—moving from third-party APIs to self-hosted nodes can feel daunting at first, but let's break this down into manageable steps. I'll cover setting up your Bitcoin daemon first, then walk through two JavaScript approaches to connect to its RPC endpoint and generate addresses.

1. Set Up & Configure Bitcoin Daemon (bitcoind) #

First, you need to install and configure bitcoind (the Bitcoin core daemon) on your server. Here's what to do:

Install Bitcoind #

• On Ubuntu/Debian: Use apt install bitcoind (or build from source if you need a specific version)
• On other systems: Grab the official binaries from the Bitcoin Core project's official distribution channels

Configure bitcoin.conf #

Once installed, locate your Bitcoin data directory (default is ~/.bitcoin/ on Linux/macOS, %APPDATA%\Bitcoin on Windows) and create/edit the bitcoin.conf file with these critical settings:

# Enable RPC server
server=1
# RPC credentials (use strong, unique values!)
rpcuser=your_rpc_username
rpcpassword=your_secure_rpc_password
# RPC port (default is 8332 for mainnet, 18332 for testnet)
rpcport=8332
# Allow connections from your app server's IP (restrict this for security!)
rpcallowip=your_app_server_ip/32
# Run daemon in background
daemon=1
# Optional: Enable SSL for RPC (strongly recommended for production)
rpcssl=1
rpcsslcertificatechainfile=/path/to/cert.pem
rpcsslprivatekeyfile=/path/to/key.pem

Save the file, then start bitcoind with bitcoind -daemon. Wait for the node to fully sync with the Bitcoin network (this can take hours/days depending on your server bandwidth—you can check progress with bitcoin-cli getblockchaininfo).

2. Connect to Bitcoin RPC with JavaScript #

Bitcoin's RPC uses JSON-RPC over HTTP, so you can use either native fetch (no dependencies) or a dedicated library like bitcoin-core (simpler for frequent use).

Option 1: Native fetch (No External Libraries) #

This approach helps you understand the underlying RPC request structure. Here's a function to generate a new address:

async function generateBTCAddress(rpcUser, rpcPassword, rpcHost, rpcPort) {
  // Encode credentials for Basic Auth
  const auth = Buffer.from(`${rpcUser}:${rpcPassword}`).toString('base64');
  
  try {
    const response = await fetch(`http://${rpcHost}:${rpcPort}/`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Basic ${auth}`
      },
      body: JSON.stringify({
        jsonrpc: '1.0',
        id: 'btc-address-generator',
        method: 'getnewaddress',
        params: [] // You can add a label here, e.g., ["user_123"] to tag the address
      })
    });

    const result = await response.json();
    if (result.error) throw new Error(result.error.message);
    return result.result; // This is your new BTC address
  } catch (error) {
    console.error('Failed to generate address:', error);
    throw error;
  }
}

// Usage example (replace with your actual credentials)
const newAddress = await generateBTCAddress(
  'your_rpc_username',
  'your_secure_rpc_password',
  'your_bitcoin_server_ip',
  8332
);
console.log('New BTC Address:', newAddress);

Option 2: Use the bitcoin-core Library #

For a cleaner, more maintainable setup, use the bitcoin-core npm package. First install it:

npm install bitcoin-core

Then connect and generate addresses like this:

const { Client } = require('bitcoin-core');

async function generateBTCAddress() {
  const client = new Client({
    host: 'your_bitcoin_server_ip',
    port: 8332,
    username: 'your_rpc_username',
    password: 'your_secure_rpc_password',
    // Optional: Enable SSL if you configured it in bitcoin.conf
    ssl: true,
    sslStrict: true
  });

  try {
    // Generate a new address (add a label as a parameter if needed)
    const newAddress = await client.getNewAddress();
    // Or with a label: await client.getNewAddress('user_123');
    console.log('New BTC Address:', newAddress);
    return newAddress;
  } catch (error) {
    console.error('Error generating address:', error);
    throw error;
  } finally {
    await client.close(); // Clean up the connection
  }
}

// Call the function
generateBTCAddress();

Critical Security & Best Practices #

• Never hardcode credentials: Use environment variables (e.g., process.env.RPC_USER, process.env.RPC_PASSWORD) instead of plaintext in your code.
• Restrict rpcallowip: Only allow connections from your application server's IP—never use 0.0.0.0/0 (open to all) in production.
• Use SSL: Enable rpcssl in bitcoind to encrypt RPC traffic between your app and the node.
• Track addresses: Store a mapping of user IDs to generated BTC addresses in your database—bitcoind will track addresses in its wallet, but you need to link them to your users for transaction tracking.
• Test on testnet first: Use testnet (set testnet=1 in bitcoind.conf) to avoid real BTC risks while you're testing.

Troubleshooting Common Issues #

• Connection refused: Check if bitcoind is running, if the RPC port is open in your server firewall, and if rpcallowip includes your app's IP.
• Authentication failed: Double-check rpcuser and rpcpassword in both bitcoind.conf and your JavaScript code.
• "Method not found" error: Ensure you're using a valid RPC method (you can list all methods with bitcoin-cli help).

内容的提问来源于stack exchange，提问作者galaxymini