@arcblock/did-connect-js 1.29.22 → 4.0.0-beta.1

package/esm/authenticator/wallet.mjs

@@ -1,556 +0,0 @@
-import { __require } from "../_virtual/rolldown_runtime.mjs";
-import { require_package } from "../package.mjs";
-import base_default, { DEFAULT_CHAIN_INFO } from "./base.mjs";
-import { appInfo, chainInfo, claims } from "../schema/index.mjs";
-import qs from "node:querystring";
-import { toAddress } from "@arcblock/did";
-import Client from "@ocap/client";
-import RSA from "@ocap/mcrypto/lib/crypter/rsa";
-import { fromBase58, toBase58, toDid } from "@ocap/util";
-import { fromAddress } from "@ocap/wallet";
-import isEqual from "lodash/isEqual.js";
-import pick from "lodash/pick.js";
-import random from "lodash/random.js";
-import shuffle from "lodash/shuffle.js";
-
-//#region src/authenticator/wallet.ts
-const debug = __require("debug")(`${require_package().name}:authenticator:wallet`);
-const DEFAULT_TIMEOUT = 8e3;
-const MFA_CODE_COUNT = 3;
-var WalletAuthenticator = class WalletAuthenticator extends base_default {
-	static formatDisplay(display) {
-		if (!display) return "";
-		if (display?.type && display.content) return JSON.stringify(pick(display, ["type", "content"]));
-		try {
-			const parsed = JSON.parse(display);
-			if (parsed?.type && parsed.content) return display;
-			return "";
-		} catch (_err) {
-			return "";
-		}
-	}
-	/**
-	* Creates an instance of DID Authenticator.
-	*
-	* @class
-	* @param {object} config
-	* @param {WalletObject|Function} config.wallet - wallet instance {@see @ocap/wallet} or a function that returns wallet instance
-	* @param {WalletObject|Function} [config.delegator] - the party that authorizes `wallet` to perform actions on behalf of `wallet`
-	* @param {string|Function} [config.delegation] - the jwt token that proves delegation relationship
-	* @param {ApplicationInfo|Function} config.appInfo - application basic info or a function that returns application info
-	* @param {ChainInfo|Function} config.chainInfo - application chain info or a function that returns chain info
-	* @param {Number} [config.timeout=8000] - timeout in milliseconds when generating claim
-	* @param {object} [config.baseUrl] - url to assemble wallet request uri, can be inferred from request object
-	* @param {string} [config.tokenKey='_t_'] - query param key for `token`
-	*/
-	constructor({ wallet, appInfo: appInfo$1, memberAppInfo, delegator, delegation, timeout = DEFAULT_TIMEOUT, chainInfo: chainInfo$1 = DEFAULT_CHAIN_INFO, baseUrl = "", tokenKey = "_t_" }) {
-		super();
-		this.wallet = this._validateWallet(wallet, false);
-		this.appInfo = this._validateAppInfo(appInfo$1);
-		this.memberAppInfo = this._validateAppInfo(memberAppInfo, true);
-		this.chainInfo = chainInfo$1;
-		this.delegator = delegator;
-		this.delegation = delegation;
-		this.baseUrl = baseUrl;
-		this.tokenKey = tokenKey;
-		this.timeout = timeout;
-		if (!this.appInfo.link) this.appInfo.link = this.baseUrl;
-	}
-	/**
-	* Generate a deep link url that can be displayed as QRCode for DID Wallet to consume
-	*
-	* @method
-	* @param {object} params
-	* @param {string} params.baseUrl - baseUrl inferred from request object
-	* @param {string} params.pathname - wallet callback pathname
-	* @param {string} params.token - action token
-	* @param {object} params.query - params that should be persisted in wallet callback url
-	* @returns {string}
-	*/
-	uri({ baseUrl, pathname = "", token = "", query = {} } = {}) {
-		const params = {
-			...query,
-			[this.tokenKey]: token
-		};
-		const payload = {
-			action: "requestAuth",
-			url: encodeURIComponent(`${this.baseUrl || baseUrl}${pathname}?${qs.stringify(params)}`)
-		};
-		const uri = `https://abtwallet.io/i/?${qs.stringify(payload)}`;
-		debug("uri", {
-			token,
-			pathname,
-			uri,
-			params,
-			payload
-		});
-		return uri;
-	}
-	/**
-	* Compute public url to return to wallet
-	*
-	* @method
-	* @param {string} pathname
-	* @param {object} params
-	* @returns {string}
-	*/
-	getPublicUrl(pathname, params = {}, baseUrl = "") {
-		return `${this.baseUrl || baseUrl}${pathname}?${qs.stringify(params)}`;
-	}
-	/**
-	* Sign a plain response, usually on auth success or error
-	*
-	* @method
-	* @param {object} params
-	* @param {object} params.response - response
-	* @param {string} params.errorMessage - error message, default to empty
-	* @param {string} params.successMessage - success message, default to empty
-	* @param {string} params.nextWorkflow - https://github.com/ArcBlock/ABT-DID-Protocol#concatenate-multiple-workflow
-	* @param {string} params.nextUrl - tell wallet do open this url in webview
-	* @param {object} params.cookies - key-value pairs to be set as cookie before open nextUrl
-	* @param {object} params.storages - key-value pairs to be set as localStorage before open nextUrl
-	* @param {string} baseUrl
-	* @param {object} request
-	* @returns {Promise<object>} { appPk, agentPk, authInfo }
-	*/
-	async signResponse({ response = {}, errorMessage = "", successMessage = "", nextWorkflow = "", nextUrl = "", cookies = {}, storages = {} }, baseUrl, request, extraParams = {}) {
-		const infoParams = {
-			baseUrl,
-			request,
-			...request.context || {},
-			extraParams
-		};
-		const [wallet, delegator, delegation] = await Promise.all([
-			this.getWalletInfo(infoParams),
-			this.getDelegator(infoParams),
-			this.getDelegation(infoParams)
-		]);
-		const [appInfo$1, memberAppInfo] = await Promise.all([this.getAppInfo({
-			...infoParams,
-			wallet,
-			delegator
-		}, "appInfo"), this.getAppInfo({
-			...infoParams,
-			wallet,
-			delegator
-		}, "memberAppInfo")]);
-		const didwallet = request.context.wallet;
-		const payload = {
-			appInfo: appInfo$1,
-			memberAppInfo,
-			status: errorMessage ? "error" : "ok",
-			errorMessage: errorMessage || "",
-			successMessage: successMessage || "",
-			nextWorkflow: nextWorkflow || "",
-			nextUrl: nextUrl || "",
-			cookies: cookies || {},
-			storages: storages || "",
-			response
-		};
-		if (delegator) {
-			payload.iss = toDid(delegator.address);
-			payload.agentDid = toDid(wallet.address);
-			payload.verifiableClaims = [{
-				type: "certificate",
-				content: delegation
-			}];
-		}
-		const result = {
-			appPk: toBase58(wallet.pk),
-			authInfo: await wallet.signJWT(payload, true, didwallet ? didwallet.jwt : void 0)
-		};
-		if (delegator) {
-			result.appPk = toBase58(delegator.pk);
-			result.agentPk = toBase58(wallet.pk);
-		}
-		return result;
-	}
-	/**
-	* Sign a auth response that returned to wallet: tell the wallet the appInfo/chainInfo
-	*
-	* @method
-	* @param {object} params
-	* @param {object} params.claims - info required by application to complete the auth
-	* @param {string} params.pathname - pathname to assemble callback url
-	* @param {string} params.baseUrl - baseUrl
-	* @param {object} params.challenge - random challenge to be included in the body
-	* @param {object} params.extraParams - extra query params and locale
-	* @param {object} params.request
-	* @param {object} params.context
-	* @param {string} params.context.token - action token
-	* @param {number} params.context.currentStep - current step
-	* @param {string} [params.context.sharedKey] - shared key between app and wallet
-	* @param {string} [params.context.encryptionKey] - encryption key from wallet
-	* @param {Function} [params.context.mfaCode] - function used to generate mfa code
-	* @param {string} params.context.userDid - decoded from req.query, base58
-	* @param {string} params.context.userPk - decoded from req.query, base58
-	* @param {string} params.context.didwallet - DID Wallet os and version
-	* @returns {Promise<object>} { appPk, agentPk, sharedKey, authInfo }
-	*/
-	async sign({ context, request, claims: claims$1, pathname = "", baseUrl = "", challenge = "", extraParams = {} }) {
-		const claimsInfo = await this.tryWithTimeout(() => this.genRequestedClaims({
-			claims: claims$1,
-			context: {
-				baseUrl,
-				request,
-				...context
-			},
-			extraParams
-		}));
-		if (claimsInfo.filter((x) => x.mfaCode && x.mfaCode.length > 0).length > 1) throw new Error("Multiple MFA is not supported when sending more than 1 claim");
-		const tmp = claimsInfo.find((x) => isEqual(this._isValidChainInfo(x.chainInfo), DEFAULT_CHAIN_INFO) === false);
-		const infoParams = {
-			baseUrl,
-			request,
-			...context,
-			extraParams
-		};
-		const [wallet, delegator, delegation, chainInfo$1] = await Promise.all([
-			this.getWalletInfo(infoParams),
-			this.getDelegator(infoParams),
-			this.getDelegation(infoParams),
-			this.getChainInfo(infoParams, tmp?.chainInfo)
-		]);
-		const [appInfo$1, memberAppInfo] = await Promise.all([this.getAppInfo({
-			...infoParams,
-			wallet,
-			delegator
-		}, "appInfo"), this.getAppInfo({
-			...infoParams,
-			wallet,
-			delegator
-		}, "memberAppInfo")]);
-		const payload = {
-			action: "responseAuth",
-			challenge,
-			appInfo: appInfo$1,
-			memberAppInfo,
-			chainInfo: chainInfo$1,
-			requestedClaims: claimsInfo.map((x) => {
-				delete x.chainInfo;
-				return x;
-			}),
-			url: `${this.baseUrl || baseUrl}${pathname}?${qs.stringify({ [this.tokenKey]: context.token })}`
-		};
-		if (delegator) {
-			payload.iss = toDid(delegator.address);
-			payload.agentDid = toDid(wallet.address);
-			payload.verifiableClaims = [{
-				type: "certificate",
-				content: delegation
-			}];
-		}
-		const version = context.didwallet ? context.didwallet.jwt : void 0;
-		const result = {
-			appPk: toBase58(wallet.pk),
-			authInfo: await wallet.signJWT(payload, true, version),
-			sensitive: claimsInfo.every((x) => ["keyPair", "encryptionKey"].includes(x.type))
-		};
-		if (result.sensitive && context.sharedKey && context.encryptionKey) try {
-			const pk = fromBase58(context.encryptionKey).toString("utf8");
-			result.sharedKey = RSA.encrypt(context.sharedKey, pk, "base58");
-		} catch (err) {
-			console.error("Failed to encrypt shared key", err);
-		}
-		if (delegator) {
-			result.appPk = toBase58(delegator.pk);
-			result.agentPk = toBase58(wallet.pk);
-		}
-		return result;
-	}
-	/**
-	* Determine chainInfo on the fly
-	*
-	* @param {object} params - contains the context of this request
-	* @param {object|undefined} [info=undefined] - chain info object or function
-	* @returns {Promise<ChainInfo>}
-	* @memberof WalletAuthenticator
-	*/
-	async getChainInfo(params, info) {
-		if (info && this._isValidChainInfo(info)) return info;
-		if (typeof this.chainInfo === "function") {
-			const result = await this.tryWithTimeout(() => this.chainInfo(params));
-			if (this._isValidChainInfo(result)) return result;
-		}
-		if (this.chainInfo && this._isValidChainInfo(this.chainInfo)) return this.chainInfo;
-		return DEFAULT_CHAIN_INFO;
-	}
-	/**
-	* Determine appInfo/memberAppInfo on the fly
-	*
-	* @param {object} params - contains the context of this request
-	* @param {string} key - appInfo | memberAppInfo
-	* @returns {Promise<ApplicationInfo>}
-	* @memberof WalletAuthenticator
-	*/
-	async getAppInfo(params, key = "appInfo") {
-		if (typeof this[key] === "function") {
-			const info = await this.tryWithTimeout(() => this[key](params));
-			if (info) {
-				if (!info.link) info.link = params.baseUrl;
-				if (!info.publisher) info.publisher = toDid(params.delegator ? params.delegator.address : params.wallet.address);
-			}
-			return this._validateAppInfo(info, key === "memberAppInfo");
-		}
-		if (this[key] && !this[key].publisher) this[key].publisher = toDid(params.delegator ? params.delegator.address : params.wallet.address);
-		return this[key];
-	}
-	async getWalletInfo(params) {
-		if (typeof this.wallet === "function") {
-			const result = await this.tryWithTimeout(() => this.wallet(params));
-			return this._validateWallet(result, false);
-		}
-		return this.wallet;
-	}
-	async getDelegator(params) {
-		if (typeof this.delegator === "function") {
-			const result = await this.tryWithTimeout(() => this.delegator(params));
-			return result ? this._validateWallet(result, false) : null;
-		}
-		return this.delegator;
-	}
-	async getDelegation(params) {
-		if (typeof this.delegation === "function") return await this.tryWithTimeout(() => this.delegation(params));
-		return this.delegation;
-	}
-	/**
-	* Verify a DID auth response sent from DID Wallet
-	*
-	* @method
-	* @param {object} data
-	* @param {string} [locale=en]
-	* @param {boolean} [enforceTimestamp=true]
-	* @returns Promise<boolean>
-	*/
-	async verify(data, locale = "en", enforceTimestamp = true) {
-		const { iss, iat, challenge = "", action = "responseAuth", requestedClaims } = await this._verify(data, "userPk", "userInfo", locale, enforceTimestamp);
-		debug("verify.context", {
-			userPk: data.userPk,
-			userDid: toAddress(iss),
-			action,
-			challenge
-		});
-		debug("verify.claims", requestedClaims);
-		return {
-			token: data.token,
-			userDid: toAddress(iss),
-			userPk: data.userPk,
-			claims: requestedClaims,
-			action,
-			challenge,
-			timestamp: iat
-		};
-	}
-	genRequestedClaims({ claims: claims$1, context, extraParams }) {
-		return Promise.all(Object.keys(claims$1).map(async (x) => {
-			let name = x;
-			let claim = claims$1[x];
-			if (Array.isArray(claims$1[x])) [name, claim] = claims$1[x];
-			if (!claims[name]) throw new Error(`Unsupported claim type ${name}`);
-			const fn = typeof this[name] === "function" ? name : "getClaimInfo";
-			const result = await this[fn]({
-				claim,
-				context,
-				extraParams
-			});
-			if (result.mfa && typeof context.mfaCode === "function") {
-				result.mfaCode = [await context.mfaCode()];
-				while (result.mfaCode.length < MFA_CODE_COUNT) {
-					const noise = random(10, 99);
-					if (result.mfaCode.includes(noise) === false) result.mfaCode.push(noise);
-				}
-				result.mfaCode = shuffle(result.mfaCode);
-			}
-			const { value, error } = claims[name].validate(result);
-			if (error) throw new Error(`Invalid ${name} claim: ${error.message}`);
-			return value;
-		}));
-	}
-	async getClaimInfo({ claim, context, extraParams }) {
-		const { userDid, userPk, didwallet } = context;
-		const result = typeof claim === "function" ? await claim({
-			userDid: userDid ? toAddress(userDid) : "",
-			userPk: userPk || "",
-			didwallet,
-			extraParams,
-			context
-		}) : claim;
-		const infoParams = {
-			...context,
-			...extraParams
-		};
-		result.chainInfo = await this.getChainInfo(infoParams, result.chainInfo);
-		return result;
-	}
-	async signature({ claim, context, extraParams }) {
-		const { data, type = "mime:text/plain", digest = "", method = "sha3", wallet, sender, display, description: desc, chainInfo: chainInfo$1, meta = {}, mfa = false, nonce = "", requirement = {
-			tokens: [],
-			assets: {}
-		} } = await this.getClaimInfo({
-			claim,
-			context,
-			extraParams
-		});
-		debug("claim.signature", {
-			data,
-			digest,
-			type,
-			sender,
-			context,
-			nonce,
-			requirement
-		});
-		if (!data && !digest) throw new Error("Signature claim requires either data or digest to be provided");
-		const description = desc || "Sign this transaction to continue.";
-		if (type.endsWith("Tx")) {
-			if (!chainInfo$1.host) throw new Error("Invalid chainInfo when trying to encoding transaction");
-			const client = new Client(chainInfo$1.host);
-			if (typeof client[`encode${type}`] !== "function") throw new Error(`Unsupported transaction type ${type}`);
-			if (!data.pk) data.pk = context.userPk;
-			try {
-				const { buffer: txBuffer } = await client[`encode${type}`]({
-					tx: data,
-					wallet: wallet || fromAddress(sender || context.userDid)
-				});
-				return {
-					type: "signature",
-					description,
-					typeUrl: "fg:t:transaction",
-					origin: toBase58(txBuffer),
-					method,
-					display: WalletAuthenticator.formatDisplay(display),
-					digest: "",
-					chainInfo: chainInfo$1,
-					meta,
-					mfa,
-					nonce,
-					requirement
-				};
-			} catch (err) {
-				throw new Error(`Failed to encode transaction: ${err.message}`);
-			}
-		}
-		if (type === "fg:t:transaction") return {
-			type: "signature",
-			description,
-			typeUrl: "fg:t:transaction",
-			origin: toBase58(data),
-			display: WalletAuthenticator.formatDisplay(display),
-			method,
-			digest: "",
-			chainInfo: chainInfo$1,
-			meta,
-			mfa,
-			nonce,
-			requirement
-		};
-		return {
-			type: "signature",
-			description: desc || "Sign this message to continue.",
-			origin: data ? toBase58(data) : "",
-			typeUrl: type,
-			display: WalletAuthenticator.formatDisplay(display),
-			method,
-			digest,
-			chainInfo: chainInfo$1,
-			meta,
-			mfa,
-			nonce,
-			requirement
-		};
-	}
-	async prepareTx({ claim, context, extraParams }) {
-		const { partialTx, requirement = {
-			tokens: [],
-			assets: {}
-		}, type, display, wallet, sender, description: desc, chainInfo: chainInfo$1, meta = {}, mfa = false, nonce = "" } = await this.getClaimInfo({
-			claim,
-			context,
-			extraParams
-		});
-		debug("claim.prepareTx", {
-			partialTx,
-			requirement,
-			type,
-			sender,
-			context
-		});
-		if (!partialTx || !requirement) throw new Error("prepareTx claim requires both partialTx and requirement to be provided");
-		const description = desc || "Prepare and sign this transaction to continue.";
-		if (type?.endsWith("Tx")) {
-			if (!chainInfo$1.host) throw new Error("Invalid chainInfo when trying to encoding partial transaction");
-			const client = new Client(chainInfo$1.host);
-			if (typeof client[`encode${type}`] !== "function") throw new Error(`Unsupported transaction type ${type} when encoding partial transaction`);
-			if (!partialTx.pk) partialTx.pk = context.userPk;
-			try {
-				const { buffer: txBuffer } = await client[`encode${type}`]({
-					tx: partialTx,
-					wallet: wallet || fromAddress(sender || context.userDid)
-				});
-				return {
-					type: "prepareTx",
-					description,
-					partialTx: toBase58(txBuffer),
-					display: WalletAuthenticator.formatDisplay(display),
-					requirement,
-					chainInfo: chainInfo$1,
-					meta,
-					mfa,
-					nonce
-				};
-			} catch (err) {
-				throw new Error(`Failed to encode partial transaction: ${err.message}`);
-			}
-		}
-		return {
-			type: "prepareTx",
-			description,
-			partialTx: toBase58(partialTx),
-			requirement,
-			display: WalletAuthenticator.formatDisplay(display),
-			chainInfo: chainInfo$1,
-			meta,
-			mfa,
-			nonce
-		};
-	}
-	_validateAppInfo(info, allowEmpty = false) {
-		if (typeof info === "function") return info;
-		if (!info) {
-			if (allowEmpty === false) throw new Error("Wallet authenticator can not work with invalid appInfo: empty");
-			return null;
-		}
-		const { value, error } = appInfo.validate(info);
-		if (error) throw new Error(`Wallet authenticator can not work with invalid appInfo: ${error.message}`);
-		return value;
-	}
-	_isValidChainInfo(x) {
-		const { error } = chainInfo.validate(x);
-		return !error;
-	}
-	tryWithTimeout(asyncFn, label = "") {
-		if (typeof asyncFn !== "function") throw new Error("asyncFn must be a valid function when calling tryWithTimeout");
-		const timeout = Number(this.timeout) || DEFAULT_TIMEOUT;
-		const inferredLabel = label || asyncFn.name || asyncFn.toString();
-		const invocationStack = (/* @__PURE__ */ new Error(`Timeout at: ${inferredLabel}`)).stack;
-		return new Promise(async (resolve, reject) => {
-			const timer = setTimeout(() => {
-				const error = /* @__PURE__ */ new Error(`Async operation (${inferredLabel}) did not complete within ${timeout} ms`);
-				error.stack = invocationStack;
-				error.name = "TIMEOUT";
-				reject(error);
-			}, timeout);
-			try {
-				resolve(await asyncFn());
-			} catch (err) {
-				reject(err);
-			} finally {
-				clearTimeout(timer);
-			}
-		});
-	}
-};
-var wallet_default = WalletAuthenticator;
-
-//#endregion
-export { wallet_default as default };

