@privy-io/node 0.1.0-alpha.2 → 0.1.0

package/src/lib/auth.ts

@@ -0,0 +1,210 @@
+import {
+  createRemoteJWKSet,
+  CryptoKey,
+  importSPKI,
+  errors as joseErrors,
+  jwtVerify,
+  JWTVerifyGetKey,
+  JWTVerifyResult,
+} from 'jose';
+import { PrivyAPIError } from '../core/error';
+import { parseUserFromIdentityTokenPayload } from './identity-token';
+import { User } from '../resources';
+
+const JWT_ALGORITHM = 'ES256';
+const JWT_ISSUER = 'privy.io';
+
+export type VerifyAuthTokenInput = {
+  /** The authentication token to verify. */
+  auth_token: string;
+  /** The Privy app ID to verify the token against. */
+  app_id: string;
+  /**
+   * The verification key to use to verify the token, or a mechanism to get the it such as via JWKS.
+   * You can find this verification key (or a JWKS endpoint) in the Privy dashboard.
+   * @see {@link createRemoteJWKSet}
+   * @see {@link importSPKI}
+   */
+  verification_key: CryptoKey | JWTVerifyGetKey | string;
+};
+
+export type VerifyAuthTokenResponse = {
+  /** The Privy app ID for which the token was issued. */
+  app_id: string;
+  /** The issuer of the token. */
+  issuer: string;
+  /** The issued at unix timestamp of the token. */
+  issued_at: number;
+  /** The expiration unix timestamp of the token. */
+  expiration: number;
+  /** The ID of the session for which the token was issued. */
+  session_id: string;
+  /** The ID of the user for which the token was issued. */
+  user_id: string;
+};
+
+/**
+ * Verifies a JWT issued by privy.io for the given app ID.
+ * This serves both auth tokens and identity tokens.
+ * @returns The verify result along with the token's payload.
+ * @throws If the token is invalid.
+ */
+async function verifyPrivyIssuedJwt(
+  jwt: string,
+  appId: string,
+  verificationKey: CryptoKey | JWTVerifyGetKey,
+): Promise<JWTVerifyResult> {
+  // Because of a type difference, the calls cannot be merged into one.
+  let verifiedToken: JWTVerifyResult;
+  if (typeof verificationKey !== 'function') {
+    verifiedToken = await jwtVerify(jwt, verificationKey, {
+      typ: 'JWT',
+      algorithms: [JWT_ALGORITHM],
+      issuer: JWT_ISSUER,
+      audience: appId,
+    }).catch(mapAndThrowJoseErrors);
+  } else {
+    verifiedToken = await jwtVerify(jwt, verificationKey, {
+      typ: 'JWT',
+      algorithms: [JWT_ALGORITHM],
+      issuer: JWT_ISSUER,
+      audience: appId,
+    }).catch(mapAndThrowJoseErrors);
+  }
+
+  return verifiedToken;
+}
+
+/**
+ * Verifies a Privy-issued authentication token.
+ *
+ * @returns The payload of the token if it is valid.
+ * @throws If the token is invalid.
+ */
+export async function verifyAuthToken({
+  auth_token: authToken,
+  app_id: appId,
+  verification_key: verificationKeyOrString,
+}: VerifyAuthTokenInput): Promise<VerifyAuthTokenResponse> {
+  const verificationKey =
+    typeof verificationKeyOrString === 'string' ?
+      await importSPKI(verificationKeyOrString, JWT_ALGORITHM)
+    : verificationKeyOrString;
+  const verifiedToken = await verifyPrivyIssuedJwt(authToken, appId, verificationKey);
+  return {
+    app_id: throwIfNotString(verifiedToken.payload.aud),
+    issuer: throwIfNotString(verifiedToken.payload.iss),
+    issued_at: throwIfNotNumber(verifiedToken.payload.iat),
+    expiration: throwIfNotNumber(verifiedToken.payload.exp),
+    session_id: throwIfNotString(verifiedToken.payload['sid']),
+    user_id: throwIfNotString(verifiedToken.payload.sub),
+  };
+}
+
+export type VerifyIdentityTokenInput = {
+  /** The identity token to verify. */
+  identity_token: string;
+  /** The Privy app ID to verify the token against. */
+  app_id: string;
+  /**
+   * The verification key to use to verify the token, or a mechanism to get the it such as via JWKS.
+   * You can find this verification key (or a JWKS endpoint) in the Privy dashboard.
+   * @see {@link createRemoteJWKSet}
+   * @see {@link importSPKI}
+   */
+  verification_key: CryptoKey | JWTVerifyGetKey | string;
+};
+
+/**
+ * Verifies an identity token, parsing it into a `User` object if it is valid.
+ *
+ * @returns The user object parsed from the identity token.
+ * @throws If the token or its payload is invalid.
+ */
+export async function verifyIdentityToken({
+  identity_token: identityToken,
+  app_id: appId,
+  verification_key: verificationKeyOrString,
+}: VerifyIdentityTokenInput): Promise<User> {
+  const verificationKey =
+    typeof verificationKeyOrString === 'string' ?
+      await importSPKI(verificationKeyOrString, JWT_ALGORITHM)
+    : verificationKeyOrString;
+  const verifiedToken = await verifyPrivyIssuedJwt(identityToken, appId, verificationKey);
+
+  if (!verifiedToken.payload) {
+    throw new InvalidAuthTokenError('Unable to parse identity token');
+  }
+
+  return parseUserFromIdentityTokenPayload(verifiedToken.payload);
+}
+
+export class InvalidAuthTokenError extends PrivyAPIError {}
+
+/** Used for asserting the values in the token payload are strings. */
+function throwIfNotString(value: unknown): string {
+  if (!value || typeof value !== 'string') {
+    throw new InvalidAuthTokenError("Token's payload is invalid");
+  }
+  return value;
+}
+
+/** Used for asserting the values in the token payload are numbers. */
+function throwIfNotNumber(value: unknown): number {
+  if (!value || typeof value !== 'number') {
+    throw new InvalidAuthTokenError("Token's payload is invalid");
+  }
+  return value;
+}
+
+/**
+ * Used to catch errors thrown by async `jose` functions and map to our own error types.
+ * This method will **always** throw an error, so it's return type is `never`.
+ */
+function mapAndThrowJoseErrors(error: unknown): never {
+  if (error instanceof joseErrors.JWTExpired) {
+    throw new InvalidAuthTokenError('Authentication token expired');
+  } else if (error instanceof joseErrors.JWTClaimValidationFailed || error instanceof joseErrors.JWTInvalid) {
+    throw new InvalidAuthTokenError('Authentication token is invalid');
+  } else {
+    throw new InvalidAuthTokenError('Failed to verify authentication token');
+  }
+}
+
+export interface CreatePrivyAppJWKSInput {
+  appId: string;
+  apiUrl: string;
+  headers: Record<string, string>;
+  verificationKeyOverride?: string | undefined;
+}
+
+export type PrivyAppJWKS = JWTVerifyGetKey;
+
+export function createPrivyAppJWKS({
+  appId,
+  apiUrl,
+  headers,
+  verificationKeyOverride,
+}: CreatePrivyAppJWKSInput): PrivyAppJWKS {
+  if (verificationKeyOverride !== undefined) {
+    // Use a closure to cache the verification key once imported
+    let verificationKey: CryptoKey;
+    return async () => {
+      if (verificationKey === undefined) {
+        try {
+          verificationKey = await importSPKI(verificationKeyOverride, JWT_ALGORITHM);
+        } catch (error) {
+          throw new InvalidAuthTokenError('Failed to import the provided verification key override');
+        }
+      }
+      return verificationKey;
+    };
+  }
+
+  const url = new URL(`${apiUrl}/v1/apps/${appId}/jwks.json`);
+  return createRemoteJWKSet(url, {
+    cacheMaxAge: 60 * 60 * 1000, // 60 minutes
+    cooldownDuration: 10 * 60 * 1000, // 10 minutes
+    headers,
+  });
+}

