@renown/sdk 6.2.3-dev.23 → 6.2.3-dev.24

package/dist/{local-credential-verifier-CU8hmFlR.js → signer-trust-D7vg4xbS.js}

@@ -1,5 +1,5 @@
-import { a as DEFAULT_RENOWN_NETWORK_ID, o as DEFAULT_RENOWN_URL, r as CREDENTIAL_TYPES } from "./constants-BexAR53F.js";
-import { m as verifyAuthBearerToken, p as parsePkhDid, s as RenownCryptoBuilder, t as RenownCryptoSigner } from "./signer-DrjINLqt.js";
+import { a as DEFAULT_RENOWN_NETWORK_ID, r as CREDENTIAL_TYPES } from "./constants-BexAR53F.js";
+import { a as verifyAuthBearerToken } from "./utils-Dtdm4vFs.js";
 import { recoverTypedDataAddress } from "viem";
 import { createAction } from "@powerhousedao/shared/document-model";
 //#region src/discovery.ts
@@ -168,9 +168,12 @@ function issuerChainId(issuerId) {
 function issuerDidAddress(issuerId) {
 	return issuerId.split(":")[4];
 }
-function bindsTo(row, address, chainId, appDid) {
+function bindsTo$1(row, address, chainId, appDid) {
+	return !row.revoked && issuedTo(row, address, chainId, appDid);
+}
+function issuedTo(row, address, chainId, appDid) {
 	const expected = address.toLowerCase();
-	return !row.revoked && row.credentialSubjectId === appDid && issuerChainId(row.issuerId) === String(chainId) && issuerDidAddress(row.issuerId)?.toLowerCase() === expected && row.issuerEthereumAddress.toLowerCase() === expected;
+	return row.credentialSubjectId === appDid && issuerChainId(row.issuerId) === String(chainId) && issuerDidAddress(row.issuerId)?.toLowerCase() === expected && row.issuerEthereumAddress.toLowerCase() === expected;
 }
 var SwitchboardClient = class {
 	#endpoint;
@@ -214,13 +217,30 @@ var SwitchboardClient = class {
 			includeRevoked: false
 		} });
 		const now = Date.now();
-		const mostRecent = renownCredentials.filter((row) => bindsTo(row, address, chainId, appDid)).filter((row) => {
+		const mostRecent = renownCredentials.filter((row) => bindsTo$1(row, address, chainId, appDid)).filter((row) => {
 			if (!row.expirationDate) return true;
 			const expiresAt = Date.parse(row.expirationDate);
 			return !Number.isNaN(expiresAt) && expiresAt > now;
 		}).sort((a, b) => Date.parse(b.issuanceDate) - Date.parse(a.issuanceDate)).at(0);
 		return mostRecent ? reshapeCredential(mostRecent) : void 0;
 	}
+	async getIssuedCredentials(params) {
+		const { address, chainId, appDid } = params;
+		const { renownCredentials } = await this.#request(CREDENTIALS_QUERY, { input: {
+			driveId: userDriveId(address),
+			ethAddress: address.toLowerCase(),
+			did: appDid,
+			includeRevoked: true
+		} });
+		const credentials = [];
+		for (const row of renownCredentials) {
+			if (!issuedTo(row, address, chainId, appDid)) continue;
+			try {
+				credentials.push(reshapeCredential(row));
+			} catch {}
+		}
+		return credentials;
+	}
 	async getProfileByAddress(address) {
 		const { renownUsers } = await this.#request(USERS_QUERY, { input: {
 			driveId: userDriveId(address),
@@ -427,11 +447,16 @@ async function fetchDelegationCredentialRest(params) {
 	}
 	return credential;
 }
+/** True when the credential's EIP-712 proof, on `chainId`, was signed by its
+* issuer address. Binding and expiry are the caller's to check. */
+async function verifyDelegationProof(credential, chainId) {
+	const withDomain = withEip712Domain(credential, chainId);
+	return withDomain.proof.eip712.domain.chainId === chainId && await verifyCredentialSignature(withDomain);
+}
 async function finalizeCredential(credential, chainId, verifySignature) {
 	if (!verifySignature) return credential;
-	const withDomain = withEip712Domain(credential, chainId);
-	if (withDomain.proof.eip712.domain.chainId !== chainId || !await verifyCredentialSignature(withDomain)) return;
-	return withDomain;
+	if (!await verifyDelegationProof(credential, chainId)) return;
+	return withEip712Domain(credential, chainId);
 }
 async function fetchDelegationCredential(options) {
 	const { address, chainId, appDid, switchboardUrl, switchboardRequest, discover = true, verifySignature = true } = options;
@@ -480,428 +505,102 @@ async function verifyAuthCredential(jwt, options = {}) {
 	};
 }
 //#endregion