package/esm/handlers/base.d.mts

@@ -1,32 +0,0 @@
-import { EventEmitter } from "node:events";
-
-//#region src/handlers/base.d.ts
-declare class BaseHandler extends EventEmitter {
-  authenticator: any;
-  tokenStorage: any;
-  pathTransformer: (v: string) => string;
-  onConnect: (...args: any[]) => any;
-  /**
-   * Creates an instance of DID Auth Handlers.
-   *
-   * @class
-   * @param {object} config
-   * @param {function} config.pathTransformer - function to transform path when generate action;
-   * @param {object} config.tokenStorage - function to generate action token
-   * @param {object} config.authenticator - Authenticator instance that can to jwt sign/verify
-   * @param {function} [config.onConnect=noop] - function called when wallet selected did
-   */
-  constructor({
-    pathTransformer,
-    tokenStorage,
-    authenticator,
-    onConnect
-  }: {
-    pathTransformer?: (v: string) => string;
-    tokenStorage: any;
-    authenticator: any;
-    onConnect?: (...args: any[]) => any;
-  });
-}
-//#endregion
-export { BaseHandler as default };

package/esm/handlers/base.mjs

@@ -1,37 +0,0 @@
-import { PROTECTED_KEYS } from "../protocol.mjs";
-import { EventEmitter } from "node:events";
-import omit from "lodash/omit.js";
-
-//#region src/handlers/base.ts
-var BaseHandler = class extends EventEmitter {
-	/**
-	* Creates an instance of DID Auth Handlers.
-	*
-	* @class
-	* @param {object} config
-	* @param {function} config.pathTransformer - function to transform path when generate action;
-	* @param {object} config.tokenStorage - function to generate action token
-	* @param {object} config.authenticator - Authenticator instance that can to jwt sign/verify
-	* @param {function} [config.onConnect=noop] - function called when wallet selected did
-	*/
-	constructor({ pathTransformer, tokenStorage, authenticator, onConnect }) {
-		super();
-		this.authenticator = authenticator;
-		this.tokenStorage = tokenStorage;
-		this.tokenStorage.on("create", (data) => this.emit("created", data));
-		this.tokenStorage.on("destroy", (token) => this.emit("deleted", { token }));
-		this.tokenStorage.on("update", async (data) => {
-			if (!data) return;
-			const payload = await this.tokenStorage.read(data.token);
-			this.emit("updated", omit(payload, PROTECTED_KEYS));
-		});
-		if (typeof pathTransformer === "function") this.pathTransformer = pathTransformer;
-		else this.pathTransformer = (v) => v;
-		if (typeof onConnect === "function") this.onConnect = onConnect;
-		else this.onConnect = () => {};
-	}
-};
-var base_default = BaseHandler;
-
-//#endregion
-export { base_default as default };

