@breeztech/breez-sdk-spark 0.16.1-dev1 → 0.17.0

package/bundler/storage/index.js

@@ -490,7 +490,7 @@ class MigrationManager {
         // Add deposit_vout to distinguish deposits sharing a funding tx. The
         // new field is carried inside the JSON `details` blob. We can't safely
         // backfill vout on the existing blobs: we never stored the original SSP
-        // output_index, and vout=0 is a valid output index — defaulting would
+        // output_index, and vout=0 is a valid output index, so defaulting would
         // silently mislabel. Instead we clear `details` on legacy deposit blobs
         // so the read path returns `details: None` (matches what the SQL
         // backends do by leaving the payments row but having no matching
@@ -545,6 +545,47 @@ class MigrationManager {
           }
         },
       },
+      {
+        name: "Backfill conversion_info type discriminator for serde tagged enum",
+        upgrade: (db, transaction) => {
+          if (db.objectStoreNames.contains("payment_metadata")) {
+            const store = transaction.objectStore("payment_metadata");
+            const request = store.openCursor();
+            request.onsuccess = (event) => {
+              const cursor = event.target.result;
+              if (cursor) {
+                const record = cursor.value;
+                if (record.conversionInfo) {
+                  try {
+                    const ci = typeof record.conversionInfo === "string"
+                      ? JSON.parse(record.conversionInfo)
+                      : record.conversionInfo;
+                    if (!ci.type) {
+                      ci.type = "amm";
+                      record.conversionInfo = JSON.stringify(ci);
+                      cursor.update(record);
+                    }
+                  } catch (e) {
+                    // Skip unparseable records
+                  }
+                }
+                cursor.continue();
+              }
+            };
+          }
+        },
+      },
+      {
+        // listActiveCrossChainSwaps scans and filters.
+        name: "Create cross_chain_swaps store",
+        upgrade: (db) => {
+          if (!db.objectStoreNames.contains("cross_chain_swaps")) {
+            db.createObjectStore("cross_chain_swaps", {
+              keyPath: ["provider", "id"],
+            });
+          }
+        },
+      },
     ];
   }
 }
