@portal-hq/passkey-storage 3.0.5

package/README.md

@@ -0,0 +1,13 @@
+# @portal-hq/passkey-storage
+
+Portal's Passkey storage adapter
+
+## Installation
+
+```sh
+npm install @portal-hq/passkey-storage
+```
+
+```sh
+yarn add @portal-hq/passkey-storage
+```

package/lib/commonjs/index.js

@@ -0,0 +1,247 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasskeyStatus = exports.PasskeyStorage = void 0;
+const utils_1 = require("@portal-hq/utils");
+const react_native_passkey_1 = require("react-native-passkey");
+class PasskeyStorage {
+    constructor(opts) {
+        this.relyingParty = 'portalhq.io';
+        this.webAuthnHost = 'https://backup.web.portalhq.io';
+        this.relyingPartyOrigins = [
+            'https://portalhq.io',
+            'https://backup.web.portalhq.io',
+        ];
+        this.relyingParty = opts.relyingParty || this.relyingParty;
+        this.relyingPartyOrigins =
+            opts.relyingPartyOrigins || this.relyingPartyOrigins;
+        this.webAuthnHost = opts.webAuthnHost || this.webAuthnHost;
+        this.passkeyApi = new utils_1.HttpRequester({
+            baseUrl: this.webAuthnHost,
+        });
+    }
+    delete() {
+        throw new Error('Method is not supported.');
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    read() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!((_a = this.api) === null || _a === void 0 ? void 0 : _a.apiKey)) {
+                    throw new Error('API key is not set');
+                }
+                const apiKey = this.api.apiKey;
+                // Construct the headers object
+                const headers = {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                };
+                const assertion = yield this.getAssertionAndSetSessionId(headers);
+                // finish login
+                const encryptionKey = yield this.getEncryptionKey(assertion);
+                return encryptionKey;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to complete read operation: ${error.message}`);
+                }
+                else {
+                    throw new Error('Failed to complete read operation due to an unexpected error');
+                }
+            }
+        });
+    }
+    write(privateKey) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!((_a = this.api) === null || _a === void 0 ? void 0 : _a.apiKey)) {
+                    throw new Error('API key is not set');
+                }
+                const apiKey = this.api.apiKey;
+                // Construct the headers object
+                const headers = {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                };
+                // Get the status of the passkey
+                const passkeyStatus = yield this.passkeyApi.get('/passkeys/status', {
+                    headers,
+                });
+                // If the passkey is registered with a credential, we login
+                if (passkeyStatus.status === PasskeyStatus.RegisteredWithCredential) {
+                    // Login
+                    const assertion = yield this.getAssertionAndSetSessionId(headers);
+                    yield this.passkeyApi.post('/passkeys/finish-login/write', {
+                        headers: {
+                            'Content-Type': 'application/json',
+                            Authorization: `Bearer ${apiKey}`,
+                        },
+                        body: {
+                            assertion: JSON.stringify(assertion),
+                            sessionId: this.sessionId,
+                            encryptionKey: privateKey,
+                            relyingParty: this.relyingParty,
+                            relyingPartyOrigins: this.relyingPartyOrigins,
+                        },
+                    });
+                }
+                else {
+                    // Register
+                    const attestation = yield this.getAttestationAndSetSessionId(headers);
+                    yield this.passkeyApi.post('/passkeys/finish-registration', {
+                        headers: {
+                            'Content-Type': 'application/json',
+                            Authorization: `Bearer ${apiKey}`,
+                        },
+                        body: {
+                            attestation: JSON.stringify(attestation),
+                            sessionId: this.sessionId,
+                            encryptionKey: privateKey,
+                            relyingParty: this.relyingParty,
+                            relyingPartyOrigins: this.relyingPartyOrigins,
+                        },
+                    });
+                }
+                return 'done';
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to complete write operation: ${error.message}`);
+                }
+                else {
+                    throw new Error('Failed to complete write operation due to an unexpected error');
+                }
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    validateOperations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isSupported = react_native_passkey_1.Passkey.isSupported();
+            return isSupported;
+        });
+    }
+    // Helper Methods
+    getAttestationAndSetSessionId(headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const beginResponse = yield this.passkeyApi.post('/passkeys/begin-registration', {
+                headers,
+                body: {
+                    relyingParty: this.relyingParty,
+                    relyingPartyOrigins: this.relyingPartyOrigins,
+                },
+            });
+            // check if challenge exists
+            if (!beginResponse.options.publicKey.challenge) {
+                throw new Error('Challenge is missing in passkey options. Please try again and check your web authn host url.');
+            }
+            beginResponse.options.publicKey.challenge = convertBase64UrlToBase64(beginResponse.options.publicKey.challenge);
+            const result = yield react_native_passkey_1.Passkey.register(beginResponse.options.publicKey);
+            const attestation = {
+                rawId: convertBase64ToBase64Url(result.rawId),
+                id: convertBase64ToBase64Url(result.id),
+                type: 'public-key',
+                response: {
+                    clientDataJSON: convertBase64ToBase64Url(result.response.clientDataJSON),
+                    attestationObject: convertBase64ToBase64Url(result.response.attestationObject),
+                },
+            };
+            // check if sessionId exists
+            if (!beginResponse.sessionId) {
+                throw new Error('Session ID is missing in passkey options. Please try again and check your web authn host url.');
+            }
+            this.sessionId = beginResponse.sessionId;
+            return attestation;
+        });
+    }
+    getAssertionAndSetSessionId(headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const beginResponse = yield this.passkeyApi.post('/passkeys/begin-login', {
+                headers,
+                body: {
+                    relyingParty: this.relyingParty,
+                    relyingPartyOrigins: this.relyingPartyOrigins,
+                },
+            });
+            // check if challenge exists
+            if (!beginResponse.options.publicKey.challenge) {
+                throw new Error('Challenge is missing in passkey options. Please try again and check your web authn host url.');
+            }
+            beginResponse.options.publicKey.challenge = convertBase64UrlToBase64(beginResponse.options.publicKey.challenge);
+            const result = yield react_native_passkey_1.Passkey.authenticate(beginResponse.options.publicKey);
+            const assertion = {
+                rawId: convertBase64ToBase64Url(result.rawId),
+                id: convertBase64ToBase64Url(result.id),
+                type: 'public-key',
+                response: {
+                    clientDataJSON: convertBase64ToBase64Url(result.response.clientDataJSON),
+                    authenticatorData: convertBase64ToBase64Url(result.response.authenticatorData),
+                    signature: convertBase64ToBase64Url(result.response.signature),
+                    userHandle: convertBase64ToBase64Url(result.response.userHandle),
+                },
+            };
+            this.sessionId = beginResponse.sessionId;
+            return assertion;
+        });
+    }
+    getEncryptionKey(assertion) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (((_a = this.api) === null || _a === void 0 ? void 0 : _a.apiKey) === undefined) {
+                throw new Error('API key is not set');
+            }
+            const finishResponse = yield this.passkeyApi.post('/passkeys/finish-login/read', {
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.api.apiKey}`,
+                },
+                body: {
+                    assertion: JSON.stringify(assertion),
+                    sessionId: this.sessionId,
+                    relyingParty: this.relyingParty,
+                    relyingPartyOrigins: this.relyingPartyOrigins,
+                },
+            });
+            // check if encryptionKey exists
+            if (!finishResponse.encryptionKey) {
+                throw new Error('No encryption key found. Please try again.');
+            }
+            return finishResponse.encryptionKey;
+        });
+    }
+}
+exports.PasskeyStorage = PasskeyStorage;
+// Assuming 'challenge' is the base64 URL-encoded string received from the server
+function convertBase64UrlToBase64(challenge) {
+    let base64 = challenge.replace(/-/g, '+').replace(/_/g, '/');
+    while (base64.length % 4 !== 0) {
+        base64 += '=';
+    }
+    return base64;
+}
+function convertBase64ToBase64Url(base64) {
+    // Replace '+' with '-' and '/' with '_'
+    let base64Url = base64.replace(/\+/g, '-').replace(/\//g, '_');
+    // Remove any '=' padding
+    base64Url = base64Url.replace(/=+$/, '');
+    return base64Url;
+}
+var PasskeyStatus;
+(function (PasskeyStatus) {
+    PasskeyStatus["NotRegistered"] = "not registered";
+    PasskeyStatus["Registered"] = "registered";
+    PasskeyStatus["RegisteredWithCredential"] = "registered with credential";
+})(PasskeyStatus = exports.PasskeyStatus || (exports.PasskeyStatus = {}));
+exports.default = PasskeyStorage;

package/lib/esm/index.js

@@ -0,0 +1,243 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { HttpRequester } from '@portal-hq/utils';
+import { Passkey, } from 'react-native-passkey';
+export class PasskeyStorage {
+    constructor(opts) {
+        this.relyingParty = 'portalhq.io';
+        this.webAuthnHost = 'https://backup.web.portalhq.io';
+        this.relyingPartyOrigins = [
+            'https://portalhq.io',
+            'https://backup.web.portalhq.io',
+        ];
+        this.relyingParty = opts.relyingParty || this.relyingParty;
+        this.relyingPartyOrigins =
+            opts.relyingPartyOrigins || this.relyingPartyOrigins;
+        this.webAuthnHost = opts.webAuthnHost || this.webAuthnHost;
+        this.passkeyApi = new HttpRequester({
+            baseUrl: this.webAuthnHost,
+        });
+    }
+    delete() {
+        throw new Error('Method is not supported.');
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    read() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!((_a = this.api) === null || _a === void 0 ? void 0 : _a.apiKey)) {
+                    throw new Error('API key is not set');
+                }
+                const apiKey = this.api.apiKey;
+                // Construct the headers object
+                const headers = {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                };
+                const assertion = yield this.getAssertionAndSetSessionId(headers);
+                // finish login
+                const encryptionKey = yield this.getEncryptionKey(assertion);
+                return encryptionKey;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to complete read operation: ${error.message}`);
+                }
+                else {
+                    throw new Error('Failed to complete read operation due to an unexpected error');
+                }
+            }
+        });
+    }
+    write(privateKey) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!((_a = this.api) === null || _a === void 0 ? void 0 : _a.apiKey)) {
+                    throw new Error('API key is not set');
+                }
+                const apiKey = this.api.apiKey;
+                // Construct the headers object
+                const headers = {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                };
+                // Get the status of the passkey
+                const passkeyStatus = yield this.passkeyApi.get('/passkeys/status', {
+                    headers,
+                });
+                // If the passkey is registered with a credential, we login
+                if (passkeyStatus.status === PasskeyStatus.RegisteredWithCredential) {
+                    // Login
+                    const assertion = yield this.getAssertionAndSetSessionId(headers);
+                    yield this.passkeyApi.post('/passkeys/finish-login/write', {
+                        headers: {
+                            'Content-Type': 'application/json',
+                            Authorization: `Bearer ${apiKey}`,
+                        },
+                        body: {
+                            assertion: JSON.stringify(assertion),
+                            sessionId: this.sessionId,
+                            encryptionKey: privateKey,
+                            relyingParty: this.relyingParty,
+                            relyingPartyOrigins: this.relyingPartyOrigins,
+                        },
+                    });
+                }
+                else {
+                    // Register
+                    const attestation = yield this.getAttestationAndSetSessionId(headers);
+                    yield this.passkeyApi.post('/passkeys/finish-registration', {
+                        headers: {
+                            'Content-Type': 'application/json',
+                            Authorization: `Bearer ${apiKey}`,
+                        },
+                        body: {
+                            attestation: JSON.stringify(attestation),
+                            sessionId: this.sessionId,
+                            encryptionKey: privateKey,
+                            relyingParty: this.relyingParty,
+                            relyingPartyOrigins: this.relyingPartyOrigins,
+                        },
+                    });
+                }
+                return 'done';
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to complete write operation: ${error.message}`);
+                }
+                else {
+                    throw new Error('Failed to complete write operation due to an unexpected error');
+                }
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    validateOperations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isSupported = Passkey.isSupported();
+            return isSupported;
+        });
+    }
+    // Helper Methods
+    getAttestationAndSetSessionId(headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const beginResponse = yield this.passkeyApi.post('/passkeys/begin-registration', {
+                headers,
+                body: {
+                    relyingParty: this.relyingParty,
+                    relyingPartyOrigins: this.relyingPartyOrigins,
+                },
+            });
+            // check if challenge exists
+            if (!beginResponse.options.publicKey.challenge) {
+                throw new Error('Challenge is missing in passkey options. Please try again and check your web authn host url.');
+            }
+            beginResponse.options.publicKey.challenge = convertBase64UrlToBase64(beginResponse.options.publicKey.challenge);
+            const result = yield Passkey.register(beginResponse.options.publicKey);
+            const attestation = {
+                rawId: convertBase64ToBase64Url(result.rawId),
+                id: convertBase64ToBase64Url(result.id),
+                type: 'public-key',
+                response: {
+                    clientDataJSON: convertBase64ToBase64Url(result.response.clientDataJSON),
+                    attestationObject: convertBase64ToBase64Url(result.response.attestationObject),
+                },
+            };
+            // check if sessionId exists
+            if (!beginResponse.sessionId) {
+                throw new Error('Session ID is missing in passkey options. Please try again and check your web authn host url.');
+            }
+            this.sessionId = beginResponse.sessionId;
+            return attestation;
+        });
+    }
+    getAssertionAndSetSessionId(headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const beginResponse = yield this.passkeyApi.post('/passkeys/begin-login', {
+                headers,
+                body: {
+                    relyingParty: this.relyingParty,
+                    relyingPartyOrigins: this.relyingPartyOrigins,
+                },
+            });
+            // check if challenge exists
+            if (!beginResponse.options.publicKey.challenge) {
+                throw new Error('Challenge is missing in passkey options. Please try again and check your web authn host url.');
+            }
+            beginResponse.options.publicKey.challenge = convertBase64UrlToBase64(beginResponse.options.publicKey.challenge);
+            const result = yield Passkey.authenticate(beginResponse.options.publicKey);
+            const assertion = {
+                rawId: convertBase64ToBase64Url(result.rawId),
+                id: convertBase64ToBase64Url(result.id),
+                type: 'public-key',
+                response: {
+                    clientDataJSON: convertBase64ToBase64Url(result.response.clientDataJSON),
+                    authenticatorData: convertBase64ToBase64Url(result.response.authenticatorData),
+                    signature: convertBase64ToBase64Url(result.response.signature),
+                    userHandle: convertBase64ToBase64Url(result.response.userHandle),
+                },
+            };
+            this.sessionId = beginResponse.sessionId;
+            return assertion;
+        });
+    }
+    getEncryptionKey(assertion) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (((_a = this.api) === null || _a === void 0 ? void 0 : _a.apiKey) === undefined) {
+                throw new Error('API key is not set');
+            }
+            const finishResponse = yield this.passkeyApi.post('/passkeys/finish-login/read', {
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.api.apiKey}`,
+                },
+                body: {
+                    assertion: JSON.stringify(assertion),
+                    sessionId: this.sessionId,
+                    relyingParty: this.relyingParty,
+                    relyingPartyOrigins: this.relyingPartyOrigins,
+                },
+            });
+            // check if encryptionKey exists
+            if (!finishResponse.encryptionKey) {
+                throw new Error('No encryption key found. Please try again.');
+            }
+            return finishResponse.encryptionKey;
+        });
+    }
+}
+// Assuming 'challenge' is the base64 URL-encoded string received from the server
+function convertBase64UrlToBase64(challenge) {
+    let base64 = challenge.replace(/-/g, '+').replace(/_/g, '/');
+    while (base64.length % 4 !== 0) {
+        base64 += '=';
+    }
+    return base64;
+}
+function convertBase64ToBase64Url(base64) {
+    // Replace '+' with '-' and '/' with '_'
+    let base64Url = base64.replace(/\+/g, '-').replace(/\//g, '_');
+    // Remove any '=' padding
+    base64Url = base64Url.replace(/=+$/, '');
+    return base64Url;
+}
+export var PasskeyStatus;
+(function (PasskeyStatus) {
+    PasskeyStatus["NotRegistered"] = "not registered";
+    PasskeyStatus["Registered"] = "registered";
+    PasskeyStatus["RegisteredWithCredential"] = "registered with credential";
+})(PasskeyStatus || (PasskeyStatus = {}));
+export default PasskeyStorage;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@portal-hq/passkey-storage",
+  "version": "3.0.5",
+  "description": "Portal's Passkey storage adapter",
+  "license": "MIT",
+  "author": "Portal Labs, Inc.",
+  "homepage": "https://portalhq.io",
+  "main": "lib/commonjs/index",
+  "module": "lib/esm/index",
+  "source": "src/index",
+  "types": "src/index",
+  "files": [
+    "lib",
+    "src",
+    "types.d.ts"
+  ],
+  "scripts": {
+    "coverage": "jest --collect-coverage",
+    "prepare": "yarn prepare:cjs && yarn prepare:esm",
+    "prepare:cjs": "tsc --outDir lib/commonjs --module commonjs",
+    "prepare:esm": "tsc --outDir lib/esm --module es2015 --target es2015",
+    "test": "jest --pass-with-no-tests"
+  },
+  "dependencies": {
+    "@portal-hq/core": "^3.0.5",
+    "@portal-hq/utils": "^3.0.5",
+    "react-native-passkey": "^2.1.1"
+  },
+  "devDependencies": {
+    "@babel/preset-typescript": "^7.18.6",
+    "@types/jest": "^29.2.0",
+    "jest": "^29.2.1",
+    "jest-environment-jsdom": "^29.2.2",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.8.4"
+  },
+  "peerDependencies": {
+    "react-native-passkey": "^2.1.1"
+  },
+  "gitHead": "58faddeac81625fcb230357540e7f4663f8c810c"
+}

