diff --git a/.github/scripts/generateCodeExamples.js b/.github/scripts/generateCodeExamples.ts
similarity index 83%
rename from .github/scripts/generateCodeExamples.js
rename to .github/scripts/generateCodeExamples.ts
index d3bbbf04..ef314a5b 100644
--- a/.github/scripts/generateCodeExamples.js
+++ b/.github/scripts/generateCodeExamples.ts
@@ -1,5 +1,13 @@
 const fs = require('fs')
 
+type Repo = {
+  organization: string
+  repo: string
+  destination: string
+  branch: string
+  files: string[]
+}
+
 const repos = [
   {
     organization: '5afe',
@@ -35,6 +43,20 @@ const repos = [
       '/layouts/default.vue',
       '/nuxt.config.ts'
     ]
+  },
+  {
+    organization: '5afe',
+    repo: 'react-native-passkeys-tutorial',
+    destination: './examples/react-native-passkeys',
+    branch: 'main',
+    files: [
+      '/lib/passkeys.ts',
+      '/lib/safe.ts',
+      '/lib/storage.ts',
+      '/App.tsx',
+      '/app.json',
+      '/.env-sample'
+    ]
   }
   // {
   //   organization: '5afe',
@@ -59,7 +81,7 @@ const generateCodeExamples = async ({
   branch,
   destination,
   files
-}) => {
+}: Repo) => {
   const fetch = await import('node-fetch')
   files.forEach(async filePath => {
     const url = `https://raw.githubusercontent.com/${organization}/${repo}/${branch}${filePath}?token=$(date +%s)`
diff --git a/.github/styles/config/vocabularies/default/accept.txt b/.github/styles/config/vocabularies/default/accept.txt
index c30eb78f..aa9a6814 100644
--- a/.github/styles/config/vocabularies/default/accept.txt
+++ b/.github/styles/config/vocabularies/default/accept.txt
@@ -60,7 +60,8 @@
 [Tt]estnet
 [Tt]rezor
 [Vv]alidator
-[Ww]hitepaper 
+[Ww]hitepaper
+[Xx]code 
 A1
 AA
 ABI
@@ -150,6 +151,7 @@ Katla
 Klaytn
 Kovan
 Kroma
+keystore
 LUKSO
 Lightlink
 Lisk
@@ -167,6 +169,7 @@ Moonbeam
 Moonriver
 Mordor
 Nova
+ngrok
 Nuxt
 OAuth
 OP
@@ -178,6 +181,7 @@ PKCE
 Polis
 Protocol Kit
 Starter Kit
+Prebuild
 Protofire
 PublicMint
 README
@@ -282,6 +286,7 @@ trace_filter
 trace_transaction
 undefined
 undeployed
+unencrypted
 v1
 viem
 zkLink
diff --git a/assets/react-native-passkeys-app-1.png b/assets/react-native-passkeys-app-1.png
new file mode 100644
index 00000000..5cba52fc
Binary files /dev/null and b/assets/react-native-passkeys-app-1.png differ
diff --git a/assets/react-native-passkeys-app-2.png b/assets/react-native-passkeys-app-2.png
new file mode 100644
index 00000000..788f8854
Binary files /dev/null and b/assets/react-native-passkeys-app-2.png differ
diff --git a/assets/react-native-passkeys-app-3.png b/assets/react-native-passkeys-app-3.png
new file mode 100644
index 00000000..d42a7e99
Binary files /dev/null and b/assets/react-native-passkeys-app-3.png differ
diff --git a/assets/react-native-passkeys-app.gif b/assets/react-native-passkeys-app.gif
new file mode 100644
index 00000000..73bb27fb
Binary files /dev/null and b/assets/react-native-passkeys-app.gif differ
diff --git a/assets/react-native-passkeys-play-store.png b/assets/react-native-passkeys-play-store.png
new file mode 100644
index 00000000..4ddf0551
Binary files /dev/null and b/assets/react-native-passkeys-play-store.png differ
diff --git a/examples/react-native-passkeys/.env-sample b/examples/react-native-passkeys/.env-sample
new file mode 100644
index 00000000..842f39a7
--- /dev/null
+++ b/examples/react-native-passkeys/.env-sample
@@ -0,0 +1,14 @@
+# Fill this information to configure your Safe account
+# ---------------------------------------------------
+# The private key of the Safe account owner that will be used to deploy the Safe or execute transactions. Should have some test Sepolia ETH.
+EXPO_PUBLIC_SAFE_SIGNER_PK=add_private_key_here
+# Add the Safe account owners. You can one or more public addresses that you own.
+EXPO_PUBLIC_SAFE_OWNERS=["0xOwnerAddress1", "..."]
+# Safe salt nonce. A random number that is used to generate to Safe account address. When you change the number a new Safe will be predicted.
+# This is useful to start testing the app with a new Safe account.
+EXPO_PUBLIC_SAFE_SALT_NONCE=1
+
+# Others
+# ---------------------------------------------------
+# RPC URL for the network where the Safe is deployed
+EXPO_PUBLIC_RPC_URL=https://eth-sepolia.public.blastapi.io
diff --git a/examples/react-native-passkeys/App.tsx b/examples/react-native-passkeys/App.tsx
new file mode 100644
index 00000000..e85c457d
--- /dev/null
+++ b/examples/react-native-passkeys/App.tsx
@@ -0,0 +1,339 @@
+import { useEffect, useState } from "react";
+import prompt from "react-native-prompt-android";
+import Safe, { PasskeyArgType } from "@safe-global/protocol-kit";
+import {
+  View,
+  Text,
+  StyleSheet,
+  Button,
+  Platform,
+  Alert,
+  ActivityIndicator,
+  SafeAreaView,
+} from "react-native";
+import {
+  getStoredPassKey,
+  removeStoredPassKey,
+  storePassKey,
+} from "./lib/storage";
+import { createPassKey, getPassKey } from "./lib/passkeys";
+import {
+  activateAccount,
+  addPasskeyOwner,
+  sendDummyPasskeyTransaction,
+  signPasskeyMessage,
+} from "./lib/safe";
+
+const PASSKEY_NAME = "safe-owner";
+
+export default function App() {
+  const [protocolKit, setProtocolKit] = useState<Safe | null>(null);
+  const [passkeySignerProtocolKit, setPasskeySignerProtocolKit] =
+    useState<Safe | null>(null);
+  const [passkeySigner, setPasskeySigner] = useState<PasskeyArgType | null>(
+    null
+  );
+  const [safeAddress, setSafeAddress] = useState<string | null>(null);
+  const [isDeployed, setIsDeployed] = useState<boolean>(false);
+  const [isLoading, setIsLoading] = useState<boolean>(true);
+
+  useEffect(() => {
+    (async () => {
+      let protocolKitInstance = await Safe.init({
+        provider: process.env.EXPO_PUBLIC_RPC_URL as string,
+        signer: process.env.EXPO_PUBLIC_SAFE_SIGNER_PK,
+        predictedSafe: {
+          safeAccountConfig: {
+            owners: JSON.parse(process.env.EXPO_PUBLIC_SAFE_OWNERS as string),
+            threshold: 1,
+          },
+          safeDeploymentConfig: {
+            saltNonce: process.env.EXPO_PUBLIC_SAFE_SALT_NONCE,
+          },
+        },
+      });
+
+      const safeAddress = await protocolKitInstance.getAddress();
+      const isDeployed = await protocolKitInstance.isSafeDeployed();
+
+      console.log("Safe address", safeAddress);
+      console.log("Is deployed", isDeployed);
+
+      setSafeAddress(safeAddress);
+      setIsDeployed(isDeployed);
+
+      if (isDeployed) {
+        protocolKitInstance = await protocolKitInstance.connect({
+          provider: process.env.EXPO_PUBLIC_RPC_URL,
+          signer: process.env.EXPO_PUBLIC_SAFE_SIGNER_PK,
+          safeAddress: safeAddress,
+        });
+      }
+
+      setProtocolKit(protocolKitInstance);
+      setIsLoading(false);
+    })();
+  }, []);
+
+  useEffect(() => {
+    (async () => {
+      const storedPasskey = await getStoredPassKey(PASSKEY_NAME);
+
+      setPasskeySigner(storedPasskey);
+    })();
+  }, []);
+
+  useEffect(() => {
+    if (!passkeySigner || !safeAddress) return;
+
+    (async () => {
+      const passkeySignerProtocolKitInstance = await Safe.init({
+        provider: process.env.EXPO_PUBLIC_RPC_URL,
+        signer: { ...passkeySigner, getFn: getPassKey } as PasskeyArgType,
+        safeAddress,
+      });
+
+      setPasskeySignerProtocolKit(passkeySignerProtocolKitInstance);
+    })();
+  }, [safeAddress, passkeySigner]);
+
+  const handleActivateAccount = async () => {
+    if (!protocolKit || !safeAddress) return;
+
+    setIsLoading(true);
+
+    const receipt = await activateAccount(protocolKit);
+
+    if (receipt.transactionHash) {
+      setIsDeployed(true);
+
+      const updatedProtocolKitInstance = await protocolKit.connect({
+        provider: protocolKit.getSafeProvider().provider,
+        signer: protocolKit.getSafeProvider().signer,
+        safeAddress: await protocolKit.getAddress(),
+      });
+
+      setProtocolKit(updatedProtocolKitInstance);
+
+      setIsLoading(false);
+    } else {
+      setIsLoading(false);
+    }
+  };
+
+  const handleAddPasskeyOwner = async () => {
+    if (!protocolKit) {
+      return;
+    }
+
+    const passkeyCredential = await createPassKey();
+
+    if (!passkeyCredential) {
+      throw Error("Passkey creation failed: No credential was returned.");
+    }
+
+    const signer = await Safe.createPasskeySigner(passkeyCredential);
+
+    setIsLoading(true);
+
+    await addPasskeyOwner(protocolKit, signer);
+
+    await storePassKey(signer, PASSKEY_NAME);
+
+    const passkeySignerProtocolKitInstance = await Safe.init({
+      provider: process.env.EXPO_PUBLIC_RPC_URL,
+      signer: { ...signer, getFn: getPassKey } as PasskeyArgType,
+      safeAddress: safeAddress as string,
+    });
+
+    setPasskeySignerProtocolKit(passkeySignerProtocolKitInstance);
+    setPasskeySigner(signer);
+    setIsLoading(false);
+  };
+
+  const handleSignMessage = async () => {
+    if (!passkeySignerProtocolKit) return;
+
+    prompt(
+      "Sign message",
+      "Enter the message to sign",
+      [
+        {
+          text: "Cancel",
+          onPress: () => console.log("Cancel Pressed"),
+          style: "cancel",
+        },
+        {
+          text: "Sign",
+          onPress: async (message: string) => {
+            const signedMessage = await signPasskeyMessage(
+              passkeySignerProtocolKit,
+              message
+            );
+
+            if (Platform.OS === "web") {
+              window.alert(
+                (signedMessage.data as string) +
+                  "\n" +
+                  signedMessage.encodedSignatures()
+              );
+            } else {
+              Alert.alert(
+                signedMessage.data as string,
+                signedMessage.encodedSignatures()
+              );
+            }
+          },
+        },
+      ],
+      {
+        type: "plain-text",
+        cancelable: false,
+        defaultValue: "",
+        placeholder: "placeholder",
+        style: "shimo",
+      }
+    );
+  };
+
+  const handleSendTransaction = async () => {
+    if (!safeAddress || !protocolKit || !passkeySignerProtocolKit) return;
+
+    setIsLoading(true);
+
+    const receipt = await sendDummyPasskeyTransaction(
+      protocolKit,
+      passkeySignerProtocolKit,
+      safeAddress
+    );
+
+    setIsLoading(false);
+
+    if (receipt.transactionHash) {
+      if (Platform.OS === "web") {
+        window.alert(receipt.transactionHash);
+      } else {
+        Alert.alert("Transaction hash", receipt.transactionHash);
+      }
+    }
+  };
+
+  const handleRemovePasskey = async () => {
+    removeStoredPassKey(PASSKEY_NAME);
+    setPasskeySigner(null);
+  };
+
+  if (isLoading) {
+    return <ActivityIndicator style={styles.loadingContainer} size="large" />;
+  }
+
+  return (
+    <SafeAreaView style={styles.container}>
+      <View style={styles.titleContainer}>
+        <Text style={styles.titleText}>Safe Passkeys Demo</Text>
+      </View>
+
+      <View style={styles.sectionContainer}>
+        <Text style={styles.sectionTitle}>Safe Address</Text>
+        <Text style={styles.text}>{safeAddress}</Text>
+      </View>
+
+      {!isDeployed && (
+        <View style={styles.sectionContainer}>
+          <Text style={styles.text}>⚠️ The account is not activated yet</Text>
+          <View style={styles.button}>
+            <Button
+              color="#10e573"
+              title="Activate Account"
+              onPress={handleActivateAccount}
+            />
+          </View>
+        </View>
+      )}
+
+      {isDeployed && (
+        <>
+          {!passkeySigner && (
+            <View style={styles.button}>
+              <Button
+                color="#10e573"
+                title="Add Passkey Owner"
+                onPress={handleAddPasskeyOwner}
+              />
+            </View>
+          )}
+
+          {passkeySigner && (
+            <>
+              <View style={styles.button}>
+                <Button
+                  color="#10e573"
+                  title="Sign Message"
+                  onPress={handleSignMessage}
+                />
+              </View>
+              <View style={styles.button}>
+                <Button
+                  color="#10e573"
+                  title="Send Dummy Transaction"
+                  onPress={handleSendTransaction}
+                />
+              </View>
+              <View style={styles.button}>
+                <Button
+                  color="#10e573"
+                  title="Remove Passkey"
+                  onPress={handleRemovePasskey}
+                />
+              </View>
+            </>
+          )}
+        </>
+      )}
+    </SafeAreaView>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: "#000",
+    color: "#fff",
+    padding: 16,
+  },
+  titleContainer: {
+    marginBottom: 16,
+    paddingHorizontal: 16,
+  },
+  titleText: {
+    fontSize: 24,
+    fontWeight: "bold",
+    textAlign: "left",
+    marginBottom: 8,
+    color: "#12FF80",
+  },
+  sectionContainer: {
+    marginBottom: 16,
+    paddingHorizontal: 16,
+  },
+  sectionTitle: {
+    fontSize: 18,
+    fontWeight: "600",
+    marginBottom: 4,
+    color: "#fff",
+  },
+  text: {
+    fontSize: 16,
+    textAlign: "left",
+    marginBottom: 8,
+    color: "#fff",
+  },
+  button: {
+    marginVertical: 8,
+    paddingHorizontal: 16,
+  },
+  loadingContainer: {
+    flex: 1,
+    justifyContent: "center",
+  },
+});
diff --git a/examples/react-native-passkeys/app.json b/examples/react-native-passkeys/app.json
new file mode 100644
index 00000000..8d2af737
--- /dev/null
+++ b/examples/react-native-passkeys/app.json
@@ -0,0 +1,47 @@
+{
+  "expo": {
+    "name": "react-native-passkeys",
+    "slug": "react-native-passkeys",
+    "version": "1.0.0",
+    "orientation": "portrait",
+    "icon": "./assets/icon.png",
+    "userInterfaceStyle": "light",
+    "newArchEnabled": true,
+    "splash": {
+      "image": "./assets/splash-icon.png",
+      "resizeMode": "contain",
+      "backgroundColor": "#ffffff"
+    },
+    "ios": {
+      "supportsTablet": true,
+      "bundleIdentifier": "com.<your_organization>.<your_app_name>",
+      "associatedDomains": [
+        "webcredentials:add_your_ngrok_domain_here?mode=developer"
+      ],
+      "appleTeamId": "your_apple_team_id"
+    },
+    "android": {
+      "adaptiveIcon": {
+        "foregroundImage": "./assets/adaptive-icon.png",
+        "backgroundColor": "#ffffff"
+      },
+      "package": "com.<your_organization>.<your_app_name>"
+    },
+    "web": {
+      "favicon": "./assets/favicon.png"
+    },
+    "plugins": [
+      [
+        "expo-build-properties",
+        {
+          "ios": {
+            "deploymentTarget": "15.1"
+          },
+          "android": {
+            "compileSdkVersion": 34
+          }
+        }
+      ]
+    ]
+  }
+}
diff --git a/examples/react-native-passkeys/lib/passkeys.ts b/examples/react-native-passkeys/lib/passkeys.ts
new file mode 100644
index 00000000..86dbc534
--- /dev/null
+++ b/examples/react-native-passkeys/lib/passkeys.ts
@@ -0,0 +1,146 @@
+import { Platform } from "react-native";
+import RNBase64 from "react-native-base64";
+import { create, get } from "react-native-passkeys";
+
+const RP_NAME = "Safe Smart Account";
+const USER_DISPLAY_NAME = "Safe account";
+const USER_NAME = "safe-account";
+const DOMAIN = "add_your_domain_here";
+const CHALLENGE = "the-challenge";
+const USER_ID = "my-user-id";
+
+// This function verifies the passkey of the user.
+export async function getPassKey(
+  options?: CredentialRequestOptions
+): Promise<Credential | null> {
+  // Convert the challenge to a base64 URL string.
+  const challenge = bufferSourceToBase64Url(options?.publicKey?.challenge);
+  // Convert the allowCredentials to a binary string.
+  const allowCredentials = options?.publicKey?.allowCredentials?.map(
+    (cred) => ({
+      type: cred.type,
+      id: getBinaryString(cred.id),
+    })
+  );
+
+  // Get the passkey of the user.
+  let credential = await get({
+    rpId: DOMAIN,
+    challenge,
+    userVerification: options?.publicKey?.userVerification,
+    allowCredentials,
+  });
+
+  // Convert the passkey to a Credential object.
+  if (credential?.response) {
+    credential.response.authenticatorData = base64ToArrayBuffer(
+      credential.response.authenticatorData
+    );
+    credential.response.clientDataJSON = base64ToArrayBuffer(
+      credential.response.clientDataJSON
+    );
+    credential.response.signature = base64ToArrayBuffer(
+      credential.response.signature
+    );
+  }
+
+  // Return the passkey credential.
+  return credential as Credential;
+}
+
+// This function creates a new passkey for the user.
+export async function createPassKey() {
+  // Convert the challenge to a base64 URL string.
+  const challenge =
+    Platform.OS === "web"
+      ? crypto.getRandomValues(new Uint8Array(32))
+      : bufferToBase64URLString(utf8StringToBuffer(CHALLENGE));
+
+  // Generate a random user ID.
+  const userId =
+    Platform.OS === "web"
+      ? crypto.getRandomValues(new Uint8Array(32))
+      : bufferToBase64URLString(utf8StringToBuffer(USER_ID));
+
+  // Create the passkey request JSON.
+  const credentialRequestJson = {
+    pubKeyCredParams: [{ alg: -7, type: "public-key" }],
+    challenge,
+    rp: {
+      id: Platform.OS === "web" ? window.location.hostname : DOMAIN,
+      name: RP_NAME,
+    },
+    user: { displayName: USER_DISPLAY_NAME, id: userId, name: USER_NAME },
+    timeout: 60_000,
+    attestation: "none",
+  };
+
+  // Add the authenticator selection to the request JSON
+  if (Platform.OS !== "web") {
+    //@ts-expect-error authenticatorSelection is not in the official types
+    credentialRequestJson.authenticatorSelection = {
+      requireResidentKey: true,
+    };
+  }
+
+  // Create the passkey for the user using official passkeys API.
+  const passkey =
+    Platform.OS === "web"
+      ? await navigator.credentials.create({
+          publicKey:
+            credentialRequestJson as unknown as PublicKeyCredentialCreationOptions,
+        })
+      : await create(credentialRequestJson as Parameters<typeof create>[0]);
+
+  return passkey;
+}
+
+/*
+* Helper functions:
+*/
+function bufferToBase64URLString(buffer: ArrayBuffer): string {
+  const bytes = new Uint8Array(buffer);
+  let str = "";
+
+  for (const charCode of bytes) {
+    str += String.fromCharCode(charCode);
+  }
+
+  const base64String = btoa(str);
+
+  return base64String.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+function utf8StringToBuffer(value: string): ArrayBuffer {
+  return new TextEncoder().encode(value);
+}
+
+function getBinaryString(buffer: any) {
+  const byteArray = new Uint8Array(buffer);
+  return Array.from(byteArray)
+    .map((byte) => String.fromCharCode(byte))
+    .join("");
+}
+
+function bufferSourceToBase64Url(bufferSource: any) {
+  const binaryString = getBinaryString(bufferSource);
+  const base64String = RNBase64.encode(binaryString);
+  return base64String
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/, "");
+}
+
+function base64ToArrayBuffer(base64: string) {
+  base64 = base64.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4 !== 0) {
+    base64 += "=";
+  }
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+//
diff --git a/examples/react-native-passkeys/lib/safe.ts b/examples/react-native-passkeys/lib/safe.ts
new file mode 100644
index 00000000..ca2c48b4
--- /dev/null
+++ b/examples/react-native-passkeys/lib/safe.ts
@@ -0,0 +1,106 @@
+import Safe, {
+  EthSafeMessage,
+  PasskeyArgType,
+  SigningMethod,
+} from "@safe-global/protocol-kit";
+import { waitForTransactionReceipt } from "viem/actions";
+import {
+  WalletClient,
+  Transport,
+  Chain,
+  Hex,
+  Account,
+  WaitForTransactionReceiptReturnType,
+} from "viem";
+
+export async function activateAccount(
+  protocolKit: Safe
+): Promise<WaitForTransactionReceiptReturnType<Chain>> {
+  const safeDeploymentTransaction =
+    await protocolKit.createSafeDeploymentTransaction();
+
+  const signer = (await protocolKit
+    .getSafeProvider()
+    .getExternalSigner()) as WalletClient<Transport, Chain, Account>;
+  const client = protocolKit.getSafeProvider().getExternalProvider();
+
+  if (!signer)
+    throw new Error(
+      "SafeProvider must be initialized with a signer to use this function"
+    );
+
+  const hash = await signer.sendTransaction({
+    to: safeDeploymentTransaction.to as `0x${string}`,
+    data: safeDeploymentTransaction.data as Hex,
+    value: BigInt(safeDeploymentTransaction.value),
+    account: signer.account,
+  });
+
+  const receipt = await waitForTransactionReceipt(client, { hash });
+
+  return receipt;
+}
+
+export async function addPasskeyOwner(
+  protocolKit: Safe,
+  signer: PasskeyArgType
+): Promise<WaitForTransactionReceiptReturnType<Chain>> {
+  const addOwnerTx = await protocolKit.createAddOwnerTx({
+    passkey: signer,
+  });
+  const client = protocolKit.getSafeProvider().getExternalProvider();
+  const signedAddOwnerTx = await protocolKit.signTransaction(
+    addOwnerTx,
+    SigningMethod.ETH_SIGN
+  );
+
+  const txResult = await protocolKit.executeTransaction(signedAddOwnerTx);
+
+  const receipt = await waitForTransactionReceipt(client, {
+    hash: txResult.hash as `0x${string}`,
+  });
+
+  return receipt;
+}
+
+export async function signPasskeyMessage(
+  protocolKit: Safe,
+  message: string
+): Promise<EthSafeMessage> {
+  const safeMessage = protocolKit.createMessage(message);
+
+  const signedMessage = await protocolKit.signMessage(
+    safeMessage,
+    SigningMethod.ETH_SIGN
+  );
+
+  return signedMessage;
+}
+
+export async function sendDummyPasskeyTransaction(
+  protocolKit: Safe,
+  protocolKitSigner: Safe,
+  to: string
+): Promise<WaitForTransactionReceiptReturnType<Chain>> {
+  const transaction = {
+    to,
+    value: "0",
+    data: "0x",
+  };
+  const client = protocolKit.getSafeProvider().getExternalProvider();
+
+  const safeTransaction = await protocolKitSigner.createTransaction({
+    transactions: [transaction],
+  });
+
+  const signedTransaction = await protocolKitSigner.signTransaction(
+    safeTransaction
+  );
+
+  const txResult = await protocolKit.executeTransaction(signedTransaction);
+  const receipt = await waitForTransactionReceipt(client, {
+    hash: txResult.hash as `0x${string}`,
+  });
+
+  return receipt;
+}
diff --git a/examples/react-native-passkeys/lib/storage.ts b/examples/react-native-passkeys/lib/storage.ts
new file mode 100644
index 00000000..9d9ee891
--- /dev/null
+++ b/examples/react-native-passkeys/lib/storage.ts
@@ -0,0 +1,37 @@
+import { Platform } from "react-native";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { PasskeyArgType } from "@safe-global/protocol-kit";
+
+const isWeb = Platform.OS === "web";
+
+// This function stores the passkey in the local storage of the device. 
+export async function storePassKey(passkey: PasskeyArgType, label: string) {
+  const serializedPasskey = JSON.stringify(passkey);
+
+  if (isWeb) {
+    localStorage.setItem(label, serializedPasskey);
+  } else {
+    await AsyncStorage.setItem(label, serializedPasskey);
+  }
+}
+
+// This function retrieves the passkey from the local storage of the device.
+export async function getStoredPassKey(label: string) {
+  if (isWeb) {
+    const passkey = localStorage.getItem(label);
+    return passkey ? JSON.parse(passkey) : undefined;
+  } else {
+    const passkey = await AsyncStorage.getItem(label);
+
+    return passkey ? JSON.parse(passkey) : undefined;
+  }
+}
+
+// This function removes the passkey from the local storage of the device.
+export async function removeStoredPassKey(label: string) {
+  if (isWeb) {
+    localStorage.removeItem(label);
+  } else {
+    await AsyncStorage.removeItem(label);
+  }
+}
diff --git a/package.json b/package.json
index 6739fb40..45c46a69 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,7 @@
     "build": "next build",
     "dev": "next dev",
     "generate-api-reference": "pnpm ts-node --project tsconfig.json .github/scripts/generateApiReference.ts",
-    "generate-code-examples": "node .github/scripts/generateCodeExamples.js",
+    "generate-code-examples": "pnpm ts-node --project tsconfig.json .github/scripts/generateCodeExamples.ts",
     "generate-supported-networks": "pnpm ts-node --project tsconfig.json .github/scripts/generateSupportedNetworks.ts",
     "get-resources-og": "node .github/scripts/getResourcesOg.js",
     "validate-resources": "node .github/scripts/validateResources.js",
diff --git a/pages/advanced/passkeys/tutorials/_meta.json b/pages/advanced/passkeys/tutorials/_meta.json
index 61e4cc36..f81d1e34 100644
--- a/pages/advanced/passkeys/tutorials/_meta.json
+++ b/pages/advanced/passkeys/tutorials/_meta.json
@@ -1,5 +1,5 @@
 {
     "react": "Build a React app with Safe and passkeys",
-    "nuxt": "Build a Vue app with Safe and passkeys"
-}
-  
\ No newline at end of file
+    "nuxt": "Build a Vue app with Safe and passkeys",
+    "react-native": "Build a React Native app with Safe and passkeys"
+}
\ No newline at end of file
diff --git a/pages/advanced/passkeys/tutorials/react-native.mdx b/pages/advanced/passkeys/tutorials/react-native.mdx
new file mode 100644
index 00000000..c174e52b
--- /dev/null
+++ b/pages/advanced/passkeys/tutorials/react-native.mdx
@@ -0,0 +1,254 @@
+import { Callout } from 'nextra/components'
+import { Bleed, Tabs } from 'nextra-theme-docs'
+
+# How to build a React Native app with Safe and passkeys
+
+An increasing number of applications rely on passkeys to authenticate users securely and with little friction. Security and user-friendliness are crucial to making web3 a reality for the next billion users.
+Being able to unlock a Safe Smart Account with your fingerprints or Face ID, sending transactions without worrying about third-party wallet interfaces, phishing attempts, or securing seed phrases will bring new forms of ownership to the connected world.
+Today, we'll learn how to use passkeys with [React Native](https://reactnative.dev) and [Expo](https://docs.expo.dev).
+
+This tutorial will show you how to create a React Native app for using [passkeys](../overview.mdx) in your Safe. This app will enable you to:
+
+- Deploy a new Safe on Ethereum Sepolia.
+- Create a new passkey secured by the user's device.
+- Sign messages and create transactions using the passkey as a signer.
+
+This is how the final app will look:
+
+![react-native-passkeys-app-1.png](../../../../assets/react-native-passkeys-app-1.png)
+
+## **What you'll need**
+
+**Prerequisite knowledge:** You will need some basic experience with [React](https://react.dev/learn), [React Native](https://reactnative.dev) and [Expo](https://docs.expo.dev).
+
+Before progressing with the tutorial, please make sure you have:
+
+- Downloaded and installed [Node.js](https://nodejs.org/en/download/package-manager).
+- Have enrolled to the [Apple Developer Program](https://developer.apple.com/programs/enroll/) and installed [Xcode](https://developer.apple.com/xcode/) (if you want to test the app on iOS)
+- Have downloaded and installed [Android Studio](https://developer.android.com/studio) and have a Google account connected to your emulator (if you want to test the app on Android)
+- Have a [ngrok](https://ngrok.com/) account to create an HTTPS tunnel to your server.
+
+**Note:** If you wish to follow along using the completed project, you can [check out the GitHub repository](https://github.com/5afe/react-native-passkeys-tutorial) for this tutorial.
+
+## 1. Setup a React Native app using Expo
+
+### Initialize a new project
+
+Initialize a new React Native project using Expo by running the following command in your terminal:
+
+```bash
+npx create-expo-app@latest --template blank-typescript
+```
+
+When prompted by the CLI, enter the name of the application (for example, react-native-passkeys).
+
+### Install dependencies
+
+Run the following command to add the project dependencies:
+
+```bash
+cd react-native-passkeys
+npm install @safe-global/protocol-kit react-native-passkeys react-native-base64 @react-native-async-storage/async-storage react-native-prompt-android expo-build-properties
+```
+
+We are using:
+
+| Package                                                                                                    | Description                                                                                                                                                                                                                                      |
+| :--------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`@safe-global/protocol-kit`](https://github.com/safe-global/safe-core-sdk)                                | [Protocol Kit](../../../sdk/protocol-kit.mdx) package from the Safe\{Core\} SDK to set up a new Safe account, sign and send transactions.                                                                                                        |
+| [`react-native-passkeys`](https://github.com/peterferguson/react-native-passkeys)                          | Expo module for creating and authenticating passkeys on iOS, Android, and the web using the same API.                                                                                                                                            |
+| [`react-native-base64`](https://github.com/eranbo/react-native-base64)                                     | Base64 encoding and decoding helping utilities.                                                                                                                                                                                                  |
+| [`@react-native-async-storage/async-storage`](https://github.com/react-native-async-storage/async-storage) | An asynchronous, unencrypted, persistent key-value storage system for React Native. We'll use local storage in the web and this AsyncStorage on the apps to store the passkey `rawId` and `coordinates`                                          |
+| [`react-native-prompt-android`](https://github.com/powerdesigninc/react-native-prompt)                     | This package allows you to use Prompt Dialog across platforms, including iOS (Alert.prompt) and Android (Dialog).                                                                                                                                |
+| [`expo-build-properties`](https://docs.expo.dev/versions/latest/sdk/build-properties)                      | A [plugin](https://docs.expo.dev/config-plugins/introduction) to configure the native build properties in your android/gradle.properties and ios/Podfile.properties.json directories during [Prebuild](https://docs.expo.dev/workflow/prebuild). |
+
+### Configure your development environment to use React Native and Expo
+
+You need to configure your environment. If you are a React Native developer, you may have already set everything up. However, if you are new to React Native, you should prepare your environment. The best option is to follow the [official Expo documentation](https://docs.expo.dev/get-started/set-up-your-environment).
+
+We will use emulators and development builds in this tutorial, so please refer to the relevant sections in the Expo documentation for proper configuration. If you know how to do that or want to use a physical device, you can skip these steps. If you only want to test one platform, that's fine too, you only need to follow one of the steps below:
+
+- [**Android Studio Emulator**](https://docs.expo.dev/get-started/set-up-your-environment/?platform=android&device=simulated&mode=development-build)
+- [**iOS Simulator**](https://docs.expo.dev/get-started/set-up-your-environment/?platform=ios&device=simulated&mode=development-build)
+
+When [creating the emulator](https://docs.expo.dev/get-started/set-up-your-environment/?platform=android&device=simulated&mode=development-build#set-up-an-emulator) using Android Studio Device Manager, ensure that you include one with Play Store services, as this is required for passkeys. The version 17 of the Java Development Kit (JDK) is used to compile the project, make sure that you are [using the correct version](https://stackoverflow.com/questions/30631286/how-to-specify-the-jdk-version-in-android-studio) before running the emulator.
+
+![react-native-passkeys-app-2.png](../../../../assets/react-native-passkeys-play-store.png)
+
+### Add environment variables
+
+Create a file named `.env` in the root of your project and add the following keys:
+
+```.env
+// from ../../../../examples/react-native-passkeys/.env-sample
+```
+
+Replace `add_private_key_here` by a private key you own, and `0xOwnerAddress1` by one or more public addresses you own. These addresses will be used to deploy the Safe and add passkey owners.
+
+### Run emulators
+
+After completing all these configurations 🙃, you can finally run the local development build of the app on the emulators (Emulators should be running) by using the following commands:
+
+```bash
+npx expo run:android
+npx expo run:ios
+```
+
+You can now begin developing the app.
+
+![react-native-passkeys-app-2.png](../../../../assets/react-native-passkeys-app-2.png)
+
+## 2. Add project lib folder
+
+Create a `lib` folder at the project root. This is the folder where we will include the logic to store and retrieve the passkey:
+
+```bash
+mkdir lib
+cd lib
+```
+
+## 3. Add storage functionality
+
+Create a `storage.ts` file inside the `lib` folder:
+
+```bash
+touch storage.ts
+```
+
+Add the following code to the `storage.ts` file:
+
+```tsx
+// from ../../../../examples/react-native-passkeys/lib/storage.ts
+```
+
+This file will contain all the logic to store the passkey in the device storage or in the web local storage depending on the platform.
+
+## 4. Add passkeys functionality
+
+Create a `passkeys.ts` file inside the lib folder:
+
+```bash
+touch passkeys.ts
+```
+
+Add the following code to the `passkeys.ts` file:
+
+```tsx
+// from ../../../../examples/react-native-passkeys/lib/passkeys.ts
+```
+
+We are adding 2 main functions here:
+
+- `createPasskey` helps generate a new passkey using `react-native-passkeys`.
+- `getPasskey` retrieves the passkey using the `react-native-passkeys` library. This method is necessary for pass to the [protocol-kit init](https://docs.safe.global/reference-sdk-protocol-kit/initialization/init) method and will be used to sign any message or transaction.
+
+## 5. Add Safe functionality
+
+Create a `safe.ts` file inside the lib folder:
+
+```bash
+touch safe.ts
+```
+
+Add the following code to the `safe.ts` file:
+
+```tsx
+// from ../../../../examples/react-native-passkeys/lib/safe.ts
+```
+
+We are introducing four new methods to securely deploy, sign messages, and execute transactions.
+
+- `activateAccount` will deploy a new Safe account on Sepolia based on the predicted configuration.
+- `addPasskeyOwner` adds a new passkey owner to the Safe account.
+- `signPasskeyMessage` helps sign messages using the passkey signer.
+- `sendDummyPasskeyTransaction` creates and executes a dummy on-chain rejection transaction to test the passkey signer.
+
+## 6. Add UI functionality
+
+Using the existing `App.tsx` file, we will add UI components to interact with the Safe account and passkeys. Let's update the entire content and use this instead:
+
+```tsx
+// from ../../../../examples/react-native-passkeys/App.tsx
+```
+
+Now we should have a functional app that enables users to activate their Safe account and interact with passkeys.
+
+![react-native-passkeys-app-3.png](../../../../assets/react-native-passkeys-app-3.png)
+
+## 7. Setup emulator specific registration files
+
+To use passkeys in the app, you need to complete some additional setup in the Android and iOS projects. To facilitate this, we are providing a simple [Node Express web server](https://github.com/5afe/aasa-server) for testing.
+
+Clone and install the repository with:
+
+```bash
+git clone https://github.com/5afe/aasa-server.git
+```
+
+{/* <!-- vale off --> */}
+
+<Tabs items={['iOS', 'Android']}>
+  <Tabs.Tab>
+    - Login or subscribe to the Apple Developer Program and [locate your Team
+    ID](https://developer.apple.com/help/account/manage-your-team/locate-your-team-id/).
+    - In the `apple-app-site-association` file in the AASA server, add your Team ID instead of `add_your_apple_team_id_here`, and a bundle identifier (following this convention `com.<your_team_name>.<your_app_name>`) instead of `add_your_package_name_here`.
+    - Activate FaceId. Go to Features > Face ID > Enrolled in the iOS simulator menu.
+  </Tabs.Tab>
+  <Tabs.Tab>
+    - Add a Google account in the settings of the Android emulated phone.
+    - Get an Android keystore SHA 256 fingerprint with this command (from the root
+    of your project):
+```bash
+keytool -list -v -keystore ./android/app/debug.keystore -alias androiddebugkey -storepass android -keypass android
+```
+    - Copy the value in front of `SHA 256` at the place of `add_your_sha256_cert_fingerprints_here` in the assetslinks.json file.
+    - Add a bundle identifier (following this convention `com.<your_team_name>.<your_app_name>`) instead of `add_your_package_name`
+  </Tabs.Tab>
+</Tabs>
+
+{/* <!-- vale on --> */}
+
+Fill in your data in the `apple-app-site-association` (if you are using iOS) or `assetlinks.json` (if using android) files as explained above. You can now start the server with:
+
+```bash
+cd aasa-server
+npm install
+npm start
+```
+
+Once you have it running, you need a public domain secured with SSL to test the passkeys (`localhost` is not valid). You can use a service like [ngrok](https://download.ngrok.com/mac-os) to create a tunnel to your local server.
+
+After the installation, create a tunnel to the localhost port you are using, which should be `3000` if you are using the provided server.
+
+```bash
+ngrok http 3000
+```
+
+The ngrok service will provide you with a public domain. You must copy this domain (without `https://`) and add it to [passkeys.ts](https://github.com/5afe/react-native-passkeys-tutorial/blob/913cc17f353062bf1c4c55ad303e8623b6035a6b/lib/passkeys.ts#L8) (line 8).
+
+Replace your project's `app.json` with the following:
+
+```json
+// from ../../../../examples/react-native-passkeys/app.json
+```
+
+In the `associatedDomains` array, replace `add_your_ngrok_domain_here` with your public ngrok domain; replace `your_apple_team_id_here` with your Apple Developer Program Team ID; lastly replace the two occurrences of `com.<your_organization>.<your_app_name>` with your app's package name (it must be the same than the one in the `apple-app-site-association` or `assetlinks.json` file).
+
+Delete the `/ios` and `/android` folders and restart the app (`npx expo run:ios` or `npx expo run:android`) to apply the changes.
+
+## 8. See the App in action
+
+![react-native-passkeys-app.mp4](../../../../assets/react-native-passkeys-app.gif)
+
+## Do more with passkeys
+
+We learned how to use passkeys (create them, store them, and use them securely) and how they can interact with a Safe (deploy it and send transactions). We hope you enjoyed this tutorial and that the combination of passkeys and the ERC-4337 will unlock new forms of ownership for your project and users.
+
+You can now integrate passkeys with more transactions and functionalities of the Safe ecosystem. You can read more about passkeys in our [overview](/advanced/passkeys/overview) or in the [WebAuthn API documentation](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API).
+
+Did you encounter any difficulties? Let us know by opening [an issue](https://github.com/5afe/react-native-passkeys-tutorial/issues/new) or asking a question on [Stack Exchange](https://ethereum.stackexchange.com/questions/tagged/safe-core) with the `safe-core` tag.
+
+## Links
+
+- [React Native Passkeys Tutorial](https://github.com/5afe/react-native-passkeys-tutorial)
+- [AASA server](https://github.com/5afe/aasa-server)