feat: added pairIdentifiers service

packages/profile-sync-controller/src/sdk/authentication-jwt-bearer/services.ts

@@ -7,6 +7,9 @@ import { AuthType } from './types';
 export const NONCE_URL = (env: Env) =>
   `${getEnvUrls(env).authApiUrl}/api/v2/nonce`;
 
+export const PAIR_IDENTIFIERS = (env: Env) =>
+  `${getEnvUrls(env).authApiUrl}/api/v2/identifiers/pair`;
+
 export const OIDC_TOKEN_URL = (env: Env) =>
   `${getEnvUrls(env).oidcApiUrl}/oauth2/token`;
 
@@ -36,6 +39,57 @@ type NonceResponse = {
   expiresIn: number;
 };
 
+type PairRequest = {
+  signature: string;
+  raw_message: string;
+  encrypted_storage_key: string;
+  identifier_type: 'SIWE' | 'SRP';
+};
+
+/**
+ * Pair multiple identifiers under a single profile
+ *
+ * @param nonce - session nonce
+ * @param logins - pairing request payload
+ * @param accessToken - JWT access token used to access protected resources
+ * @param env - server environment
+ * @returns void.
+ */
+export async function pairIdentifiers(
+  nonce: string,
+  logins: PairRequest[],
+  accessToken: string,
+  env: Env,
+): Promise<void> {
+  const pairUrl = new URL(PAIR_IDENTIFIERS(env));
+
+  try {
+    const response = await fetch(pairUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${accessToken}`,
+      },
+      body: JSON.stringify({
+        nonce,
+        logins,
+      }),
+    });
+
+    if (!response.ok) {
+      const responseBody = (await response.json()) as ErrorMessage;
+      throw new Error(
+        `HTTP error message: ${responseBody.message}, error: ${responseBody.error}`,
+      );
+    }
+  } catch (e) {
+    /* istanbul ignore next */
+    const errorMessage =
+      e instanceof Error ? e.message : JSON.stringify(e ?? '');
+    throw new SignInError(`unable to pair identifiers: ${errorMessage}`);
+  }
+}
+
 /**
  * Service to Get Nonce for JWT Bearer Flow
  *

packages/profile-sync-controller/src/sdk/authentication-jwt-bearer/types.ts

@@ -70,3 +70,9 @@ export type ErrorMessage = {
   message: string;
   error: string;
 };
+
+export type Pair = {
+  identifier: string;
+  encryptedStorageKey: string;
+  identifierType: 'SIWE' | 'SRP';
+};

packages/profile-sync-controller/src/sdk/authentication.ts

@@ -1,7 +1,12 @@
 import { SIWEJwtBearerAuth } from './authentication-jwt-bearer/flow-siwe';
 import { SRPJwtBearerAuth } from './authentication-jwt-bearer/flow-srp';
-import type { UserProfile } from './authentication-jwt-bearer/types';
+import {
+  getNonce,
+  pairIdentifiers,
+} from './authentication-jwt-bearer/services';
+import type { UserProfile, Pair } from './authentication-jwt-bearer/types';
 import { AuthType } from './authentication-jwt-bearer/types';
+import type { Env } from './env';
 import { UnsupportedAuthTypeError } from './errors';
 
 // Computing the Classes, so we only get back the public methods for the interface.
@@ -16,10 +21,13 @@ type JwtBearerAuthParams = SiweParams | SRPParams;
 export class JwtBearerAuth implements SIWEInterface, SRPInterface {
   #type: AuthType;
 
+  #env: Env;
+
   #sdk: SIWEJwtBearerAuth | SRPJwtBearerAuth;
 
   constructor(...args: JwtBearerAuthParams) {
     this.#type = args[0].type;
+    this.#env = args[0].env;
 
     if (args[0].type === AuthType.SRP) {
       this.#sdk = new SRPJwtBearerAuth(args[0], args[1]);
@@ -50,6 +58,29 @@ export class JwtBearerAuth implements SIWEInterface, SRPInterface {
     return await this.#sdk.signMessage(message);
   }
 
+  async pairIdentifiers(
+    pairing: Pair[],
+    signMessage: (message: string) => Promise<string>,
+  ): Promise<void> {
+    const profile = await this.getUserProfile();
+    const n = await getNonce(profile.profileId, this.#env);
+    const logins = await Promise.all(
+      pairing.map(async (p) => {
+        const raw = `metamask:${n.nonce}:${p.identifier}`;
+        const sig = await signMessage(raw);
+        return {
+          signature: sig,
+          raw_message: raw,
+          encrypted_storage_key: p.encryptedStorageKey,
+          identifier_type: p.identifierType,
+        };
+      }),
+    );
+
+    const accessToken = await this.getAccessToken();
+    return pairIdentifiers(n.nonce, logins, accessToken, this.#env);
+  }
+
   prepare(signer: {
     address: string;
     chainId: number;