@buildonspark/spark-sdk 0.2.4 → 0.2.6

package/src/graphql/client.ts

@@ -10,6 +10,7 @@ import {
 import { sha256 } from "@noble/hashes/sha2";
 import { AuthenticationError, NetworkError } from "../errors/index.js";
 import { SparkSigner } from "../signer/signer.js";
+import { UserRequestType } from "../types/sdk-types.js";
 import { ClaimStaticDeposit } from "./mutations/ClaimStaticDeposit.js";
 import { CompleteCoopExit } from "./mutations/CompleteCoopExit.js";
 import { CompleteLeavesSwap } from "./mutations/CompleteLeavesSwap.js";
@@ -19,6 +20,7 @@ import { RequestLightningReceive } from "./mutations/RequestLightningReceive.js"
 import { RequestLightningSend } from "./mutations/RequestLightningSend.js";
 import { RequestSwapLeaves } from "./mutations/RequestSwapLeaves.js";
 import { VerifyChallenge } from "./mutations/VerifyChallenge.js";
+import { ClaimStaticDepositFromJson } from "./objects/ClaimStaticDeposit.js";
 import ClaimStaticDepositOutput, {
   ClaimStaticDepositOutputFromJson,
 } from "./objects/ClaimStaticDepositOutput.js";
@@ -29,7 +31,7 @@ import CoopExitRequest, {
   CoopExitRequestFromJson,
 } from "./objects/CoopExitRequest.js";
 import { GetChallengeOutputFromJson } from "./objects/GetChallengeOutput.js";
-import type {
+import {
   BitcoinNetwork,
   CompleteCoopExitInput,
   CompleteLeavesSwapInput,
@@ -70,7 +72,7 @@ import { GetClaimDepositQuote } from "./queries/GetClaimDepositQuote.js";
 import { GetCoopExitFeeQuote } from "./queries/GetCoopExitFeeQuote.js";
 import { LeavesSwapFeeEstimate } from "./queries/LeavesSwapFeeEstimate.js";
 import { LightningSendFeeEstimate } from "./queries/LightningSendFeeEstimate.js";
-import { GetTransfer } from "./queries/Transfer.js";
+import { GetTransfers } from "./queries/Transfers.js";
 import { UserRequest } from "./queries/UserRequest.js";
 
 export interface SspClientOptions {
@@ -79,6 +81,10 @@ export interface SspClientOptions {
   schemaEndpoint?: string;
 }
 
+export interface TransferWithUserRequest extends Transfer {
+  userRequest?: UserRequestType;
+}
+
 export interface MayHaveSspClientOptions {
   readonly sspClientOptions?: SspClientOptions;
 }
@@ -485,14 +491,49 @@ export default class SspClient {
     });
   }
 
-  async getTransfer(id: string): Promise<Transfer | null> {
+  async getTransfers(ids: string[]): Promise<TransferWithUserRequest[]> {
     return await this.executeRawQuery({
-      queryPayload: GetTransfer,
+      queryPayload: GetTransfers,
       variables: {
-        transfer_spark_id: id,
-      },
-      constructObject: (response: { transfer: any }) => {
-        return TransferFromJson(response.transfer);
+        transfer_spark_ids: ids,
+      },
+      constructObject: (response: { transfers: any }) => {
+        return response.transfers.map((transfer: any) => {
+          const transferObj: TransferWithUserRequest = TransferFromJson(
+            transfer,
+          ) as TransferWithUserRequest;
+
+          switch (transfer.transfer_user_request.__typename) {
+            case "ClaimStaticDeposit":
+              transferObj.userRequest = ClaimStaticDepositFromJson(
+                transfer.transfer_user_request,
+              );
+              break;
+            case "CoopExitRequest":
+              transferObj.userRequest = CoopExitRequestFromJson(
+                transfer.transfer_user_request,
+              );
+              break;
+            case "LeavesSwapRequest":
+              transferObj.userRequest = LeavesSwapRequestFromJson(
+                transfer.transfer_user_request,
+              );
+              break;
+            case "LightningReceiveRequest":
+              transferObj.userRequest = LightningReceiveRequestFromJson(
+                transfer.transfer_user_request,
+              );
+              break;
+            case "LightningSendRequest":
+              transferObj.userRequest = LightningSendRequestFromJson(
+                transfer.transfer_user_request,
+              );
+              break;
+          }
+
+          const { userRequestId, ...rest } = transferObj;
+          return rest;
+        });
       },
     });
   }

package/src/graphql/objects/SparkWalletUser.ts

@@ -2,7 +2,7 @@
 
 import { Query, isObject } from "@lightsparkdev/core";
 import autoBind from "../../auto-bind.js";
-import LightsparkClient from "../client.js";
+import type LightsparkClient from "../client.js";
 import BitcoinNetwork from "./BitcoinNetwork.js";
 import Entity from "./Entity.js";
 import SparkUserRequestStatus from "./SparkUserRequestStatus.js";

package/src/graphql/queries/Transfers.ts

@@ -0,0 +1,15 @@
+import { FRAGMENT as TransferFragment } from "../objects/Transfer.js";
+import { FRAGMENT as UserRequestFragment } from "../objects/UserRequest.js";
+
+export const GetTransfers = `
+  query Transfers($transfer_spark_ids: [UUID!]!) {
+    transfers(transfer_spark_ids: $transfer_spark_ids) {
+      ...TransferFragment
+      transfer_user_request: user_request {
+        ...UserRequestFragment
+      }
+    }
+  }
+  ${TransferFragment}
+  ${UserRequestFragment}
+`;

package/src/index.node.ts

@@ -1,6 +1,7 @@
 /* Root Node.js entrypoint */
 
 import nodeCrypto from "crypto";
+
 import { setCrypto } from "./utils/crypto.js";
 
 const cryptoImpl =
@@ -21,7 +22,10 @@ export {
 } from "./signer/signer.js";
 export * from "./signer/types.js";
 
-export { SparkWallet } from "./spark-wallet/spark-wallet.node.js";
+export {
+  SparkWalletNodeJS as SparkWallet,
+  initializeTracerEnvNodeJS as initializeTracerEnv,
+} from "./spark-wallet/spark-wallet.node.js";
 export * from "./spark-wallet/types.js";
 
 export { type WalletConfigService } from "./services/config.js";

package/src/index.ts

@@ -24,7 +24,10 @@ export {
 } from "./signer/signer.js";
 export * from "./signer/types.js";
 
-export { SparkWallet } from "./spark-wallet/spark-wallet.js";
+export {
+  SparkWalletBrowser as SparkWallet,
+  initializeTracerEnvBrowser as initializeTracerEnv,
+} from "./spark-wallet/spark-wallet.browser.js";
 export * from "./spark-wallet/types.js";
 
 export { type WalletConfigService } from "./services/config.js";

package/src/services/config.ts

@@ -10,6 +10,7 @@ import {
   ConfigOptions,
   WalletConfig,
   SigningOperator,
+  ConsoleOptions,
 } from "./wallet-config.js";
 import { ConfigurationError } from "../errors/types.js";
 
@@ -47,7 +48,7 @@ export class WalletConfigService
 
   public getCoordinatorAddress(): string {
     const coordinator =
-      this.config.signingOperators[this.config.coodinatorIdentifier];
+      this.config.signingOperators[this.config.coordinatorIdentifier];
     if (!coordinator) {
       throw new ConfigurationError(
         "Coordinator not found in signing operators",
@@ -72,7 +73,7 @@ export class WalletConfigService
   }
 
   public getCoordinatorIdentifier(): string {
-    return this.config.coodinatorIdentifier;
+    return this.config.coordinatorIdentifier;
   }
 
   public getExpectedWithdrawBondSats(): number {
@@ -124,7 +125,17 @@ export class WalletConfigService
     return this.config.electrsUrl;
   }
 
+  public getSspBaseUrl(): string {
+    return this.config.sspClientOptions.baseUrl;
+  }
+
   public getSspIdentityPublicKey(): string {
     return this.config.sspClientOptions.identityPublicKey;
   }
+
+  public getConsoleOptions(): ConsoleOptions {
+    return {
+      ...this.config.console,
+    };
+  }
 }

package/src/services/token-transactions.ts

@@ -71,8 +71,8 @@ export interface QueryTokenTransactionsParams {
   tokenTransactionHashes?: string[];
   tokenIdentifiers?: string[];
   outputIds?: string[];
-  pageSize: number;
-  offset: number;
+  pageSize?: number;
+  offset?: number;
 }
 
 export class TokenTransactionService {
@@ -1043,6 +1043,8 @@ export class TokenTransactionService {
       tokenTransactionHashes,
       tokenIdentifiers,
       outputIds,
+      pageSize,
+      offset,
     } = params;
 
     const sparkClient = await this.connectionManager.createSparkClient(
@@ -1052,11 +1054,17 @@ export class TokenTransactionService {
     let queryParams: QueryTokenTransactionsRequestV0 = {
       tokenPublicKeys: issuerPublicKeys?.map(hexToBytes)!,
       ownerPublicKeys: ownerPublicKeys?.map(hexToBytes)!,
-      tokenIdentifiers: tokenIdentifiers?.map(hexToBytes)!,
+      tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
+        const { tokenIdentifier } = decodeBech32mTokenIdentifier(
+          identifier as Bech32mTokenIdentifier,
+          this.config.getNetworkType(),
+        );
+        return tokenIdentifier;
+      })!,
       tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes)!,
       outputIds: outputIds || [],
-      limit: 100,
-      offset: 0,
+      limit: pageSize!,
+      offset: offset!,
     };
 
     try {
@@ -1120,11 +1128,17 @@ export class TokenTransactionService {
     let queryParams: QueryTokenTransactionsRequestV1 = {
       issuerPublicKeys: issuerPublicKeys?.map(hexToBytes)!,
       ownerPublicKeys: ownerPublicKeys?.map(hexToBytes)!,
-      tokenIdentifiers: tokenIdentifiers?.map(hexToBytes)!,
+      tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
+        const { tokenIdentifier } = decodeBech32mTokenIdentifier(
+          identifier as Bech32mTokenIdentifier,
+          this.config.getNetworkType(),
+        );
+        return tokenIdentifier;
+      })!,
       tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes)!,
       outputIds: outputIds || [],
-      limit: pageSize,
-      offset: offset,
+      limit: pageSize!,
+      offset: offset!,
     };
 
     try {

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,
+};