-//#region src/storage/common.ts
-var BaseStorage = class {};
-var MemoryStorage = class extends BaseStorage {
-	data = /* @__PURE__ */ new Map();
-	get(key) {
-		return this.data.get(key);
-	}
-	set(key, value) {
-		if (value === void 0) this.data.delete(key);
-		else this.data.set(key, value);
-	}
-	delete(key) {
-		this.data.delete(key);
-	}
-};
-//#endregion
-//#region src/common.ts
-var RenownMemoryStorage = class extends MemoryStorage {};
+//#region src/signer-trust.ts
+const DEFAULT_MAX_ACCEPTED = 1e4;
+const DEFAULT_REFUSAL_TTL_MS = 6e4;
 /**
-* The acting identity an action's signature carries.
-*
-* `User` here is the whole session record — it also holds the DID, the
-* credential, the fetched profile and ENS info — while `UserActionSigner` is
-* what travels on a signed action, and it is deliberately just an address on a
-* chain. The reactor's `ReactorSignerUserInput` declares exactly these three
-* fields, and a GraphQL input object refuses a field it does not declare by
-* rejecting the WHOLE request, so handing the session record to the signer
-* makes every signed push fail before it reaches the reactor.
-*
-* Narrowed here rather than at the transport, because the session record has no
-* business being on an operation in the first place: it is stored on every
-* operation a local reactor writes, not only on the ones that go over a wire.
-*
-* The compiler cannot catch the difference — excess-property checks apply to
-* fresh object literals, never to a variable of a wider type — which is why
-* this is a function rather than a type annotation.
+* Accepts a key the user's EIP-712 Renown credential delegates to, ignoring
+* expiry and revocation. Verdicts are cached per (address, key); this node's
+* own key is checked before the cache and never cached.
 */