package/src/lib/identity-token.ts

@@ -0,0 +1,280 @@
+import { JWTPayload } from 'jose';
+import { User } from '../resources';
+import { PrivyAPIError } from '../error';
+import { EmbeddedWalletLinkedAccount, ExternalWalletLinkedAccount } from './user-utils';
+
+/**
+ * Parses the payload of an identity token (JWT) into a `User` object.
+ * Note that the user object may be incomplete due to the size constraints of the identity token.
+ *
+ * @param payload The payload of the identity token.
+ * @returns The user object parsed from the identity token.
+ * @throws If the payload is invalid.
+ */
+export function parseUserFromIdentityTokenPayload(payload: JWTPayload): User {
+  const customMetadata = parseCustomMetadataClaim(payload);
+
+  return {
+    id: payload.sub as string,
+    created_at: parseInt(payload['cr'] as string),
+    is_guest: payload['guest'] === 't',
+    linked_accounts: parseLinkedAccountsClaim(payload),
+    ...(customMetadata ? { custom_metadata: customMetadata } : {}),
+    has_accepted_terms: false,
+    mfa_methods: [],
+  };
+}
+
+function parseLinkedAccountsClaim(payload: JWTPayload): User['linked_accounts'] {
+  const linkedAccountsClaim = payload['linked_accounts'];
+  if (typeof linkedAccountsClaim !== 'string') {
+    throw new InvalidIdentityTokenError('Unable to parse identity token');
+  }
+  const parsedLinkedAccounts = JSON.parse(linkedAccountsClaim) as unknown;
+  if (!Array.isArray(parsedLinkedAccounts)) {
+    throw new InvalidIdentityTokenError('Unable to parse identity token');
+  }
+
+  return parsedLinkedAccounts
+    .map(mapIdLinkedAccountToUserLinkedAccount)
+    .filter((account) => account !== null);
+}
+
+function mapIdLinkedAccountToUserLinkedAccount(account: any): User['linked_accounts'][number] | null {
+  if (account.type === 'email') {
+    return {
+      type: 'email',
+      address: account.address,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountEmail;
+  }
+  if (account.type === 'phone') {
+    return {
+      type: 'phone',
+      phoneNumber: account.phone_number,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountPhone;
+  }
+
+  // Parses all wallet types
+  if (account.type === 'wallet') {
+    if (account.wallet_client_type === 'privy') {
+      return {
+        type: 'wallet',
+        wallet_client_type: 'privy',
+        wallet_client: 'privy',
+        connector_type: 'embedded',
+        id: account.id,
+        address: account.address,
+        chain_type: account.chain_type,
+        first_verified_at: null,
+        verified_at: account.lv,
+        latest_verified_at: account.lv,
+        // The following fields are not present in the identity token,
+        // but are required. We set them to some safe defaults.
+        chain_id: '',
+        delegated: false,
+        imported: false,
+        public_key: '',
+        wallet_index: 0,
+        recovery_method: account.id ? 'privy-v2' : 'privy',
+      } satisfies EmbeddedWalletLinkedAccount;
+    }
+    return {
+      type: 'wallet',
+      wallet_client: 'unknown',
+      address: account.address,
+      chain_type: account.chain_type,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies ExternalWalletLinkedAccount;
+  }
+  if (account.type === 'smart_wallet') {
+    return {
+      type: 'smart_wallet',
+      address: account.address,
+      smart_wallet_type: account.smart_wallet_type,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountSmartWallet;
+  }
+  if (account.type === 'farcaster') {
+    return {
+      type: 'farcaster',
+      fid: account.fid,
+      username: account.username,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+      owner_address: account.oa,
+    } satisfies User.LinkedAccountFarcaster;
+  }
+  if (account.type === 'google_oauth') {
+    return {
+      type: 'google_oauth',
+      subject: account.subject,
+      email: account.email,
+      name: account.name,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountGoogleOAuth;
+  }
+  if (account.type === 'twitter_oauth') {
+    // We send along three potential URL shapes here based on possible profile picture URLs, all
+    // done to preserve size.
+    //   1. pfp begins with `default`, in which case we use the default profile picture URL structure
+    //   2. pfp does not start with https, in which case we assume the profile picture URL structure
+    //   3. Otherwise, we use the pfp URL as-is
+    let pfp = account.pfp ? account.pfp : null;
+    if (pfp?.startsWith('default')) {
+      pfp = `https://abs.twimg.com/sticky/default_profile_images/${pfp}`;
+    } else if (!pfp?.startsWith('https://')) {
+      pfp = `https://pbs.twimg.com/profile_images/${pfp}`;
+    }
+
+    return {
+      type: 'twitter_oauth',
+      subject: account.subject,
+      username: account.username,
+      name: account.name ? account.name : null,
+      profile_picture_url: pfp,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountTwitterOAuth;
+  }
+  if (account.type === 'discord_oauth') {
+    return {
+      type: 'discord_oauth',
+      subject: account.subject,
+      username: account.username,
+      email: null, // not a part of the identity token
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountDiscordOAuth;
+  }
+  if (account.type === 'github_oauth') {
+    return {
+      type: 'github_oauth',
+      subject: account.subject,
+      username: account.username,
+      email: null, // not a part of the identity token
+      name: null, // not a part of the identity token
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountGitHubOAuth;
+  }
+  if (account.type === 'spotify_oauth') {
+    return {
+      type: 'spotify_oauth',
+      subject: account.subject,
+      email: null, // not a part of the identity token
+      name: null, // not a part of the identity token
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountSpotifyOAuth;
+  }
+  if (account.type === 'instagram_oauth') {
+    return {
+      type: 'instagram_oauth',
+      subject: account.subject,
+      username: account.username,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountInstagramOAuth;
+  }
+  if (account.type === 'tiktok_oauth') {
+    return {
+      type: 'tiktok_oauth',
+      subject: account.subject,
+      username: account.username,
+      name: null, // not a part of the identity token
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountTiktokOAuth;
+  }
+  if (account.type === 'linkedin_oauth') {
+    return {
+      type: 'linkedin_oauth',
+      subject: account.subject,
+      email: account.email,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountLinkedInOAuth;
+  }
+  if (account.type === 'apple_oauth') {
+    return {
+      type: 'apple_oauth',
+      subject: account.subject,
+      email: account.email,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountAppleOAuth;
+  }
+  if (account.type === 'cross_app') {
+    return {
+      type: 'cross_app',
+      subject: account.subject,
+      provider_app_id: account.provider_app_id,
+      embedded_wallets: account.embedded_wallets,
+      smart_wallets: account.smart_wallets,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountCrossApp;
+  }
+  if (account.type === 'custom_auth') {
+    return {
+      type: 'custom_auth',
+      custom_user_id: account.custom_user_id,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountCustomJwt;
+  }
+
+  if (account.type === 'telegram') {
+    return {
+      type: 'telegram',
+      telegram_user_id: account.telegram_user_id,
+      username: account.username,
+      first_verified_at: null,
+      verified_at: account.lv,
+      latest_verified_at: account.lv,
+    } satisfies User.LinkedAccountTelegram;
+  }
+
+  return null;
+}
+
+function parseCustomMetadataClaim(payload: JWTPayload): User['custom_metadata'] {
+  const customMetadataClaim = payload['custom_metadata'];
+  if (customMetadataClaim === undefined) {
+    return undefined;
+  }
+  if (typeof customMetadataClaim !== 'string') {
+    throw new InvalidIdentityTokenError('Unable to parse identity token');
+  }
+  const parsedCustomMetadata = JSON.parse(customMetadataClaim) as unknown;
+  if (!parsedCustomMetadata || typeof parsedCustomMetadata !== 'object') {
+    throw new InvalidIdentityTokenError('Unable to parse identity token');
+  }
+
+  return parsedCustomMetadata as User['custom_metadata'];
+}
+
+export class InvalidIdentityTokenError extends PrivyAPIError {}

package/src/lib/user-utils.ts

@@ -0,0 +1,31 @@
+import type { User } from '../resources/users';
+
+export type LinkedAccount = User['linked_accounts'][number];
+
+// prettier-ignore
+export type ExternalWalletLinkedAccount = Exclude<
+  Extract<LinkedAccount, { type: 'wallet' }>,
+  EmbeddedWalletLinkedAccount
+>;
+
+/**
+ * An embedded wallet linked account is a wallet owned by the user that can be used with the Privy API.
+ */
+export type EmbeddedWalletLinkedAccount = Extract<
+  LinkedAccount,
+  { type: 'wallet'; wallet_client_type: 'privy'; connector_type: 'embedded' }
+>;
+
+/**
+ * Determines if a given linked account is an embedded wallet account.
+ * Embedded wallet accounts are wallets that can be used with the Privy API.
+ *
+ * @param account a linked account
+ * @returns whether the account is an embedded wallet account
+ */
+export const isEmbeddedWalletLinkedAccount = (
+  account: User['linked_accounts'][number],
+): account is EmbeddedWalletLinkedAccount =>
+  account.type === 'wallet' &&
+  account.wallet_client_type === 'privy' &&
+  account.connector_type === 'embedded';

package/src/public-api/PrivyClient.ts

@@ -7,6 +7,7 @@ import { PrivyUsersService } from './services/users';
 import { PrivyUtils } from './services/utils';
 import { JwtExchangeService } from '../lib/jwt-exchange';
 import { VERSION } from '../version';
+import { createPrivyAppJWKS } from '../lib/auth';
 
 type InternalClientOptions = Omit<ClientOptions, 'appID' | 'appSecret' | 'baseUrl'>;
 
@@ -15,6 +16,7 @@ export interface PrivyClientOptions extends InternalClientOptions {
   appSecret: string;
   apiUrl?: string;
   authorizationKeyCacheMaxCapacity?: number;
+  jwtVerificationKey?: string;
 }
 
 const DEFAULT_AUTHORIZATION_KEY_CACHE_MAX_CAPACITY = 1000;
@@ -40,6 +42,7 @@ export class PrivyClient {
     apiUrl,
     authorizationKeyCacheMaxCapacity = DEFAULT_AUTHORIZATION_KEY_CACHE_MAX_CAPACITY,
     defaultHeaders,
+    jwtVerificationKey,
     ...clientOptions
   }: PrivyClientOptions) {
     this.privyApiClient = new PrivyAPI({
@@ -53,6 +56,13 @@ export class PrivyClient {
         'privy-client': `node:${VERSION}`,
       },
     });
+    const appJwks = createPrivyAppJWKS({
+      appId: this.privyApiClient.appID,
+      apiUrl: this.privyApiClient.baseURL,
+      headers: { 'privy-client': `node:${VERSION}` },
+      verificationKeyOverride: jwtVerificationKey,
+    });
+
     this.jwtExchangeService = new JwtExchangeService(
       this.privyApiClient.wallets,
       authorizationKeyCacheMaxCapacity,
@@ -61,8 +71,8 @@ export class PrivyClient {
     this.policiesService = new PrivyPoliciesService(this.privyApiClient, this);
     this.transactionsService = new PrivyTransactionsService(this.privyApiClient);
     this.keyQuorumsService = new PrivyKeyQuorumsService(this.privyApiClient, this);
-    this.usersService = new PrivyUsersService(this.privyApiClient);
-    this.utilsService = new PrivyUtils(this);
+    this.usersService = new PrivyUsersService(this.privyApiClient, appJwks);
+    this.utilsService = new PrivyUtils(this.privyApiClient, this, appJwks);
   }
 
   public wallets(): PrivyWalletsService {

package/src/public-api/services/ethereum.ts

@@ -57,10 +57,6 @@ export class PrivyEthereumService {
       chain_type: 'ethereum',
     });
 
-    if (!response.data) {
-      throw new Error(response.error?.message ?? 'Unexpected response from Privy API');
-    }
-
     return response.data;
   }
 
@@ -100,10 +96,6 @@ export class PrivyEthereumService {
       chain_type: 'ethereum',
     });
 
-    if (!response.data) {
-      throw new Error(response.error?.message ?? 'Unexpected response from Privy API');
-    }
-
     return response.data;
   }
 }

package/src/public-api/services/solana.ts

@@ -75,10 +75,6 @@ export class PrivySolanaService {
       params,
     });
 
-    if (!response.data) {
-      throw new Error(response.error?.message ?? 'Unexpected response from Privy API');
-    }
-
     return response.data;
   }
 }

package/src/public-api/services/users.ts

@@ -1,3 +1,37 @@
-import { Users } from '../../resources';
+import { PrivyAPI } from '../../client';
+import { PrivyAppJWKS, verifyIdentityToken } from '../../lib/auth';
+import { User, Users } from '../../resources';
 
-export class PrivyUsersService extends Users {}
+export class PrivyUsersService extends Users {
+  private appJwks: PrivyAppJWKS;
+  constructor(privyApiClient: PrivyAPI, appJwks: PrivyAppJWKS) {
+    super(privyApiClient);
+    this.appJwks = appJwks;
+  }
+
+  /**
+   * Gets a user object from the identity token.
+   * This verifies the token and parses the payload into a `User` object.
+   * Note the user object may be incomplete due to the size constraints of the identity token.
+   *
+   * @param input.id_token the identity token to parse.
+   * @returns the user object parsed from the identity token.
+   *
+   * @example
+   * const idToken = req.cookies.get('privy-id-token'); // or however your framework surfaces cookies
+   * const user = await client.users().get({idToken});
+   */
+  public async get({ id_token }: PrivyUsersService.GetInput): Promise<User> {
+    return verifyIdentityToken({
+      identity_token: id_token,
+      app_id: this._client.appID,
+      verification_key: this.appJwks,
+    });
+  }
+}
+
+export namespace PrivyUsersService {
+  export type GetInput = {
+    id_token: string;
+  };
+}

package/src/public-api/services/utils/auth.ts

@@ -0,0 +1,41 @@
+import { PrivyAPI } from '../../../client';
+import {
+  PrivyAppJWKS,
+  verifyAuthToken,
+  VerifyAuthTokenResponse,
+  verifyIdentityToken,
+} from '../../../lib/auth';
+import { User } from '../../../resources';
+
+export class PrivyAuthUtils {
+  private appJwks: PrivyAppJWKS;
+  private privyAppID: string;
+
+  constructor(privyApiClient: PrivyAPI, appJwks: PrivyAppJWKS) {
+    this.appJwks = appJwks;
+    this.privyAppID = privyApiClient.appID;
+  }
+
+  /**
+   * Verifies the authentication token, and returns the payload if it is valid.
+   *
+   * @param authToken - The authentication token to verify.
+   * @returns The payload of the token if it is valid.
+   * @throws If the token is invalid.
+   */
+  public async verifyAuthToken(authToken: string): Promise<VerifyAuthTokenResponse> {
+    return verifyAuthToken({
+      auth_token: authToken,
+      app_id: this.privyAppID,
+      verification_key: this.appJwks,
+    });
+  }
+
+  public async verifyIdentityToken(identityToken: string): Promise<User> {
+    return verifyIdentityToken({
+      identity_token: identityToken,
+      app_id: this.privyAppID,
+      verification_key: this.appJwks,
+    });
+  }
+}

package/src/public-api/services/utils/request-formatter.ts

@@ -0,0 +1,6 @@
+import { formatRequestForAuthorizationSignature } from '../../../lib/authorization';
+
+export class PrivyRequestFormatter {
+  // Expose these as methods here for convenience
+  public formatRequestForAuthorizationSignature = formatRequestForAuthorizationSignature;
+}