@@ -573,7 +614,7 @@ class IndexedDBStorage {
     // so existing databases depend on indices never shifting. Never insert,
     // reorder, or delete a migration — only append. dbVersion MUST equal the
     // number of migrations (enforced by the guard in initialize()).
-    this.dbVersion = 18; // Current schema version (= migration count)
+    this.dbVersion = 20; // Current schema version (= migration count)
   }
 
   /**
@@ -2190,6 +2231,77 @@ class IndexedDBStorage {
     });
   }
 
+  // ===== Cross-Chain Swap Operations =====
+
+  async setCrossChainSwap(swap) {
+    if (!this.db) {
+      throw new StorageError("Database not initialized");
+    }
+
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction("cross_chain_swaps", "readwrite");
+      const store = transaction.objectStore("cross_chain_swaps");
+      // IndexedDB stores nested objects natively, so `data` is kept as-is.
+      const request = store.put(swap);
+      request.onsuccess = () => resolve();
+      request.onerror = () => {
+        reject(
+          new StorageError(
+            `Failed to set cross-chain swap '${swap.provider}:${swap.id}': ${request.error?.message || "Unknown error"}`,
+            request.error
+          )
+        );
+      };
+    });
+  }
+
+  async getCrossChainSwap(provider, id) {
+    if (!this.db) {
+      throw new StorageError("Database not initialized");
+    }
+
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction("cross_chain_swaps", "readonly");
+      const store = transaction.objectStore("cross_chain_swaps");
+      const request = store.get([provider, id]);
+      request.onsuccess = () => resolve(request.result || null);
+      request.onerror = () => {
+        reject(
+          new StorageError(
+            `Failed to get cross-chain swap '${provider}:${id}': ${request.error?.message || "Unknown error"}`,
+            request.error
+          )
+        );
+      };
+    });
+  }
+
+  async listActiveCrossChainSwaps(provider) {
+    if (!this.db) {
+      throw new StorageError("Database not initialized");
+    }
+
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction("cross_chain_swaps", "readonly");
+      const store = transaction.objectStore("cross_chain_swaps");
+      const request = store.getAll();
+      request.onsuccess = () => {
+        const all = request.result || [];
+        resolve(
+          all.filter((swap) => swap.provider === provider && !swap.isTerminal)
+        );
+      };
+      request.onerror = () => {
+        reject(
+          new StorageError(
+            `Failed to list active cross-chain swaps for '${provider}': ${request.error?.message || "Unknown error"}`,
+            request.error
+          )
+        );
+      };
+    });
+  }
+
   // ===== Private Helper Methods =====
 
   _paymentToStore(payment) {
@@ -2265,6 +2377,10 @@ class IndexedDBStorage {
       // Filter by payment details. If any filter matches, we include the payment
       let paymentDetailsFilterMatches = false;
       for (const paymentDetailsFilter of request.paymentDetailsFilter) {
+        // Base type check: the payment's details type must match the filter type
+        if (details.type !== paymentDetailsFilter.type) {
+          continue;
+        }
         // Filter by HTLC status (Spark or Lightning)
         if (
           (paymentDetailsFilter.type === "spark" ||
@@ -2282,11 +2398,12 @@ class IndexedDBStorage {
             continue;
           }
         }
-        // Filter by token conversion info presence
+        // Filter by conversion type + status
         if (
           (paymentDetailsFilter.type === "spark" ||
-            paymentDetailsFilter.type === "token") &&
-          paymentDetailsFilter.conversionRefundNeeded != null
+            paymentDetailsFilter.type === "token" ||
+            paymentDetailsFilter.type === "lightning") &&
+          paymentDetailsFilter.conversionFilter != null
         ) {
           if (
             details.type !== paymentDetailsFilter.type ||
@@ -2295,11 +2412,20 @@ class IndexedDBStorage {
             continue;
           }
 
-          if (
-            paymentDetailsFilter.conversionRefundNeeded ===
-            (details.conversionInfo.status !== "refundNeeded")
-          ) {
-            continue;
+          const ci = details.conversionInfo;
+          if (paymentDetailsFilter.conversionFilter === "ammRefundNeeded") {
+            if (ci.type !== "amm" || ci.status !== "refundNeeded") {
+              continue;
+            }
+          } else if (paymentDetailsFilter.conversionFilter === "orchestraPending") {
+            if (ci.type !== "orchestra" || ["completed", "failed", "refunded"].includes(ci.status)) {
+              continue;
+            }
+          } else if (paymentDetailsFilter.conversionFilter === "boltzPending") {
+            // Boltz conversion lives on the Lightning leg.
+            if (ci.type !== "boltz" || ["completed", "failed", "refunded"].includes(ci.status)) {
+              continue;
+            }
           }
         }
         // Filter by token transaction hash
@@ -2440,17 +2566,23 @@ class IndexedDBStorage {
             );
           }
         }
-      } else if (details.type == "spark" || details.type == "token") {
-        // If conversionInfo exists, parse and add to details
-        if (metadata.conversionInfo) {
-          try {
-            details.conversionInfo = JSON.parse(metadata.conversionInfo);
-          } catch (e) {
-            throw new StorageError(
-              `Failed to parse conversionInfo JSON for payment ${payment.id}: ${e.message}`,
-              e
-            );
-          }
+      }
+
+      // conversionInfo is surfaced on Lightning (Boltz hold-invoice pay),
+      // Spark, and Token details — every variant that can carry a conversion.
+      if (
+        (details.type == "lightning" ||
+          details.type == "spark" ||
+          details.type == "token") &&
+        metadata.conversionInfo
+      ) {
+        try {
+          details.conversionInfo = JSON.parse(metadata.conversionInfo);
+        } catch (e) {
+          throw new StorageError(
+            `Failed to parse conversionInfo JSON for payment ${payment.id}: ${e.message}`,
+            e
+          );
         }
       }
     }

package/deno/breez_sdk_spark_wasm.d.ts

@@ -605,6 +605,7 @@ export interface Config {
     maxConcurrentClaims: number;
     sparkConfig?: SparkConfig;
     backgroundTasksEnabled: boolean;
+    crossChainConfig?: CrossChainConfig;
 }
 
 export interface ConnectRequest {
@@ -621,10 +622,23 @@ export interface Contact {
     updatedAt: number;
 }
 
+export interface Conversion {
+    provider: ConversionProvider;
+    status: ConversionStatus;
+    from: ConversionSide;
+    to: ConversionSide;
+    amountAdjustment?: AmountAdjustmentReason;
+}
+
+export interface ConversionAsset {
+    ticker: string;
+    identifier?: string;
+    decimals: number;
+}
+
 export interface ConversionDetails {
     status: ConversionStatus;
-    from?: ConversionStep;
-    to?: ConversionStep;
+    conversions?: Conversion[];
 }
 
 export interface ConversionEstimate {
@@ -635,28 +649,17 @@ export interface ConversionEstimate {
     amountAdjustment?: AmountAdjustmentReason;
 }
 
-export interface ConversionInfo {
-    poolId: string;
-    conversionId: string;
-    status: ConversionStatus;
-    fee?: string;
-    purpose?: ConversionPurpose;
-    amountAdjustment?: AmountAdjustmentReason;
-}
-
 export interface ConversionOptions {
     conversionType: ConversionType;
     maxSlippageBps?: number;
     completionTimeoutSecs?: number;
 }
 
-export interface ConversionStep {
-    paymentId: string;
-    amount: bigint;
-    fee: bigint;
-    method: PaymentMethod;
-    tokenMetadata?: TokenMetadata;
-    amountAdjustment?: AmountAdjustmentReason;
+export interface ConversionSide {
+    chain: ConversionChain;
+    asset: ConversionAsset;
+    amount: string;
+    fee: string;
 }
 
 export interface CreateIssuerTokenRequest {
@@ -672,6 +675,30 @@ export interface Credentials {
     password: string;
 }
 
+export interface CrossChainAddressDetails {
+    address: string;
+    addressFamily: CrossChainAddressFamily;
+    contractAddress?: string;
+    chainId?: number;
+    amount?: bigint;
+}
+
+export interface CrossChainConfig {
+    defaultSlippageBps?: number;
+    defaultTargetOverpayBps?: number;
+}
+
+export interface CrossChainRoutePair {
+    provider: CrossChainProvider;
+    chain: string;
+    chainId?: string;
+    asset: string;
+    contractAddress?: string;
+    decimals: number;
+    exactOutEligible: boolean;
+    supportedSources: SourceAsset[];
+}
+
 export interface CurrencyInfo {
     name: string;
     fractionSize: number;
@@ -1208,7 +1235,7 @@ export interface PrepareLnurlPayResponse {
 }
 
 export interface PrepareSendPaymentRequest {
-    paymentRequest: string;
+    paymentRequest: PaymentRequest;
     amount?: bigint;
     tokenIdentifier?: string;
     conversionOptions?: ConversionOptions;
@@ -1429,6 +1456,7 @@ export interface SparkSigningOperator {
     identifier: string;
     address: string;
     identityPublicKey: string;
+    caCertPem?: string;
 }
 
 export interface SparkSspConfig {
@@ -1481,6 +1509,9 @@ export interface Storage {
     getContact: (id: string) => Promise<Contact>;
     insertContact: (contact: Contact) => Promise<void>;
     deleteContact: (id: string) => Promise<void>;
+    setCrossChainSwap: (swap: StoredCrossChainSwap) => Promise<void>;
+    getCrossChainSwap: (provider: string, id: string) => Promise<StoredCrossChainSwap | null>;
+    listActiveCrossChainSwaps: (provider: string) => Promise<StoredCrossChainSwap[]>;
     syncAddOutgoingChange: (record: UnversionedRecordChange) => Promise<number>;
     syncCompleteOutgoingSync: (record: Record) => Promise<void>;
     syncGetPendingOutgoingChanges: (limit: number) => Promise<OutgoingChange[]>;
@@ -1504,6 +1535,15 @@ export interface StorageListPaymentsRequest {
     sortAscending?: boolean;
 }
 
+export interface StoredCrossChainSwap {
+    provider: string;
+    id: string;
+    isTerminal: boolean;
+    updatedAt: number;
+    data: string;
+    secrets: string;
+}
+
 export interface Symbol {
     grapheme?: string;
     template?: string;
@@ -1637,12 +1677,30 @@ export type BuyBitcoinRequest = { type: "moonpay"; lockedAmountSat?: number; red
 
 export type ChainApiType = "esplora" | "mempoolSpace";
 
+export type ConversionChain = { type: "spark" } | { type: "lightning" } | { type: "external"; name: string; chainId?: string };
+
+export type ConversionFilter = "ammRefundNeeded" | "orchestraPending" | "boltzPending";
+
+export type ConversionInfo = { type: "amm"; poolId: string; conversionId: string; status: ConversionStatus; fee?: string; purpose?: ConversionPurpose; amountAdjustment?: AmountAdjustmentReason } | { type: "orchestra"; chain: string; chainId?: string; asset?: string; assetContract?: string; recipientAddress: string; assetAmountIn?: string; estimatedOut: string; deliveredAmount?: string; status: ConversionStatus; feeAmount?: string; serviceFeeAmount?: string; serviceFeeAsset?: string; assetDecimals: number; orderId: string; quoteId: string; readToken?: string } | { type: "boltz"; chain: string; chainId?: string; asset?: string; assetContract?: string; recipientAddress: string; assetAmountIn?: string; estimatedOut: string; deliveredAmount?: string; status: ConversionStatus; feeAmount?: string; serviceFeeAmount?: string; serviceFeeAsset?: string; assetDecimals: number; swapId: string; invoice: string; invoiceAmountSats: number; bridgeRef?: string; maxSlippageBps: number; quoteDegraded?: boolean };
+
+export type ConversionProvider = "amm" | "orchestra" | "boltz";
+
 export type ConversionPurpose = { type: "ongoingPayment"; paymentRequest: string } | { type: "selfTransfer" } | { type: "autoConversion" };
 
 export type ConversionStatus = "pending" | "completed" | "failed" | "refundNeeded" | "refunded";
 
 export type ConversionType = { type: "fromBitcoin" } | { type: "toBitcoin"; fromTokenIdentifier: string };
 
+export type CrossChainAddressFamily = "evm" | "solana" | "tron";
+
+export type CrossChainFeeMode = "feesExcluded" | "feesIncluded";
+
+export type CrossChainProvider = "orchestra" | "boltz";
+
+export type CrossChainProviderContext = { type: "orchestra"; quoteId: string; depositAddress: string; depositAmount?: string } | { type: "boltz"; swapId: string; invoice: string; invoiceAmountSats?: number; maxSlippageBps: number };
+
+export type CrossChainRouteFilter = { type: "send"; addressDetails: CrossChainAddressDetails } | { type: "receive"; contractAddress?: string };
+
 export type DepositClaimError = { type: "maxDepositClaimFeeExceeded"; tx: string; vout: number; maxFee?: Fee; requiredFeeSats: number; requiredFeeRateSatPerVbyte: number } | { type: "missingUtxo"; tx: string; vout: number } | { type: "generic"; message: string };
 
 export type ExternalFrostDerivation = { type: "signingLeaf"; leafId: ExternalTreeNodeId } | { type: "staticDeposit"; index: number } | { type: "htlcPreimage" } | { type: "identity" };
@@ -1655,7 +1713,7 @@ export type Fee = { type: "fixed"; amount: number } | { type: "rate"; satPerVbyt
 
 export type FeePolicy = "feesExcluded" | "feesIncluded";
 
-export type InputType = ({ type: "bitcoinAddress" } & BitcoinAddressDetails) | ({ type: "bolt11Invoice" } & Bolt11InvoiceDetails) | ({ type: "bolt12Invoice" } & Bolt12InvoiceDetails) | ({ type: "bolt12Offer" } & Bolt12OfferDetails) | ({ type: "lightningAddress" } & LightningAddressDetails) | ({ type: "lnurlPay" } & LnurlPayRequestDetails) | ({ type: "silentPaymentAddress" } & SilentPaymentAddressDetails) | ({ type: "lnurlAuth" } & LnurlAuthRequestDetails) | ({ type: "url" } & string) | ({ type: "bip21" } & Bip21Details) | ({ type: "bolt12InvoiceRequest" } & Bolt12InvoiceRequestDetails) | ({ type: "lnurlWithdraw" } & LnurlWithdrawRequestDetails) | ({ type: "sparkAddress" } & SparkAddressDetails) | ({ type: "sparkInvoice" } & SparkInvoiceDetails);
+export type InputType = ({ type: "bitcoinAddress" } & BitcoinAddressDetails) | ({ type: "bolt11Invoice" } & Bolt11InvoiceDetails) | ({ type: "bolt12Invoice" } & Bolt12InvoiceDetails) | ({ type: "bolt12Offer" } & Bolt12OfferDetails) | ({ type: "lightningAddress" } & LightningAddressDetails) | ({ type: "lnurlPay" } & LnurlPayRequestDetails) | ({ type: "silentPaymentAddress" } & SilentPaymentAddressDetails) | ({ type: "lnurlAuth" } & LnurlAuthRequestDetails) | ({ type: "url" } & string) | ({ type: "bip21" } & Bip21Details) | ({ type: "bolt12InvoiceRequest" } & Bolt12InvoiceRequestDetails) | ({ type: "lnurlWithdraw" } & LnurlWithdrawRequestDetails) | ({ type: "sparkAddress" } & SparkAddressDetails) | ({ type: "sparkInvoice" } & SparkInvoiceDetails) | ({ type: "crossChainAddress" } & CrossChainAddressDetails);
 
 export type LnurlCallbackStatus = { type: "ok" } | { type: "errorStatus"; errorDetails: LnurlErrorDetails };
 
@@ -1669,12 +1727,14 @@ export type OptimizationMode = "full" | "singleRound";
 
 export type OptimizationOutcome = { type: "completed"; roundsExecuted: number } | { type: "inProgress" };
 
-export type PaymentDetails = { type: "spark"; invoiceDetails?: SparkInvoicePaymentDetails; htlcDetails?: SparkHtlcDetails; conversionInfo?: ConversionInfo } | { type: "token"; metadata: TokenMetadata; txHash: string; txType: TokenTransactionType; invoiceDetails?: SparkInvoicePaymentDetails; conversionInfo?: ConversionInfo } | { type: "lightning"; description?: string; invoice: string; destinationPubkey: string; htlcDetails: SparkHtlcDetails; lnurlPayInfo?: LnurlPayInfo; lnurlWithdrawInfo?: LnurlWithdrawInfo; lnurlReceiveMetadata?: LnurlReceiveMetadata } | { type: "withdraw"; txId: string } | { type: "deposit"; txId: string; vout: number };
+export type PaymentDetails = { type: "spark"; invoiceDetails?: SparkInvoicePaymentDetails; htlcDetails?: SparkHtlcDetails; conversionInfo?: ConversionInfo } | { type: "token"; metadata: TokenMetadata; txHash: string; txType: TokenTransactionType; invoiceDetails?: SparkInvoicePaymentDetails; conversionInfo?: ConversionInfo } | { type: "lightning"; description?: string; invoice: string; destinationPubkey: string; htlcDetails: SparkHtlcDetails; lnurlPayInfo?: LnurlPayInfo; lnurlWithdrawInfo?: LnurlWithdrawInfo; lnurlReceiveMetadata?: LnurlReceiveMetadata; conversionInfo?: ConversionInfo } | { type: "withdraw"; txId: string } | { type: "deposit"; txId: string; vout: number };
 
 export type PaymentDetailsFilter = { type: "spark"; htlcStatus?: SparkHtlcStatus[]; conversionRefundNeeded?: boolean } | { type: "token"; conversionRefundNeeded?: boolean; txHash?: string; txType?: TokenTransactionType } | { type: "lightning"; htlcStatus?: SparkHtlcStatus[] };
 
 export type PaymentMethod = "lightning" | "spark" | "token" | "deposit" | "withdraw" | "unknown";
 
+export type PaymentRequest = { type: "input"; input: string } | { type: "crossChain"; address: string; route: CrossChainRoutePair; maxSlippageBps?: number; targetOverpayBps?: number };
+
 export type PaymentStatus = "completed" | "pending" | "failed";
 
 export type PaymentType = "send" | "receive";
@@ -1687,7 +1747,7 @@ export type SdkEvent = { type: "synced" } | { type: "unclaimedDeposits"; unclaim
 
 export type Seed = { type: "mnemonic"; mnemonic: string; passphrase?: string } | ({ type: "entropy" } & number[]);
 
-export type SendPaymentMethod = { type: "bitcoinAddress"; address: BitcoinAddressDetails; feeQuote: SendOnchainFeeQuote } | { type: "bolt11Invoice"; invoiceDetails: Bolt11InvoiceDetails; sparkTransferFeeSats?: number; lightningFeeSats: number } | { type: "sparkAddress"; address: string; fee: string; tokenIdentifier?: string } | { type: "sparkInvoice"; sparkInvoiceDetails: SparkInvoiceDetails; fee: string; tokenIdentifier?: string };
+export type SendPaymentMethod = { type: "bitcoinAddress"; address: BitcoinAddressDetails; feeQuote: SendOnchainFeeQuote } | { type: "bolt11Invoice"; invoiceDetails: Bolt11InvoiceDetails; sparkTransferFeeSats?: number; lightningFeeSats: number } | { type: "sparkAddress"; address: string; fee: string; tokenIdentifier?: string } | { type: "sparkInvoice"; sparkInvoiceDetails: SparkInvoiceDetails; fee: string; tokenIdentifier?: string } | { type: "crossChainAddress"; route: CrossChainRoutePair; recipientAddress: string; amountIn: string; assetAmountIn: string; estimatedOut: string; feeAmount: string; serviceFeeAmount: string; serviceFeeAsset?: string; sourceTransferFeeSats: number; feeMode: CrossChainFeeMode; expiresAt: string; providerContext: CrossChainProviderContext };
 
 export type SendPaymentOptions = { type: "bitcoinAddress"; confirmationSpeed: OnchainConfirmationSpeed } | { type: "bolt11Invoice"; preferSpark: boolean; completionTimeoutSecs?: number } | { type: "sparkAddress"; htlcOptions?: SparkHtlcOptions };
 
@@ -1695,11 +1755,13 @@ export type ServiceStatus = "operational" | "degraded" | "partial" | "unknown" |
 
 export type SessionStoreError = { type: "notFound" } | ({ type: "generic" } & string);
 
+export type SourceAsset = { type: "bitcoin" } | { type: "token"; tokenIdentifier: string };
+
 export type SparkHtlcStatus = "waitingForPreimage" | "preimageShared" | "returned";
 
 export type StableBalanceActiveLabel = { type: "set"; label: string } | { type: "unset" };
 
-export type StoragePaymentDetailsFilter = { type: "spark"; htlcStatus?: SparkHtlcStatus[]; conversionRefundNeeded?: boolean } | { type: "token"; conversionRefundNeeded?: boolean; txHash?: string; txType?: TokenTransactionType } | { type: "lightning"; htlcStatus?: SparkHtlcStatus[] };
+export type StoragePaymentDetailsFilter = { type: "spark"; htlcStatus?: SparkHtlcStatus[]; conversionFilter?: ConversionFilter } | { type: "token"; conversionFilter?: ConversionFilter; txHash?: string; txType?: TokenTransactionType } | { type: "lightning"; htlcStatus?: SparkHtlcStatus[]; conversionFilter?: ConversionFilter };
 
 export type SuccessAction = { type: "aes"; data: AesSuccessActionData } | { type: "message"; data: MessageSuccessActionData } | { type: "url"; data: UrlSuccessActionData };
 
@@ -1748,6 +1810,7 @@ export class BreezSdk {
     deleteLightningAddress(): Promise<void>;
     disconnect(): Promise<void>;
     fetchConversionLimits(request: FetchConversionLimitsRequest): Promise<FetchConversionLimitsResponse>;
+    getCrossChainRoutes(filter: CrossChainRouteFilter): Promise<CrossChainRoutePair[]>;
     getInfo(request: GetInfoRequest): Promise<GetInfoResponse>;
     getLightningAddress(): Promise<LightningAddressInfo | undefined>;
     getPayment(request: GetPaymentRequest): Promise<GetPaymentResponse>;
@@ -2092,6 +2155,14 @@ export function newSharedSdkContext(config: WasmSdkContextConfig): Promise<WasmS
  */
 export function postgresStorage(config: PostgresStorageConfig): WasmStorageConfig;
 
+/**
+ * Runs automatically when the wasm module is instantiated. Installs the
+ * panic hook so Rust panics surface as readable `console.error` output
+ * (with the panic message + `file.rs:line`) instead of a bare
+ * `RuntimeError: unreachable`.
+ */
+export function start(): void;
+
 /**
  * Entry point invoked by JavaScript in a worker.
  */