package/esm/handlers/util.d.mts

@@ -1,70 +0,0 @@
-import { ConnectRequest, ConnectResponse, NextFunction } from "../types.mjs";
-
-//#region src/handlers/util.d.ts
-declare const errors: Record<string, Record<string, string>>;
-declare const preparePathname: (path: string, req: ConnectRequest) => string;
-declare const prepareBaseUrl: (req: ConnectRequest, params?: Record<string, any>) => string;
-declare const getStepChallenge: () => any;
-declare const parseWalletUA: (userAgent: string) => {
-  os: string;
-  version: string;
-  jwt: string;
-};
-declare const isDeepLink: (str: string) => boolean;
-declare const isConnectedOnly: (params: any, sessionUserDid?: string) => boolean | string;
-interface CreateHandlersOptions {
-  action: string;
-  pathname: string;
-  claims: any;
-  onStart: (...args: any[]) => any;
-  onConnect: (...args: any[]) => any;
-  onAuth: (...args: any[]) => any;
-  onDecline: (...args: any[]) => any;
-  onComplete: (...args: any[]) => any;
-  onExpire: (...args: any[]) => any;
-  onError: (...args: any[]) => any;
-  pathTransformer: (v: string) => string;
-  tokenStorage: any;
-  authenticator: any;
-  authPrincipal: any;
-  persistentDynamicClaims?: boolean;
-  getSignParams?: (req: ConnectRequest) => any;
-  getPathName?: (pathname: string, req: ConnectRequest) => string;
-  options: {
-    tokenKey: string;
-    encKey: string;
-    versionKey: string;
-    cleanupDelay: number;
-  };
-}
-declare function createHandlers({
-  action,
-  pathname,
-  claims,
-  onStart,
-  onConnect,
-  onAuth,
-  onDecline,
-  onComplete,
-  onExpire,
-  onError,
-  pathTransformer,
-  tokenStorage,
-  authenticator,
-  authPrincipal,
-  persistentDynamicClaims,
-  getSignParams,
-  getPathName,
-  options
-}: CreateHandlersOptions): {
-  generateSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
-  expireSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
-  checkSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
-  onAuthRequest: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
-  onAuthResponse: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
-  ensureContext: (req: ConnectRequest, _res: ConnectResponse, next: NextFunction) => Promise<void>;
-  ensureSignedJson: (req: ConnectRequest, res: ConnectResponse, next: NextFunction) => void;
-  createExtraParams: (locale: string, params: any, extra?: any) => any;
-};
-//#endregion
-export { CreateHandlersOptions, createHandlers as default, errors, getStepChallenge, isConnectedOnly, isDeepLink, parseWalletUA, prepareBaseUrl, preparePathname };