@renown/sdk 6.2.3-dev.26 → 6.2.3-dev.28

package/dist/crypto.d.ts

@@ -1,4 +1,4 @@
-import { a as JwkKeyPair, i as JsonWebKeyPairStorage, n as IConnectCrypto, r as IRenownCrypto, t as DID } from "./types-DOTk0z2D.js";
-import { a as parseSignatureHashField, c as RenownCryptoBuilder, i as extractResultingHashFromSignature, l as ConnectCrypto, n as RenownCryptoSigner, o as signatureHasResultingHash, r as createSignatureVerifier, s as MemoryKeyStorage, t as BrowserKeyStorage, u as RenownCrypto } from "./index-CGTiUojp.js";
+import { a as JwkKeyPair, i as JsonWebKeyPairStorage, n as IConnectCrypto, r as IRenownCrypto, t as DID } from "./types-Ceiz2dkk.js";
+import { a as parseSignatureHashField, c as RenownCryptoBuilder, i as extractResultingHashFromSignature, l as ConnectCrypto, n as RenownCryptoSigner, o as signatureHasResultingHash, r as createSignatureVerifier, s as MemoryKeyStorage, t as BrowserKeyStorage, u as RenownCrypto } from "./index-DbiBjqs6.js";
 export { BrowserKeyStorage, ConnectCrypto, type DID, type IConnectCrypto, type IRenownCrypto, type JsonWebKeyPairStorage, type JwkKeyPair, MemoryKeyStorage, RenownCrypto, RenownCryptoBuilder, RenownCryptoSigner, createSignatureVerifier, extractResultingHashFromSignature, parseSignatureHashField, signatureHasResultingHash };
 export {};

package/dist/{index-CGTiUojp.d.ts → index-DbiBjqs6.d.ts}

