@renown/sdk 6.0.0-dev.23 → 6.0.0-dev.230

package/dist/utils-BGF8Qb5f.d.ts

@@ -0,0 +1,689 @@
+import { Resolver } from "did-resolver";
+import { Action, AppActionSigner, ISigner, ISigner as ISigner$1, Signature, SignatureVerificationHandler, User, UserActionSigner } from "@powerhousedao/shared/document-model";
+
+//#region src/constants.d.ts
+declare const DEFAULT_RENOWN_URL = "https://www.renown.id";
+declare const DEFAULT_RENOWN_NETWORK_ID = "eip155";
+declare const DEFAULT_RENOWN_CHAIN_ID = "1";
+declare const DOMAIN_TYPE: readonly [{
+  readonly name: "name";
+  readonly type: "string";
+}, {
+  readonly name: "version";
+  readonly type: "string";
+}, {
+  readonly name: "chainId";
+  readonly type: "uint256";
+}, {
+  readonly name: "verifyingContract";
+  readonly type: "address";
+}];
+declare const VERIFIABLE_CREDENTIAL_EIP712_TYPE: readonly [{
+  readonly name: "@context";
+  readonly type: "string[]";
+}, {
+  readonly name: "type";
+  readonly type: "string[]";
+}, {
+  readonly name: "id";
+  readonly type: "string";
+}, {
+  readonly name: "issuer";
+  readonly type: "Issuer";
+}, {
+  readonly name: "credentialSubject";
+  readonly type: "CredentialSubject";
+}, {
+  readonly name: "credentialSchema";
+  readonly type: "CredentialSchema";
+}, {
+  readonly name: "issuanceDate";
+  readonly type: "string";
+}, {
+  readonly name: "expirationDate";
+  readonly type: "string";
+}];
+declare const CREDENTIAL_SCHEMA_EIP712_TYPE: readonly [{
+  readonly name: "id";
+  readonly type: "string";
+}, {
+  readonly name: "type";
+  readonly type: "string";
+}];
+declare const CREDENTIAL_SUBJECT_TYPE: readonly [{
+  readonly name: "app";
+  readonly type: "string";
+}, {
+  readonly name: "id";
+  readonly type: "string";
+}, {
+  readonly name: "name";
+  readonly type: "string";
+}];
+declare const ISSUER_TYPE: readonly [{
+  readonly name: "id";
+  readonly type: "string";
+}, {
+  readonly name: "ethereumAddress";
+  readonly type: "string";
+}];
+declare const CREDENTIAL_TYPES: {
+  readonly EIP712Domain: readonly [{
+    readonly name: "name";
+    readonly type: "string";
+  }, {
+    readonly name: "version";
+    readonly type: "string";
+  }, {
+    readonly name: "chainId";
+    readonly type: "uint256";
+  }, {
+    readonly name: "verifyingContract";
+    readonly type: "address";
+  }];
+  readonly VerifiableCredential: readonly [{
+    readonly name: "@context";
+    readonly type: "string[]";
+  }, {
+    readonly name: "type";
+    readonly type: "string[]";
+  }, {
+    readonly name: "id";
+    readonly type: "string";
+  }, {
+    readonly name: "issuer";
+    readonly type: "Issuer";
+  }, {
+    readonly name: "credentialSubject";
+    readonly type: "CredentialSubject";
+  }, {
+    readonly name: "credentialSchema";
+    readonly type: "CredentialSchema";
+  }, {
+    readonly name: "issuanceDate";
+    readonly type: "string";
+  }, {
+    readonly name: "expirationDate";
+    readonly type: "string";
+  }];
+  readonly CredentialSchema: readonly [{
+    readonly name: "id";
+    readonly type: "string";
+  }, {
+    readonly name: "type";
+    readonly type: "string";
+  }];
+  readonly CredentialSubject: readonly [{
+    readonly name: "app";
+    readonly type: "string";
+  }, {
+    readonly name: "id";
+    readonly type: "string";
+  }, {
+    readonly name: "name";
+    readonly type: "string";
+  }];
+  readonly Issuer: readonly [{
+    readonly name: "id";
+    readonly type: "string";
+  }, {
+    readonly name: "ethereumAddress";
+    readonly type: "string";
+  }];
+};
+//#endregion
+//#region src/crypto/types.d.ts
+type JwkKeyPair = {
+  publicKey: JsonWebKey;
+  privateKey: JsonWebKey;
+};
+interface JsonWebKeyPairStorage {
+  loadKeyPair(): Promise<JwkKeyPair | undefined>;
+  saveKeyPair(keyPair: JwkKeyPair): Promise<void>;
+  removeKeyPair(): Promise<void>;
+}
+type DID = `did:${string}`;
+interface IRenownCrypto {
+  did: DID;
+  publicKey: CryptoKey;
+  removeDid(): Promise<void>;
+  sign: (data: Uint8Array) => Promise<Uint8Array>;
+  verify: (data: Uint8Array, signature: Uint8Array) => Promise<boolean>;
+  issuer: Issuer;
+  getBearerToken: (address: string | undefined, options?: CreateBearerTokenOptions) => Promise<string>;
+}
+/**
+ * @deprecated Use IRenownCrypto instead
+ */
+interface IConnectCrypto extends IRenownCrypto {}
+//#endregion
+//#region src/event/types.d.ts
+interface IEventEmitter<Events extends Record<string, unknown>> {
+  /**
+   * Registers a listener for the specified event.
+   * @param event - The event name.
+   * @param listener - The listener function for the event.
+   * @returns A function to remove the listener.
+   */
+  on<K extends keyof Events>(event: K, listener: (data: Events[K]) => void): () => void;
+  /**
+   * Emits an event with the specified data.
+   * @param event - The event name.
+   * @param data - The data to pass to listeners.
+   */
+  emit<K extends keyof Events>(event: K, data: Events[K]): void;
+}
+//#endregion
+//#region src/storage/common.d.ts
+interface IStorage<T extends Record<string, unknown> = Record<string, unknown>, Key extends keyof T = keyof T> {
+  get(key: Key): T[Key] | undefined;
+  set(key: Key, value?: T[Key]): void;
+  delete(key: Key): void;
+}
+declare abstract class BaseStorage<T extends Record<string, unknown> = Record<string, unknown>, Key extends keyof T = keyof T> implements IStorage<T> {
+  abstract get(key: Key): T[Key] | undefined;
+  abstract set(key: Key, value?: T[Key]): void;
+  abstract delete(key: Key): void;
+}
+declare class MemoryStorage<T extends Record<string, unknown> = Record<string, unknown>, Key extends keyof T = keyof T> extends BaseStorage<T> {
+  private readonly data;
+  get(key: Key): T[Key] | undefined;
+  set(key: Key, value?: T[Key]): void;
+  delete(key: Key): void;
+}
+//#endregion
+//#region src/types.d.ts
+interface EcdsaSignature {
+  r: string;
+  s: string;
+  recoveryParam?: number;
+}
+type Signer = (data: string | Uint8Array) => Promise<EcdsaSignature | string>;
+interface JWTPayload {
+  iss?: string;
+  sub?: string;
+  aud?: string | string[];
+  iat?: number;
+  nbf?: number;
+  exp?: number;
+  rexp?: number;
+  [x: string]: any;
+}
+interface JWTVerifyPolicies {
+  now?: number;
+  nbf?: boolean;
+  iat?: boolean;
+  exp?: boolean;
+  aud?: boolean;
+}
+interface JWTVerified {
+  verified: true;
+  payload: Partial<JWTPayload>;
+  didResolutionResult: DIDResolutionResult;
+  issuer: string;
+  signer: VerificationMethod;
+  jwt: string;
+  policies?: JWTVerifyPolicies;
+}
+interface DIDResolutionResult {
+  "@context"?: "https://w3id.org/did-resolution/v1" | string | string[];
+  didResolutionMetadata: DIDResolutionMetadata;
+  didDocument: DIDDocument | null;
+  didDocumentMetadata: DIDDocumentMetadata;
+}
+interface DIDResolutionMetadata {
+  contentType?: string;
+  error?: "invalidDid" | "notFound" | "representationNotSupported" | "unsupportedDidMethod" | string;
+  [x: string]: any;
+}
+interface DIDDocumentMetadata {
+  created?: string;
+  updated?: string;
+  deactivated?: boolean;
+  versionId?: string;
+  nextUpdate?: string;
+  nextVersionId?: string;
+  equivalentId?: string;
+  canonicalId?: string;
+  [x: string]: any;
+}
+type KeyCapabilitySection = "authentication" | "assertionMethod" | "keyAgreement" | "capabilityInvocation" | "capabilityDelegation";
+type DIDDocument = {
+  "@context"?: "https://www.w3.org/ns/did/v1" | string | string[];
+  id: string;
+  alsoKnownAs?: string[];
+  controller?: string | string[];
+  verificationMethod?: VerificationMethod[];
+  service?: Service[]; /** @deprecated */
+  publicKey?: VerificationMethod[];
+} & { [x in KeyCapabilitySection]?: (string | VerificationMethod)[] };
+interface Service {
+  id: string;
+  type: string;
+  serviceEndpoint: ServiceEndpoint | ServiceEndpoint[];
+  [x: string]: any;
+}
+type ServiceEndpoint = string | Record<string, any>;
+interface JsonWebKey$1 {
+  alg?: string;
+  crv?: string;
+  e?: string;
+  ext?: boolean;
+  key_ops?: string[];
+  kid?: string;
+  kty: string;
+  n?: string;
+  use?: string;
+  x?: string;
+  y?: string;
+  [x: string]: any;
+}
+interface VerificationMethod {
+  id: string;
+  type: string;
+  controller: string;
+  publicKeyBase58?: string;
+  publicKeyBase64?: string;
+  publicKeyJwk?: JsonWebKey$1;
+  publicKeyHex?: string;
+  publicKeyMultibase?: string;
+  blockchainAccountId?: string;
+  ethereumAddress?: string;
+  conditionOr?: VerificationMethod[];
+  conditionAnd?: VerificationMethod[];
+  threshold?: number;
+  conditionThreshold?: VerificationMethod[];
+  conditionWeightedThreshold?: ConditionWeightedThreshold[];
+  conditionDelegated?: string;
+  relationshipParent?: string[];
+  relationshipChild?: string[];
+  relationshipSibling?: string[];
+}
+interface ConditionWeightedThreshold {
+  condition: VerificationMethod;
+  weight: number;
+}
+interface Issuer {
+  did: string;
+  signer: Signer;
+  alg?: string;
+}
+interface Proof {
+  type?: string;
+  [x: string]: any;
+}
+type Verifiable<T> = Readonly<T> & {
+  readonly proof: Proof;
+};
+interface CredentialStatus {
+  id: string;
+  type: string;
+}
+type W3CCredential = {
+  "@context": string[];
+  id?: string;
+  type: string[];
+  issuer: {
+    id: string;
+    [x: string]: any;
+  };
+  issuanceDate: string;
+  expirationDate?: string;
+  credentialSubject: {
+    id?: string;
+    [x: string]: any;
+  };
+  credentialStatus?: CredentialStatus;
+  evidence?: any;
+  termsOfUse?: any;
+  [x: string]: any;
+};
+type VerifiedJWT = JWTVerified;
+type VerifiedCredential = VerifiedJWT & {
+  verifiableCredential: Verifiable<W3CCredential>;
+};
+type RenownProfile = {
+  documentId: string;
+  username: string | null;
+  ethAddress: string | null;
+  userImage: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+type InternalUser = User & {
+  did: string;
+  credential: PowerhouseVerifiableCredential | undefined;
+  profile?: RenownProfile;
+};
+type User$1 = InternalUser;
+/**
+ * Strategy function for fetching user profile data.
+ * Called after successful authentication to enrich the user object.
+ * Should return the user's Renown profile, or undefined if not available.
+ * Must not throw — return undefined on failure.
+ */
+type ProfileFetcher = (user: User$1, baseUrl: string) => Promise<RenownProfile | undefined>;
+type Unsubscribe = () => void;
+type LoginStatus = "initial" | "checking" | "authorized" | "not-authorized";
+type RenownStorageMap = {
+  user: InternalUser | undefined;
+};
+type RenownStorage = IStorage<RenownStorageMap>;
+type RenownEvents = {
+  user: User$1 | undefined;
+  status: LoginStatus;
+};
+type RenownEventEmitter = IEventEmitter<RenownEvents>;
+interface IRenown extends Pick<RenownEventEmitter, "on"> {
+  readonly baseUrl: string;
+  readonly user: User$1 | undefined;
+  readonly status: LoginStatus;
+  login: (userDid: string) => Promise<User$1>;
+  logout: () => Promise<void>;
+  readonly crypto: IRenownCrypto;
+  readonly signer: ISigner$1;
+  readonly did: string;
+  readonly profileFetcher: ProfileFetcher | undefined;
+  verifyBearerToken: (token: string) => Promise<false | VerifiedCredential>;
+  getBearerToken: (options: CreateBearerTokenOptions, refresh?: boolean) => Promise<string>;
+}
+type IssuerType<T> = {
+  id: string;
+} & T;
+type CredentialSubjecType<T> = {
+  id?: string;
+} & T;
+interface CredentialSchema {
+  id: string;
+  type: string;
+}
+interface IVerifiableCredentialPayload<Subject, Issuer> {
+  "@context": string[];
+  id: string;
+  type: string[];
+  issuer: IssuerType<Issuer>;
+  issuanceDate: string;
+  expirationDate?: string;
+  credentialSubject: CredentialSubjecType<Subject>;
+  credentialStatus?: CredentialStatus;
+  credentialSchema: CredentialSchema;
+}
+interface IProof {
+  verificationMethod: string;
+  ethereumAddress: `0x${string}`;
+  created: string;
+  proofPurpose: string;
+  type: string;
+  proofValue: string;
+  eip712: {
+    domain: {
+      name: string;
+      version: string;
+      chainId: number;
+      verifyingContract: string;
+    };
+    types: typeof CREDENTIAL_TYPES;
+    primaryType: "VerifiableCredential";
+  };
+}
+interface IVerifiableCredential<Subject, Issuer> extends IVerifiableCredentialPayload<Subject, Issuer> {
+  proof: IProof;
+}
+interface IPowerhouseCredentialSubject {
+  id: string;
+  app: string;
+  name?: string;
+}
+interface IPowerhouseIssuerType {
+  ethereumAddress: `0x${string}`;
+}
+type PowerhouseVerifiableCredential = IVerifiableCredential<IPowerhouseCredentialSubject, IPowerhouseIssuerType>;
+interface IAuthCredentialSubject {
+  chainId: number;
+  networkId: string;
+  address: string;
+}
+type AuthVerifiableCredential = IVerifiableCredential<IAuthCredentialSubject, {}>;
+type AuthVerifiedCredential = VerifiedCredential & {
+  verifiableCredential: Verifiable<AuthVerifiableCredential>;
+};
+type PKHDid = {
+  networkId: string;
+  chainId: number;
+  address: `0x${string}`;
+};
+interface CreateBearerTokenOptions {
+  expiresIn?: number;
+  aud?: string;
+}
+//#endregion
+//#region src/crypto/renown-crypto.d.ts
+declare class RenownCrypto implements IRenownCrypto {
+  #private;
+  readonly did: DID;
+  static algorithm: EcKeyAlgorithm;
+  static signAlgorithm: {
+    name: string;
+    namedCurve: string;
+    hash: string;
+  };
+  constructor(keyPairStorage: JsonWebKeyPairStorage, crypto: SubtleCrypto, keyPair: CryptoKeyPair, did: DID);
+  get publicKey(): CryptoKey;
+  getBearerToken(address: string | undefined, options?: CreateBearerTokenOptions): Promise<string>;
+  removeDid(): Promise<void>;
+  sign(data: Uint8Array | string): Promise<Uint8Array>;
+  verify(data: Uint8Array, signature: Uint8Array): Promise<boolean>;
+  get issuer(): Issuer;
+}
+/**
+ * @deprecated Use RenownCrypto instead
+ */
+declare class ConnectCrypto extends RenownCrypto {}
+//#endregion
+//#region src/crypto/renown-crypto-builder.d.ts
+declare class RenownCryptoBuilder {
+  #private;
+  private keyPairStorage?;
+  private subtleCrypto?;
+  withKeyPairStorage(storage: JsonWebKeyPairStorage): this;
+  withSubtleCrypto(crypto: SubtleCrypto): this;
+  build(): Promise<RenownCrypto>;
+}
+//#endregion
+//#region src/crypto/memory-key-storage.d.ts
+declare class MemoryKeyStorage implements JsonWebKeyPairStorage {
+  private keyPair;
+  constructor(keyPair?: JwkKeyPair);
+  loadKeyPair(): Promise<JwkKeyPair | undefined>;
+  saveKeyPair(keyPair: JwkKeyPair): Promise<void>;
+  removeKeyPair(): Promise<void>;
+}
+//#endregion
+//#region src/crypto/signer.d.ts
+declare class RenownCryptoSigner implements ISigner {
+  private readonly crypto;
+  private readonly appName;
+  user?: UserActionSigner | undefined;
+  readonly app: AppActionSigner;
+  constructor(crypto: IRenownCrypto, appName: string, user?: UserActionSigner | undefined);
+  get publicKey(): CryptoKey;
+  sign(data: Uint8Array): Promise<Uint8Array>;
+  verify(data: Uint8Array, signature: Uint8Array): Promise<void>;
+  signAction(action: Action, abortSignal?: AbortSignal): Promise<Signature>;
+  /**
+   * Signs an action including a predicted resulting state hash.
+   *
+   * The resulting hash is packed into the signature tuple's 4th element (index 3)
+   * using the format: `${prevStateHash}:${resultingStateHash}`
+   *
+   * This allows offline verification of documents without reducer logic:
+   * - Verifier can check that the signature is valid for the claimed resulting state
+   * - Verifier can compare claimed resulting state to actual operation.hash
+   *
+   * @param action - The action to sign
+   * @param resultingStateHash - The predicted hash of document state AFTER this action runs
+   * @param abortSignal - Optional abort signal
+   * @returns A Signature tuple with the resulting hash encoded in element [3]
+   */
+  signActionWithResultingState(action: Action, resultingStateHash: string, abortSignal?: AbortSignal): Promise<Signature>;
+  /**
+   * Internal signing implementation shared by signAction and signActionWithResultingState.
+   */
+  private _signAction;
+  private hashAction;
+  private buildSignatureMessage;
+  private arrayBufferToHex;
+  private arrayBufferToBase64;
+}
+/**
+ * Creates a signature verification handler that verifies signatures using the Web Crypto API.
+ * The verification uses ECDSA with P-256 curve and SHA-256 hash, matching the RenownCrypto signing algorithm.
+ */
+declare function createSignatureVerifier(requireSignature?: boolean): SignatureVerificationHandler;
+/**
+ * Parses the hash field (element [3]) from a signature tuple.
+ *
+ * Supports two formats:
+ * - Old format: just `prevStateHash` (no colon)
+ * - New format: `prevStateHash:resultingStateHash` (colon-separated)
+ *
+ * @param hashField - The 4th element of a Signature tuple
+ * @returns Object with prevStateHash and optional resultingStateHash
+ */
+declare function parseSignatureHashField(hashField: string): {
+  prevStateHash: string;
+  resultingStateHash: string | undefined;
+};
+/**
+ * Extracts the resulting state hash from a signature, if present.
+ *
+ * @param signature - A Signature tuple
+ * @returns The resulting state hash, or undefined if not present
+ */
+declare function extractResultingHashFromSignature(signature: Signature): string | undefined;
+/**
+ * Checks if a signature includes a resulting state hash.
+ *
+ * @param signature - A Signature tuple
+ * @returns true if the signature includes a resulting state hash
+ */
+declare function signatureHasResultingHash(signature: Signature): boolean;
+//#endregion
+//#region src/common.d.ts
+declare class RenownMemoryStorage extends MemoryStorage<RenownStorageMap> {}
+declare class Renown implements IRenown {
+  #private;
+  constructor(store: RenownStorage, eventEmitter: RenownEventEmitter, crypto: IRenownCrypto, appName: string, baseUrl?: string, profileFetcher?: ProfileFetcher);
+  get baseUrl(): string;
+  get user(): InternalUser | undefined;
+  get status(): LoginStatus;
+  get signer(): ISigner$1;
+  get crypto(): IRenownCrypto;
+  get did(): `did:${string}`;
+  get profileFetcher(): ProfileFetcher | undefined;
+  login(userDid: string): Promise<User$1>;
+  logout(): Promise<void>;
+  on<K extends keyof RenownEvents>(event: K, listener: (data: RenownEvents[K]) => void): () => void;
+  verifyBearerToken(token: string): Promise<false | AuthVerifiedCredential>;
+  getBearerToken(options: CreateBearerTokenOptions): Promise<string>;
+}
+//#endregion
+//#region src/renown-builder.d.ts
+interface RenownBuilderOptions {
+  appName: string;
+  storage?: RenownStorage;
+  eventEmitter?: RenownEventEmitter;
+  crypto?: IRenownCrypto;
+  keyPairStorage?: JsonWebKeyPairStorage;
+  baseUrl?: string;
+  profileFetcher?: ProfileFetcher;
+}
+/**
+ * Base builder for creating Renown instances.
+ * Use platform-specific builders (RenownBuilder from init.browser.js or init.node.js)
+ * for pre-configured defaults.
+ */
+declare class BaseRenownBuilder {
+  #private;
+  /**
+   * @param appName - Application name used for signing context
+   */
+  constructor(appName: string);
+  /**
+   * Set custom storage for user data persistence.
+   * Defaults to in-memory storage if not set.
+   */
+  withStorage(storage: RenownStorage): this;
+  /**
+   * Set custom event emitter for user state changes.
+   * Defaults to in-memory event emitter if not set.
+   */
+  withEventEmitter(eventEmitter: RenownEventEmitter): this;
+  /**
+   * Set a pre-built crypto instance.
+   * Either crypto or keyPairStorage must be provided.
+   */
+  withCrypto(crypto: IRenownCrypto): 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: JsonWebKeyPairStorage): this;
+  /**
+   * Set the Renown server URL for credential verification.
+   * Defaults to https://www.renown.id
+   */
+  withBaseUrl(baseUrl: string): 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: ProfileFetcher): 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
+   */
+  build(): Promise<Renown>;
+  /**
+   * Create a BaseRenownBuilder from options object for a more concise API
+   */
+  static from(options: RenownBuilderOptions): BaseRenownBuilder;
+}
+//#endregion
+//#region src/profile.d.ts
+declare const fetchRenownProfile: ProfileFetcher;
+//#endregion
+//#region src/utils.d.ts
+type ILogger = {
+  level: "verbose" | "debug" | "info" | "warn" | "error";
+  verbose: (message: string, ...replacements: any[]) => void;
+  debug: (message: string, ...replacements: any[]) => void;
+  info: (message: string, ...replacements: any[]) => void;
+  warn: (message: string, ...replacements: any[]) => void;
+  error: (message: string, ...replacements: any[]) => void;
+};
+/**
+ * Parse a DID:pkh string to extract network, chain ID, and address information
+ * @param did - The DID string in format "did:pkh:networkId:chainId:address"
+ * @returns Parsed DID information
+ * @throws Error if the DID format is invalid
+ */
+declare function parsePkhDid(did: string): PKHDid;
+interface VerifyAuthBearerTokenOptions {
+  /** Expected `aud` claim. Required when verifying tokens that include an
+   *  audience claim — did-jwt rejects them otherwise with
+   *  `invalid_config: JWT audience is required but your app address has not
+   *  been configured`. Tokens minted without `aud` are unaffected. */
+  audience?: string;
+}
+declare function verifyAuthBearerToken(jwt: string, options?: VerifyAuthBearerTokenOptions): Promise<false | AuthVerifiedCredential>;
+declare function assertIsAuthCredential(credential: VerifiedCredential): asserts credential is AuthVerifiedCredential;
+declare function createAuthBearerToken(chainId: number, networkId: string, address: string, issuer: Issuer, options?: CreateBearerTokenOptions): Promise<string>;
+declare const getResolver: () => Resolver;
+//#endregion
+export { RenownProfile as $, DIDResolutionResult as A, Issuer as B, AuthVerifiedCredential as C, DEFAULT_RENOWN_NETWORK_ID as Ct, DIDDocument as D, VERIFIABLE_CREDENTIAL_EIP712_TYPE as Dt, CredentialStatus as E, ISSUER_TYPE as Et, IProof as F, KeyCapabilitySection as G, JWTVerified as H, IRenown as I, PowerhouseVerifiableCredential as J, LoginStatus as K, ISigner$1 as L, IAuthCredentialSubject as M, IPowerhouseCredentialSubject as N, DIDDocumentMetadata as O, IPowerhouseIssuerType as P, RenownEvents as Q, IVerifiableCredential as R, AuthVerifiableCredential as S, DEFAULT_RENOWN_CHAIN_ID as St, CreateBearerTokenOptions as T, DOMAIN_TYPE as Tt, JWTVerifyPolicies as U, JWTPayload as V, JsonWebKey$1 as W, Proof as X, ProfileFetcher as Y, RenownEventEmitter as Z, signatureHasResultingHash as _, JsonWebKeyPairStorage as _t, getResolver as a, Unsubscribe as at, ConnectCrypto as b, CREDENTIAL_SUBJECT_TYPE as bt, fetchRenownProfile as c, VerificationMethod as ct, Renown as d, W3CCredential as dt, RenownStorage as et, RenownMemoryStorage as f, BaseStorage as ft, parseSignatureHashField as g, IRenownCrypto as gt, extractResultingHashFromSignature as h, IConnectCrypto as ht, createAuthBearerToken as i, Signer as it, EcdsaSignature as j, DIDResolutionMetadata as k, BaseRenownBuilder as l, VerifiedCredential as lt, createSignatureVerifier as m, DID as mt, VerifyAuthBearerTokenOptions as n, Service as nt, parsePkhDid as o, User$1 as ot, RenownCryptoSigner as p, IEventEmitter as pt, PKHDid as q, assertIsAuthCredential as r, ServiceEndpoint as rt, verifyAuthBearerToken as s, Verifiable as st, ILogger as t, RenownStorageMap as tt, RenownBuilderOptions as u, VerifiedJWT as ut, MemoryKeyStorage as v, JwkKeyPair as vt, ConditionWeightedThreshold as w, DEFAULT_RENOWN_URL as wt, RenownCrypto as x, CREDENTIAL_TYPES as xt, RenownCryptoBuilder as y, CREDENTIAL_SCHEMA_EIP712_TYPE as yt, InternalUser as z };
+//# sourceMappingURL=utils-BGF8Qb5f.d.ts.map