-function toActionSigner(user) {
-	if (!user) return void 0;
-	return {
+function createRenownTrustPolicy(options = {}) {
+	const maxAccepted = options.maxAccepted ?? DEFAULT_MAX_ACCEPTED;
+	const refusalTtlMs = options.refusalTtlMs ?? DEFAULT_REFUSAL_TTL_MS;
+	const client = options.switchboard ? new SwitchboardClient(options.switchboard) : void 0;
+	const renownUrl = options.renownUrl ?? "https://www.renown.id";
+	const accepted = /* @__PURE__ */ new Set();
+	const refusedUntil = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const issued = (user, key) => client ? client.getIssuedCredentials({
 		address: user.address,
-		networkId: user.networkId,
-		chainId: user.chainId
-	};
-}
-var Renown = class {
-	#baseUrl;
-	#store;
-	#eventEmitter;
-	#appName;
-	#crypto;
-	#signer;
-	#profileFetcher;
-	#switchboard;
-	#chainId;
-	#status = "initial";
-	constructor(store, eventEmitter, crypto, appName, baseUrl = DEFAULT_RENOWN_URL, profileFetcher, switchboard, chainId = 1) {
-		this.#store = store;
-		this.#eventEmitter = eventEmitter;
-		this.#baseUrl = baseUrl;
-		this.#crypto = crypto;
-		this.#appName = appName;
-		this.#profileFetcher = profileFetcher;
-		this.#switchboard = switchboard;
-		this.#chainId = chainId;
-		const restoredUser = this.user;
-		this.#signer = new RenownCryptoSigner(crypto, this.#appName, toActionSigner(restoredUser));
-		if (restoredUser) this.#status = "authorized";
-		this.on("user", (user) => {
-			this.#signer.user = toActionSigner(user);
-		});
-	}
-	get baseUrl() {
-		return this.#baseUrl;
-	}
-	/** Chain id this app issues credentials on; a session from another chain is rejected by {@link signIn}. */
-	get chainId() {
-		return this.#chainId;
-	}
-	get user() {
-		return this.#store.get("user");
-	}
-	get status() {
-		return this.#status;
-	}
-	get signer() {
-		return this.#signer;
-	}
-	get crypto() {
-		return this.#crypto;
-	}
-	get did() {
-		return this.#crypto.did;
-	}
-	get profileFetcher() {
-		return this.#profileFetcher;
-	}
-	#updateStatus(status) {
-		this.#status = status;
-		this.#eventEmitter.emit("status", status);
-	}
-	#updateUser(user) {
-		if (user) this.#store.set("user", user);
-		else this.#store.delete("user");
-		this.#eventEmitter.emit("user", user);
+		chainId: user.chainId,
+		appDid: key
+	}) : fetchIssuedCredentialRest(user, key, renownUrl);
+	async function lookup(user, key) {
+		for (const credential of await issued(user, key)) if (bindsTo(credential, user, key) && await verifyDelegationProof(credential, user.chainId)) return true;
+		return false;
 	}
-	async login(userDid) {
-		this.#updateStatus("checking");
-		try {
-			const result = parsePkhDid(userDid);
-			const credential = await this.#getCredential(result.address, result.chainId, this.#crypto.did);
-			if (!credential) {
-				this.#updateUser(void 0);
-				throw new Error("Credential not found");
+	function remember(entry, verdict) {
+		if (verdict) {
+			if (accepted.size >= maxAccepted) {
+				const oldest = accepted.values().next().value;
+				if (oldest !== void 0) accepted.delete(oldest);
 			}
-			return await this.#completeLogin(userDid, result, credential);
-		} catch (error) {
-			this.#updateUser(void 0);
-			this.#updateStatus("not-authorized");
-			throw error;
-		}
-	}
-	async signIn(params) {
-		if (!this.#switchboard) throw new MissingSwitchboardError();
-		const { address, chainId, signTypedData, username, userImage, expiresInDays } = params;
-		if (chainId !== this.#chainId) throw new Error(`Renown signIn: wallet is on chain ${chainId}, but this app issues credentials on chain ${this.#chainId}. Switch networks and retry — signing here would create a separate identity for the same address.`);
-		this.#updateStatus("checking");
-		try {
-			const credential = await buildAndSignCredential({
-				signTypedData,
-				address,
-				chainId,
-				app: this.#appName,
-				appId: this.did,
-				expiresInDays
-			});
-			await this.#switchboard.issueCredential(credential);
-			await this.#switchboard.findOrCreateUser(address, {
-				username,
-				userImage
-			});
-			const userDid = `did:pkh:${DEFAULT_RENOWN_NETWORK_ID}:${chainId}:${address.toLowerCase()}`;
-			return await this.#completeLogin(userDid, parsePkhDid(userDid), credential);
-		} catch (error) {
-			this.#updateUser(void 0);
-			this.#updateStatus("not-authorized");
+			accepted.add(entry);
+			refusedUntil.delete(entry);
+		} else refusedUntil.set(entry, Date.now() + refusalTtlMs);
+	}
+	return { authorizeSigner(signer, key) {
+		const user = signer.user;
+		const self = ownIdentity(options);
+		if (self && isSelf(self, user, key)) return Promise.resolve(true);
+		if (!user || !isLookupable(user, key)) return Promise.resolve(false);
+		const entry = `${user.networkId}|${user.chainId}|${user.address.toLowerCase()}|${key}`;
+		if (accepted.has(entry)) return Promise.resolve(true);
+		const until = refusedUntil.get(entry);
+		if (until !== void 0 && until > Date.now()) return Promise.resolve(false);
+		const inFlight = pending.get(entry);
+		if (inFlight) return inFlight;
+		const verdict = lookup(user, key).then((result) => {
+			pending.delete(entry);
+			remember(entry, result);
+			return result;
+		}, (error) => {
+			pending.delete(entry);
 			throw error;
-		}
-	}
-	async #completeLogin(userDid, result, credential) {
-		if (!(credential.issuer.id === userDid && credential.credentialSubject.id === this.did)) throw new Error("Invalid credential");
-		const verifiableCredential = credential.proof.eip712?.domain ? credential : {
-			...credential,
-			proof: {
-				...credential.proof,
-				eip712: {
-					domain: {
-						version: "1",
-						chainId: result.chainId
-					},
-					types: CREDENTIAL_TYPES,
-					primaryType: "VerifiableCredential"
-				}
-			}
-		};
-		if (credential.issuer.ethereumAddress.toLowerCase() !== result.address.toLowerCase() || verifiableCredential.proof.eip712.domain.chainId !== result.chainId || !await verifyCredentialSignature(verifiableCredential)) throw new Error("Invalid credential signature");
-		const user = {
-			...result,
-			address: credential.issuer.ethereumAddress,
-			did: userDid,
-			credential: verifiableCredential
-		};
-		this.#updateUser(user);
-		this.#updateStatus("authorized");
-		if (this.#profileFetcher) this.#profileFetcher(user, this.#baseUrl).then((profile) => {
-			if (profile && this.user?.address === user.address && this.user.chainId === user.chainId) this.#updateUser({
-				...this.user,
-				profile,
-				ens: {
-					name: profile.username ?? void 0,
-					avatarUrl: profile.userImage ?? void 0
-				}
-			});
-		}).catch(console.error);
-		return user;
-	}
-	logout() {
-		this.#updateUser(void 0);
-		this.#updateStatus("initial");
-		return Promise.resolve();
-	}
-	async revalidate() {
-		const user = this.user;
-		if (!user) return false;
-		try {
-			if (!await this.#getCredential(user.address, user.chainId, this.#crypto.did)) {
-				await this.logout();
-				return false;
-			}
-			await this.refreshProfile();
-			return true;
-		} catch {
-			return true;
-		}
-	}
-	async refreshProfile() {
-		const user = this.user;
-		if (!user || !this.#profileFetcher) return false;
-		try {
-			const profile = await this.#profileFetcher(user, this.#baseUrl);
-			if (!profile) return false;
-			const current = this.user;
-			if (!current || current.address !== user.address || current.chainId !== user.chainId) return false;
-			if (current.profile !== void 0 && current.profile.documentId === profile.documentId && current.profile.username === profile.username && current.profile.userImage === profile.userImage) return false;
-			this.#updateUser({
-				...current,
-				profile,
-				ens: {
-					name: profile.username ?? void 0,
-					avatarUrl: profile.userImage ?? void 0
-				}
-			});
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	on(event, listener) {
-		return this.#eventEmitter.on(event, listener);
-	}
-	async #getCredential(address, chainId, appDid) {
-		if (this.#switchboard) return this.#switchboard.getCredential({
-			address,
-			chainId,
-			appDid
-		});
-		if (!this.#baseUrl) throw new Error("RENOWN_URL is not set");
-		const url = new URL(`/api/auth/credential?address=${encodeURIComponent(address)}&chainId=${encodeURIComponent(chainId)}&connectId=${encodeURIComponent(appDid)}&appId=${encodeURIComponent(appDid)}`, this.#baseUrl);
-		const response = await fetch(url, { method: "GET" });
-		if (response.ok) return (await response.json()).credential;
-		else throw new Error(`Failed to get credential: ${response.status}`);
-	}
-	async verifyBearerToken(token) {
-		return verifyAuthBearerToken(token);
-	}
-	async getBearerToken(options) {
-		if (!this.user) throw new Error("User not found");
-		return this.#crypto.getBearerToken(this.user.address, options);
-	}
-};
-//#endregion
-//#region src/event/memory.ts
-var MemoryEventEmitter = class {
-	#listeners = /* @__PURE__ */ new Map();
-	on(event, listener) {
-		if (!this.#listeners.has(event)) this.#listeners.set(event, /* @__PURE__ */ new Set());
-		this.#listeners.get(event).add(listener);
-		return () => {
-			this.#listeners.get(event)?.delete(listener);
-		};
-	}
-	emit(event, data) {
-		this.#listeners.get(event)?.forEach((listener) => listener(data));
-	}
-};
-//#endregion
-//#region src/profile.ts
-const fetchRenownProfile = async (user, baseUrl) => {
-	try {
-		const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/api/profile`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ ethAddress: user.address })
 		});
-		if (!response.ok) return;
-		return (await response.json()).profile ?? void 0;
-	} catch {
-		return;
-	}
-};
-//#endregion
-//#region src/renown-builder.ts
-/**
-* Base builder for creating Renown instances.
-* Use platform-specific builders (RenownBuilder from init.browser.js or init.node.js)
-* for pre-configured defaults.
-*/
-var BaseRenownBuilder = class BaseRenownBuilder {
-	#appName;
-	#storage;
-	#eventEmitter;
-	#crypto;
-	#keyPairStorage;
-	#baseUrl;
-	#switchboardUrl;
-	#profileFetcher;
-	#chainId;
-	/**
-	* @param appName - Application name used for signing context
-	*/
-	constructor(appName) {
-		this.#appName = appName;
-	}
-	/**
-	* Set custom storage for user data persistence.
-	* Defaults to in-memory storage if not set.
-	*/
-	withStorage(storage) {
-		this.#storage = storage;
-		return this;
-	}
-	/**
-	* Set custom event emitter for user state changes.
-	* Defaults to in-memory event emitter if not set.
-	*/
-	withEventEmitter(eventEmitter) {
-		this.#eventEmitter = eventEmitter;
-		return this;
-	}
-	/**
-	* Set a pre-built crypto instance.
-	* Either crypto or keyPairStorage must be provided.
-	*/
-	withCrypto(crypto) {
-		this.#crypto = crypto;
-		return this;
-	}
-	/**
-	* Set key pair storage for cryptographic keys.
-	* A crypto instance will be built from this storage.
-	* Either crypto or keyPairStorage must be provided.
-	*/
-	withKeyPairStorage(keyPairStorage) {
-		this.#keyPairStorage = keyPairStorage;
-		return this;
-	}
-	/**
-	* Set the Renown server URL for credential verification.
-	* Defaults to https://www.renown.id
-	*/
-	withBaseUrl(baseUrl) {
-		this.#baseUrl = baseUrl;
-		return this;
-	}
-	withSwitchboardUrl(switchboardUrl) {
-		this.#switchboardUrl = switchboardUrl;
-		return this;
-	}
-	withChainId(chainId) {
-		this.#chainId = chainId;
-		return this;
-	}
-	/**
-	* Set a profile fetcher strategy for enriching user data after login.
-	* The fetcher receives the authenticated user and the base URL,
-	* and returns a RenownProfile. Called in the background after each login.
-	* Defaults to fetchRenownProfile which calls the Renown API.
-	*/
-	withProfileFetcher(profileFetcher) {
-		this.#profileFetcher = profileFetcher;
-		return this;
-	}
-	/**
-	* Build and initialize the Renown instance.
-	* If a user is stored, attempts to re-authenticate them.
-	* @throws Error if neither crypto nor keyPairStorage is provided
-	*/
-	async build() {
-		if (!this.#crypto && !this.#keyPairStorage) throw new Error("Either crypto or keyPairStorage is required. Use withCrypto() or withKeyPairStorage() to set one.");
-		const chainId = this.#chainId ?? 1;
-		const crypto = this.#crypto ?? await new RenownCryptoBuilder().withKeyPairStorage(this.#keyPairStorage).withChainId(chainId).build();
-		if (crypto.chainId !== void 0 && crypto.chainId !== chainId) console.warn(`Renown: the supplied crypto signs bearer tokens for chain ${crypto.chainId}, but credentials are issued on chain ${chainId}.`);
-		const storage = this.#storage ?? new RenownMemoryStorage();
-		const eventEmitter = this.#eventEmitter ?? new MemoryEventEmitter();
-		const baseUrl = this.#baseUrl ?? "https://www.renown.id";
-		const switchboardEndpoint = await resolveSwitchboardEndpoint({
-			switchboardUrl: this.#switchboardUrl,
-			baseUrl
-		});
-		const switchboard = switchboardEndpoint ? new SwitchboardClient(switchboardEndpoint) : void 0;
-		const profileFetcher = this.#profileFetcher ?? (switchboard ? switchboard.profileFetcher : fetchRenownProfile);
-		return new Renown(storage, eventEmitter, crypto, this.#appName, baseUrl, profileFetcher, switchboard, chainId);
-	}
-	/**
-	* Create a BaseRenownBuilder from options object for a more concise API
-	*/
-	static from(options) {
-		const builder = new BaseRenownBuilder(options.appName);
-		if (options.storage) builder.withStorage(options.storage);
-		if (options.eventEmitter) builder.withEventEmitter(options.eventEmitter);
-		if (options.crypto) builder.withCrypto(options.crypto);
-		if (options.keyPairStorage) builder.withKeyPairStorage(options.keyPairStorage);
-		if (options.baseUrl) builder.withBaseUrl(options.baseUrl);
-		if (options.switchboardUrl) builder.withSwitchboardUrl(options.switchboardUrl);
-		if (options.profileFetcher) builder.withProfileFetcher(options.profileFetcher);
-		if (options.chainId !== void 0) builder.withChainId(options.chainId);
-		return builder;
-	}
-};
-//#endregion
-//#region src/local-credential-verifier.ts
-/** A credential check that reads a Switchboard's own renown read model through
-* `execute`, rather than any Renown or Switchboard over HTTP. */
-function createLocalCredentialVerifier(execute, options = {}) {
-	const request = async (query, variables) => {
-		try {
-			return await execute(query, variables);
-		} catch (error) {
-			options.onError?.(error);
-			throw error;
+		pending.set(entry, verdict);
+		return verdict;
+	} };
+}
+function ownIdentity(options) {
+	if (!options.ownSigner) return options.self;
+	const { app, user } = options.ownSigner;
+	return {
+		key: app?.key ?? "",
+		user: {
+			address: user?.address ?? "",
+			networkId: user?.networkId ?? "",
+			chainId: user?.chainId ?? 0
 		}
 	};
-	return async ({ address, chainId, appId }) => {
-		return await fetchDelegationCredential({
-			address,
-			chainId,
-			appDid: appId,
-			switchboardRequest: request
-		}) !== void 0;
-	};
+}
+function isSelf(self, user, key) {
+	return self.key !== "" && key === self.key && (user?.address ?? "").toLowerCase() === self.user.address.toLowerCase() && (user?.networkId ?? "") === self.user.networkId && (user?.chainId ?? 0) === self.user.chainId;
+}
+function isLookupable(user, key) {
+	return key.startsWith("did:key:") && /^0x[0-9a-fA-F]{40}$/.test(user.address) && user.networkId !== "" && Number.isInteger(user.chainId) && user.chainId > 0;
+}
+function bindsTo(credential, user, key) {
+	const address = user.address.toLowerCase();
+	const issuer = credential.issuer.id.split(":");
+	if (issuer.length !== 5) return false;
+	const [scheme, method, networkId, chainId, issuerAddress] = issuer;
+	return credential.credentialSubject.id === key && scheme === "did" && method === "pkh" && networkId === user.networkId && chainId === String(user.chainId) && issuerAddress.toLowerCase() === address && credential.issuer.ethereumAddress.toLowerCase() === address;
+}
+async function fetchIssuedCredentialRest(user, key, renownUrl) {
+	const url = new URL("/api/auth/credential", renownUrl);
+	url.searchParams.set("address", user.address);
+	url.searchParams.set("chainId", String(user.chainId));
+	url.searchParams.set("connectId", key);
+	url.searchParams.set("appId", key);
+	const response = await fetch(url, { method: "GET" });
+	if (response.status === 404) return [];
+	if (!response.ok) throw new Error(`Renown credential lookup failed: ${response.status}`);
+	const { credential } = await response.json();
+	return credential ? [credential] : [];
 }
 //#endregion
-export { RenownMemoryStorage as a, fetchDelegationCredential as c, verifyCredentialSignature as d, MissingSwitchboardError as f, Renown as i, recoverCredentialSigner as l, resolveSwitchboardEndpoint as m, BaseRenownBuilder as n, BaseStorage as o, SwitchboardClient as p, fetchRenownProfile as r, buildAndSignCredential as s, createLocalCredentialVerifier as t, verifyAuthCredential as u };
+export { verifyAuthCredential as a, MissingSwitchboardError as c, recoverCredentialSigner as i, SwitchboardClient as l, buildAndSignCredential as n, verifyCredentialSignature as o, fetchDelegationCredential as r, verifyDelegationProof as s, createRenownTrustPolicy as t, resolveSwitchboardEndpoint as u };
 
-//# sourceMappingURL=local-credential-verifier-CU8hmFlR.js.map
+//# sourceMappingURL=signer-trust-D7vg4xbS.js.map