@dynamic-labs-wallet/browser 1.0.89 → 1.0.91

package/index.cjs

@@ -652,13 +652,17 @@ function meetsMinVersion(sdkVersion, { minVersionByNamespace, fallbackMinVersion
                 // canRefresh only proves a local callback exists, not that the host answers it.
                 if (!this.supportsReverseChannel()) {
                     this.logger.warn(`[${operationName}] host SDK version predates the signed-session reverse channel, declining nonce refresh`, _extends({
-                        status
+                        http: {
+                            status_code: status
+                        }
                     }, logContext));
                     return alsoRetry ? alsoRetry(status) : false;
                 }
                 onRefreshed(await this.resolve());
                 this.logger.info(`[${operationName}] refreshed signed session, retrying`, _extends({
-                    status
+                    http: {
+                        status_code: status
+                    }
                 }, logContext));
                 return true;
             }
@@ -674,7 +678,9 @@ function meetsMinVersion(sdkVersion, { minVersionByNamespace, fallbackMinVersion
         this.logger.info(NONCE_FAILURE_EVENT, _extends({}, logContext, {
             operationName,
             attempt,
-            status,
+            http: {
+                status_code: status
+            },
             reason: classifyNonceFailure(body),
             errorCode: body.code,
             errorMessage: body.message,
@@ -2114,17 +2120,21 @@ const initializeCloudKit = async (config, signInButtonId, onSignInRequired, onSi
         // Downgrade them to warn so monitors can filter on status:error and
         // still catch real system-side failures (5xx/network/unknown) without
         // the user-side noise drowning out the signal.
-        const logFn = isUserActionable ? logger.warn : logger.error;
         // When every location failed for the same reason (the dominant case)
         // surface a single string; otherwise emit the array so consumers can
         // see the mix.
         const logErrorReason = uniqueReasons.length === 1 ? uniqueReasons[0] : uniqueReasons;
-        logFn.call(logger, '[DynamicWaasWalletClient] Google Drive backup failed', _extends({}, logContext, {
+        const logPayload = _extends({}, logContext, {
             errorCount: failures.length,
             errorReason: logErrorReason,
             isUserActionable,
             errors: failures.map((f)=>`Failed to backup keyshares to ${f.locationName}: ${f.message}`)
-        }));
+        });
+        if (isUserActionable) {
+            logger.warn('[DynamicWaasWalletClient] Google Drive backup failed', logPayload);
+        } else {
+            logger.error('[DynamicWaasWalletClient] Google Drive backup failed', logPayload);
+        }
         // Both upload destinations (appDataFolder + personal) commonly fail with
         // the same underlying error (e.g., missing OAuth scope). When all failures
         // share one message, surface it once without per-location wrapping;
@@ -2171,7 +2181,12 @@ const classifyWaasErrorKind = (error)=>{
 // only if the deadline passes; per-attempt we just tag the kind.
 const classifyTransientPollError = (error)=>{
     const status = readHttpStatus(error);
-    if (status === 429 || status !== undefined && status >= 500) return 'transient_exhausted';
+    // `NETWORK_ERROR_STATUS` (0) is "no response received" — as transient as a 5xx.
+    // It previously arrived here as 500 because handleAxiosError coerced every
+    // unmapped failure to that, so it must stay classified as transient.
+    if (status === 429 || status === core.NETWORK_ERROR_STATUS || status !== undefined && status >= 500) {
+        return 'transient_exhausted';
+    }
     return classifyWaasErrorKind(error);
 };
 // Builds a structured log payload tagged with the HTTPS transport, dropping
@@ -2187,18 +2202,35 @@ const buildHttpCeremonyMeta = (fields)=>_extends({
  * so they don't pollute error dashboards with user mistakes.
  */ const isExpectedUserError = (error)=>error instanceof InvalidPasswordError;
 /**
- * Returns true for transient API errors that are already logged at the
- * appropriate level by `handleAxiosError` but may be re-thrown as
- * `WalletApiError` and caught again (e.g. by queue error handlers).
- * Logging these at `warn` prevents double-counting them as real errors.
- */ const isTransientApiError = (error)=>error instanceof core.WalletApiError && error.status === 429;
+ * Reads the HTTP status off a `WalletApiError`.
+ *
+ * Matches on `name` as well as `instanceof` because core is inlined into more
+ * than one bundle, and a second copy of the class makes `instanceof` fail
+ * against the first — which would silently defeat every downgrade below. An
+ * error without a numeric status is treated as unrecognised (fail safe: stays
+ * at the caller's fallback level).
+ */ const getWalletApiErrorStatus = (error)=>{
+    const isWalletApiError = error instanceof core.WalletApiError || error instanceof Error && error.name === 'WalletApiError';
+    if (!isWalletApiError) return undefined;
+    const { status } = error;
+    return typeof status === 'number' ? status : undefined;
+};
 /**
- * Returns true for missing/expired end-user auth (401). This is a normal
- * session-lifecycle event (cookie/JWT expired, user must re-authenticate),
- * not an actionable server error — retrying cannot add credentials. Logged
- * at `warn` so it stays queryable without firing error-level monitors. It was
- * the dominant `Error in getWallet` catch-all contributor.
- */ const isExpiredAuthError = (error)=>error instanceof core.WalletApiError && error.status === 401;
+ * Returns true for client-class API errors (4xx, including 429 and 401)
+ * surfaced as `WalletApiError`. A bad request, missing/invalid auth, forbidden,
+ * or rate-limit is caused by the caller or is transient, so none of them are
+ * actionable as backend errors — the catch-site `logError` logs them at `warn`
+ * to keep them out of error-level dashboards. 401 in particular was the
+ * dominant `Error in getWallet` catch-all contributor.
+ *
+ * 5xx is deliberately NOT downgraded: those are genuine backend failures and
+ * the 500 monitors depend on them staying at `error`. The `handleAxiosError`
+ * HTTP-layer log also records them with fuller context, now that it no longer
+ * collides with Datadog's reserved `status` field.
+ */ const isDowngradableApiError = (error)=>{
+    const status = getWalletApiErrorStatus(error);
+    return status !== undefined && status < 500;
+};
 /**
  * Returns true for p-queue TimeoutError. These are transient and
  * retryable client-side, so logging at `warn` prevents them from
@@ -2218,15 +2250,93 @@ const CLIENT_NETWORK_ERROR_MESSAGES = new Set([
     const msg = error.message.toLowerCase();
     return CLIENT_NETWORK_ERROR_MESSAGES.has(msg) || msg.startsWith('webassembly compilation aborted: network error');
 };
-const resolveLogLevel = (error, fallback)=>{
-    if (isExpectedUserError(error)) {
-        return 'info';
-    }
-    if (isTransientApiError(error) || isExpiredAuthError(error) || isQueueTimeoutError(error) || isClientNetworkError(error)) {
-        return 'warn';
+const classifyOne = (error)=>{
+    if (isExpectedUserError(error)) return 'info';
+    if (isDowngradableApiError(error) || isQueueTimeoutError(error) || isClientNetworkError(error)) return 'warn';
+    return undefined;
+};
+/** Bounded so a self-referencing or cyclic `cause` chain cannot spin. */ const MAX_CAUSE_DEPTH = 5;
+/**
+ * Single source of truth for "how bad is this error". Exported so callers
+ * classify identically instead of hard-coding `logger.error` for every failure.
+ *
+ * Walks the `cause` chain, because the outermost error is frequently a wrapper
+ * that carries no information about severity — a chain client throws
+ * `new Error(ERROR_SIGN_MESSAGE, { cause })`, so classifying only the top link
+ * sees a bare `Error` and falls through to `error`. That is how a Cloudflare WAF
+ * 429 kept being reported as a hard SDK failure even after the direct call sites
+ * were fixed: the wrapper, not the cause, was being classified.
+ *
+ * The first classifiable link wins, so the most specific known failure in the
+ * chain decides.
+ */ const resolveLogLevel = (error, fallback)=>{
+    let current = error;
+    for(let depth = 0; current !== undefined && current !== null && depth < MAX_CAUSE_DEPTH; depth += 1){
+        const level = classifyOne(current);
+        if (level) return level;
+        const next = current instanceof Error ? current.cause : undefined;
+        if (next === current) break;
+        current = next;
     }
     return fallback;
 };
+const MAX_DESCRIBED_LENGTH = 200;
+/**
+ * Builds a human-readable message for a thrown value that is not an `Error` —
+ * most often an API response body, e.g.
+ * `{ existingWalletId, error: 'Multiple wallets per chain not allowed' }`.
+ *
+ * `String(value)` would collapse that to `[object Object]`, losing the only
+ * diagnostic content it had, so prefer a recognisable message field and fall
+ * back to bounded JSON.
+ */ const describeNonError = (value)=>{
+    if (typeof value === 'string') return value.slice(0, MAX_DESCRIBED_LENGTH);
+    if (value !== null && typeof value === 'object') {
+        const record = value;
+        const named = [
+            record['error'],
+            record['message'],
+            record['detail']
+        ].find((candidate)=>typeof candidate === 'string' && candidate.length > 0);
+        if (named) return named.slice(0, MAX_DESCRIBED_LENGTH);
+        try {
+            return JSON.stringify(value).slice(0, MAX_DESCRIBED_LENGTH);
+        } catch (e) {
+        // Circular or non-serialisable — fall through to String().
+        }
+    }
+    return String(value).slice(0, MAX_DESCRIBED_LENGTH);
+};
+/**
+ * Decides how an operation failure reaches the Datadog logger, whose signature
+ * is `(message, context, error)`.
+ *
+ * The rule that matters: a non-`Error` value must never be passed as `context`.
+ * Datadog spreads a context object into top-level log attributes, so a thrown
+ * API response body carrying `status: 500` lands on Datadog's reserved `status`
+ * field and silently rewrites the log's own severity to `info` — the failure
+ * then appears in neither the error nor the warn stream. Non-Errors are nested
+ * under `operationError` instead, and a real `Error` is synthesised so the log
+ * still gets a stack and an `error.kind`.
+ *
+ * Returned as a plain object so this is unit-testable without constructing a
+ * wallet client (which pulls the MPC WASM bundle).
+ */ const buildOperationFailureLog = (error)=>{
+    // Classify the original value: an Error's `cause` chain carries the severity,
+    // and normalising first would discard it.
+    const level = resolveLogLevel(error, 'error');
+    return error instanceof Error ? {
+        level,
+        context: undefined,
+        error
+    } : {
+        level,
+        context: {
+            operationError: error
+        },
+        error: new Error(describeNonError(error))
+    };
+};
 const logError = ({ message, error, context, level = 'error' })=>{
     if (error instanceof axios.AxiosError) {
         core.handleAxiosError(error, message, context);
@@ -2990,6 +3100,17 @@ class DynamicWalletClient {
         return this.walletMap[normalizeAddress(accountAddress)];
     }
     /**
+   * Sync variant of {@link requireWalletFromMap} (no refetch). Replaces the
+   * `getWalletFromMap(...)!` non-null assertions that surfaced a missing
+   * wallet as an opaque property-access TypeError at some later line.
+   */ getRequiredWalletFromMap(accountAddress) {
+        const walletData = this.getWalletFromMap(accountAddress);
+        if (!walletData) {
+            throw new Error(`Wallet not found for address: ${accountAddress}`);
+        }
+        return walletData;
+    }
+    /**
    * Get wallet properties from the map, refetching once if not found.
    * Uses getWallet (with NO_OPERATION) when signedSessionId is available for a
    * more robust fetch, otherwise falls back to getWallets().
@@ -4882,7 +5003,7 @@ class DynamicWalletClient {
             signedSessionId
         });
         const walletId = wallet.walletId;
-        const currentScheme = this.getWalletFromMap(accountAddress).thresholdSignatureScheme;
+        const currentScheme = this.getRequiredWalletFromMap(accountAddress).thresholdSignatureScheme;
         const bitcoinConfig = this.getBitcoinConfigForChain(chainName, accountAddress);
         // Same-parties reshare — only the caller's share participates.
         const [existingClientShare] = await this.ensureClientShare(accountAddress);
@@ -5797,7 +5918,7 @@ class DynamicWalletClient {
             useShareSetReshare,
             initialSignerRules
         });
-        const backupInfo = this.getWalletFromMap(accountAddress).clientKeySharesBackupInfo;
+        const backupInfo = this.getRequiredWalletFromMap(accountAddress).clientKeySharesBackupInfo;
         const delegatedKeyShares = backupInfo.backups[core.BackupLocation.DELEGATED] || [];
         return delegatedKeyShares;
     }
@@ -6260,7 +6381,7 @@ class DynamicWalletClient {
         if (shares.length > 1) {
             this.logger.warn('[DynamicWaasWalletClient] Multiple client key shares found in storage', {
                 accountAddress,
-                source,
+                shareSource: source,
                 count: shares.length
             });
         }
@@ -6311,7 +6432,7 @@ class DynamicWalletClient {
    */ logSharePersistence({ accountAddress, clientKeyShares, source }) {
         this.logger.info('[DynamicWaasWalletClient] Persisting client key shares', {
             accountAddress,
-            source,
+            shareSource: source,
             inputCount: clientKeyShares.length
         });
     }
@@ -6818,8 +6939,8 @@ class DynamicWalletClient {
         } catch (error) {
             var _error_cause_context;
             const errorReason = classifyPasswordBackupError(error);
-            const logFn = isUserActionablePasswordBackupErrorReason(errorReason) ? this.logger.warn : this.logger.error;
-            logFn.call(this.logger, '[backupSharesWithDistribution] failed', _extends({}, logContext, {
+            const isUserActionable = isUserActionablePasswordBackupErrorReason(errorReason);
+            const logPayload = _extends({}, logContext, {
                 chainName: walletData == null ? void 0 : walletData.chainName,
                 errorReason,
                 errorName: error instanceof Error ? error.name : undefined,
@@ -6829,7 +6950,12 @@ class DynamicWalletClient {
                 // failures show the underlying KeyShareDecryptionError / kdfVersion.
                 errorCauseName: error instanceof Error && error.cause instanceof Error ? error.cause.name : undefined,
                 kdfVersion: error instanceof Error && error.cause instanceof KeyShareDecryptionError ? (_error_cause_context = error.cause.context) == null ? void 0 : _error_cause_context.kdfVersion : undefined
-            }));
+            });
+            if (isUserActionable) {
+                this.logger.warn('[backupSharesWithDistribution] failed', logPayload);
+            } else {
+                this.logger.error('[backupSharesWithDistribution] failed', logPayload);
+            }
             logError({
                 message: 'Error in backupSharesWithDistribution',
                 error: error,
@@ -7080,9 +7206,9 @@ class DynamicWalletClient {
     // they don't count against the dashboard's System-side Success Rate metric.
     logPasswordOperationFailure(passwordOperation, error, context) {
         const errorReason = classifyPasswordBackupError(error);
-        const logFn = isUserActionablePasswordBackupErrorReason(errorReason) ? this.logger.warn : this.logger.error;
+        const isUserActionable = isUserActionablePasswordBackupErrorReason(errorReason);
         const errorContext = error instanceof KeyShareDecryptionError ? error.context : undefined;
-        logFn.call(this.logger, `[${passwordOperation}] failed`, _extends({}, context, {
+        const logPayload = _extends({}, context, {
             passwordOperation,
             errorReason,
             environmentId: this.environmentId,
@@ -7092,7 +7218,12 @@ class DynamicWalletClient {
             errorStack: error instanceof Error ? error.stack : undefined
         }, errorContext ? {
             errorContext
-        } : {}));
+        } : {});
+        if (isUserActionable) {
+            this.logger.warn(`[${passwordOperation}] failed`, logPayload);
+        } else {
+            this.logger.error(`[${passwordOperation}] failed`, logPayload);
+        }
     }
     async updatePassword({ accountAddress, existingPassword, newPassword, signedSessionId, sessionPublicKey, passwordUpdateBatchId }) {
         const dynamicRequestId = uuid.v4();
@@ -7407,7 +7538,14 @@ class DynamicWalletClient {
    */ recoverStrategy({ clientKeyShareBackupInfo, thresholdSignatureScheme, walletOperation, shareCount = undefined }) {
         var _clientKeyShareBackupInfo_backups_BackupLocation_DYNAMIC;
         const { backups } = clientKeyShareBackupInfo;
-        const { clientThreshold } = core.MPC_CONFIG[thresholdSignatureScheme];
+        // Wallet metadata can carry a missing/unknown scheme (e.g. legacy or
+        // partially-created wallets); indexing MPC_CONFIG with it used to throw a
+        // bare destructuring TypeError that hid the actual problem.
+        const mpcConfig = core.MPC_CONFIG[thresholdSignatureScheme];
+        if (!mpcConfig) {
+            throw new Error(`Unsupported or missing thresholdSignatureScheme: ${String(thresholdSignatureScheme)}`);
+        }
+        const { clientThreshold } = mpcConfig;
         let requiredShareCount = walletOperation === core.WalletOperation.REFRESH || walletOperation === core.WalletOperation.REACH_ALL_PARTIES || walletOperation === core.WalletOperation.RESHARE ? clientThreshold : 1;
         // Override requiredShareCount if shareCount is provided
         if (shareCount !== undefined) {
@@ -7476,7 +7614,7 @@ class DynamicWalletClient {
     }
     async internalRecoverEncryptedBackupByWallet({ accountAddress, password, walletOperation, signedSessionId, shareCount = undefined, storeRecoveredShares = true, mfaToken }) {
         try {
-            const wallet = this.getWalletFromMap(accountAddress);
+            const wallet = this.getRequiredWalletFromMap(accountAddress);
             this.logger.debug(`recoverEncryptedBackupByWallet wallet: ${walletOperation}`, wallet);
             const { shares } = this.recoverStrategy({
                 clientKeyShareBackupInfo: wallet.clientKeySharesBackupInfo,
@@ -7585,7 +7723,7 @@ class DynamicWalletClient {
                 password,
                 signedSessionId
             });
-            const walletData = this.getWalletFromMap(accountAddress);
+            const walletData = this.getRequiredWalletFromMap(accountAddress);
             const currentThresholdSignatureScheme = walletData.thresholdSignatureScheme;
             if (currentThresholdSignatureScheme === core.ThresholdSignatureScheme.TWO_OF_TWO) {
                 // Reshare to 2-of-3, which will automatically handle the backup distribution
@@ -7644,7 +7782,7 @@ class DynamicWalletClient {
    * every provider already holding a backup plus the requested one,
    * restricted to providers the reshare can deliver to.
    */ async reshareNonDelegatedTwoOfThree({ accountAddress, backupLocation, password, signedSessionId, sessionPublicKey, googleDriveAccessToken, googleDriveTokenSource }) {
-        const walletData = this.getWalletFromMap(accountAddress);
+        const walletData = this.getRequiredWalletFromMap(accountAddress);
         const cloudProviders = new Set([
             ...getActiveCloudProviders(walletData.clientKeySharesBackupInfo).filter((provider)=>provider === core.BackupLocation.GOOGLE_DRIVE || provider === core.BackupLocation.ICLOUD),
             backupLocation
@@ -7783,14 +7921,18 @@ class DynamicWalletClient {
             // misuse of an externally-supplied token (e.g. repeated failures) is
             // traceable, not just completed backups. Enum only; the original error
             // still propagates after this. Failures log at warn to surface them.
-            const logFn = success ? this.logger.info : this.logger.warn;
-            logFn.call(this.logger, '[DynamicWaasWalletClient] Google Drive backup token source', {
+            const logPayload = {
                 accountAddress,
                 environmentId: this.environmentId,
                 userId: this.userId,
                 tokenSource,
                 success
-            });
+            };
+            if (success) {
+                this.logger.info('[DynamicWaasWalletClient] Google Drive backup token source', logPayload);
+            } else {
+                this.logger.warn('[DynamicWaasWalletClient] Google Drive backup token source', logPayload);
+            }
         }
     }
     /**
@@ -7809,8 +7951,7 @@ class DynamicWalletClient {
         ]);
         const { blocking } = preflightResult;
         if (blocking) {
-            const logFn = blocking.isUserActionable ? this.logger.warn : this.logger.error;
-            logFn.call(this.logger, '[DynamicWaasWalletClient] Google Drive backup failed (preflight)', {
+            const logPayload = {
                 accountAddress,
                 environmentId: this.environmentId,
                 userId: this.userId,
@@ -7821,8 +7962,13 @@ class DynamicWalletClient {
                     `Preflight (${blocking.source}): ${blocking.message}`
                 ],
                 preflight: true,
-                source: blocking.source
-            });
+                preflightSource: blocking.source
+            };
+            if (blocking.isUserActionable) {
+                this.logger.warn('[DynamicWaasWalletClient] Google Drive backup failed (preflight)', logPayload);
+            } else {
+                this.logger.error('[DynamicWaasWalletClient] Google Drive backup failed (preflight)', logPayload);
+            }
             throw createGoogleDriveError({
                 message: blocking.message,
                 isRetryable: false,
@@ -7938,7 +8084,7 @@ class DynamicWalletClient {
             if (encryptedKeyShares.length === 0) {
                 throw new Error('No key shares found');
             }
-            const thresholdSignatureScheme = this.getWalletFromMap(accountAddress).thresholdSignatureScheme;
+            const thresholdSignatureScheme = this.getRequiredWalletFromMap(accountAddress).thresholdSignatureScheme;
             const backupData = createBackupData({
                 encryptedKeyShares,
                 accountAddress,
@@ -7965,7 +8111,7 @@ class DynamicWalletClient {
                 signedSessionId
             });
             const accessToken = googleDriveAccessToken != null ? googleDriveAccessToken : await this.fetchGoogleDriveAccessToken(accountAddress);
-            const thresholdSignatureScheme = this.getWalletFromMap(accountAddress).thresholdSignatureScheme;
+            const thresholdSignatureScheme = this.getRequiredWalletFromMap(accountAddress).thresholdSignatureScheme;
             const backupFileName = getClientKeyShareExportFileName({
                 thresholdSignatureScheme,
                 accountAddress,
@@ -8185,7 +8331,7 @@ class DynamicWalletClient {
         });
         const { requiredShareCount } = this.recoverStrategy({
             clientKeyShareBackupInfo: clientKeySharesBackupInfo,
-            thresholdSignatureScheme: this.getWalletFromMap(accountAddress).thresholdSignatureScheme,
+            thresholdSignatureScheme: this.getRequiredWalletFromMap(accountAddress).thresholdSignatureScheme,
             walletOperation
         });
         if (clientKeyShares.length >= requiredShareCount) {
@@ -8290,7 +8436,7 @@ class DynamicWalletClient {
                 accountAddress,
                 walletOperation
             })) {
-                const walletData = this.getWalletFromMap(accountAddress);
+                const walletData = this.getRequiredWalletFromMap(accountAddress);
                 const isPasswordEncrypted = isWalletPasswordEncrypted(walletData);
                 // Locked wallet (password-encrypted, no password supplied): its shares need the
                 // user's password, not the environmentId. Return it ENCRYPTED for any operation
@@ -8595,7 +8741,7 @@ class DynamicWalletClient {
                 additionalWalletsUnlocked,
                 additionalWalletsFailed
             });
-            return this.getWalletFromMap(accountAddress);
+            return this.getRequiredWalletFromMap(accountAddress);
         } catch (error) {
             this.logPasswordOperationFailure('unlockWallet', error, {
                 accountAddress
@@ -9042,6 +9188,16 @@ class DynamicWalletClient {
             time: (traceContext == null ? void 0 : traceContext.startTime) ? now - traceContext.startTime : 0
         }, traceContext);
     }
+    /**
+   * Log a chain-client operation failure at a severity that matches the
+   * underlying cause. Logs through `this.logger` (not `logError`) so the
+   * structured `error.causes` chain survives — that chain is what makes these
+   * failures diagnosable — while still honouring the shared level policy, so a
+   * transient 429/401/network blip does not read as a hard SDK error.
+   */ logOperationFailure(message, error) {
+        const { level, context, error: normalizedError } = buildOperationFailureLog(error);
+        this.logger[level](message, context, normalizedError);
+    }
     constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, featureFlags, argon2idRebackupTargets, authMode = core.AuthMode.HEADER, authToken = undefined, backupServiceAuthToken, // Represents the version of the client SDK used by developer
     sdkVersion, forwardMPCClient, baseClientKeysharesRelayApiUrl, iCloudConfig, logger }, internalOptions){
         this.userId = undefined;
@@ -9281,6 +9437,7 @@ exports.isStaleClientSharesError = isStaleClientSharesError;
 exports.listICloudBackups = listICloudBackups;
 exports.markCeremonyErrorNonRetryable = markCeremonyErrorNonRetryable;
 exports.readEnvironmentSettings = readEnvironmentSettings;
+exports.resolveLogLevel = resolveLogLevel;
 exports.retryPromise = retryPromise;
 exports.shouldReshareToSameBackups = shouldReshareToSameBackups;
 exports.timeoutPromise = timeoutPromise;