@@ -1,4 +1,4 @@
-import { a as JwkKeyPair, i as JsonWebKeyPairStorage, l as CreateBearerTokenOptions, r as IRenownCrypto, t as DID, w as Issuer } from "./types-DOTk0z2D.js";
+import { a as JwkKeyPair, i as JsonWebKeyPairStorage, l as CreateBearerTokenOptions, r as IRenownCrypto, t as DID, w as Issuer } from "./types-Ceiz2dkk.js";
 import { Action, ActionSigningTarget, AppActionSigner, ISigner, Signature, SignatureVerificationHandler, UserActionSigner } from "@powerhousedao/shared/document-model";
 //#region src/crypto/renown-crypto.d.ts
 declare class RenownCrypto implements IRenownCrypto {
@@ -119,4 +119,4 @@ declare class BrowserKeyStorage implements JsonWebKeyPairStorage {
 //#endregion
 export { parseSignatureHashField as a, RenownCryptoBuilder as c, extractResultingHashFromSignature as i, ConnectCrypto as l, RenownCryptoSigner as n, signatureHasResultingHash as o, createSignatureVerifier as r, MemoryKeyStorage as s, BrowserKeyStorage as t, RenownCrypto as u };
 export {};
-//# sourceMappingURL=index-CGTiUojp.d.ts.map
+//# sourceMappingURL=index-DbiBjqs6.d.ts.map

package/dist/{index-CGTiUojp.d.ts.map → index-DbiBjqs6.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-CGTiUojp.d.ts","names":[],"sources":["../src/crypto/renown-crypto.ts","../src/crypto/renown-crypto-builder.ts","../src/crypto/memory-key-storage.ts","../src/crypto/signer.ts","../src/crypto/browser-key-storage.ts"],"mappings":";;;cAUa,wBAAwB;;WAK1B,KAAK;;WAEL;SAEF,WAAS;SACT;;;;;EAEP,YACE,gBAAgB,uBAChB,QAAQ,cACR,SAAS,eACT,KAAK,KACL;MASE,aAAS;EAIP,eACJ,6BACA,UAAU,2BACT;EAUG,aAAa;EAQb,KAAK,MAAM,sBAAsB,QAAQ;EAazC,OAAO,MAAM,YAAY,WAAW,aAAa;MASnD,UAAU;;;;;cAiBH,sBAAsB;;;cC3FtB;;UACH;UACA;UACA;EAER,mBAAmB,SAAS;EAK5B,iBAAiB,QAAQ;EAOzB,YAAY;EAKN,SAAS,QAAQ;;;;cC7BZ,4BAA4B;UAC/B;EAER,YAAY,UAAU;EAItB,eAAW,QAAA;EAIX,YAAY,SAAS,aAAU;EAK/B,iBAAa;;;;cCIF,8BAA8B;mBAItB;mBACA;EACV,OAAO;WALP,KAAK;EAEd,YACmB,QAAQ,eACR,iBACV,OAAO;MAQZ,aAAS;EAIP,KAAK,MAAM,aAAa,QAAQ;EAIhC,OAAO,MAAM,YAAY,WAAW,aAAa;EAOjD,WACJ,QAAQ,QACR,QAAQ,qBACR,cAAc,cACb,QAAQ;;;;;EASL,6BACJ,QAAQ,QACR,QAAQ,qBACR,4BACA,cAAc,cACb,QAAQ;;;;;EAUL,iBACJ,QAAQ,QACR,cAAc,cACb,QAAQ;UAqBG;UAyBA;UAYN;UASA;UAQA;;;;;;iBAcM,wBACd,6BACC;;;;;;;;;;;iBAgNa,wBAAwB;EACtC;EACA;;;;;;;;iBAuBc,kCACd,WAAW;;;;;;;iBAaG,0BAA0B,WAAW;;;cC9ZxC,6BAA6B;;EAGxC,YAAY,IAAI;SAIH,OACX,kBACC,QAAQ;EA4CL,YAAY,SAAS,aAAU;EAS/B,eAAe,QAAQ;EAavB,iBAAiB"}
+{"version":3,"file":"index-DbiBjqs6.d.ts","names":[],"sources":["../src/crypto/renown-crypto.ts","../src/crypto/renown-crypto-builder.ts","../src/crypto/memory-key-storage.ts","../src/crypto/signer.ts","../src/crypto/browser-key-storage.ts"],"mappings":";;;cAUa,wBAAwB;;WAK1B,KAAK;;WAEL;SAEF,WAAS;SACT;;;;;EAEP,YACE,gBAAgB,uBAChB,QAAQ,cACR,SAAS,eACT,KAAK,KACL;MASE,aAAS;EAIP,eACJ,6BACA,UAAU,2BACT;EAUG,aAAa;EAQb,KAAK,MAAM,sBAAsB,QAAQ;EAazC,OAAO,MAAM,YAAY,WAAW,aAAa;MASnD,UAAU;;;;;cAiBH,sBAAsB;;;cC3FtB;;UACH;UACA;UACA;EAER,mBAAmB,SAAS;EAK5B,iBAAiB,QAAQ;EAOzB,YAAY;EAKN,SAAS,QAAQ;;;;cC7BZ,4BAA4B;UAC/B;EAER,YAAY,UAAU;EAItB,eAAW,QAAA;EAIX,YAAY,SAAS,aAAU;EAK/B,iBAAa;;;;cCIF,8BAA8B;mBAItB;mBACA;EACV,OAAO;WALP,KAAK;EAEd,YACmB,QAAQ,eACR,iBACV,OAAO;MAQZ,aAAS;EAIP,KAAK,MAAM,aAAa,QAAQ;EAIhC,OAAO,MAAM,YAAY,WAAW,aAAa;EAOjD,WACJ,QAAQ,QACR,QAAQ,qBACR,cAAc,cACb,QAAQ;;;;;EASL,6BACJ,QAAQ,QACR,QAAQ,qBACR,4BACA,cAAc,cACb,QAAQ;;;;;EAUL,iBACJ,QAAQ,QACR,cAAc,cACb,QAAQ;UAqBG;UAyBA;UAYN;UASA;UAQA;;;;;;iBAcM,wBACd,6BACC;;;;;;;;;;;iBAgNa,wBAAwB;EACtC;EACA;;;;;;;;iBAuBc,kCACd,WAAW;;;;;;;iBAaG,0BAA0B,WAAW;;;cC9ZxC,6BAA6B;;EAGxC,YAAY,IAAI;SAIH,OACX,kBACC,QAAQ;EA4CL,YAAY,SAAS,aAAU;EAS/B,eAAe,QAAQ;EAavB,iBAAiB"}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { A as LoginStatus, B as Service, C as InternalUser, Ct as DEFAULT_RENOWN_URL, D as JWTVerifyPolicies, Dt as RENOWN_SESSION_COOKIE, E as JWTVerified, Et as RENOWN_READ_MODEL_SUBGRAPH, F as RenownEventEmitter, G as User, H as SignInParams, I as RenownEvents, J as VerificationMethod, K as UserActionSigner, L as RenownProfile, M as PowerhouseVerifiableCredential, N as ProfileFetcher, O as JsonWebKey, Ot as VERIFIABLE_CREDENTIAL_EIP712_TYPE, P as Proof, Q as BaseStorage, R as RenownStorage, S as IVerifiableCredential, St as DEFAULT_RENOWN_NETWORK_ID, T as JWTPayload, Tt as ISSUER_TYPE, U as Signer, V as ServiceEndpoint, W as Unsubscribe, X as VerifiedJWT, Y as VerifiedCredential, Z as W3CCredential, _ as IPowerhouseCredentialSubject, _t as SwitchboardSource, a as JwkKeyPair, at as SignCredentialTypedData, b as IRenown, bt as CREDENTIAL_TYPES, c as ConditionWeightedThreshold, ct as buildAndSignCredential, d as DIDDocument, dt as verifyAuthCredential, et as IEventEmitter, f as DIDDocumentMetadata, ft as verifyCredentialSignature, g as IAuthCredentialSubject, gt as SwitchboardRequestFn, h as EcdsaSignature, ht as SwitchboardClient, i as JsonWebKeyPairStorage, it as FetchDelegationCredentialOptions, j as PKHDid, k as KeyCapabilitySection, l as CreateBearerTokenOptions, lt as fetchDelegationCredential, m as DIDResolutionResult, mt as MissingSwitchboardError, n as IConnectCrypto, nt as CredentialDomain, o as AuthVerifiableCredential, ot as VerifiedAuthCredential, p as DIDResolutionMetadata, pt as verifyDelegationProof, q as Verifiable, r as IRenownCrypto, rt as CredentialMessage, s as AuthVerifiedCredential, st as VerifyAuthCredentialOptions, t as DID, tt as BuildCredentialParams, u as CredentialStatus, ut as recoverCredentialSigner, v as IPowerhouseIssuerType, vt as CREDENTIAL_SCHEMA_EIP712_TYPE, w as Issuer, wt as DOMAIN_TYPE, x as ISigner, xt as DEFAULT_RENOWN_CHAIN_ID, y as IProof, yt as CREDENTIAL_SUBJECT_TYPE, z as RenownStorageMap } from "./types-DOTk0z2D.js";
-import { a as parseSignatureHashField, c as RenownCryptoBuilder, i as extractResultingHashFromSignature, l as ConnectCrypto, n as RenownCryptoSigner, o as signatureHasResultingHash, r as createSignatureVerifier, s as MemoryKeyStorage, t as BrowserKeyStorage, u as RenownCrypto } from "./index-CGTiUojp.js";
-import { C as RenownMemoryStorage, S as Renown, _ as CredentialCheck, a as getResolver, b as BaseRenownBuilder, d as RenownSessionProfile, g as fetchRenownProfile, i as createAuthBearerToken, n as VerifyAuthBearerTokenOptions, o as parsePkhDid, r as assertIsAuthCredential, s as verifyAuthBearerToken, t as ILogger, u as RenownSessionCookie, v as LocalCredentialVerifierOptions, x as RenownBuilderOptions, y as createLocalCredentialVerifier } from "./utils-C_2VV8CS.js";
-import { a as ResolveSwitchboardEndpointOptions, i as createRenownTrustPolicy, n as RenownTrustPolicy, o as resolveSwitchboardEndpoint, r as RenownTrustPolicyOptions, t as RenownOwnSigner } from "./signer-trust-DstQutcf.js";
+import { A as LoginStatus, At as VERIFIABLE_CREDENTIAL_EIP712_TYPE, B as Service, C as InternalUser, Ct as DEFAULT_RENOWN_CHAIN_ID, D as JWTVerifyPolicies, Dt as ISSUER_TYPE, E as JWTVerified, Et as DOMAIN_TYPE, F as RenownEventEmitter, G as User, H as SignInParams, I as RenownEvents, J as VerificationMethod, K as UserActionSigner, L as RenownProfile, M as PowerhouseVerifiableCredential, N as ProfileFetcher, O as JsonWebKey, Ot as RENOWN_READ_MODEL_SUBGRAPH, P as Proof, Q as BaseStorage, R as RenownStorage, S as IVerifiableCredential, St as CREDENTIAL_TYPES, T as JWTPayload, Tt as DEFAULT_RENOWN_URL, U as Signer, V as ServiceEndpoint, W as Unsubscribe, X as VerifiedJWT, Y as VerifiedCredential, Z as W3CCredential, _ as IPowerhouseCredentialSubject, _t as SwitchboardRequestFn, a as JwkKeyPair, at as SignCredentialTypedData, b as IRenown, bt as CREDENTIAL_SCHEMA_EIP712_TYPE, c as ConditionWeightedThreshold, ct as buildAndSignCredential, d as DIDDocument, dt as verifyAuthCredential, et as IEventEmitter, f as DIDDocumentMetadata, ft as verifyCredentialSignature, g as IAuthCredentialSubject, gt as SwitchboardClient, h as EcdsaSignature, ht as RenownWriteAuth, i as JsonWebKeyPairStorage, it as FetchDelegationCredentialOptions, j as PKHDid, k as KeyCapabilitySection, kt as RENOWN_SESSION_COOKIE, l as CreateBearerTokenOptions, lt as fetchDelegationCredential, m as DIDResolutionResult, mt as MissingSwitchboardError, n as IConnectCrypto, nt as CredentialDomain, o as AuthVerifiableCredential, ot as VerifiedAuthCredential, p as DIDResolutionMetadata, pt as verifyDelegationProof, q as Verifiable, r as IRenownCrypto, rt as CredentialMessage, s as AuthVerifiedCredential, st as VerifyAuthCredentialOptions, t as DID, tt as BuildCredentialParams, u as CredentialStatus, ut as recoverCredentialSigner, v as IPowerhouseIssuerType, vt as SwitchboardRequestOptions, w as Issuer, wt as DEFAULT_RENOWN_NETWORK_ID, x as ISigner, xt as CREDENTIAL_SUBJECT_TYPE, y as IProof, yt as SwitchboardSource, z as RenownStorageMap } from "./types-Ceiz2dkk.js";
+import { a as parseSignatureHashField, c as RenownCryptoBuilder, i as extractResultingHashFromSignature, l as ConnectCrypto, n as RenownCryptoSigner, o as signatureHasResultingHash, r as createSignatureVerifier, s as MemoryKeyStorage, t as BrowserKeyStorage, u as RenownCrypto } from "./index-DbiBjqs6.js";
+import { C as BaseRenownBuilder, E as RenownMemoryStorage, S as createLocalCredentialVerifier, T as Renown, _ as profileMessage, a as getResolver, b as CredentialCheck, d as RenownSessionProfile, g as SIGNATURE_WINDOW_MS, i as createAuthBearerToken, n as VerifyAuthBearerTokenOptions, o as parsePkhDid, r as assertIsAuthCredential, s as verifyAuthBearerToken, t as ILogger, u as RenownSessionCookie, v as revokeMessage, w as RenownBuilderOptions, x as LocalCredentialVerifierOptions, y as fetchRenownProfile } from "./utils-DkVxP7Ug.js";
+import { a as ResolveSwitchboardEndpointOptions, i as createRenownTrustPolicy, n as RenownTrustPolicy, o as resolveSwitchboardEndpoint, r as RenownTrustPolicyOptions, t as RenownOwnSigner } from "./signer-trust-FmbMTn39.js";
 //#region src/event/event.browser.d.ts
 declare class BrowserEventEmitter<Events extends Record<string, unknown>> implements IEventEmitter<Events> {
   #private;
@@ -68,6 +68,6 @@ export declare class RenownBuilder extends BaseRenownBuilder {
  */
 export declare function initRenown(appName: string, options?: BrowserRenownBuilderOptions): Promise<Renown>;
 //#endregion
-export { AuthVerifiableCredential, AuthVerifiedCredential, BaseRenownBuilder, BrowserKeyStorage, BuildCredentialParams, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ConditionWeightedThreshold, ConnectCrypto, CreateBearerTokenOptions, CredentialCheck, CredentialDomain, CredentialMessage, CredentialStatus, DEFAULT_RENOWN_CHAIN_ID, DEFAULT_RENOWN_NETWORK_ID, DEFAULT_RENOWN_URL, type DID, DIDDocument, DIDDocumentMetadata, DIDResolutionMetadata, DIDResolutionResult, DOMAIN_TYPE, EcdsaSignature, FetchDelegationCredentialOptions, IAuthCredentialSubject, type IConnectCrypto, ILogger, IPowerhouseCredentialSubject, IPowerhouseIssuerType, IProof, IRenown, type IRenownCrypto, ISSUER_TYPE, type ISigner, IVerifiableCredential, InternalUser, Issuer, JWTPayload, JWTVerified, JWTVerifyPolicies, JsonWebKey, type JsonWebKeyPairStorage, type JwkKeyPair, KeyCapabilitySection, LocalCredentialVerifierOptions, LoginStatus, MemoryKeyStorage, MissingSwitchboardError, PKHDid, PowerhouseVerifiableCredential, ProfileFetcher, Proof, RENOWN_READ_MODEL_SUBGRAPH, RENOWN_SESSION_COOKIE, Renown, RenownBuilderOptions, RenownCrypto, RenownCryptoBuilder, RenownCryptoSigner, RenownEventEmitter, RenownEvents, RenownMemoryStorage, RenownOwnSigner, RenownProfile, type RenownSessionCookie, type RenownSessionProfile, RenownStorage, RenownStorageMap, RenownTrustPolicy, RenownTrustPolicyOptions, ResolveSwitchboardEndpointOptions, Service, ServiceEndpoint, SignCredentialTypedData, SignInParams, Signer, SwitchboardClient, SwitchboardRequestFn, SwitchboardSource, Unsubscribe, User, type UserActionSigner, VERIFIABLE_CREDENTIAL_EIP712_TYPE, Verifiable, VerificationMethod, VerifiedAuthCredential, VerifiedCredential, VerifiedJWT, VerifyAuthBearerTokenOptions, VerifyAuthCredentialOptions, W3CCredential, assertIsAuthCredential, buildAndSignCredential, createAuthBearerToken, createLocalCredentialVerifier, createRenownTrustPolicy, createSignatureVerifier, extractResultingHashFromSignature, fetchDelegationCredential, fetchRenownProfile, getResolver, parsePkhDid, parseSignatureHashField, recoverCredentialSigner, resolveSwitchboardEndpoint, signatureHasResultingHash, verifyAuthBearerToken, verifyAuthCredential, verifyCredentialSignature, verifyDelegationProof };
+export { AuthVerifiableCredential, AuthVerifiedCredential, BaseRenownBuilder, BrowserKeyStorage, BuildCredentialParams, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ConditionWeightedThreshold, ConnectCrypto, CreateBearerTokenOptions, CredentialCheck, CredentialDomain, CredentialMessage, CredentialStatus, DEFAULT_RENOWN_CHAIN_ID, DEFAULT_RENOWN_NETWORK_ID, DEFAULT_RENOWN_URL, type DID, DIDDocument, DIDDocumentMetadata, DIDResolutionMetadata, DIDResolutionResult, DOMAIN_TYPE, EcdsaSignature, FetchDelegationCredentialOptions, IAuthCredentialSubject, type IConnectCrypto, ILogger, IPowerhouseCredentialSubject, IPowerhouseIssuerType, IProof, IRenown, type IRenownCrypto, ISSUER_TYPE, type ISigner, IVerifiableCredential, InternalUser, Issuer, JWTPayload, JWTVerified, JWTVerifyPolicies, JsonWebKey, type JsonWebKeyPairStorage, type JwkKeyPair, KeyCapabilitySection, LocalCredentialVerifierOptions, LoginStatus, MemoryKeyStorage, MissingSwitchboardError, PKHDid, PowerhouseVerifiableCredential, ProfileFetcher, Proof, RENOWN_READ_MODEL_SUBGRAPH, RENOWN_SESSION_COOKIE, Renown, RenownBuilderOptions, RenownCrypto, RenownCryptoBuilder, RenownCryptoSigner, RenownEventEmitter, RenownEvents, RenownMemoryStorage, RenownOwnSigner, RenownProfile, type RenownSessionCookie, type RenownSessionProfile, RenownStorage, RenownStorageMap, RenownTrustPolicy, RenownTrustPolicyOptions, RenownWriteAuth, ResolveSwitchboardEndpointOptions, SIGNATURE_WINDOW_MS, Service, ServiceEndpoint, SignCredentialTypedData, SignInParams, Signer, SwitchboardClient, SwitchboardRequestFn, SwitchboardRequestOptions, SwitchboardSource, Unsubscribe, User, type UserActionSigner, VERIFIABLE_CREDENTIAL_EIP712_TYPE, Verifiable, VerificationMethod, VerifiedAuthCredential, VerifiedCredential, VerifiedJWT, VerifyAuthBearerTokenOptions, VerifyAuthCredentialOptions, W3CCredential, assertIsAuthCredential, buildAndSignCredential, createAuthBearerToken, createLocalCredentialVerifier, createRenownTrustPolicy, createSignatureVerifier, extractResultingHashFromSignature, fetchDelegationCredential, fetchRenownProfile, getResolver, parsePkhDid, parseSignatureHashField, profileMessage, recoverCredentialSigner, resolveSwitchboardEndpoint, revokeMessage, signatureHasResultingHash, verifyAuthBearerToken, verifyAuthCredential, verifyCredentialSignature, verifyDelegationProof };
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,9 +1,9 @@
 import { a as DEFAULT_RENOWN_NETWORK_ID, c as ISSUER_TYPE, d as VERIFIABLE_CREDENTIAL_EIP712_TYPE, i as DEFAULT_RENOWN_CHAIN_ID, l as RENOWN_READ_MODEL_SUBGRAPH, n as CREDENTIAL_SUBJECT_TYPE, o as DEFAULT_RENOWN_URL, r as CREDENTIAL_TYPES, s as DOMAIN_TYPE, t as CREDENTIAL_SCHEMA_EIP712_TYPE, u as RENOWN_SESSION_COOKIE } from "./constants-DVOF17NB.js";
-import { a as verifyAuthCredential, c as MissingSwitchboardError, i as recoverCredentialSigner, l as SwitchboardClient, n as buildAndSignCredential, o as verifyCredentialSignature, r as fetchDelegationCredential, s as verifyDelegationProof, t as createRenownTrustPolicy, u as resolveSwitchboardEndpoint } from "./signer-trust-C6UJAsNJ.js";
+import { a as verifyAuthCredential, c as MissingSwitchboardError, i as recoverCredentialSigner, l as SwitchboardClient, n as buildAndSignCredential, o as verifyCredentialSignature, r as fetchDelegationCredential, s as verifyDelegationProof, t as createRenownTrustPolicy, u as resolveSwitchboardEndpoint } from "./signer-trust-H1rNzUcd.js";
 import { a as verifyAuthBearerToken, i as parsePkhDid, n as createAuthBearerToken, r as getResolver, t as assertIsAuthCredential } from "./utils-DLQ5VVqT.js";
 import { a as signatureHasResultingHash, c as ConnectCrypto, i as parseSignatureHashField, l as RenownCrypto, n as createSignatureVerifier, o as MemoryKeyStorage, r as extractResultingHashFromSignature, s as RenownCryptoBuilder, t as RenownCryptoSigner } from "./signer-GzTlZLjR.js";
 import { t as BrowserKeyStorage } from "./browser-key-storage-wjSwTnhs.js";
-import { a as RenownMemoryStorage, i as Renown, n as BaseRenownBuilder, o as BaseStorage, r as fetchRenownProfile, t as createLocalCredentialVerifier } from "./local-credential-verifier-BC4HS01T.js";
+import { a as BaseRenownBuilder, c as RenownMemoryStorage, i as createLocalCredentialVerifier, l as BaseStorage, n as profileMessage, o as fetchRenownProfile, r as revokeMessage, s as Renown, t as SIGNATURE_WINDOW_MS } from "./signed-message-Cp5oRPLN.js";
 //#region src/event/event.browser.ts
 var TypedCustomEvent = class extends CustomEvent {
 	constructor(type, detail) {
@@ -121,6 +121,6 @@ function initRenown(appName, options = {}) {
 	return new RenownBuilder(appName, options).build();
 }
 //#endregion
-export { BaseRenownBuilder, BrowserKeyStorage, BrowserRenownEventEmitter, BrowserRenownStorage, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ConnectCrypto, DEFAULT_RENOWN_CHAIN_ID, DEFAULT_RENOWN_NETWORK_ID, DEFAULT_RENOWN_URL, DOMAIN_TYPE, ISSUER_TYPE, MemoryKeyStorage, MissingSwitchboardError, RENOWN_READ_MODEL_SUBGRAPH, RENOWN_SESSION_COOKIE, Renown, RenownBuilder, RenownCrypto, RenownCryptoBuilder, RenownCryptoSigner, RenownMemoryStorage, SwitchboardClient, VERIFIABLE_CREDENTIAL_EIP712_TYPE, assertIsAuthCredential, buildAndSignCredential, createAuthBearerToken, createLocalCredentialVerifier, createRenownTrustPolicy, createSignatureVerifier, extractResultingHashFromSignature, fetchDelegationCredential, fetchRenownProfile, getResolver, initRenown, parsePkhDid, parseSignatureHashField, readPersistedUser, recoverCredentialSigner, resolveSwitchboardEndpoint, signatureHasResultingHash, verifyAuthBearerToken, verifyAuthCredential, verifyCredentialSignature, verifyDelegationProof };
+export { BaseRenownBuilder, BrowserKeyStorage, BrowserRenownEventEmitter, BrowserRenownStorage, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ConnectCrypto, DEFAULT_RENOWN_CHAIN_ID, DEFAULT_RENOWN_NETWORK_ID, DEFAULT_RENOWN_URL, DOMAIN_TYPE, ISSUER_TYPE, MemoryKeyStorage, MissingSwitchboardError, RENOWN_READ_MODEL_SUBGRAPH, RENOWN_SESSION_COOKIE, Renown, RenownBuilder, RenownCrypto, RenownCryptoBuilder, RenownCryptoSigner, RenownMemoryStorage, SIGNATURE_WINDOW_MS, SwitchboardClient, VERIFIABLE_CREDENTIAL_EIP712_TYPE, assertIsAuthCredential, buildAndSignCredential, createAuthBearerToken, createLocalCredentialVerifier, createRenownTrustPolicy, createSignatureVerifier, extractResultingHashFromSignature, fetchDelegationCredential, fetchRenownProfile, getResolver, initRenown, parsePkhDid, parseSignatureHashField, profileMessage, readPersistedUser, recoverCredentialSigner, resolveSwitchboardEndpoint, revokeMessage, signatureHasResultingHash, verifyAuthBearerToken, verifyAuthCredential, verifyCredentialSignature, verifyDelegationProof };
 
 //# sourceMappingURL=index.js.map

package/dist/{meta-DlON7DmF.d.ts → meta-Dpmn2Ywp.d.ts}

@@ -1,4 +1,4 @@
-import { o as WalletAdapterMeta, t as LoginMethod } from "./types-CHIgkzKb.js";
+import { o as WalletAdapterMeta, t as LoginMethod } from "./types-7xgrEnx7.js";
 //#region src/wallet/mock/meta.d.ts
 type MockLoginMethod = "wallet" | "google" | "apple" | "email";
 declare const DEFAULT_MOCK_METHODS: LoginMethod[];
@@ -16,4 +16,4 @@ declare const mockAdapterMeta: Omit<WalletAdapterMeta, "supportedMethods">;
 //#endregion
 export { resolveMockMethods as a, mockAdapterMeta as i, MockLoginMethod as n, PHRenownMockAdapterConfig as r, DEFAULT_MOCK_METHODS as t };
 export {};
-//# sourceMappingURL=meta-DlON7DmF.d.ts.map
+//# sourceMappingURL=meta-Dpmn2Ywp.d.ts.map

package/dist/{meta-DlON7DmF.d.ts.map → meta-Dpmn2Ywp.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"meta-DlON7DmF.d.ts","names":[],"sources":["../src/wallet/mock/meta.ts"],"mappings":";;KAEY;cAUC,sBAAsB;;UAOlB;;EAEf;;EAEA;;EAEA,UAAU;;iBAKI,mBAAmB,qBAAqB;cAe3C,iBAAiB,KAAK"}
+{"version":3,"file":"meta-Dpmn2Ywp.d.ts","names":[],"sources":["../src/wallet/mock/meta.ts"],"mappings":";;KAEY;cAUC,sBAAsB;;UAOlB;;EAEf;;EAEA;;EAEA,UAAU;;iBAKI,mBAAmB,qBAAqB;cAe3C,iBAAiB,KAAK"}

package/dist/{meta-CpBbgZnu.d.ts → meta-qadFdiX7.d.ts}

@@ -1,4 +1,4 @@
-import { o as WalletAdapterMeta, t as LoginMethod } from "./types-CHIgkzKb.js";
+import { o as WalletAdapterMeta, t as LoginMethod } from "./types-7xgrEnx7.js";
 //#region src/wallet/rainbow/meta.d.ts
 interface PHRenownChain {
   id: number;
@@ -16,4 +16,4 @@ declare const rainbowAdapterMeta: WalletAdapterMeta;
 //#endregion
 export { rainbowAdapterMeta as i, PHRenownRainbowAdapterConfig as n, RAINBOW_METHODS as r, PHRenownChain as t };
 export {};
-//# sourceMappingURL=meta-CpBbgZnu.d.ts.map
+//# sourceMappingURL=meta-qadFdiX7.d.ts.map

package/dist/{meta-CpBbgZnu.d.ts.map → meta-qadFdiX7.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"meta-CpBbgZnu.d.ts","names":[],"sources":["../src/wallet/rainbow/meta.ts"],"mappings":";;UAIiB;EACf;EACA;;UAKe;EAGf;EACA;EACA;EAGA,mBAAmB,kBAAkB;EAGrC;;cAGW,iBAAiB;cAIjB,oBAAoB"}
+{"version":3,"file":"meta-qadFdiX7.d.ts","names":[],"sources":["../src/wallet/rainbow/meta.ts"],"mappings":";;UAIiB;EACf;EACA;;UAKe;EAGf;EACA;EACA;EAGA,mBAAmB,kBAAkB;EAGrC;;cAGW,iBAAiB;cAIjB,oBAAoB"}

package/dist/node.d.ts

@@ -1,7 +1,7 @@
-import { A as LoginStatus, B as Service, C as InternalUser, Ct as DEFAULT_RENOWN_URL, D as JWTVerifyPolicies, Dt as RENOWN_SESSION_COOKIE, E as JWTVerified, Et as RENOWN_READ_MODEL_SUBGRAPH, F as RenownEventEmitter, G as User, H as SignInParams, I as RenownEvents, J as VerificationMethod, K as UserActionSigner, L as RenownProfile, M as PowerhouseVerifiableCredential, N as ProfileFetcher, O as JsonWebKey, Ot as VERIFIABLE_CREDENTIAL_EIP712_TYPE, P as Proof, Q as BaseStorage, R as RenownStorage, S as IVerifiableCredential, St as DEFAULT_RENOWN_NETWORK_ID, T as JWTPayload, Tt as ISSUER_TYPE, U as Signer, V as ServiceEndpoint, W as Unsubscribe, X as VerifiedJWT, Y as VerifiedCredential, Z as W3CCredential, _ as IPowerhouseCredentialSubject, _t as SwitchboardSource, a as JwkKeyPair, at as SignCredentialTypedData, b as IRenown, bt as CREDENTIAL_TYPES, c as ConditionWeightedThreshold, ct as buildAndSignCredential, d as DIDDocument, dt as verifyAuthCredential, et as IEventEmitter, f as DIDDocumentMetadata, ft as verifyCredentialSignature, g as IAuthCredentialSubject, gt as SwitchboardRequestFn, h as EcdsaSignature, ht as SwitchboardClient, i as JsonWebKeyPairStorage, it as FetchDelegationCredentialOptions, j as PKHDid, k as KeyCapabilitySection, l as CreateBearerTokenOptions, lt as fetchDelegationCredential, m as DIDResolutionResult, mt as MissingSwitchboardError, n as IConnectCrypto, nt as CredentialDomain, o as AuthVerifiableCredential, ot as VerifiedAuthCredential, p as DIDResolutionMetadata, pt as verifyDelegationProof, q as Verifiable, r as IRenownCrypto, rt as CredentialMessage, s as AuthVerifiedCredential, st as VerifyAuthCredentialOptions, t as DID, tt as BuildCredentialParams, u as CredentialStatus, ut as recoverCredentialSigner, v as IPowerhouseIssuerType, vt as CREDENTIAL_SCHEMA_EIP712_TYPE, w as Issuer, wt as DOMAIN_TYPE, x as ISigner, xt as DEFAULT_RENOWN_CHAIN_ID, y as IProof, yt as CREDENTIAL_SUBJECT_TYPE, z as RenownStorageMap } from "./types-DOTk0z2D.js";
-import { a as parseSignatureHashField, c as RenownCryptoBuilder, i as extractResultingHashFromSignature, l as ConnectCrypto, n as RenownCryptoSigner, o as signatureHasResultingHash, r as createSignatureVerifier, s as MemoryKeyStorage, u as RenownCrypto } from "./index-CGTiUojp.js";
-import { C as RenownMemoryStorage, S as Renown, _ as CredentialCheck, a as getResolver, b as BaseRenownBuilder, c as RenownSession, d as RenownSessionProfile, f as VerifyRenownSessionOptions, g as fetchRenownProfile, h as verifyRenownSession, i as createAuthBearerToken, l as RenownSessionClaims, m as serializeRenownSessionCookie, n as VerifyAuthBearerTokenOptions, o as parsePkhDid, p as readSessionClaims, r as assertIsAuthCredential, s as verifyAuthBearerToken, t as ILogger, u as RenownSessionCookie, v as LocalCredentialVerifierOptions, x as RenownBuilderOptions, y as createLocalCredentialVerifier } from "./utils-C_2VV8CS.js";
-import { a as ResolveSwitchboardEndpointOptions, i as createRenownTrustPolicy, n as RenownTrustPolicy, o as resolveSwitchboardEndpoint, r as RenownTrustPolicyOptions, t as RenownOwnSigner } from "./signer-trust-DstQutcf.js";
+import { A as LoginStatus, At as VERIFIABLE_CREDENTIAL_EIP712_TYPE, B as Service, C as InternalUser, Ct as DEFAULT_RENOWN_CHAIN_ID, D as JWTVerifyPolicies, Dt as ISSUER_TYPE, E as JWTVerified, Et as DOMAIN_TYPE, F as RenownEventEmitter, G as User, H as SignInParams, I as RenownEvents, J as VerificationMethod, K as UserActionSigner, L as RenownProfile, M as PowerhouseVerifiableCredential, N as ProfileFetcher, O as JsonWebKey, Ot as RENOWN_READ_MODEL_SUBGRAPH, P as Proof, Q as BaseStorage, R as RenownStorage, S as IVerifiableCredential, St as CREDENTIAL_TYPES, T as JWTPayload, Tt as DEFAULT_RENOWN_URL, U as Signer, V as ServiceEndpoint, W as Unsubscribe, X as VerifiedJWT, Y as VerifiedCredential, Z as W3CCredential, _ as IPowerhouseCredentialSubject, _t as SwitchboardRequestFn, a as JwkKeyPair, at as SignCredentialTypedData, b as IRenown, bt as CREDENTIAL_SCHEMA_EIP712_TYPE, c as ConditionWeightedThreshold, ct as buildAndSignCredential, d as DIDDocument, dt as verifyAuthCredential, et as IEventEmitter, f as DIDDocumentMetadata, ft as verifyCredentialSignature, g as IAuthCredentialSubject, gt as SwitchboardClient, h as EcdsaSignature, ht as RenownWriteAuth, i as JsonWebKeyPairStorage, it as FetchDelegationCredentialOptions, j as PKHDid, k as KeyCapabilitySection, kt as RENOWN_SESSION_COOKIE, l as CreateBearerTokenOptions, lt as fetchDelegationCredential, m as DIDResolutionResult, mt as MissingSwitchboardError, n as IConnectCrypto, nt as CredentialDomain, o as AuthVerifiableCredential, ot as VerifiedAuthCredential, p as DIDResolutionMetadata, pt as verifyDelegationProof, q as Verifiable, r as IRenownCrypto, rt as CredentialMessage, s as AuthVerifiedCredential, st as VerifyAuthCredentialOptions, t as DID, tt as BuildCredentialParams, u as CredentialStatus, ut as recoverCredentialSigner, v as IPowerhouseIssuerType, vt as SwitchboardRequestOptions, w as Issuer, wt as DEFAULT_RENOWN_NETWORK_ID, x as ISigner, xt as CREDENTIAL_SUBJECT_TYPE, y as IProof, yt as SwitchboardSource, z as RenownStorageMap } from "./types-Ceiz2dkk.js";
+import { a as parseSignatureHashField, c as RenownCryptoBuilder, i as extractResultingHashFromSignature, l as ConnectCrypto, n as RenownCryptoSigner, o as signatureHasResultingHash, r as createSignatureVerifier, s as MemoryKeyStorage, u as RenownCrypto } from "./index-DbiBjqs6.js";
+import { C as BaseRenownBuilder, E as RenownMemoryStorage, S as createLocalCredentialVerifier, T as Renown, _ as profileMessage, a as getResolver, b as CredentialCheck, c as RenownSession, d as RenownSessionProfile, f as VerifyRenownSessionOptions, g as SIGNATURE_WINDOW_MS, h as verifyRenownSession, i as createAuthBearerToken, l as RenownSessionClaims, m as serializeRenownSessionCookie, n as VerifyAuthBearerTokenOptions, o as parsePkhDid, p as readSessionClaims, r as assertIsAuthCredential, s as verifyAuthBearerToken, t as ILogger, u as RenownSessionCookie, v as revokeMessage, w as RenownBuilderOptions, x as LocalCredentialVerifierOptions, y as fetchRenownProfile } from "./utils-DkVxP7Ug.js";
+import { a as ResolveSwitchboardEndpointOptions, i as createRenownTrustPolicy, n as RenownTrustPolicy, o as resolveSwitchboardEndpoint, r as RenownTrustPolicyOptions, t as RenownOwnSigner } from "./signer-trust-FmbMTn39.js";
 import { UserActionSigner as UserActionSigner$1 } from "@powerhousedao/shared/document-model";
 //#region src/crypto/node-key-storage.d.ts
 export declare const RENOWN_PRIVATE_KEY_ENV = "PH_RENOWN_PRIVATE_KEY";
@@ -149,6 +149,6 @@ export declare function parseExpiry(expiry: string): number;
  */
 export declare function formatExpiry(expiresIn: number): string;
 //#endregion
-export { AuthVerifiableCredential, AuthVerifiedCredential, BaseRenownBuilder, BuildCredentialParams, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ConditionWeightedThreshold, ConnectCrypto, CreateBearerTokenOptions, CredentialCheck, CredentialDomain, CredentialMessage, CredentialStatus, DEFAULT_RENOWN_CHAIN_ID, DEFAULT_RENOWN_NETWORK_ID, DEFAULT_RENOWN_URL, type DID, DIDDocument, DIDDocumentMetadata, DIDResolutionMetadata, DIDResolutionResult, DOMAIN_TYPE, EcdsaSignature, FetchDelegationCredentialOptions, IAuthCredentialSubject, type IConnectCrypto, ILogger, IPowerhouseCredentialSubject, IPowerhouseIssuerType, IProof, IRenown, type IRenownCrypto, ISSUER_TYPE, type ISigner, IVerifiableCredential, InternalUser, Issuer, JWTPayload, JWTVerified, JWTVerifyPolicies, JsonWebKey, type JsonWebKeyPairStorage, type JwkKeyPair, KeyCapabilitySection, LocalCredentialVerifierOptions, LoginStatus, MemoryKeyStorage, MissingSwitchboardError, type NodeRenownSignerArgs, PKHDid, PowerhouseVerifiableCredential, ProfileFetcher, Proof, RENOWN_READ_MODEL_SUBGRAPH, RENOWN_SESSION_COOKIE, Renown, RenownBuilderOptions, RenownCrypto, RenownCryptoBuilder, RenownCryptoSigner, RenownEventEmitter, RenownEvents, RenownMemoryStorage, RenownOwnSigner, RenownProfile, RenownSession, RenownSessionClaims, RenownSessionCookie, RenownSessionProfile, RenownStorage, RenownStorageMap, RenownTrustPolicy, RenownTrustPolicyOptions, ResolveSwitchboardEndpointOptions, Service, ServiceEndpoint, SignCredentialTypedData, SignInParams, Signer, SwitchboardClient, SwitchboardRequestFn, SwitchboardSource, Unsubscribe, User, type UserActionSigner, VERIFIABLE_CREDENTIAL_EIP712_TYPE, Verifiable, VerificationMethod, VerifiedAuthCredential, VerifiedCredential, VerifiedJWT, VerifyAuthBearerTokenOptions, VerifyAuthCredentialOptions, VerifyRenownSessionOptions, W3CCredential, assertIsAuthCredential, buildAndSignCredential, createAuthBearerToken, createLocalCredentialVerifier, createRenownTrustPolicy, createSignatureVerifier, extractResultingHashFromSignature, fetchDelegationCredential, fetchRenownProfile, getResolver, parsePkhDid, parseSignatureHashField, readSessionClaims, recoverCredentialSigner, resolveSwitchboardEndpoint, serializeRenownSessionCookie, signatureHasResultingHash, verifyAuthBearerToken, verifyAuthCredential, verifyCredentialSignature, verifyDelegationProof, verifyRenownSession };
+export { AuthVerifiableCredential, AuthVerifiedCredential, BaseRenownBuilder, BuildCredentialParams, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ConditionWeightedThreshold, ConnectCrypto, CreateBearerTokenOptions, CredentialCheck, CredentialDomain, CredentialMessage, CredentialStatus, DEFAULT_RENOWN_CHAIN_ID, DEFAULT_RENOWN_NETWORK_ID, DEFAULT_RENOWN_URL, type DID, DIDDocument, DIDDocumentMetadata, DIDResolutionMetadata, DIDResolutionResult, DOMAIN_TYPE, EcdsaSignature, FetchDelegationCredentialOptions, IAuthCredentialSubject, type IConnectCrypto, ILogger, IPowerhouseCredentialSubject, IPowerhouseIssuerType, IProof, IRenown, type IRenownCrypto, ISSUER_TYPE, type ISigner, IVerifiableCredential, InternalUser, Issuer, JWTPayload, JWTVerified, JWTVerifyPolicies, JsonWebKey, type JsonWebKeyPairStorage, type JwkKeyPair, KeyCapabilitySection, LocalCredentialVerifierOptions, LoginStatus, MemoryKeyStorage, MissingSwitchboardError, type NodeRenownSignerArgs, PKHDid, PowerhouseVerifiableCredential, ProfileFetcher, Proof, RENOWN_READ_MODEL_SUBGRAPH, RENOWN_SESSION_COOKIE, Renown, RenownBuilderOptions, RenownCrypto, RenownCryptoBuilder, RenownCryptoSigner, RenownEventEmitter, RenownEvents, RenownMemoryStorage, RenownOwnSigner, RenownProfile, RenownSession, RenownSessionClaims, RenownSessionCookie, RenownSessionProfile, RenownStorage, RenownStorageMap, RenownTrustPolicy, RenownTrustPolicyOptions, RenownWriteAuth, ResolveSwitchboardEndpointOptions, SIGNATURE_WINDOW_MS, Service, ServiceEndpoint, SignCredentialTypedData, SignInParams, Signer, SwitchboardClient, SwitchboardRequestFn, SwitchboardRequestOptions, SwitchboardSource, Unsubscribe, User, type UserActionSigner, VERIFIABLE_CREDENTIAL_EIP712_TYPE, Verifiable, VerificationMethod, VerifiedAuthCredential, VerifiedCredential, VerifiedJWT, VerifyAuthBearerTokenOptions, VerifyAuthCredentialOptions, VerifyRenownSessionOptions, W3CCredential, assertIsAuthCredential, buildAndSignCredential, createAuthBearerToken, createLocalCredentialVerifier, createRenownTrustPolicy, createSignatureVerifier, extractResultingHashFromSignature, fetchDelegationCredential, fetchRenownProfile, getResolver, parsePkhDid, parseSignatureHashField, profileMessage, readSessionClaims, recoverCredentialSigner, resolveSwitchboardEndpoint, revokeMessage, serializeRenownSessionCookie, signatureHasResultingHash, verifyAuthBearerToken, verifyAuthCredential, verifyCredentialSignature, verifyDelegationProof, verifyRenownSession };
 export {};
 //# sourceMappingURL=node.d.ts.map

package/dist/node.js

@@ -1,8 +1,8 @@
 import { a as DEFAULT_RENOWN_NETWORK_ID, c as ISSUER_TYPE, d as VERIFIABLE_CREDENTIAL_EIP712_TYPE, i as DEFAULT_RENOWN_CHAIN_ID, l as RENOWN_READ_MODEL_SUBGRAPH, n as CREDENTIAL_SUBJECT_TYPE, o as DEFAULT_RENOWN_URL, r as CREDENTIAL_TYPES, s as DOMAIN_TYPE, t as CREDENTIAL_SCHEMA_EIP712_TYPE, u as RENOWN_SESSION_COOKIE } from "./constants-DVOF17NB.js";
-import { a as verifyAuthCredential, c as MissingSwitchboardError, i as recoverCredentialSigner, l as SwitchboardClient, n as buildAndSignCredential, o as verifyCredentialSignature, r as fetchDelegationCredential, s as verifyDelegationProof, t as createRenownTrustPolicy, u as resolveSwitchboardEndpoint } from "./signer-trust-C6UJAsNJ.js";
+import { a as verifyAuthCredential, c as MissingSwitchboardError, i as recoverCredentialSigner, l as SwitchboardClient, n as buildAndSignCredential, o as verifyCredentialSignature, r as fetchDelegationCredential, s as verifyDelegationProof, t as createRenownTrustPolicy, u as resolveSwitchboardEndpoint } from "./signer-trust-H1rNzUcd.js";
 import { a as verifyAuthBearerToken, i as parsePkhDid, n as createAuthBearerToken, r as getResolver, t as assertIsAuthCredential } from "./utils-DLQ5VVqT.js";
 import { a as signatureHasResultingHash, c as ConnectCrypto, i as parseSignatureHashField, l as RenownCrypto, n as createSignatureVerifier, o as MemoryKeyStorage, r as extractResultingHashFromSignature, s as RenownCryptoBuilder, t as RenownCryptoSigner } from "./signer-GzTlZLjR.js";
-import { a as RenownMemoryStorage, i as Renown, n as BaseRenownBuilder, o as BaseStorage, r as fetchRenownProfile, t as createLocalCredentialVerifier } from "./local-credential-verifier-BC4HS01T.js";
+import { a as BaseRenownBuilder, c as RenownMemoryStorage, i as createLocalCredentialVerifier, l as BaseStorage, n as profileMessage, o as fetchRenownProfile, r as revokeMessage, s as Renown, t as SIGNATURE_WINDOW_MS } from "./signed-message-Cp5oRPLN.js";
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { EventEmitter } from "node:events";
@@ -409,6 +409,6 @@ async function verifyRenownSession(value, options = {}) {
 	return session;
 }
 //#endregion
-export { BaseRenownBuilder, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ConnectCrypto, DEFAULT_KEYPAIR_PATH, DEFAULT_RENOWN_CHAIN_ID, DEFAULT_RENOWN_NETWORK_ID, DEFAULT_RENOWN_STORAGE_PATH, DEFAULT_RENOWN_URL, DOMAIN_TYPE, ISSUER_TYPE, MemoryKeyStorage, MissingSwitchboardError, NodeEventEmitter, NodeKeyStorage, NodeRenownEventEmitter, NodeRenownStorage, NodeStorage, RENOWN_PRIVATE_KEY_ENV, RENOWN_READ_MODEL_SUBGRAPH, RENOWN_SESSION_COOKIE, Renown, RenownBuilder, RenownCrypto, RenownCryptoBuilder, RenownCryptoSigner, RenownMemoryStorage, SwitchboardClient, VERIFIABLE_CREDENTIAL_EIP712_TYPE, assertIsAuthCredential, browserLogin, buildAndSignCredential, createAuthBearerToken, createLocalCredentialVerifier, createNodeRenownSigner, createRenownTrustPolicy, createSignatureVerifier, extractResultingHashFromSignature, fetchDelegationCredential, fetchRenownProfile, formatExpiry, generateAccessToken, getAuthStatus, getResolver, openBrowser, parseExpiry, parsePkhDid, parseSignatureHashField, readSessionClaims, recoverCredentialSigner, resolveSwitchboardEndpoint, serializeRenownSessionCookie, signatureHasResultingHash, verifyAuthBearerToken, verifyAuthCredential, verifyCredentialSignature, verifyDelegationProof, verifyRenownSession };
+export { BaseRenownBuilder, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ConnectCrypto, DEFAULT_KEYPAIR_PATH, DEFAULT_RENOWN_CHAIN_ID, DEFAULT_RENOWN_NETWORK_ID, DEFAULT_RENOWN_STORAGE_PATH, DEFAULT_RENOWN_URL, DOMAIN_TYPE, ISSUER_TYPE, MemoryKeyStorage, MissingSwitchboardError, NodeEventEmitter, NodeKeyStorage, NodeRenownEventEmitter, NodeRenownStorage, NodeStorage, RENOWN_PRIVATE_KEY_ENV, RENOWN_READ_MODEL_SUBGRAPH, RENOWN_SESSION_COOKIE, Renown, RenownBuilder, RenownCrypto, RenownCryptoBuilder, RenownCryptoSigner, RenownMemoryStorage, SIGNATURE_WINDOW_MS, SwitchboardClient, VERIFIABLE_CREDENTIAL_EIP712_TYPE, assertIsAuthCredential, browserLogin, buildAndSignCredential, createAuthBearerToken, createLocalCredentialVerifier, createNodeRenownSigner, createRenownTrustPolicy, createSignatureVerifier, extractResultingHashFromSignature, fetchDelegationCredential, fetchRenownProfile, formatExpiry, generateAccessToken, getAuthStatus, getResolver, openBrowser, parseExpiry, parsePkhDid, parseSignatureHashField, profileMessage, readSessionClaims, recoverCredentialSigner, resolveSwitchboardEndpoint, revokeMessage, serializeRenownSessionCookie, signatureHasResultingHash, verifyAuthBearerToken, verifyAuthCredential, verifyCredentialSignature, verifyDelegationProof, verifyRenownSession };
 
 //# sourceMappingURL=node.js.map

package/dist/{local-credential-verifier-BC4HS01T.js → signed-message-Cp5oRPLN.js}

@@ -1,5 +1,5 @@
 import { a as DEFAULT_RENOWN_NETWORK_ID, o as DEFAULT_RENOWN_URL, r as CREDENTIAL_TYPES } from "./constants-DVOF17NB.js";
-import { c as MissingSwitchboardError, l as SwitchboardClient, n as buildAndSignCredential, o as verifyCredentialSignature, r as fetchDelegationCredential, u as resolveSwitchboardEndpoint } from "./signer-trust-C6UJAsNJ.js";
+import { c as MissingSwitchboardError, l as SwitchboardClient, n as buildAndSignCredential, o as verifyCredentialSignature, r as fetchDelegationCredential, u as resolveSwitchboardEndpoint } from "./signer-trust-H1rNzUcd.js";
 import { a as verifyAuthBearerToken, i as parsePkhDid } from "./utils-DLQ5VVqT.js";
 import { s as RenownCryptoBuilder, t as RenownCryptoSigner } from "./signer-GzTlZLjR.js";
 //#region src/storage/common.ts
@@ -139,18 +139,31 @@ var Renown = class {
 				expiresInDays
 			});
 			await this.#switchboard.issueCredential(credential);
-			await this.#switchboard.findOrCreateUser(address, {
+			const userDid = `did:pkh:${DEFAULT_RENOWN_NETWORK_ID}:${chainId}:${address.toLowerCase()}`;
+			const user = await this.#completeLogin(userDid, parsePkhDid(userDid), credential);
+			if (username !== void 0 || userImage !== void 0) this.#writeProfile(address, {
 				username,
 				userImage
-			});
-			const userDid = `did:pkh:${DEFAULT_RENOWN_NETWORK_ID}:${chainId}:${address.toLowerCase()}`;
-			return await this.#completeLogin(userDid, parsePkhDid(userDid), credential);
+			}).catch(() => void 0);
+			return user;
 		} catch (error) {
 			this.#updateUser(void 0);
 			this.#updateStatus("not-authorized");
 			throw error;
 		}
 	}
+	async #writeProfile(address, profile) {
+		if (!this.#switchboard) return;
+		const token = await this.#crypto.getBearerToken(address);
+		const attempts = 5;
+		for (let attempt = 1; attempt <= attempts; attempt++) try {
+			await this.#switchboard.upsertUserProfile(address, profile, { token });
+			return;
+		} catch (error) {
+			if (attempt === attempts) throw error;
+			await new Promise((resolve) => setTimeout(resolve, 600));
+		}
+	}
 	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 : {
@@ -424,6 +437,32 @@ function createLocalCredentialVerifier(execute, options = {}) {
 	};
 }
 //#endregion
-export { RenownMemoryStorage as a, Renown as i, BaseRenownBuilder as n, BaseStorage as o, fetchRenownProfile as r, createLocalCredentialVerifier as t };
+//#region src/signed-message.ts
+const SIGNATURE_WINDOW_MS = 6e5;
+function toHex(bytes) {
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sha256hex(input) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
+	return toHex(new Uint8Array(digest));
+}
+/** Canonical message a caller signs to authorize revoking `credentialId`. */
+function revokeMessage(credentialId, timestamp) {
+	return `Revoke Renown credential ${credentialId} at ${timestamp}`;
+}
+/**
+* Canonical message a caller signs to authorize a profile upsert. The payload
+* is hashed (rather than embedded raw) so the signed message has a fixed
+* shape regardless of field content.
+*/
+async function profileMessage(address, profile, timestamp) {
+	const hash = await sha256hex(JSON.stringify({
+		username: profile.username ?? null,
+		userImage: profile.userImage ?? null
+	}));
+	return `Update Renown profile ${address.toLowerCase()} ${hash} at ${timestamp}`;
+}
+//#endregion
+export { BaseRenownBuilder as a, RenownMemoryStorage as c, createLocalCredentialVerifier as i, BaseStorage as l, profileMessage as n, fetchRenownProfile as o, revokeMessage as r, Renown as s, SIGNATURE_WINDOW_MS as t };
 
-//# sourceMappingURL=local-credential-verifier-BC4HS01T.js.map
+//# sourceMappingURL=signed-message-Cp5oRPLN.js.map

package/dist/signed-message-Cp5oRPLN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signed-message-Cp5oRPLN.js","names":[],"sources":["../src/storage/common.ts","../src/common.ts","../src/event/memory.ts","../src/profile.ts","../src/renown-builder.ts","../src/local-credential-verifier.ts","../src/signed-message.ts"],"sourcesContent":["export interface IStorage<\n  T extends Record<string, unknown> = Record<string, unknown>,\n  Key extends keyof T = keyof T,\n> {\n  get(key: Key): T[Key] | undefined;\n  set(key: Key, value?: T[Key]): void;\n  delete(key: Key): void;\n}\n\nexport abstract class BaseStorage<\n  T extends Record<string, unknown> = Record<string, unknown>,\n  Key extends keyof T = keyof T,\n> implements IStorage<T> {\n  abstract get(key: Key): T[Key] | undefined;\n  abstract set(key: Key, value?: T[Key]): void;\n  abstract delete(key: Key): void;\n}\n\nexport class MemoryStorage<\n  T extends Record<string, unknown> = Record<string, unknown>,\n  Key extends keyof T = keyof T,\n> extends BaseStorage<T> {\n  private readonly data = new Map<Key, T[Key]>();\n\n  get(key: Key) {\n    return this.data.get(key);\n  }\n\n  set(key: Key, value?: T[Key]): void {\n    if (value === undefined) {\n      this.data.delete(key);\n    } else {\n      this.data.set(key, value);\n    }\n  }\n\n  delete(key: Key): void {\n    this.data.delete(key);\n  }\n}\n","import {\n  CREDENTIAL_TYPES,\n  DEFAULT_RENOWN_CHAIN_ID,\n  DEFAULT_RENOWN_NETWORK_ID,\n  DEFAULT_RENOWN_URL,\n} from \"./constants.js\";\nimport {\n  buildAndSignCredential,\n  verifyCredentialSignature,\n} from \"./credential.js\";\nimport { RenownCryptoSigner, type IRenownCrypto } from \"./crypto/index.js\";\nimport { MemoryStorage } from \"./storage/common.js\";\nimport {\n  MissingSwitchboardError,\n  type SwitchboardClient,\n} from \"./switchboard.js\";\nimport type {\n  CreateBearerTokenOptions,\n  IProof,\n  IRenown,\n  ISigner,\n  LoginStatus,\n  PKHDid,\n  PowerhouseVerifiableCredential,\n  ProfileFetcher,\n  RenownEventEmitter,\n  RenownEvents,\n  RenownStorage,\n  RenownStorageMap,\n  SignInParams,\n  User,\n  UserActionSigner,\n} from \"./types.js\";\nimport { parsePkhDid, verifyAuthBearerToken } from \"./utils.js\";\nexport * from \"./constants.js\";\n\nexport class RenownMemoryStorage extends MemoryStorage<RenownStorageMap> {}\n\n/**\n * The acting identity an action's signature carries.\n *\n * `User` here is the whole session record — it also holds the DID, the\n * credential, the fetched profile and ENS info — while `UserActionSigner` is\n * what travels on a signed action, and it is deliberately just an address on a\n * chain. The reactor's `ReactorSignerUserInput` declares exactly these three\n * fields, and a GraphQL input object refuses a field it does not declare by\n * rejecting the WHOLE request, so handing the session record to the signer\n * makes every signed push fail before it reaches the reactor.\n *\n * Narrowed here rather than at the transport, because the session record has no\n * business being on an operation in the first place: it is stored on every\n * operation a local reactor writes, not only on the ones that go over a wire.\n *\n * The compiler cannot catch the difference — excess-property checks apply to\n * fresh object literals, never to a variable of a wider type — which is why\n * this is a function rather than a type annotation.\n */\nfunction toActionSigner(user: User | undefined): UserActionSigner | undefined {\n  if (!user) return undefined;\n  return {\n    address: user.address,\n    networkId: user.networkId,\n    chainId: user.chainId,\n  };\n}\n\nexport class Renown implements IRenown {\n  #baseUrl: string;\n  #store: RenownStorage;\n  #eventEmitter: RenownEventEmitter;\n  #appName: string;\n  #crypto: IRenownCrypto;\n  #signer: ISigner;\n  #profileFetcher?: ProfileFetcher;\n  #switchboard?: SwitchboardClient;\n  #chainId: number;\n  #status: LoginStatus = \"initial\";\n\n  constructor(\n    store: RenownStorage,\n    eventEmitter: RenownEventEmitter,\n    crypto: IRenownCrypto,\n    appName: string,\n    baseUrl = DEFAULT_RENOWN_URL,\n    profileFetcher?: ProfileFetcher,\n    switchboard?: SwitchboardClient,\n    chainId = Number(DEFAULT_RENOWN_CHAIN_ID),\n  ) {\n    this.#store = store;\n    this.#eventEmitter = eventEmitter;\n    this.#baseUrl = baseUrl;\n    this.#crypto = crypto;\n    this.#appName = appName;\n    this.#profileFetcher = profileFetcher;\n    this.#switchboard = switchboard;\n    this.#chainId = chainId;\n    const restoredUser = this.user;\n    this.#signer = new RenownCryptoSigner(\n      crypto,\n      this.#appName,\n      toActionSigner(restoredUser),\n    );\n\n    // A restored, previously-verified user is an authorized session; otherwise\n    // status stays \"initial\" after a reload while the user is present.\n    if (restoredUser) {\n      this.#status = \"authorized\";\n    }\n\n    this.on(\"user\", (user) => {\n      this.#signer.user = toActionSigner(user);\n    });\n  }\n\n  get baseUrl() {\n    return this.#baseUrl;\n  }\n\n  /** Chain id this app issues credentials on; a session from another chain is rejected by {@link signIn}. */\n  get chainId() {\n    return this.#chainId;\n  }\n\n  get user() {\n    return this.#store.get(\"user\");\n  }\n\n  get status() {\n    return this.#status;\n  }\n\n  get signer() {\n    return this.#signer;\n  }\n\n  get crypto() {\n    return this.#crypto;\n  }\n\n  get did() {\n    return this.#crypto.did;\n  }\n\n  get profileFetcher() {\n    return this.#profileFetcher;\n  }\n\n  #updateStatus(status: LoginStatus) {\n    this.#status = status;\n    this.#eventEmitter.emit(\"status\", status);\n  }\n\n  #updateUser(user: User | undefined) {\n    if (user) {\n      this.#store.set(\"user\", user);\n    } else {\n      this.#store.delete(\"user\");\n    }\n    this.#eventEmitter.emit(\"user\", user);\n  }\n\n  async login(userDid: string): Promise<User> {\n    this.#updateStatus(\"checking\");\n    try {\n      const result = parsePkhDid(userDid);\n      const credential = await this.#getCredential(\n        result.address,\n        result.chainId,\n        this.#crypto.did,\n      );\n\n      if (!credential) {\n        this.#updateUser(undefined);\n        throw new Error(\"Credential not found\");\n      }\n\n      return await this.#completeLogin(userDid, result, credential);\n    } catch (error) {\n      this.#updateUser(undefined);\n      this.#updateStatus(\"not-authorized\");\n      throw error;\n    }\n  }\n\n  // Sign in without the Renown redirect: build + sign a delegation credential\n  // with the caller's wallet signer, write it to the switchboard, then log in.\n  async signIn(params: SignInParams): Promise<User> {\n    if (!this.#switchboard) throw new MissingSwitchboardError();\n    const {\n      address,\n      chainId,\n      signTypedData,\n      username,\n      userImage,\n      expiresInDays,\n    } = params;\n\n    // The chain id goes into the issuer DID and the EIP-712 domain, so signing on\n    // another chain would mint a second identity for the same wallet.\n    if (chainId !== this.#chainId) {\n      throw new Error(\n        `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.`,\n      );\n    }\n\n    this.#updateStatus(\"checking\");\n    try {\n      const credential = await buildAndSignCredential({\n        signTypedData,\n        address,\n        chainId,\n        app: this.#appName,\n        appId: this.did,\n        expiresInDays,\n      });\n\n      await this.#switchboard.issueCredential(credential);\n\n      const userDid = `did:pkh:${DEFAULT_RENOWN_NETWORK_ID}:${chainId}:${address.toLowerCase()}`;\n      // Authenticate from the freshly signed credential — no read-back, which\n      // avoids racing the read-model processor that indexes the write.\n      const user = await this.#completeLogin(\n        userDid,\n        parsePkhDid(userDid),\n        credential,\n      );\n\n      // Best-effort profile write in the background: sign-in resolves without\n      // waiting for it (it may retry for a few seconds) and never fails on it.\n      if (username !== undefined || userImage !== undefined) {\n        void this.#writeProfile(address, { username, userImage }).catch(\n          () => undefined,\n        );\n      }\n\n      return user;\n    } catch (error) {\n      this.#updateUser(undefined);\n      this.#updateStatus(\"not-authorized\");\n      throw error;\n    }\n  }\n\n  // Write the profile via an authenticated request, retrying while the reactor's\n  // read model catches up to the just-issued credential (needed to authenticate).\n  async #writeProfile(\n    address: string,\n    profile: { username?: string; userImage?: string },\n  ): Promise<void> {\n    if (!this.#switchboard) return;\n    const token = await this.#crypto.getBearerToken(address);\n    const attempts = 5;\n    for (let attempt = 1; attempt <= attempts; attempt++) {\n      try {\n        await this.#switchboard.upsertUserProfile(address, profile, { token });\n        return;\n      } catch (error) {\n        if (attempt === attempts) throw error;\n        await new Promise((resolve) => setTimeout(resolve, 600));\n      }\n    }\n  }\n\n  // Verify a credential binds to userDid + this app key, set the user, and\n  // start the background profile fetch. Throws if the credential is invalid.\n  async #completeLogin(\n    userDid: string,\n    result: PKHDid,\n    credential: PowerhouseVerifiableCredential,\n  ): Promise<User> {\n    if (\n      !(\n        credential.issuer.id === userDid &&\n        credential.credentialSubject.id === this.did\n      )\n    ) {\n      throw new Error(\"Invalid credential\");\n    }\n\n    // The API may return proof.eip712 without domain/types; the domain is\n    // canonical (version \"1\", the chainId), so reconstruct it before verifying.\n    const eip712 = credential.proof.eip712 as\n      | Partial<IProof[\"eip712\"]>\n      | undefined;\n    const verifiableCredential: PowerhouseVerifiableCredential = eip712?.domain\n      ? credential\n      : {\n          ...credential,\n          proof: {\n            ...credential.proof,\n            eip712: {\n              domain: { version: \"1\", chainId: result.chainId },\n              types: CREDENTIAL_TYPES,\n              primaryType: \"VerifiableCredential\",\n            },\n          },\n        };\n\n    // Verify the EIP-712 proof was signed by the DID's address on its chain.\n    if (\n      credential.issuer.ethereumAddress.toLowerCase() !==\n        result.address.toLowerCase() ||\n      verifiableCredential.proof.eip712.domain.chainId !== result.chainId ||\n      !(await verifyCredentialSignature(verifiableCredential))\n    ) {\n      throw new Error(\"Invalid credential signature\");\n    }\n\n    const user: User = {\n      ...result,\n      address: credential.issuer.ethereumAddress,\n      did: userDid,\n      credential: verifiableCredential,\n    };\n\n    this.#updateUser(user);\n    this.#updateStatus(\"authorized\");\n\n    // Fetch profile data in the background if a fetcher is configured\n    if (this.#profileFetcher) {\n      this.#profileFetcher(user, this.#baseUrl)\n        .then((profile) => {\n          if (\n            profile &&\n            this.user?.address === user.address &&\n            this.user.chainId === user.chainId\n          ) {\n            this.#updateUser({\n              ...this.user,\n              profile,\n              ens: {\n                name: profile.username ?? undefined,\n                avatarUrl: profile.userImage ?? undefined,\n              },\n            });\n          }\n        })\n        .catch(console.error);\n    }\n\n    return user;\n  }\n\n  logout() {\n    this.#updateUser(undefined);\n    this.#updateStatus(\"initial\");\n    return Promise.resolve();\n  }\n\n  // Re-check the current user's credential at the source; logs out if it was\n  // revoked or expired. Network errors keep the session (fail open).\n  async revalidate(): Promise<boolean> {\n    const user = this.user;\n    if (!user) return false;\n    try {\n      const credential = await this.#getCredential(\n        user.address,\n        user.chainId,\n        this.#crypto.did,\n      );\n      if (!credential) {\n        await this.logout();\n        return false;\n      }\n      await this.refreshProfile();\n      return true;\n    } catch {\n      return true;\n    }\n  }\n\n  // Re-read profile attributes at the source so a renamed user or changed avatar\n  // shows up on the next load. Carries no logout risk, unlike revalidate().\n  async refreshProfile(): Promise<boolean> {\n    const user = this.user;\n    if (!user || !this.#profileFetcher) return false;\n    try {\n      const profile = await this.#profileFetcher(user, this.#baseUrl);\n      if (!profile) return false;\n      // Asserted because narrowing from the pre-await read would otherwise hide\n      // that a logout during the fetch can clear this.\n      const current = this.user as User | undefined;\n      if (\n        !current ||\n        current.address !== user.address ||\n        current.chainId !== user.chainId\n      ) {\n        return false;\n      }\n      // Narrow `profile` first: the fetched payload is unvalidated JSON, so a\n      // missing documentId must not make the undefined case compare equal.\n      const unchanged =\n        current.profile !== undefined &&\n        current.profile.documentId === profile.documentId &&\n        current.profile.username === profile.username &&\n        current.profile.userImage === profile.userImage;\n      if (unchanged) return false;\n      this.#updateUser({\n        ...current,\n        profile,\n        ens: {\n          name: profile.username ?? undefined,\n          avatarUrl: profile.userImage ?? undefined,\n        },\n      });\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  on<K extends keyof RenownEvents>(\n    event: K,\n    listener: (data: RenownEvents[K]) => void,\n  ): () => void {\n    return this.#eventEmitter.on(event, listener);\n  }\n\n  async #getCredential(\n    address: string,\n    chainId: number,\n    appDid: string,\n  ): Promise<PowerhouseVerifiableCredential | undefined> {\n    // Direct-switchboard flow: read the credential from the reactor subgraph.\n    if (this.#switchboard) {\n      return this.#switchboard.getCredential({ address, chainId, appDid });\n    }\n    if (!this.#baseUrl) {\n      throw new Error(\"RENOWN_URL is not set\");\n    }\n    const url = new URL(\n      `/api/auth/credential?address=${encodeURIComponent(address)}&chainId=${encodeURIComponent(chainId)}&connectId=${encodeURIComponent(appDid)}&appId=${encodeURIComponent(appDid)}`,\n      this.#baseUrl,\n    );\n    const response = await fetch(url, {\n      method: \"GET\",\n    });\n    if (response.ok) {\n      const result = (await response.json()) as {\n        credential: PowerhouseVerifiableCredential;\n      };\n      return result.credential;\n    } else {\n      throw new Error(`Failed to get credential: ${response.status}`);\n    }\n  }\n\n  async verifyBearerToken(token: string) {\n    return verifyAuthBearerToken(token);\n  }\n\n  async getBearerToken(options: CreateBearerTokenOptions) {\n    if (!this.user) {\n      throw new Error(\"User not found\");\n    }\n    return this.#crypto.getBearerToken(this.user.address, options);\n  }\n}\n","import type { RenownEvents } from \"../types.js\";\nimport type { IEventEmitter } from \"./types.js\";\n\nexport class MemoryEventEmitter implements IEventEmitter<RenownEvents> {\n  #listeners = new Map<keyof RenownEvents, Set<(data: unknown) => void>>();\n\n  on<K extends keyof RenownEvents>(\n    event: K,\n    listener: (data: RenownEvents[K]) => void,\n  ): () => void {\n    if (!this.#listeners.has(event)) {\n      this.#listeners.set(event, new Set());\n    }\n    this.#listeners.get(event)!.add(listener as (data: unknown) => void);\n    return () => {\n      this.#listeners.get(event)?.delete(listener as (data: unknown) => void);\n    };\n  }\n\n  emit<K extends keyof RenownEvents>(event: K, data: RenownEvents[K]): void {\n    this.#listeners.get(event)?.forEach((listener) => listener(data));\n  }\n}\n","import type { ProfileFetcher, RenownProfile } from \"./types.js\";\n\nexport const fetchRenownProfile: ProfileFetcher = async (user, baseUrl) => {\n  try {\n    const response = await fetch(`${baseUrl.replace(/\\/+$/, \"\")}/api/profile`, {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n      },\n      body: JSON.stringify({\n        ethAddress: user.address,\n      }),\n    });\n\n    if (!response.ok) {\n      return undefined;\n    }\n\n    const result = (await response.json()) as {\n      profile?: RenownProfile;\n    };\n\n    return result.profile ?? undefined;\n  } catch {\n    return undefined;\n  }\n};\n","import { Renown, RenownMemoryStorage } from \"./common.js\";\nimport { DEFAULT_RENOWN_CHAIN_ID, DEFAULT_RENOWN_URL } from \"./constants.js\";\nimport { RenownCryptoBuilder } from \"./crypto/renown-crypto-builder.js\";\nimport type { IRenownCrypto, JsonWebKeyPairStorage } from \"./crypto/types.js\";\nimport { resolveSwitchboardEndpoint } from \"./discovery.js\";\nimport { MemoryEventEmitter } from \"./event/memory.js\";\nimport { fetchRenownProfile } from \"./profile.js\";\nimport { SwitchboardClient } from \"./switchboard.js\";\nimport type {\n  ProfileFetcher,\n  RenownEventEmitter,\n  RenownStorage,\n} from \"./types.js\";\n\nexport interface RenownBuilderOptions {\n  appName: string;\n  storage?: RenownStorage;\n  eventEmitter?: RenownEventEmitter;\n  crypto?: IRenownCrypto;\n  keyPairStorage?: JsonWebKeyPairStorage;\n  baseUrl?: string;\n  switchboardUrl?: string;\n  profileFetcher?: ProfileFetcher;\n  /** Chain id credentials are issued on (default 1). The issuer DID embeds it, so `signIn` rejects a wallet session from another chain. */\n  chainId?: number;\n}\n\n/**\n * Base builder for creating Renown instances.\n * Use platform-specific builders (RenownBuilder from init.browser.js or init.node.js)\n * for pre-configured defaults.\n */\nexport class BaseRenownBuilder {\n  #appName: string;\n  #storage?: RenownStorage;\n  #eventEmitter?: RenownEventEmitter;\n  #crypto?: IRenownCrypto;\n  #keyPairStorage?: JsonWebKeyPairStorage;\n  #baseUrl?: string;\n  #switchboardUrl?: string;\n  #profileFetcher?: ProfileFetcher;\n  #chainId?: number;\n\n  /**\n   * @param appName - Application name used for signing context\n   */\n  constructor(appName: string) {\n    this.#appName = appName;\n  }\n\n  /**\n   * Set custom storage for user data persistence.\n   * Defaults to in-memory storage if not set.\n   */\n  withStorage(storage: RenownStorage): this {\n    this.#storage = storage;\n    return this;\n  }\n\n  /**\n   * Set custom event emitter for user state changes.\n   * Defaults to in-memory event emitter if not set.\n   */\n  withEventEmitter(eventEmitter: RenownEventEmitter): this {\n    this.#eventEmitter = eventEmitter;\n    return this;\n  }\n\n  /**\n   * Set a pre-built crypto instance.\n   * Either crypto or keyPairStorage must be provided.\n   */\n  withCrypto(crypto: IRenownCrypto): this {\n    this.#crypto = crypto;\n    return this;\n  }\n\n  /**\n   * Set key pair storage for cryptographic keys.\n   * A crypto instance will be built from this storage.\n   * Either crypto or keyPairStorage must be provided.\n   */\n  withKeyPairStorage(keyPairStorage: JsonWebKeyPairStorage): this {\n    this.#keyPairStorage = keyPairStorage;\n    return this;\n  }\n\n  /**\n   * Set the Renown server URL for credential verification.\n   * Defaults to https://www.renown.id\n   */\n  withBaseUrl(baseUrl: string): this {\n    this.#baseUrl = baseUrl;\n    return this;\n  }\n\n  // Set the Switchboard GraphQL endpoint to read from the reactor directly.\n  // When unset, the SDK discovers it from the base URL, else uses the REST flow.\n  withSwitchboardUrl(switchboardUrl: string): this {\n    this.#switchboardUrl = switchboardUrl;\n    return this;\n  }\n\n  // Set the chain id credentials are issued on (default 1). It is part of the\n  // issuer DID, so signIn rejects a wallet session from a different chain.\n  withChainId(chainId: number): this {\n    this.#chainId = chainId;\n    return this;\n  }\n\n  /**\n   * Set a profile fetcher strategy for enriching user data after login.\n   * The fetcher receives the authenticated user and the base URL,\n   * and returns a RenownProfile. Called in the background after each login.\n   * Defaults to fetchRenownProfile which calls the Renown API.\n   */\n  withProfileFetcher(profileFetcher: ProfileFetcher): this {\n    this.#profileFetcher = profileFetcher;\n    return this;\n  }\n\n  /**\n   * Build and initialize the Renown instance.\n   * If a user is stored, attempts to re-authenticate them.\n   * @throws Error if neither crypto nor keyPairStorage is provided\n   */\n  async build(): Promise<Renown> {\n    if (!this.#crypto && !this.#keyPairStorage) {\n      throw new Error(\n        \"Either crypto or keyPairStorage is required. Use withCrypto() or withKeyPairStorage() to set one.\",\n      );\n    }\n\n    const chainId = this.#chainId ?? Number(DEFAULT_RENOWN_CHAIN_ID);\n    const crypto =\n      this.#crypto ??\n      (await new RenownCryptoBuilder()\n        .withKeyPairStorage(this.#keyPairStorage!)\n        .withChainId(chainId)\n        .build());\n\n    // A crypto supplied via withCrypto() carries its own chain; the bearer token\n    // it mints would then disagree with the credentials issued here.\n    if (crypto.chainId !== undefined && crypto.chainId !== chainId) {\n      console.warn(\n        `Renown: the supplied crypto signs bearer tokens for chain ${crypto.chainId}, but credentials are issued on chain ${chainId}.`,\n      );\n    }\n\n    const storage = this.#storage ?? new RenownMemoryStorage();\n    const eventEmitter = this.#eventEmitter ?? new MemoryEventEmitter();\n    const baseUrl = this.#baseUrl ?? DEFAULT_RENOWN_URL;\n\n    // Pick the transport once: direct-switchboard when an endpoint resolves,\n    // else the REST flow. A custom profile fetcher always takes precedence.\n    const switchboardEndpoint = await resolveSwitchboardEndpoint({\n      switchboardUrl: this.#switchboardUrl,\n      baseUrl,\n    });\n    const switchboard = switchboardEndpoint\n      ? new SwitchboardClient(switchboardEndpoint)\n      : undefined;\n    const profileFetcher =\n      this.#profileFetcher ??\n      (switchboard ? switchboard.profileFetcher : fetchRenownProfile);\n\n    const renown = new Renown(\n      storage,\n      eventEmitter,\n      crypto,\n      this.#appName,\n      baseUrl,\n      profileFetcher,\n      switchboard,\n      chainId,\n    );\n\n    // A stored user is loaded as-is for an instant, offline-safe start; callers\n    // revalidate against the source separately via renown.revalidate().\n    return renown;\n  }\n\n  /**\n   * Create a BaseRenownBuilder from options object for a more concise API\n   */\n  static from(options: RenownBuilderOptions): BaseRenownBuilder {\n    const builder = new BaseRenownBuilder(options.appName);\n\n    if (options.storage) {\n      builder.withStorage(options.storage);\n    }\n    if (options.eventEmitter) {\n      builder.withEventEmitter(options.eventEmitter);\n    }\n    if (options.crypto) {\n      builder.withCrypto(options.crypto);\n    }\n    if (options.keyPairStorage) {\n      builder.withKeyPairStorage(options.keyPairStorage);\n    }\n    if (options.baseUrl) {\n      builder.withBaseUrl(options.baseUrl);\n    }\n    if (options.switchboardUrl) {\n      builder.withSwitchboardUrl(options.switchboardUrl);\n    }\n    if (options.profileFetcher) {\n      builder.withProfileFetcher(options.profileFetcher);\n    }\n    if (options.chainId !== undefined) {\n      builder.withChainId(options.chainId);\n    }\n\n    return builder;\n  }\n}\n","import { fetchDelegationCredential } from \"./credential.js\";\nimport type { SwitchboardRequestFn } from \"./switchboard.js\";\n\n/** Confirms an authenticated signer's delegation credential is still live. */\nexport type CredentialCheck = (params: {\n  address: string;\n  chainId: number;\n  appId: string;\n}) => Promise<boolean>;\n\nexport interface LocalCredentialVerifierOptions {\n  /** Notified when the read itself fails; the check then fails closed. */\n  onError?: (error: unknown) => void;\n}\n\n/** A credential check that reads a Switchboard's own renown read model through\n * `execute`, rather than any Renown or Switchboard over HTTP. */\nexport function createLocalCredentialVerifier(\n  execute: SwitchboardRequestFn,\n  options: LocalCredentialVerifierOptions = {},\n): CredentialCheck {\n  // fetchDelegationCredential turns a read failure into \"no credential\" — the\n  // right verdict, but silent; surface it before it is swallowed.\n  const request: SwitchboardRequestFn = async (query, variables) => {\n    try {\n      return await execute(query, variables);\n    } catch (error) {\n      options.onError?.(error);\n      throw error;\n    }\n  };\n\n  return async ({ address, chainId, appId }) => {\n    const credential = await fetchDelegationCredential({\n      address,\n      chainId,\n      appDid: appId,\n      switchboardRequest: request,\n    });\n    return credential !== undefined;\n  };\n}\n","// Canonical messages a caller personal_signs (EIP-191) to authorize a Renown\n// write without a login token. Kept byte-identical to renown-package\n// `subgraphs/renown-auth/core/signed-message.ts`, which verifies them; the\n// pinned strings in test/signed-message.test.ts guard both sides.\n\n// Signed actions (revoke, profile update) must carry a timestamp within this\n// window of the server's clock, in either direction. Signing a fresh message\n// and replaying an old one both fail outside this bound.\nexport const SIGNATURE_WINDOW_MS = 600_000;\n\nfunction toHex(bytes: Uint8Array): string {\n  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, \"0\")).join(\n    \"\",\n  );\n}\n\nasync function sha256hex(input: string): Promise<string> {\n  const digest = await crypto.subtle.digest(\n    \"SHA-256\",\n    new TextEncoder().encode(input),\n  );\n  return toHex(new Uint8Array(digest));\n}\n\n/** Canonical message a caller signs to authorize revoking `credentialId`. */\nexport function revokeMessage(credentialId: string, timestamp: string): string {\n  return `Revoke Renown credential ${credentialId} at ${timestamp}`;\n}\n\n/**\n * Canonical message a caller signs to authorize a profile upsert. The payload\n * is hashed (rather than embedded raw) so the signed message has a fixed\n * shape regardless of field content.\n */\nexport async function profileMessage(\n  address: string,\n  profile: { username?: string | null; userImage?: string | null },\n  timestamp: string,\n): Promise<string> {\n  const payload = JSON.stringify({\n    username: profile.username ?? null,\n    userImage: profile.userImage ?? null,\n  });\n  const hash = await sha256hex(payload);\n  return `Update Renown profile ${address.toLowerCase()} ${hash} at ${timestamp}`;\n}\n"],"mappings":"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"}

