ThunderHub Documentation

After creating your service and module, you must register it so the NodeService can find it.

1. Inject and Map: In src/server/modules/node/provider-registry.service.ts, inject your new service into the constructor and add it to the providers Map using your new NodeType.
2. Import Module: In src/server/modules/node/provider-registry.module.ts, add your new module to the imports array.

// src/server/modules/node/provider-registry.service.ts
@Injectable()
export class ProviderRegistryService {
  private providers = new Map<string, LightningProvider>();

  constructor(
    lndService: LndService,
    yourTypeService: YourTypeService, // ← add this
  ) {
    this.providers.set(NodeType.LND, lndService);
    this.providers.set(NodeType.YOUR_TYPE, yourTypeService); // ← add this
  }
}

// src/server/modules/node/provider-registry.module.ts
@Module({
  imports: [LndModule, YourTypeModule], // ← add YourTypeModule
  providers: [ProviderRegistryService],
  exports: [ProviderRegistryService],
})
export class ProviderRegistryModule {}

To add a new provider, create a service that implements the LightningProvider interface from src/server/modules/node/lightning.types.ts.

Key Implementation Details:

• getCapabilities(): Return a Set<Capability> indicating what features your provider supports (e.g., Capability.CHANNELS, Capability.INVOICES). The UI uses this to hide unsupported features.
• connect(config): This method is called once per account at startup. It should return a connection object (e.g., an Axios instance, gRPC client, or WebSocket) which is then passed as the first argument to all other provider methods.
• Method Implementation: Every method in the LightningProvider interface must be implemented. If a method is not supported, throw an error.
• Return Shapes: Data returned by your methods must match the shapes expected by the existing GraphQL resolvers. Use the LndService as a reference for expected return structures (e.g., public_key, alias, etc.).

import { Injectable } from '@nestjs/common';
import {
  Capability,
  LightningProvider,
  // ... import option types
} from '../lightning.types';

@Injectable()
export class YourTypeService implements LightningProvider {
  getCapabilities(): Set<Capability> {
    return new Set([
      Capability.WALLET_INFO,
      Capability.CHANNELS,
      // ...
    ]);
  }

  connect(config: {
    socket: string;
    cert?: string;
    macaroon?: string;
    authToken?: string;
  }): YourConnectionType {
    return createYourClient({
      url: config.socket,
      token: config.authToken,
    });
  }

  async getWalletInfo(connection: YourConnectionType) {
    const info = await connection.getInfo();
    return {
      public_key: info.pubkey,
      alias: info.alias,
      chains: [info.chain],
    };
  }

  // ... implement remaining methods
}

ThunderHub provides a centralized event logging system for managing application events (successes, errors, etc.). To use it, wrap your component tree with EventLogProvider. You can then use the useEventLog hook to interact with the log by adding new events or clearing the existing log.

Event Structure

When adding an event via addEvent, you provide:

• title: A string title for the event.
• summary: An array of EventField objects (containing label and value).
• details (optional): An array of EventField objects for expanded information.
• status (optional): Either 'success' or 'error' (defaults to 'success').
• type (optional): A string identifying the event category (defaults to 'event').

The log maintains a maximum of 100 entries, with the newest entries appearing first.

import { EventLogProvider, useEventLog } from './path-to-context';

function App() {
  return (
    <EventLogProvider>
      <MyComponent />
    </EventLogProvider>
  );
}

function MyComponent() {
  const { addEvent, clearEvents } = useEventLog();

  const handleAction = () => {
    addEvent({
      title: 'Transaction Completed',
      summary: [{ label: 'Amount', value: '0.001 BTC' }],
      details: [{ label: 'TXID', value: 'abc123...' }],
      status: 'success',
      type: 'lightning'
    });
  };

  return <button onClick={handleAction}>Log Event</button>;
}

ThunderHub uses a ConfigProvider to manage UI state such as themes, currency preferences, sidebar visibility, and channel display settings. The configuration is persisted in localStorage (excluding the theme which is stored separately).

To use the configuration in your components, wrap your application in the ConfigProvider and use the useConfigState and useConfigDispatch hooks.

import { ConfigProvider, useConfigState, useConfigDispatch } from './context/ConfigContext';

function App() {
  return (
    <ConfigProvider initialConfig={{ theme: 'dark' }}>
      <MyComponent />
    </ConfigProvider>
  );
}

function MyComponent() {
  const config = useConfigState();
  const dispatch = useConfigDispatch();

  const toggleSidebar = () => {
    dispatch({ type: 'change', sidebar: !config.sidebar });
  };

  return <button onClick={toggleSidebar}>Toggle Sidebar</button>;
}

Lightning Terminal (LitD) services in this setup use several command-line flags to configure the integrated LND node and Taproot Assets features.

Common configuration flags include:

• --network: The blockchain network (e.g., regtest).
• --lnd-mode=integrated: Enables the integrated LND mode.
• --lnd.bitcoin.node: The hostname of the Bitcoin node (e.g., bitcoind).
• --lnd.bitcoind.rpchost: The RPC host and port for Bitcoin.
• --lnd.bitcoind.rpcuser / --lnd.bitcoind.rpcpass: Credentials for the Bitcoin RPC.
• --uipassword: Password for the Lightning Terminal web UI.
• --taproot-assets.universe.public-access: Access level for the Taproot Assets universe (e.g., rw).
• --taproot-assets.proofcourieraddr: The URI for the proof courier (e.g., universerpc://<hostname>:8443).

# Example LitD command configuration
command:
  - --httpslisten=0.0.0.0:8443
  - --uipassword=testpassword123!
  - --lnd-mode=integrated
  - --network=regtest
  - --lnd.bitcoin.node=bitcoind
  - --lnd.bitcoind.rpchost=bitcoind:18443
  - --lnd.bitcoind.rpcuser=rpcuser
  - --lnd.bitcoind.rpcpass=rpcpassword