@thesight/sdk 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,175 +1,485 @@
-import { Connection, } from '@solana/web3.js';
-import { trace, context, SpanStatusCode } from '@opentelemetry/api';
-import { parseLogs, IdlResolver, enrichTree, flatAttributions } from '@thesight/core';
-/**
- * Drop-in replacement for @solana/web3.js Connection that instruments
- * every transaction with OpenTelemetry spans.
- *
- * Usage:
- *   const connection = new InstrumentedConnection(rpcUrl, {
- *     tracer: trace.getTracer('my-service'),
- *   });
- *
- * The Solana transaction becomes a child span of whatever OTel context
- * is active when sendAndConfirmTransaction is called — so it automatically
- * nests inside your HTTP handler or background job span.
- */
-export class InstrumentedConnection extends Connection {
-    sightConfig;
-    idlResolver;
-    tracer;
-    constructor(endpoint, config) {
-        const { tracer, idlRpcEndpoint, skipIdlResolution, idls, allowOnChainIdlFetch, ...connectionConfig } = config ?? {};
-        super(endpoint, connectionConfig);
-        this.sightConfig = { tracer, idlRpcEndpoint, skipIdlResolution, allowOnChainIdlFetch };
-        this.idlResolver = new IdlResolver({
-            rpcEndpoint: idlRpcEndpoint ?? endpoint,
-            allowOnChainFetch: allowOnChainIdlFetch ?? false,
+// src/index.ts
+import {
+  Connection
+} from "@solana/web3.js";
+import {
+  trace as trace2,
+  context as context2,
+  SpanStatusCode as SpanStatusCode2
+} from "@opentelemetry/api";
+import { parseLogs as parseLogs2, IdlResolver as IdlResolver2, enrichTree as enrichTree2, flatAttributions as flatAttributions2 } from "@thesight/core";
+import { IdlResolver as IdlResolver3 } from "@thesight/core";
+
+// src/init.ts
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { Resource } from "@opentelemetry/resources";
+import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+
+// src/exporter.ts
+import {
+  hrTimeToMilliseconds,
+  ExportResultCode
+} from "@opentelemetry/core";
+var SightSpanExporter = class {
+  apiKey;
+  ingestUrl;
+  fetchImpl;
+  maxBatchSize;
+  shuttingDown = false;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.ingestUrl = config.ingestUrl;
+    this.fetchImpl = config.fetchImpl ?? globalThis.fetch;
+    this.maxBatchSize = Math.min(100, config.maxBatchSize ?? 100);
+    if (!this.fetchImpl) {
+      throw new Error(
+        "SightSpanExporter: globalThis.fetch is not available. Node >= 18 ships with fetch built in, or pass `fetchImpl` explicitly."
+      );
+    }
+  }
+  async export(spans, resultCallback) {
+    if (this.shuttingDown) {
+      resultCallback({ code: ExportResultCode.FAILED, error: new Error("Exporter is shut down") });
+      return;
+    }
+    const chunks = [];
+    for (let i = 0; i < spans.length; i += this.maxBatchSize) {
+      chunks.push(spans.slice(i, i + this.maxBatchSize));
+    }
+    try {
+      for (const chunk of chunks) {
+        await this.sendChunk(chunk);
+      }
+      resultCallback({ code: ExportResultCode.SUCCESS });
+    } catch (err) {
+      resultCallback({
+        code: ExportResultCode.FAILED,
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    }
+  }
+  async shutdown() {
+    this.shuttingDown = true;
+  }
+  async forceFlush() {
+  }
+  // ─── Internal ──────────────────────────────────────────────────────────────
+  async sendChunk(spans) {
+    const payload = {
+      spans: spans.map((span) => this.convertSpan(span))
+    };
+    const response = await this.fetchImpl(this.ingestUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const body = await safeReadText(response);
+      throw new Error(
+        `Sight ingest returned ${response.status} ${response.statusText}: ${body}`
+      );
+    }
+  }
+  convertSpan(span) {
+    const attr = span.attributes;
+    const resource = span.resource.attributes;
+    const serviceName = typeof resource["service.name"] === "string" ? resource["service.name"] : void 0;
+    const startTimeMs = hrTimeToMilliseconds(span.startTime);
+    const endTimeMs = hrTimeToMilliseconds(span.endTime);
+    const durationMs = Math.max(0, endTimeMs - startTimeMs);
+    const out = {
+      traceId: span.spanContext().traceId,
+      spanId: span.spanContext().spanId,
+      spanName: span.name,
+      startTimeMs,
+      durationMs
+    };
+    const parentSpanId = span.parentSpanId;
+    if (parentSpanId) out.parentSpanId = parentSpanId;
+    if (serviceName) out.serviceName = serviceName;
+    copyIfString(attr, "solana.tx.signature", out);
+    copyIfEnum(attr, "solana.tx.status", out, ["confirmed", "failed", "timeout"]);
+    copyIfNumber(attr, "solana.tx.slot", out);
+    copyIfNumber(attr, "solana.tx.cu_used", out);
+    copyIfNumber(attr, "solana.tx.cu_budget", out);
+    copyIfNumber(attr, "solana.tx.cu_utilization", out);
+    copyIfString(attr, "solana.tx.program", out);
+    copyIfString(attr, "solana.tx.instruction", out);
+    copyIfString(attr, "solana.tx.error", out);
+    copyIfNumber(attr, "solana.tx.error_code", out);
+    copyIfString(attr, "solana.tx.error_program", out);
+    copyIfNumber(attr, "solana.tx.submit_ms", out);
+    copyIfNumber(attr, "solana.tx.confirmation_ms", out);
+    copyIfNumber(attr, "solana.tx.fee_lamports", out);
+    return out;
+  }
+};
+function copyIfString(attr, key, out) {
+  const v = attr[key];
+  if (typeof v === "string") {
+    out[key] = v;
+  }
+}
+function copyIfNumber(attr, key, out) {
+  const v = attr[key];
+  if (typeof v === "number" && Number.isFinite(v)) {
+    out[key] = v;
+  }
+}
+function copyIfEnum(attr, key, out, allowed) {
+  const v = attr[key];
+  if (typeof v === "string" && allowed.includes(v)) {
+    out[key] = v;
+  }
+}
+async function safeReadText(res) {
+  try {
+    return (await res.text()).slice(0, 500);
+  } catch {
+    return "<no body>";
+  }
+}
+
+// src/init.ts
+var DEFAULT_INGEST_URL = "https://ingest.thesight.dev/ingest";
+function initSight(config) {
+  if (!config.apiKey) {
+    throw new Error("initSight: `apiKey` is required");
+  }
+  if (!config.serviceName) {
+    throw new Error("initSight: `serviceName` is required");
+  }
+  const resource = new Resource({
+    [SEMRESATTRS_SERVICE_NAME]: config.serviceName,
+    ...config.serviceVersion ? { [SEMRESATTRS_SERVICE_VERSION]: config.serviceVersion } : {}
+  });
+  const provider = new NodeTracerProvider({ resource });
+  const exporter = new SightSpanExporter({
+    apiKey: config.apiKey,
+    ingestUrl: config.ingestUrl ?? DEFAULT_INGEST_URL,
+    fetchImpl: config.fetchImpl,
+    maxBatchSize: config.maxBatchSize
+  });
+  const processor = new BatchSpanProcessor(exporter, {
+    scheduledDelayMillis: config.batchDelayMs ?? 5e3,
+    maxExportBatchSize: config.maxBatchSize ?? 100,
+    maxQueueSize: 2048
+  });
+  provider.addSpanProcessor(processor);
+  provider.register();
+  return {
+    provider,
+    shutdown: async () => {
+      await provider.shutdown();
+    }
+  };
+}
+
+// src/track.ts
+import { trace, context, SpanStatusCode } from "@opentelemetry/api";
+import { parseLogs, IdlResolver, enrichTree, flatAttributions } from "@thesight/core";
+async function trackSolanaTransaction(opts) {
+  const tracerName = opts.serviceName ?? "@thesight/sdk";
+  const tracer = opts.tracer ?? trace.getTracer(tracerName);
+  const span = tracer.startSpan("solana.trackTransaction", {}, context.active());
+  span.setAttribute("solana.tx.signature", opts.signature);
+  const start = Date.now();
+  const deadline = start + (opts.timeoutMs ?? 3e4);
+  const commitment = opts.commitment ?? "confirmed";
+  const basePoll = opts.pollIntervalMs ?? 500;
+  const resolver = opts.idlResolver ?? buildResolverFromIdls(opts.idls);
+  try {
+    const txDetails = await pollGetTransaction(opts.connection, opts.signature, commitment, deadline, basePoll);
+    if (!txDetails) {
+      span.setAttribute("solana.tx.status", "timeout");
+      span.setAttribute("solana.tx.enrichment_ms", Date.now() - start);
+      return;
+    }
+    span.setAttribute("solana.tx.status", txDetails.meta?.err ? "failed" : "confirmed");
+    span.setAttribute("solana.tx.slot", txDetails.slot);
+    const fee = txDetails.meta?.fee;
+    if (fee !== void 0) span.setAttribute("solana.tx.fee_lamports", fee);
+    const cuUsed = txDetails.meta?.computeUnitsConsumed;
+    if (cuUsed !== void 0 && cuUsed !== null) {
+      span.setAttribute("solana.tx.cu_used", Number(cuUsed));
+      span.setAttribute("solana.tx.cu_budget", 2e5);
+      span.setAttribute(
+        "solana.tx.cu_utilization",
+        parseFloat((Number(cuUsed) / 2e5 * 100).toFixed(1))
+      );
+    }
+    const logs = txDetails.meta?.logMessages ?? [];
+    if (logs.length > 0) {
+      const { cpiTree } = parseLogs({ logs });
+      await enrichTree(cpiTree, resolver);
+      for (const attr of flatAttributions(cpiTree)) {
+        span.addEvent("cpi.invoke", {
+          "cpi.program": attr.programName ?? attr.programId,
+          "cpi.instruction": attr.instructionName ?? "unknown",
+          "cpi.depth": attr.depth,
+          "cpi.cu_consumed": attr.cuConsumed,
+          "cpi.cu_self": attr.cuSelf,
+          "cpi.percentage": parseFloat(attr.percentage.toFixed(2))
         });
-        if (idls)
-            this.idlResolver.registerMany(idls);
-        this.tracer = tracer ?? trace.getTracer('@thesight/sdk');
-    }
-    /**
-     * Register an IDL for a single program. Convenience forwarder for the
-     * underlying resolver. Anchor users typically call this right after
-     * constructing a `Program`:
-     *
-     *     const program = new Program(idl, programId, provider);
-     *     connection.registerIdl(program.programId.toBase58(), program.idl);
-     */
-    registerIdl(programId, idl) {
-        this.idlResolver.register(programId, idl);
-    }
-    /** Bulk-register multiple IDLs. */
-    registerIdls(idls) {
-        this.idlResolver.registerMany(idls);
-    }
-    /**
-     * Sends and confirms a transaction, wrapped in an OTel span.
-     * The span is a child of the current active context.
-     */
-    async sendAndConfirmInstrumented(transaction, options) {
-        const commitment = options?.commitment ?? this.sightConfig.commitment ?? 'confirmed';
-        const finality = commitment === 'processed' ? 'confirmed' : commitment;
-        const span = this.tracer.startSpan('solana.sendAndConfirmTransaction', {}, context.active());
-        const submitStart = Date.now();
-        try {
-            // Submit the transaction
-            const signature = await this.sendRawTransaction('serialize' in transaction
-                ? transaction.serialize()
-                : transaction.serialize(), { skipPreflight: false, ...options });
-            span.setAttribute('solana.tx.signature', signature);
-            const submitMs = Date.now() - submitStart;
-            span.setAttribute('solana.tx.submit_ms', submitMs);
-            // Await confirmation
-            const confirmStart = Date.now();
-            const { value: result } = await this.confirmTransaction({ signature, ...(await this.getLatestBlockhash(commitment)) }, commitment);
-            const confirmMs = Date.now() - confirmStart;
-            span.setAttribute('solana.tx.confirmation_ms', confirmMs);
-            if (result.err) {
-                span.setAttribute('solana.tx.status', 'failed');
-                span.setStatus({ code: SpanStatusCode.ERROR });
-                if (!this.sightConfig.skipIdlResolution) {
-                    // Enrich error with IDL decoding
-                    const txDetails = await this.getParsedTransaction(signature, {
-                        commitment: finality,
-                        maxSupportedTransactionVersion: 0,
-                    });
-                    const accountKeys = txDetails?.transaction.message.accountKeys.map((k) => k.pubkey ? k.pubkey.toBase58() : k.toBase58()) ?? [];
-                    const programIds = txDetails?.transaction.message.instructions.map((ix) => ix.programId ? ix.programId.toBase58() : accountKeys[ix.programIdIndex] ?? '') ?? [];
-                    const decoded = await this.idlResolver.decodeError(result.err, accountKeys, programIds);
-                    if (decoded.errorName) {
-                        span.setAttribute('solana.tx.error', decoded.errorName);
-                    }
-                    if (decoded.errorCode !== undefined) {
-                        span.setAttribute('solana.tx.error_code', decoded.errorCode);
-                    }
-                    if (decoded.programName) {
-                        span.setAttribute('solana.tx.error_program', decoded.programName);
-                    }
-                    if (decoded.errorMsg) {
-                        span.setAttribute('solana.tx.error_msg', decoded.errorMsg);
-                    }
-                    span.end();
-                    return { signature, error: decoded };
-                }
-                span.end();
-                return { signature };
-            }
-            span.setAttribute('solana.tx.status', 'confirmed');
-            // Enrich with on-chain details
-            if (!this.sightConfig.skipIdlResolution) {
-                const enrichStart = Date.now();
-                const txDetails = await this.getTransaction(signature, {
-                    commitment: finality,
-                    maxSupportedTransactionVersion: 0,
-                });
-                if (txDetails) {
-                    const slot = txDetails.slot;
-                    const fee = txDetails.meta?.fee;
-                    const logs = txDetails.meta?.logMessages ?? [];
-                    const cuUsed = txDetails.meta?.computeUnitsConsumed;
-                    span.setAttribute('solana.tx.slot', slot);
-                    if (fee !== undefined)
-                        span.setAttribute('solana.tx.fee_lamports', fee);
-                    if (cuUsed !== undefined) {
-                        span.setAttribute('solana.tx.cu_used', cuUsed);
-                        span.setAttribute('solana.tx.cu_budget', 200_000);
-                        span.setAttribute('solana.tx.cu_utilization', parseFloat((cuUsed / 200_000 * 100).toFixed(1)));
-                    }
-                    // Parse logs into CPI tree
-                    const { cpiTree } = parseLogs({ logs });
-                    if (!this.sightConfig.skipIdlResolution) {
-                        await enrichTree(cpiTree, this.idlResolver);
-                    }
-                    // Emit one span event per CPI invocation
-                    const attributions = flatAttributions(cpiTree);
-                    for (const attr of attributions) {
-                        span.addEvent('cpi.invoke', {
-                            'cpi.program': attr.programName ?? attr.programId,
-                            'cpi.instruction': attr.instructionName ?? 'unknown',
-                            'cpi.depth': attr.depth,
-                            'cpi.cu_consumed': attr.cuConsumed,
-                            'cpi.cu_self': attr.cuSelf,
-                            'cpi.percentage': parseFloat(attr.percentage.toFixed(2)),
-                        });
-                    }
-                    // Top-level instruction info
-                    const root = cpiTree.roots[0];
-                    if (root) {
-                        if (root.programName)
-                            span.setAttribute('solana.tx.program', root.programName);
-                        if (root.instructionName)
-                            span.setAttribute('solana.tx.instruction', root.instructionName);
-                    }
-                    span.setAttribute('solana.tx.enrichment_ms', Date.now() - enrichStart);
-                    span.setStatus({ code: SpanStatusCode.OK });
-                    span.end();
-                    return { signature, cpiTree };
-                }
-            }
-            span.setStatus({ code: SpanStatusCode.OK });
-            span.end();
-            return { signature };
-        }
-        catch (err) {
-            span.setAttribute('solana.tx.status', 'failed');
-            span.setAttribute('solana.tx.submit_ms', Date.now() - submitStart);
-            span.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: err instanceof Error ? err.message : String(err),
-            });
-            span.end();
-            throw err;
+      }
+      const root = cpiTree.roots[0];
+      if (root) {
+        if (root.programName) span.setAttribute("solana.tx.program", root.programName);
+        if (root.instructionName) span.setAttribute("solana.tx.instruction", root.instructionName);
+      }
+    }
+    span.setAttribute("solana.tx.enrichment_ms", Date.now() - start);
+    if (txDetails.meta?.err) {
+      span.setStatus({ code: SpanStatusCode.ERROR });
+    } else {
+      span.setStatus({ code: SpanStatusCode.OK });
+    }
+  } catch (err) {
+    span.recordException(err instanceof Error ? err : new Error(String(err)));
+    span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: err instanceof Error ? err.message : String(err)
+    });
+  } finally {
+    span.end();
+  }
+}
+function buildResolverFromIdls(idls) {
+  const resolver = new IdlResolver();
+  if (idls) resolver.registerMany(idls);
+  return resolver;
+}
+async function pollGetTransaction(connection, signature, commitment, deadline, basePollMs) {
+  let attempt = 0;
+  while (Date.now() < deadline) {
+    try {
+      const tx = await connection.getTransaction(signature, {
+        commitment,
+        maxSupportedTransactionVersion: 0
+      });
+      if (tx) return tx;
+    } catch {
+    }
+    attempt++;
+    const waitMs = Math.min(basePollMs * Math.pow(1.5, attempt - 1), 2e3);
+    await new Promise((resolve) => setTimeout(resolve, waitMs));
+  }
+  return null;
+}
+
+// src/index.ts
+var InstrumentedConnection = class extends Connection {
+  sightConfig;
+  idlResolver;
+  tracer;
+  constructor(endpoint, config) {
+    const {
+      tracer,
+      idlRpcEndpoint,
+      skipIdlResolution,
+      idls,
+      allowOnChainIdlFetch,
+      enrichmentTimeoutMs,
+      enrichmentPollIntervalMs,
+      disableAutoSpan,
+      commitment,
+      ...connectionConfig
+    } = config ?? {};
+    super(endpoint, connectionConfig);
+    this.sightConfig = {
+      tracer,
+      idlRpcEndpoint,
+      skipIdlResolution,
+      allowOnChainIdlFetch,
+      enrichmentTimeoutMs: enrichmentTimeoutMs ?? 3e4,
+      enrichmentPollIntervalMs: enrichmentPollIntervalMs ?? 500,
+      disableAutoSpan,
+      commitment
+    };
+    this.idlResolver = new IdlResolver2({
+      rpcEndpoint: idlRpcEndpoint ?? endpoint,
+      allowOnChainFetch: allowOnChainIdlFetch ?? false
+    });
+    if (idls) this.idlResolver.registerMany(idls);
+    this.tracer = tracer ?? trace2.getTracer("@thesight/sdk");
+  }
+  /**
+   * Register an IDL for a single program. Convenience forwarder for the
+   * underlying resolver. Anchor users typically call this right after
+   * constructing a `Program`:
+   *
+   *     const program = new Program(idl, programId, provider);
+   *     connection.registerIdl(program.programId.toBase58(), program.idl);
+   */
+  registerIdl(programId, idl) {
+    this.idlResolver.register(programId, idl);
+  }
+  /** Bulk-register multiple IDLs. */
+  registerIdls(idls) {
+    this.idlResolver.registerMany(idls);
+  }
+  // ─── Overridden method ────────────────────────────────────────────────────
+  /**
+   * Overrides the parent `Connection.sendRawTransaction` so every submit —
+   * including those made by Anchor's `provider.sendAndConfirm`, web3.js's
+   * top-level `sendAndConfirmTransaction`, and wallet adapter flows — is
+   * observed by an OTel span automatically.
+   *
+   * The span is a child of whatever OTel context is active when the call
+   * fires, so app-level parent spans (HTTP handlers, job runs, wallet flow
+   * spans from another SDK) nest the Sight span correctly.
+   */
+  async sendRawTransaction(rawTransaction, options) {
+    if (this.sightConfig.disableAutoSpan) {
+      return super.sendRawTransaction(rawTransaction, options);
+    }
+    const span = this.tracer.startSpan("solana.sendRawTransaction", {}, context2.active());
+    const submitStart = Date.now();
+    let signature;
+    try {
+      signature = await super.sendRawTransaction(rawTransaction, options);
+    } catch (err) {
+      const submitMs = Date.now() - submitStart;
+      span.setAttribute("solana.tx.submit_ms", submitMs);
+      span.setAttribute("solana.tx.status", "failed");
+      span.recordException(err instanceof Error ? err : new Error(String(err)));
+      span.setStatus({
+        code: SpanStatusCode2.ERROR,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      span.end();
+      throw err;
+    }
+    span.setAttribute("solana.tx.signature", signature);
+    span.setAttribute("solana.tx.submit_ms", Date.now() - submitStart);
+    span.setAttribute("solana.tx.status", "submitted");
+    void this.enrichSpanInBackground(span, signature, submitStart);
+    return signature;
+  }
+  // ─── Background enrichment ───────────────────────────────────────────────
+  /**
+   * Poll `getTransaction` until the on-chain record is available, then
+   * enrich the span with CU attribution, program names, decoded errors,
+   * and per-CPI events.
+   *
+   * This runs async and is never awaited by callers of `sendRawTransaction`.
+   * Failures inside this method attach to the span via recordException
+   * rather than throwing.
+   */
+  async enrichSpanInBackground(span, signature, submitStart) {
+    const enrichStart = Date.now();
+    const deadline = enrichStart + (this.sightConfig.enrichmentTimeoutMs ?? 3e4);
+    const commitment = this.sightConfig.commitment ?? "confirmed";
+    const basePollMs = this.sightConfig.enrichmentPollIntervalMs ?? 500;
+    try {
+      const txDetails = await this.pollForTransaction(signature, commitment, deadline, basePollMs);
+      if (!txDetails) {
+        span.setAttribute("solana.tx.status", "timeout");
+        span.setAttribute("solana.tx.enrichment_ms", Date.now() - submitStart);
+        span.end();
+        return;
+      }
+      this.attachTxDetailsToSpan(span, txDetails);
+      if (!this.sightConfig.skipIdlResolution) {
+        const logs = txDetails.meta?.logMessages ?? [];
+        if (logs.length > 0) {
+          await this.attachParsedLogsToSpan(span, logs);
         }
+      }
+      span.setAttribute("solana.tx.enrichment_ms", Date.now() - submitStart);
+      if (txDetails.meta?.err) {
+        span.setStatus({ code: SpanStatusCode2.ERROR });
+      } else {
+        span.setStatus({ code: SpanStatusCode2.OK });
+      }
+    } catch (err) {
+      span.recordException(err instanceof Error ? err : new Error(String(err)));
+      span.setAttribute(
+        "solana.tx.enrichment_error",
+        err instanceof Error ? err.message : String(err)
+      );
+    } finally {
+      span.end();
+    }
+  }
+  /**
+   * Poll `getTransaction(signature)` until either the on-chain record is
+   * returned or the deadline passes. Exponential backoff (1.5x) capped at
+   * 2 seconds to balance responsiveness against RPC load.
+   */
+  async pollForTransaction(signature, commitment, deadline, basePollMs) {
+    let attempt = 0;
+    while (Date.now() < deadline) {
+      try {
+        const tx = await super.getTransaction(signature, {
+          commitment,
+          maxSupportedTransactionVersion: 0
+        });
+        if (tx) return tx;
+      } catch {
+      }
+      attempt++;
+      const waitMs = Math.min(basePollMs * Math.pow(1.5, attempt - 1), 2e3);
+      await sleep(waitMs);
+    }
+    return null;
+  }
+  /** Attach the flat fields (slot, fee, CU, status) from a tx response to a span. */
+  attachTxDetailsToSpan(span, txDetails) {
+    span.setAttribute("solana.tx.status", txDetails.meta?.err ? "failed" : "confirmed");
+    span.setAttribute("solana.tx.slot", txDetails.slot);
+    const fee = txDetails.meta?.fee;
+    if (fee !== void 0) span.setAttribute("solana.tx.fee_lamports", fee);
+    const cuUsed = txDetails.meta?.computeUnitsConsumed;
+    if (cuUsed !== void 0 && cuUsed !== null) {
+      span.setAttribute("solana.tx.cu_used", Number(cuUsed));
+      span.setAttribute("solana.tx.cu_budget", 2e5);
+      span.setAttribute(
+        "solana.tx.cu_utilization",
+        parseFloat((Number(cuUsed) / 2e5 * 100).toFixed(1))
+      );
+    }
+  }
+  /**
+   * Parse program logs into a CPI tree, enrich with registered IDLs, and
+   * emit one `cpi.invoke` event per invocation onto the span. Root
+   * program/instruction names are copied onto span attributes so dashboards
+   * can filter by them without walking events.
+   */
+  async attachParsedLogsToSpan(span, logs) {
+    const { cpiTree } = parseLogs2({ logs });
+    await enrichTree2(cpiTree, this.idlResolver);
+    const attributions = flatAttributions2(cpiTree);
+    for (const attr of attributions) {
+      span.addEvent("cpi.invoke", {
+        "cpi.program": attr.programName ?? attr.programId,
+        "cpi.instruction": attr.instructionName ?? "unknown",
+        "cpi.depth": attr.depth,
+        "cpi.cu_consumed": attr.cuConsumed,
+        "cpi.cu_self": attr.cuSelf,
+        "cpi.percentage": parseFloat(attr.percentage.toFixed(2))
+      });
+    }
+    const root = cpiTree.roots[0];
+    if (root) {
+      if (root.programName) span.setAttribute("solana.tx.program", root.programName);
+      if (root.instructionName) span.setAttribute("solana.tx.instruction", root.instructionName);
     }
+    return cpiTree;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-export { IdlResolver } from '@thesight/core';
-// ─── Tracing initialization ──────────────────────────────────────────────────
-// One-call setup that wires a NodeTracerProvider + SightSpanExporter as the
-// global OTel tracer. After calling initSight, every InstrumentedConnection
-// span routes to Sight ingest automatically — no separate OTel setup needed.
-export { initSight } from './init.js';
-export { SightSpanExporter } from './exporter.js';
+export {
+  IdlResolver3 as IdlResolver,
+  InstrumentedConnection,
+  SightSpanExporter,
+  initSight,
+  trackSolanaTransaction
+};
 //# sourceMappingURL=index.js.map