package/dist/{signer-trust-DstQutcf.d.ts → signer-trust-FmbMTn39.d.ts}

@@ -1,4 +1,4 @@
-import { _t as SwitchboardSource } from "./types-DOTk0z2D.js";
+import { yt as SwitchboardSource } from "./types-Ceiz2dkk.js";
 import { ActionSigner } from "@powerhousedao/shared/document-model";
 //#region src/discovery.d.ts
 interface ResolveSwitchboardEndpointOptions {
@@ -50,4 +50,4 @@ declare function createRenownTrustPolicy(options?: RenownTrustPolicyOptions): Re
 //#endregion
 export { ResolveSwitchboardEndpointOptions as a, createRenownTrustPolicy as i, RenownTrustPolicy as n, resolveSwitchboardEndpoint as o, RenownTrustPolicyOptions as r, RenownOwnSigner as t };
 export {};
-//# sourceMappingURL=signer-trust-DstQutcf.d.ts.map
+//# sourceMappingURL=signer-trust-FmbMTn39.d.ts.map

package/dist/{signer-trust-DstQutcf.d.ts.map → signer-trust-FmbMTn39.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"signer-trust-DstQutcf.d.ts","names":[],"sources":["../src/discovery.ts","../src/signer-trust.ts"],"mappings":";;;UAAiB;EAEf;EAEA;EAEA;;iBAcoB,2BACpB,SAAS,oCACR;;;KChBE,aAAa;;UAGD;WACN;aAAiB;;WACjB,OAAO;;UAGD;;EAEf,cAAc;;EAEd;;EAEA,YAAY;;;;;EAKZ;IAAS;IAAa,MAAM;;;EAE5B;;EAEA;;;UAIe;EACf,gBACE,QAAQ,cACR,aACA,qBACC;;;;;;;iBAWW,wBACd,UAAS,2BACR"}
+{"version":3,"file":"signer-trust-FmbMTn39.d.ts","names":[],"sources":["../src/discovery.ts","../src/signer-trust.ts"],"mappings":";;;UAAiB;EAEf;EAEA;EAEA;;iBAcoB,2BACpB,SAAS,oCACR;;;KChBE,aAAa;;UAGD;WACN;aAAiB;;WACjB,OAAO;;UAGD;;EAEf,cAAc;;EAEd;;EAEA,YAAY;;;;;EAKZ;IAAS;IAAa,MAAM;;;EAE5B;;EAEA;;;UAIe;EACf,gBACE,QAAQ,cACR,aACA,qBACC;;;;;;;iBAWW,wBACd,UAAS,2BACR"}

package/dist/{signer-trust-C6UJAsNJ.js → signer-trust-H1rNzUcd.js}

@@ -121,8 +121,70 @@ const LEGACY_MUTATE_DOCUMENT_MUTATION = `
 function isUnknownExecuteField(error) {
 	return error instanceof Error && /Cannot query field "execute" on type "Mutation"/.test(error.message);
 }
+const ISSUE_CREDENTIAL_MUTATION = `
+  mutation RenownIssueCredential(
+    $input: RenownCredential_InitInput!
+    $username: String
+    $userImage: String
+    $userDocId: PHID
+  ) {
+    renown_issueCredential(
+      input: $input
+      username: $username
+      userImage: $userImage
+      userDocId: $userDocId
+    )
+  }
+`;
+const UPSERT_PROFILE_MUTATION = `
+  mutation RenownUpsertProfile(
+    $address: String!
+    $username: String
+    $userImage: String
+    $signature: String
+    $timestamp: String
+  ) {
+    renown_upsertProfile(
+      address: $address
+      username: $username
+      userImage: $userImage
+      signature: $signature
+      timestamp: $timestamp
+    )
+  }
+`;
+const REVOKE_CREDENTIAL_MUTATION = `
+  mutation RenownRevokeCredential(
+    $credentialId: String!
+    $signature: String
+    $timestamp: String
+  ) {
+    renown_revokeCredential(
+      credentialId: $credentialId
+      signature: $signature
+      timestamp: $timestamp
+    )
+  }
+`;
+function authParts(auth) {
+	return "token" in auth ? {
+		token: auth.token,
+		signed: {}
+	} : { signed: {
+		signature: auth.signature,
+		timestamp: auth.timestamp
+	} };
+}
 const RENOWN_CREDENTIAL_DOC_TYPE = "powerhouse/renown-credential";
 const RENOWN_USER_DOC_TYPE = "powerhouse/renown-user";
+function quoted(name) {
+	return `\\\\?"${name}\\\\?"`;
+}
+function isUnknownSchemaError(error, field, ...types) {
+	const message = error instanceof Error ? error.message : String(error);
+	if (new RegExp(`Cannot query field ${quoted(field)}`).test(message)) return true;
+	return !message.includes("got invalid value") && types.some((type) => new RegExp(`Unknown type ${quoted(type)}`).test(message));
+}
 function reshapeCredential(row) {
 	const domain = JSON.parse(row.proofEip712Domain);
 	return {
@@ -182,17 +244,20 @@ var SwitchboardClient = class {
 	constructor(source) {
 		if (typeof source === "string") {
 			this.#endpoint = source;
-			this.#transport = (query, variables) => this.#post(source, query, variables);
+			this.#transport = (query, variables, options) => this.#post(source, query, variables, options?.token);
 		} else this.#transport = source;
 	}
 	/** The HTTP endpoint, or undefined when reading through a local executor. */
 	get endpoint() {
 		return this.#endpoint;
 	}
-	async #post(endpoint, query, variables) {
+	async #post(endpoint, query, variables, token) {
 		const response = await fetch(endpoint, {
 			method: "POST",
-			headers: { "Content-Type": "application/json" },
+			headers: {
+				"Content-Type": "application/json",
+				...token ? { Authorization: `Bearer ${token}` } : {}
+			},
 			body: JSON.stringify({
 				query,
 				variables
@@ -203,8 +268,8 @@ var SwitchboardClient = class {
 		if (!response.ok || !body) throw new Error(`Switchboard request failed: ${response.status}`);
 		return body.data;
 	}
-	async #request(query, variables) {
-		const data = await this.#transport(query, variables);
+	async #request(query, variables, token) {
+		const data = await (token ? this.#transport(query, variables, { token }) : this.#transport(query, variables));
 		if (!data) throw new Error("Switchboard returned no data");
 		return data;
 	}
@@ -257,30 +322,29 @@ var SwitchboardClient = class {
 			updatedAt: user.updatedAt
 		};
 	}
-	async createEmptyDocument(documentType, parentIdentifier) {
+	async createEmptyDocument(documentType, parentIdentifier, token) {
 		const { createEmptyDocument } = await this.#request(CREATE_EMPTY_DOCUMENT_MUTATION, {
 			documentType,
 			parentIdentifier
-		});
+		}, token);
 		return createEmptyDocument.id;
 	}
-	async mutateDocument(documentIdentifier, actions) {
+	async mutateDocument(documentIdentifier, actions, token) {
 		const variables = {
 			documentIdentifier,
 			actions
 		};
 		if (!this.#legacyMutate) try {
-			const { mutateDocument } = await this.#request(MUTATE_DOCUMENT_MUTATION, variables);
+			const { mutateDocument } = await this.#request(MUTATE_DOCUMENT_MUTATION, variables, token);
 			return mutateDocument.id;
 		} catch (error) {
 			if (!isUnknownExecuteField(error)) throw error;
 			this.#legacyMutate = true;
 		}
-		const { mutateDocument } = await this.#request(LEGACY_MUTATE_DOCUMENT_MUTATION, variables);
+		const { mutateDocument } = await this.#request(LEGACY_MUTATE_DOCUMENT_MUTATION, variables, token);
 		return mutateDocument.id;
 	}
 	async issueCredential(credential, parentIdentifier) {
-		const documentId = await this.createEmptyDocument(RENOWN_CREDENTIAL_DOC_TYPE, parentIdentifier);
 		const input = {
 			id: credential.id,
 			context: credential["@context"],
@@ -315,27 +379,65 @@ var SwitchboardClient = class {
 				}
 			}
 		};
-		await this.mutateDocument(documentId, [createAction("INIT", input)]);
-		return documentId;
+		try {
+			const { renown_issueCredential } = await this.#request(ISSUE_CREDENTIAL_MUTATION, { input });
+			return renown_issueCredential;
+		} catch (error) {
+			if (!isUnknownSchemaError(error, "renown_issueCredential", "RenownCredential_InitInput")) throw error;
+			const documentId = await this.createEmptyDocument(RENOWN_CREDENTIAL_DOC_TYPE, parentIdentifier);
+			await this.mutateDocument(documentId, [createAction("INIT", input)]);
+			return documentId;
+		}
 	}
-	async findOrCreateUser(address, profile = {}) {
+	async upsertUserProfile(address, profile, auth) {
+		const { token, signed } = authParts(auth);
+		try {
+			const { renown_upsertProfile } = await this.#request(UPSERT_PROFILE_MUTATION, {
+				address,
+				username: profile.username,
+				userImage: profile.userImage,
+				...signed
+			}, token);
+			return renown_upsertProfile;
+		} catch (error) {
+			if (!isUnknownSchemaError(error, "renown_upsertProfile")) throw error;
+			return this.#legacyUpsertUserProfile(address, profile, token);
+		}
+	}
+	async #legacyUpsertUserProfile(address, profile, token) {
 		const updates = [];
-		if (profile.username !== void 0) updates.push(createAction("SET_USERNAME", { username: profile.username }));
-		if (profile.userImage !== void 0) updates.push(createAction("SET_USER_IMAGE", { userImage: profile.userImage }));
+		if (profile.username != null) updates.push(createAction("SET_USERNAME", { username: profile.username }));
+		if (profile.userImage != null) updates.push(createAction("SET_USER_IMAGE", { userImage: profile.userImage }));
 		const existing = await this.getProfileByAddress(address);
 		if (existing) {
-			if (updates.length) await this.mutateDocument(existing.documentId, updates);
+			if (updates.length) await this.mutateDocument(existing.documentId, updates, token);
 			return existing.documentId;
 		}
-		const documentId = await this.createEmptyDocument(RENOWN_USER_DOC_TYPE);
-		await this.mutateDocument(documentId, [createAction("SET_ETH_ADDRESS", { ethAddress: address }), ...updates]);
+		const documentId = await this.createEmptyDocument(RENOWN_USER_DOC_TYPE, void 0, token);
+		await this.mutateDocument(documentId, [createAction("SET_ETH_ADDRESS", { ethAddress: address }), ...updates], token);
 		return documentId;
 	}
-	async revokeCredential(documentId, reason) {
-		await this.mutateDocument(documentId, [createAction("REVOKE", {
-			revokedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			reason: reason ?? null
-		})]);
+	async revokeCredential(credentialId, auth) {
+		const { token, signed } = authParts(auth);
+		try {
+			await this.#request(REVOKE_CREDENTIAL_MUTATION, {
+				credentialId,
+				...signed
+			}, token);
+		} catch (error) {
+			if (!isUnknownSchemaError(error, "renown_revokeCredential")) throw error;
+			await this.#legacyRevokeCredential(credentialId, token);
+		}
+	}
+	async #legacyRevokeCredential(credentialId, token) {
+		const { renownCredentials } = await this.#request(CREDENTIALS_QUERY, { input: { includeRevoked: false } }, token);
+		const documentIds = renownCredentials.filter((row) => row.credentialId === credentialId).map((row) => row.documentId);
+		if (!documentIds.length) throw new Error(`Credential not found: ${credentialId}`);
+		const revokedAt = (/* @__PURE__ */ new Date()).toISOString();
+		for (const documentId of documentIds) await this.mutateDocument(documentId, [createAction("REVOKE", {
+			revokedAt,
+			reason: null
+		})], token);
 	}
 	profileFetcher = (user) => this.getProfileByAddress(user.address).catch(() => void 0);
 };
@@ -603,4 +705,4 @@ async function fetchIssuedCredentialRest(user, key, renownUrl) {
 //#endregion
 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=signer-trust-C6UJAsNJ.js.map
+//# sourceMappingURL=signer-trust-H1rNzUcd.js.map