@push.rocks/smartnetwork 4.5.2 → 4.7.0

package/ts/smartnetwork.classes.ipintelligence.ts

@@ -30,6 +30,7 @@ export interface IIpIntelligenceResult {
   registrantOrg: string | null;
   registrantCountry: string | null;
   networkRange: string | null;
+  networkCidrs: string[] | null;
   abuseContact: string | null;
 
   // Geolocation (MaxMind GeoLite2 City)
@@ -50,6 +51,13 @@ export interface IIpIntelligenceOptions {
   dbMaxAge?: number;
   /** Timeout (ms) for RDAP/DNS/CDN requests. Default: 5000 */
   timeout?: number;
+  /**
+   * Optional injected smartdns client. When provided, IpIntelligence will
+   * not create or destroy its own client (the owner — typically SmartNetwork —
+   * manages lifecycle). When omitted, a short-lived client is created per
+   * Team Cymru lookup and destroyed in finally.
+   */
+  dnsClient?: InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns>;
 }
 
 // CDN URLs for GeoLite2 MMDB files (served via jsDelivr from npm packages)
@@ -72,6 +80,11 @@ interface IBootstrapEntry {
   baseUrl: string;
 }
 
+interface IRdapNetworkInfo {
+  networkRange: string | null;
+  networkCidrs: string[] | null;
+}
+
 /**
  * IpIntelligence provides IP address intelligence by combining three data sources:
  * - RDAP (direct to RIRs) for registration/org data
@@ -93,9 +106,13 @@ export class IpIntelligence {
   private bootstrapEntries: IBootstrapEntry[] | null = null;
   private bootstrapPromise: Promise<void> | null = null;
 
+  // Optional injected smartdns client (shared by SmartNetwork)
+  private readonly sharedDnsClient: InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns> | null;
+
   constructor(options?: IIpIntelligenceOptions) {
     this.dbMaxAge = options?.dbMaxAge ?? DEFAULT_DB_MAX_AGE;
     this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+    this.sharedDnsClient = options?.dnsClient ?? null;
   }
 
   /**
@@ -109,6 +126,7 @@ export class IpIntelligence {
       registrantOrg: null,
       registrantCountry: null,
       networkRange: null,
+      networkCidrs: null,
       abuseContact: null,
       country: null,
       countryCode: null,
@@ -132,6 +150,7 @@ export class IpIntelligence {
       result.registrantOrg = rdap.registrantOrg;
       result.registrantCountry = rdap.registrantCountry;
       result.networkRange = rdap.networkRange;
+      result.networkCidrs = rdap.networkCidrs;
       result.abuseContact = rdap.abuseContact;
     }
 
@@ -246,6 +265,7 @@ export class IpIntelligence {
     registrantOrg: string | null;
     registrantCountry: string | null;
     networkRange: string | null;
+    networkCidrs: string[] | null;
     abuseContact: string | null;
   } | null> {
     await this.ensureBootstrap();
@@ -269,14 +289,7 @@ export class IpIntelligence {
       let registrantCountry: string | null = data.country || null;
       let abuseContact: string | null = null;
 
-      // Parse network range
-      let networkRange: string | null = null;
-      if (data.cidr0_cidrs && data.cidr0_cidrs.length > 0) {
-        const cidr = data.cidr0_cidrs[0];
-        networkRange = `${cidr.v4prefix || cidr.v6prefix}/${cidr.length}`;
-      } else if (data.startAddress && data.endAddress) {
-        networkRange = `${data.startAddress} - ${data.endAddress}`;
-      }
+      const { networkRange, networkCidrs } = this.parseRdapNetworkInfo(data);
 
       // Parse entities
       if (data.entities && Array.isArray(data.entities)) {
@@ -309,7 +322,7 @@ export class IpIntelligence {
         }
       }
 
-      return { registrantOrg, registrantCountry, networkRange, abuseContact };
+      return { registrantOrg, registrantCountry, networkRange, networkCidrs, abuseContact };
     } catch (err: any) {
       this.logger.debug?.(`RDAP query failed for ${ip}: ${err.message}`);
       return null;
@@ -318,6 +331,40 @@ export class IpIntelligence {
     }
   }
 
+  private parseRdapNetworkInfo(data: any): IRdapNetworkInfo {
+    const cidrs = this.extractRdapCidrs(data);
+    if (cidrs.length > 0) {
+      return {
+        networkRange: cidrs[0],
+        networkCidrs: cidrs,
+      };
+    }
+
+    if (typeof data.startAddress === 'string' && typeof data.endAddress === 'string') {
+      const rangeCidrs = this.ipv4RangeToCidrs(data.startAddress, data.endAddress);
+      return {
+        networkRange: rangeCidrs.length === 1
+          ? rangeCidrs[0]
+          : `${data.startAddress} - ${data.endAddress}`,
+        networkCidrs: rangeCidrs.length > 0 ? rangeCidrs : null,
+      };
+    }
+
+    return { networkRange: null, networkCidrs: null };
+  }
+
+  private extractRdapCidrs(data: any): string[] {
+    if (!Array.isArray(data.cidr0_cidrs)) return [];
+    return data.cidr0_cidrs
+      .map((cidr: any) => {
+        const prefix = cidr?.v4prefix || cidr?.v6prefix;
+        const length = Number(cidr?.length);
+        if (typeof prefix !== 'string' || !Number.isInteger(length)) return null;
+        return `${prefix}/${length}`;
+      })
+      .filter(Boolean) as string[];
+  }
+
   /**
    * Extract the 'fn' (formatted name) from an entity's vcardArray
    */
@@ -385,16 +432,19 @@ export class IpIntelligence {
    * Response: "ASN | prefix | CC | rir | date"
    */
   private async queryTeamCymru(ip: string): Promise<{ asn: number; prefix: string; country: string } | null> {
-    let dnsClient: InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns> | null = null;
+    const external = this.sharedDnsClient !== null;
+    let dnsClient = this.sharedDnsClient;
     try {
       const reversed = ip.split('.').reverse().join('.');
       const queryName = `${reversed}.origin.asn.cymru.com`;
 
-      dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({
-        strategy: 'prefer-system',
-        allowDohFallback: true,
-        timeoutMs: this.timeout,
-      });
+      if (!dnsClient) {
+        dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({
+          strategy: 'prefer-system',
+          allowDohFallback: true,
+          timeoutMs: this.timeout,
+        });
+      }
 
       const records = await dnsClient.getRecordsTxt(queryName);
       if (!records || records.length === 0) return null;
@@ -418,7 +468,8 @@ export class IpIntelligence {
       this.logger.debug?.(`Team Cymru DNS query failed for ${ip}: ${err.message}`);
       return null;
     } finally {
-      if (dnsClient) {
+      // Only destroy clients we created ourselves; leave injected ones alone.
+      if (!external && dnsClient) {
         dnsClient.destroy();
       }
     }
@@ -558,4 +609,56 @@ export class IpIntelligence {
         parseInt(parts[3], 10)) >>> 0
     );
   }
+
+  private ipv4RangeToCidrs(startIp: string, endIp: string): string[] {
+    const start = this.ipv4ToBigInt(startIp);
+    const end = this.ipv4ToBigInt(endIp);
+    if (start === undefined || end === undefined || start > end) return [];
+
+    const cidrs: string[] = [];
+    let current = start;
+    while (current <= end) {
+      let maxBlockSize = current === 0n ? 1n << 32n : current & -current;
+      const remaining = end - current + 1n;
+      while (maxBlockSize > remaining) {
+        maxBlockSize = maxBlockSize / 2n;
+      }
+      const prefixLength = 32 - this.powerOfTwoExponent(maxBlockSize);
+      cidrs.push(`${this.numberToIpv4(current)}/${prefixLength}`);
+      current += maxBlockSize;
+    }
+    return cidrs;
+  }
+
+  private ipv4ToBigInt(ip: string): bigint | undefined {
+    const parts = ip.trim().split('.');
+    if (parts.length !== 4) return undefined;
+    let result = 0n;
+    for (const part of parts) {
+      if (!/^\d+$/.test(part)) return undefined;
+      const number = Number(part);
+      if (!Number.isInteger(number) || number < 0 || number > 255) return undefined;
+      result = (result * 256n) + BigInt(number);
+    }
+    return result;
+  }
+
+  private numberToIpv4(value: bigint): string {
+    return [
+      Number((value >> 24n) & 255n),
+      Number((value >> 16n) & 255n),
+      Number((value >> 8n) & 255n),
+      Number(value & 255n),
+    ].join('.');
+  }
+
+  private powerOfTwoExponent(value: bigint): number {
+    let exponent = 0;
+    let remaining = value;
+    while (remaining > 1n) {
+      remaining >>= 1n;
+      exponent++;
+    }
+    return exponent;
+  }
 }

package/ts/smartnetwork.classes.smartnetwork.ts

@@ -2,10 +2,14 @@ import * as plugins from './smartnetwork.plugins.js';
 import { CloudflareSpeed } from './smartnetwork.classes.cloudflarespeed.js';
 import { PublicIp } from './smartnetwork.classes.publicip.js';
 import { IpIntelligence, type IIpIntelligenceResult } from './smartnetwork.classes.ipintelligence.js';
+import { DomainIntelligence, type IDomainIntelligenceResult } from './smartnetwork.classes.domainintelligence.js';
 import { getLogger } from './logging.js';
 import { NetworkError } from './errors.js';
 import { RustNetworkBridge } from './smartnetwork.classes.rustbridge.js';
 
+/** Type alias for the shared Smartdns client instance */
+type TSmartdnsClient = InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns>;
+
 /**
  * Configuration options for SmartNetwork
  */
@@ -54,6 +58,8 @@ export class SmartNetwork {
   private rustBridge: RustNetworkBridge;
   private bridgeStarted = false;
   private ipIntelligence: IpIntelligence | null = null;
+  private domainIntelligence: DomainIntelligence | null = null;
+  private dnsClient: TSmartdnsClient | null = null;
 
   constructor(options?: SmartNetworkOptions) {
     this.options = options || {};
@@ -73,13 +79,24 @@ export class SmartNetwork {
   }
 
   /**
-   * Stop the Rust binary bridge.
+   * Stop the Rust binary bridge and tear down the shared Smartdns client.
+   * Call this before your Node process exits if you've used any DNS or
+   * Rust-backed features, otherwise the smartdns Rust backend may keep
+   * the event loop alive.
    */
   public async stop(): Promise<void> {
     if (this.bridgeStarted) {
       await this.rustBridge.stop();
       this.bridgeStarted = false;
     }
+    if (this.dnsClient) {
+      this.dnsClient.destroy();
+      this.dnsClient = null;
+      // Intelligence instances hold a stale reference to the destroyed
+      // client; drop them so the next call rebuilds with a fresh one.
+      this.ipIntelligence = null;
+      this.domainIntelligence = null;
+    }
   }
 
   /**
@@ -91,6 +108,23 @@ export class SmartNetwork {
     }
   }
 
+  /**
+   * Lazily create the shared Smartdns client. The Rust backend inside
+   * Smartdns is only spawned on first query that requires it (NS/MX/SOA
+   * with prefer-system strategy, or any query with doh/udp strategy).
+   * The client is destroyed by stop().
+   */
+  private ensureDnsClient(): TSmartdnsClient {
+    if (!this.dnsClient) {
+      this.dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({
+        strategy: 'prefer-system',
+        allowDohFallback: true,
+        timeoutMs: 5000,
+      });
+    }
+    return this.dnsClient;
+  }
+
   /**
    * Get network speed via Cloudflare speed test (pure TS, no Rust needed).
    */
@@ -310,16 +344,15 @@ export class SmartNetwork {
   }
 
   /**
-   * Resolve DNS records (A, AAAA, MX) — uses smartdns, no Rust needed.
+   * Resolve DNS records (A, AAAA, MX) via the shared smartdns client.
+   * The client is lifecycle-managed by start()/stop() — MX queries spawn
+   * the smartdns Rust bridge, which is torn down by stop().
    */
   public async resolveDns(
     host: string,
   ): Promise<{ A: string[]; AAAA: string[]; MX: { exchange: string; priority: number }[] }> {
     try {
-      const dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({
-        strategy: 'prefer-system',
-        allowDohFallback: true,
-      });
+      const dnsClient = this.ensureDnsClient();
 
       const [aRecords, aaaaRecords, mxRecords] = await Promise.all([
         dnsClient.getRecordsA(host).catch((): any[] => []),
@@ -404,7 +437,7 @@ export class SmartNetwork {
    */
   public async getIpIntelligence(ip: string): Promise<IIpIntelligenceResult> {
     if (!this.ipIntelligence) {
-      this.ipIntelligence = new IpIntelligence();
+      this.ipIntelligence = new IpIntelligence({ dnsClient: this.ensureDnsClient() });
     }
     const fetcher = () => this.ipIntelligence!.getIntelligence(ip);
     if (this.options.cacheTtl && this.options.cacheTtl > 0) {
@@ -413,6 +446,22 @@ export class SmartNetwork {
     return fetcher();
   }
 
+  /**
+   * Get domain intelligence: registrar, registrant, nameservers, registration
+   * events, status flags, DNSSEC, and abuse contact via RDAP. Pure TS, no
+   * Rust needed.
+   */
+  public async getDomainIntelligence(domain: string): Promise<IDomainIntelligenceResult> {
+    if (!this.domainIntelligence) {
+      this.domainIntelligence = new DomainIntelligence({ dnsClient: this.ensureDnsClient() });
+    }
+    const fetcher = () => this.domainIntelligence!.getIntelligence(domain);
+    if (this.options.cacheTtl && this.options.cacheTtl > 0) {
+      return this.getCached(`domainIntelligence:${domain}`, fetcher);
+    }
+    return fetcher();
+  }
+
   /**
    * Internal caching helper
    */