package/src/index.ts

@@ -0,0 +1,304 @@
+import { HttpRequester, IPortalApi, type Storage } from '@portal-hq/utils'
+import {
+  Passkey,
+  PasskeyAuthenticationResult,
+  PasskeyRegistrationResult,
+} from 'react-native-passkey'
+
+import type {
+  AuthenticationResponse,
+  LoginReadResponse,
+  PasskeyOptions,
+  PasskeyStatusResponse,
+  RegistrationResponse,
+} from '../types'
+
+export class PasskeyStorage implements Storage {
+  public api?: IPortalApi
+  private passkeyApi: HttpRequester
+  private relyingParty: string = 'portalhq.io'
+  private webAuthnHost: string = 'https://backup.web.portalhq.io'
+  private relyingPartyOrigins: string[] = [
+    'https://portalhq.io',
+    'https://backup.web.portalhq.io',
+  ]
+  private sessionId?: string
+
+  constructor(opts: PasskeyOptions) {
+    this.relyingParty = opts.relyingParty || this.relyingParty
+    this.relyingPartyOrigins =
+      opts.relyingPartyOrigins || this.relyingPartyOrigins
+    this.webAuthnHost = opts.webAuthnHost || this.webAuthnHost
+    this.passkeyApi = new HttpRequester({
+      baseUrl: this.webAuthnHost,
+    })
+  }
+
+  delete(): Promise<boolean> {
+    throw new Error('Method is not supported.')
+  }
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  public async read(): Promise<string> {
+    try {
+      if (!this.api?.apiKey) {
+        throw new Error('API key is not set')
+      }
+
+      const apiKey = this.api.apiKey
+
+      // Construct the headers object
+      const headers = {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+      }
+      const assertion = await this.getAssertionAndSetSessionId(headers)
+
+      // finish login
+      const encryptionKey = await this.getEncryptionKey(assertion)
+
+      return encryptionKey
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to complete read operation: ${error.message}`)
+      } else {
+        throw new Error(
+          'Failed to complete read operation due to an unexpected error',
+        )
+      }
+    }
+  }
+
+  public async write(privateKey: string): Promise<string> {
+    try {
+      if (!this.api?.apiKey) {
+        throw new Error('API key is not set')
+      }
+
+      const apiKey = this.api.apiKey
+
+      // Construct the headers object
+      const headers = {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+      }
+
+      // Get the status of the passkey
+      const passkeyStatus = await this.passkeyApi.get<PasskeyStatusResponse>(
+        '/passkeys/status',
+        {
+          headers,
+        },
+      )
+
+      // If the passkey is registered with a credential, we login
+      if (passkeyStatus.status === PasskeyStatus.RegisteredWithCredential) {
+        // Login
+        const assertion = await this.getAssertionAndSetSessionId(headers)
+
+        await this.passkeyApi.post<string>('/passkeys/finish-login/write', {
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+          },
+          body: {
+            assertion: JSON.stringify(assertion),
+            sessionId: this.sessionId,
+            encryptionKey: privateKey,
+            relyingParty: this.relyingParty,
+            relyingPartyOrigins: this.relyingPartyOrigins,
+          },
+        })
+      } else {
+        // Register
+        const attestation = await this.getAttestationAndSetSessionId(headers)
+
+        await this.passkeyApi.post<string>('/passkeys/finish-registration', {
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+          },
+          body: {
+            attestation: JSON.stringify(attestation),
+            sessionId: this.sessionId,
+            encryptionKey: privateKey,
+            relyingParty: this.relyingParty,
+            relyingPartyOrigins: this.relyingPartyOrigins,
+          },
+        })
+      }
+
+      return 'done'
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to complete write operation: ${error.message}`)
+      } else {
+        throw new Error(
+          'Failed to complete write operation due to an unexpected error',
+        )
+      }
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  public async validateOperations(): Promise<boolean> {
+    const isSupported: boolean = Passkey.isSupported()
+    return isSupported
+  }
+
+  // Helper Methods
+  private async getAttestationAndSetSessionId(
+    headers: Record<string, any>,
+  ): Promise<PasskeyRegistrationResult> {
+    const beginResponse = await this.passkeyApi.post<RegistrationResponse>(
+      '/passkeys/begin-registration',
+      {
+        headers,
+        body: {
+          relyingParty: this.relyingParty,
+          relyingPartyOrigins: this.relyingPartyOrigins,
+        },
+      },
+    )
+
+    // check if challenge exists
+    if (!beginResponse.options.publicKey.challenge) {
+      throw new Error(
+        'Challenge is missing in passkey options. Please try again and check your web authn host url.',
+      )
+    }
+    beginResponse.options.publicKey.challenge = convertBase64UrlToBase64(
+      beginResponse.options.publicKey.challenge,
+    )
+
+    const result: PasskeyRegistrationResult = await Passkey.register(
+      beginResponse.options.publicKey,
+    )
+    const attestation = {
+      rawId: convertBase64ToBase64Url(result.rawId),
+      id: convertBase64ToBase64Url(result.id),
+      type: 'public-key',
+      response: {
+        clientDataJSON: convertBase64ToBase64Url(
+          result.response.clientDataJSON,
+        ),
+        attestationObject: convertBase64ToBase64Url(
+          result.response.attestationObject,
+        ),
+      },
+    }
+
+    // check if sessionId exists
+    if (!beginResponse.sessionId) {
+      throw new Error(
+        'Session ID is missing in passkey options. Please try again and check your web authn host url.',
+      )
+    }
+    this.sessionId = beginResponse.sessionId
+
+    return attestation
+  }
+
+  private async getAssertionAndSetSessionId(
+    headers: Record<string, any>,
+  ): Promise<PasskeyAuthenticationResult> {
+    const beginResponse = await this.passkeyApi.post<AuthenticationResponse>(
+      '/passkeys/begin-login',
+      {
+        headers,
+        body: {
+          relyingParty: this.relyingParty,
+          relyingPartyOrigins: this.relyingPartyOrigins,
+        },
+      },
+    )
+
+    // check if challenge exists
+    if (!beginResponse.options.publicKey.challenge) {
+      throw new Error(
+        'Challenge is missing in passkey options. Please try again and check your web authn host url.',
+      )
+    }
+    beginResponse.options.publicKey.challenge = convertBase64UrlToBase64(
+      beginResponse.options.publicKey.challenge,
+    )
+
+    const result: PasskeyAuthenticationResult = await Passkey.authenticate(
+      beginResponse.options.publicKey,
+    )
+
+    const assertion = {
+      rawId: convertBase64ToBase64Url(result.rawId),
+      id: convertBase64ToBase64Url(result.id),
+      type: 'public-key',
+      response: {
+        clientDataJSON: convertBase64ToBase64Url(
+          result.response.clientDataJSON,
+        ),
+        authenticatorData: convertBase64ToBase64Url(
+          result.response.authenticatorData,
+        ),
+        signature: convertBase64ToBase64Url(result.response.signature),
+        userHandle: convertBase64ToBase64Url(result.response.userHandle),
+      },
+    }
+
+    this.sessionId = beginResponse.sessionId
+    return assertion
+  }
+
+  private async getEncryptionKey(
+    assertion: PasskeyAuthenticationResult,
+  ): Promise<string> {
+    if (this.api?.apiKey === undefined) {
+      throw new Error('API key is not set')
+    }
+
+    const finishResponse = await this.passkeyApi.post<LoginReadResponse>(
+      '/passkeys/finish-login/read',
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.api.apiKey}`,
+        },
+        body: {
+          assertion: JSON.stringify(assertion),
+          sessionId: this.sessionId,
+          relyingParty: this.relyingParty,
+          relyingPartyOrigins: this.relyingPartyOrigins,
+        },
+      },
+    )
+    // check if encryptionKey exists
+    if (!finishResponse.encryptionKey) {
+      throw new Error('No encryption key found. Please try again.')
+    }
+    return finishResponse.encryptionKey
+  }
+}
+// Assuming 'challenge' is the base64 URL-encoded string received from the server
+function convertBase64UrlToBase64(challenge: string): string {
+  let base64 = challenge.replace(/-/g, '+').replace(/_/g, '/')
+  while (base64.length % 4 !== 0) {
+    base64 += '='
+  }
+  return base64
+}
+
+function convertBase64ToBase64Url(base64: string) {
+  // Replace '+' with '-' and '/' with '_'
+  let base64Url = base64.replace(/\+/g, '-').replace(/\//g, '_')
+  // Remove any '=' padding
+  base64Url = base64Url.replace(/=+$/, '')
+  return base64Url
+}
+
+export enum PasskeyStatus {
+  NotRegistered = 'not registered',
+  Registered = 'registered',
+  RegisteredWithCredential = 'registered with credential',
+}
+
+export default PasskeyStorage

package/types.d.ts

@@ -0,0 +1,50 @@
+import {
+  PasskeyRegistrationRequest,
+  PasskeyAuthenticationRequest,
+} from 'react-native-passkey/lib/typescript/Passkey'
+import { PasskeyStatus } from './src'
+
+export declare class PasskeyStorage {
+  public accessToken?: string
+  public api: HttpRequester
+
+  constructor(options: PasskeyOptions)
+
+  public async read(): Promise<string | null>
+
+  public async write(content: string): Promise<string | null>
+
+  public async validateOperations(): Promise<boolean>
+}
+
+export interface PasskeyOptions {
+  relyingParty?: string
+  webAuthnHost?: string
+  relyingPartyOrigins?: string[]
+}
+
+export interface PasskeyStatusResponse {
+  status: PasskeyStatus
+}
+
+export interface RegistrationResponse {
+  options: RegistrationOptions
+  sessionId: string
+}
+
+export interface RegistrationOptions {
+  publicKey: PasskeyRegistrationRequest
+}
+
+export interface AuthenticationResponse {
+  options: AuthenticationOptions
+  sessionId: string
+}
+
+export interface AuthenticationOptions {
+  publicKey: PasskeyAuthenticationRequest
+}
+
+export interface LoginReadResponse {
+  encryptionKey: string
+}