@buildonspark/spark-sdk 0.2.5 → 0.2.6

package/src/services/wallet-config.ts

@@ -132,11 +132,16 @@ export type SigningOperator = {
   readonly identityPublicKey: string;
 };
 
+/* Console logging and debug tool options */
+export type ConsoleOptions = {
+  otel?: boolean;
+};
+
 export type ConfigOptions = MayHaveLrc20WalletApiConfig &
   MayHaveSspClientOptions & {
     readonly network?: NetworkType;
     readonly signingOperators?: Readonly<Record<string, SigningOperator>>;
-    readonly coodinatorIdentifier?: string;
+    readonly coordinatorIdentifier?: string;
     readonly frostSignerAddress?: string;
     readonly lrc20Address?: string;
     readonly threshold?: number;
@@ -148,14 +153,9 @@ export type ConfigOptions = MayHaveLrc20WalletApiConfig &
     readonly sspClientOptions?: SspClientOptions;
     readonly expectedWithdrawBondSats?: number;
     readonly expectedWithdrawRelativeBlockLocktime?: number;
+    readonly console?: ConsoleOptions;
   };
 
-const DEV_PUBKEYS = [
-  "03acd9a5a88db102730ff83dee69d69088cc4c9d93bbee893e90fd5051b7da9651",
-  "02d2d103cacb1d6355efeab27637c74484e2a7459e49110c3fe885210369782e23",
-  "0350f07ffc21bfd59d31e0a7a600e2995273938444447cb9bc4c75b8a895dbb853",
-];
-
 const PROD_PUBKEYS = [
   "03dfbdff4b6332c220f8fa2ba8ed496c698ceada563fa01b67d9983bfc5c95e763",
   "03e625e9768651c9be268e287245cc33f96a68ce9141b0b4769205db027ee8ed77",
@@ -169,7 +169,7 @@ function getLocalFrostSignerAddress(): string {
 const BASE_CONFIG: Required<ConfigOptions> = {
   network: "LOCAL",
   lrc20Address: getLrc20Url("LOCAL"),
-  coodinatorIdentifier:
+  coordinatorIdentifier:
     "0000000000000000000000000000000000000000000000000000000000000001",
   frostSignerAddress: getLocalFrostSignerAddress(),
   threshold: 2,
@@ -190,6 +190,9 @@ const BASE_CONFIG: Required<ConfigOptions> = {
     identityPublicKey: getSspIdentityPublicKey("LOCAL"),
     schemaEndpoint: getSspSchemaEndpoint("LOCAL"),
   },
+  console: {
+    otel: false,
+  },
 };
 
 const LOCAL_WALLET_CONFIG: Required<ConfigOptions> = {
@@ -280,6 +283,12 @@ function getSigningOperators(): Record<string, SigningOperator> {
 }
 
 export function getLocalSigningOperators(): Record<string, SigningOperator> {
+  const addresses = Array.from({ length: 5 }, (_, i) =>
+    isHermeticTest
+      ? `https://${i}.spark.minikube.local`
+      : `https://localhost:${i + 8535}`,
+  );
+
   const pubkeys = [
     "0322ca18fc489ae25418a0e768273c2c61cabb823edfb14feb891e9bec62016510",
     "0341727a6c41b168f07eb50865ab8c397a53c7eef628ac1020956b705e43b6cb27",
@@ -293,35 +302,35 @@ export function getLocalSigningOperators(): Record<string, SigningOperator> {
       id: 0,
       identifier:
         "0000000000000000000000000000000000000000000000000000000000000001",
-      address: "https://localhost:8535",
+      address: addresses[0]!,
       identityPublicKey: pubkeys[0]!,
     },
     "0000000000000000000000000000000000000000000000000000000000000002": {
       id: 1,
       identifier:
         "0000000000000000000000000000000000000000000000000000000000000002",
-      address: "https://localhost:8536",
+      address: addresses[1]!,
       identityPublicKey: pubkeys[1]!,
     },
     "0000000000000000000000000000000000000000000000000000000000000003": {
       id: 2,
       identifier:
         "0000000000000000000000000000000000000000000000000000000000000003",
-      address: "https://localhost:8537",
+      address: addresses[2]!,
       identityPublicKey: pubkeys[2]!,
     },
     "0000000000000000000000000000000000000000000000000000000000000004": {
       id: 3,
       identifier:
         "0000000000000000000000000000000000000000000000000000000000000004",
-      address: "https://localhost:8538",
+      address: addresses[3]!,
       identityPublicKey: pubkeys[3]!,
     },
     "0000000000000000000000000000000000000000000000000000000000000005": {
       id: 4,
       identifier:
         "0000000000000000000000000000000000000000000000000000000000000005",
-      address: "https://localhost:8539",
+      address: addresses[4]!,
       identityPublicKey: pubkeys[4]!,
     },
   };

package/src/spark-wallet/spark-wallet.browser.ts

@@ -0,0 +1,72 @@
+import { SparkWallet as BaseSparkWallet } from "./spark-wallet.js";
+import {
+  ConsoleSpanExporter,
+  SimpleSpanProcessor,
+  SpanProcessor,
+  WebTracerProvider,
+} from "@opentelemetry/sdk-trace-web";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { FetchInstrumentation } from "@opentelemetry/instrumentation-fetch";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { propagation } from "@opentelemetry/api";
+import { SparkWalletProps } from "../spark-wallet/types.js";
+import type { ConfigOptions } from "../services/wallet-config.js";
+import type { SparkSigner } from "../signer/signer.js";
+
+export class SparkWalletBrowser extends BaseSparkWallet {
+  public static async initialize({
+    mnemonicOrSeed,
+    accountNumber,
+    signer,
+    options,
+  }: SparkWalletProps) {
+    const wallet = new SparkWalletBrowser(options, signer);
+    wallet.initializeTracer(wallet);
+
+    const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
+
+    return {
+      wallet,
+      ...initResponse,
+    };
+  }
+
+  protected initializeTracerEnv({
+    spanProcessors,
+    traceUrls,
+  }: Parameters<BaseSparkWallet["initializeTracerEnv"]>[0]) {
+    initializeTracerEnvBrowser({ spanProcessors, traceUrls });
+  }
+}
+
+export function initializeTracerEnvBrowser({
+  spanProcessors,
+  traceUrls,
+}: Parameters<BaseSparkWallet["initializeTracerEnv"]>[0]) {
+  const provider = new WebTracerProvider({ spanProcessors });
+  provider.register();
+
+  propagation.setGlobalPropagator(new W3CTraceContextPropagator());
+
+  registerInstrumentations({
+    instrumentations: [
+      new FetchInstrumentation({
+        ignoreUrls: [
+          /* Since we're wrapping global fetch we should be careful to avoid
+             adding headers for unrelated requests */
+          new RegExp(
+            `^(?!(${traceUrls
+              .map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+              .join("|")}))`,
+          ),
+        ],
+        propagateTraceHeaderCorsUrls: /.*/,
+      }),
+    ],
+  });
+}
+
+export {
+  SparkWalletBrowser as SparkWallet,
+  initializeTracerEnvBrowser as initializeTracerEnv,
+};

package/src/spark-wallet/spark-wallet.node.ts

@@ -1,129 +1,71 @@
-import { Tracer } from "@opentelemetry/api";
 import { SparkWallet as BaseSparkWallet } from "./spark-wallet.js";
-import type { InitWalletResponse } from "./types.js";
-import { isObject } from "@lightsparkdev/core";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
+import {
+  ConsoleSpanExporter,
+  SimpleSpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
+import { SparkWalletProps } from "./types.js";
 
-export class SparkWallet extends BaseSparkWallet {
-  private tracer: Tracer | null = null;
+export class SparkWalletNodeJS extends BaseSparkWallet {
+  public static async initialize({
+    mnemonicOrSeed,
+    accountNumber,
+    signer,
+    options,
+  }: SparkWalletProps) {
+    const wallet = new SparkWalletNodeJS(options, signer);
+    wallet.initializeTracer(wallet);
 
-  protected wrapWithOtelSpan<A extends unknown[], R>(
-    name: string,
-    fn: (...args: A) => Promise<R>,
-  ) {
-    return async (...args: A) => {
-      if (!this.tracer) {
-        throw new Error("Tracer not initialized");
-      }
+    const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
 
-      return await this.tracer.startActiveSpan(name, async (span) => {
-        const traceId = span.spanContext().traceId;
-        try {
-          const result = await fn(...args);
-          return result;
-        } catch (error) {
-          if (error instanceof Error) {
-            error.message += ` [traceId: ${traceId}]`;
-          } else if (isObject(error)) {
-            error["traceId"] = traceId;
-          }
-          throw error;
-        } finally {
-          span.end();
-        }
-      });
+    return {
+      wallet,
+      ...initResponse,
     };
   }
 
-  protected async initializeTracer(tracerName: string) {
-    const { trace, propagation, context } = await import("@opentelemetry/api");
-    const { W3CTraceContextPropagator } = await import("@opentelemetry/core");
-    const { AsyncLocalStorageContextManager } = await import(
-      "@opentelemetry/context-async-hooks"
-    );
-    const { BasicTracerProvider } = await import(
-      "@opentelemetry/sdk-trace-base"
-    );
-
-    trace.setGlobalTracerProvider(new BasicTracerProvider());
-    propagation.setGlobalPropagator(new W3CTraceContextPropagator());
-    context.setGlobalContextManager(new AsyncLocalStorageContextManager());
-
-    this.tracer = trace.getTracer(tracerName);
-  }
-
-  private getTraceName(methodName: string) {
-    return `SparkWallet.${methodName}`;
+  protected initializeTracerEnv({
+    spanProcessors,
+    traceUrls,
+  }: Parameters<BaseSparkWallet["initializeTracerEnv"]>[0]) {
+    initializeTracerEnvNodeJS({ spanProcessors, traceUrls });
   }
+}
 
-  private wrapPublicMethodsWithOtelSpan<M extends keyof SparkWallet>(
-    methodName: M,
-  ) {
-    const original = this[methodName];
-
-    if (typeof original !== "function") {
-      throw new Error(`Method ${methodName} is not a function on SparkWallet.`);
-    }
-
-    const wrapped = this.wrapWithOtelSpan(
-      this.getTraceName(methodName),
-      original.bind(this) as (...args: unknown[]) => Promise<unknown>,
-    ) as SparkWallet[M];
-
-    (this as SparkWallet)[methodName] = wrapped;
-  }
-
-  private wrapSparkWalletWithTracing() {
-    const methods = [
-      "getLeaves",
-      "getIdentityPublicKey",
-      "getSparkAddress",
-      "createSparkPaymentIntent",
-      "getSwapFeeEstimate",
-      "getTransfers",
-      "getBalance",
-      "getSingleUseDepositAddress",
-      "getStaticDepositAddress",
-      "queryStaticDepositAddresses",
-      "getClaimStaticDepositQuote",
-      "claimStaticDeposit",
-      "refundStaticDeposit",
-      "getUnusedDepositAddresses",
-      "claimDeposit",
-      "advancedDeposit",
-      "transfer",
-      "createLightningInvoice",
-      "payLightningInvoice",
-      "getLightningSendFeeEstimate",
-      "withdraw",
-      "getWithdrawalFeeQuote",
-      "getTransferFromSsp",
-      "getTransfer",
-      "transferTokens",
-      "batchTransferTokens",
-      "queryTokenTransactions",
-      "getLightningReceiveRequest",
-      "getLightningSendRequest",
-      "getCoopExitRequest",
-      "checkTimelock",
-      "testOnly_expireTimelock",
-    ] as const;
-
-    methods.forEach((m) => this.wrapPublicMethodsWithOtelSpan(m));
-
-    /* Private methods can't be indexed on `this` and need to be wrapped individually: */
-    this.initWallet = this.wrapWithOtelSpan(
-      this.getTraceName("initWallet"),
-      this.initWallet.bind(this),
-    );
-  }
+export function initializeTracerEnvNodeJS({
+  spanProcessors,
+  traceUrls,
+}: Parameters<BaseSparkWallet["initializeTracerEnv"]>[0]) {
+  const provider = new NodeTracerProvider({ spanProcessors });
+  provider.register({
+    contextManager: new AsyncLocalStorageContextManager(),
+    propagator: new W3CTraceContextPropagator(),
+  });
 
-  protected async initWallet(
-    mnemonicOrSeed?: Uint8Array | string,
-    accountNumber?: number,
-  ): Promise<InitWalletResponse | undefined> {
-    const res = super.initWallet(mnemonicOrSeed, accountNumber);
-    await this.initializeTracer(this.tracerId);
-    this.wrapSparkWalletWithTracing();
-    return res;
-  }
+  registerInstrumentations({
+    instrumentations: [
+      new UndiciInstrumentation({
+        ignoreRequestHook: (request) => {
+          /* Since we're wrapping global fetch we should be careful to avoid
+               adding headers or causing errors for unrelated requests */
+          try {
+            return !traceUrls.some((prefix) =>
+              request.origin.startsWith(prefix),
+            );
+          } catch {
+            return true;
+          }
+        },
+      }),
+    ],
+  });
 }
+
+export {
+  SparkWalletNodeJS as SparkWallet,
+  initializeTracerEnvNodeJS as initializeTracerEnv,
+};