diff --git a/.github/scripts/aggregate-passport-metadata.js b/.github/scripts/aggregate-passport-metadata.js
new file mode 100755
index 000000000..1f0dd3bd5
--- /dev/null
+++ b/.github/scripts/aggregate-passport-metadata.js
@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const PASSPORT_ROOT = './sample/Assets/Scripts/Passport';
+const TUTORIALS_DIR = path.join(PASSPORT_ROOT, '_tutorials');
+const OUTPUT_DIR = './_parsed';
+const OUTPUT_FILE = path.join(OUTPUT_DIR, 'passport-features.json');
+const FEATURES_JSON_PATH = path.join(PASSPORT_ROOT, 'features.json');
+
+// Ensure output directory exists
+try {
+  if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  }
+} catch (error) {
+  console.error(`Error creating output directory: ${error.message}`);
+  process.exit(1);
+}
+
+console.log('Processing Passport features metadata...');
+
+// Load features.json to get feature groups and their features
+let featureGroups = {};
+try {
+  const featuresContent = fs.readFileSync(FEATURES_JSON_PATH, 'utf8');
+  const featuresJson = JSON.parse(featuresContent);
+  featureGroups = featuresJson.features || {};
+} catch (error) {
+  console.error(`Error reading features.json: ${error.message}`);
+  process.exit(1);
+}
+
+// Find all feature group directories in _tutorials
+const findFeatureGroupDirectories = () => {
+  const featureGroupDirs = [];
+
+  if (!fs.existsSync(TUTORIALS_DIR)) {
+    console.warn(`Tutorials directory does not exist: ${TUTORIALS_DIR}`);
+    return featureGroupDirs;
+  }
+  
+  try {
+    const dirs = fs.readdirSync(TUTORIALS_DIR, { withFileTypes: true });
+    
+    dirs.forEach((dirent) => {
+      if (dirent.isDirectory()) {
+        featureGroupDirs.push(path.join(TUTORIALS_DIR, dirent.name));
+      }
+    });
+  } catch (err) {
+    console.warn(`Error reading tutorials directory ${TUTORIALS_DIR}: ${err.message}`);
+  }
+  
+  return featureGroupDirs;
+};
+
+// Process metadata files
+const processFeatureGroups = (featureGroupDirs) => {
+  const featuresObject = {};
+  
+  featureGroupDirs.forEach((groupDir) => {
+    const groupName = path.basename(groupDir);
+    console.log(`Processing feature group: ${groupName}`);
+    
+    // Check if this group exists in features.json (case-insensitive)
+    const matchingGroup = Object.keys(featureGroups).find(
+      key => key.toLowerCase() === groupName.toLowerCase()
+    );
+    
+    if (!matchingGroup) {
+      console.warn(`Feature group ${groupName} not found in features.json, skipping`);
+      return;
+    }
+    
+    // Path to metadata.json in this feature group directory
+    const metadataPath = path.join(groupDir, 'metadata.json');
+    if (!fs.existsSync(metadataPath)) {
+      console.warn(`No metadata.json found for feature group ${groupName} in ${groupDir}`);
+      return;
+    }
+    
+    // Path to tutorial.md in this feature group directory
+    const tutorialPath = path.join(groupDir, 'tutorial.md');
+    const tutorialExists = fs.existsSync(tutorialPath);
+    
+    // Use the folder name directly as the feature key
+    const featureKey = groupName;
+    
+    if (!featureKey) {
+      console.warn(`Generated empty feature key for ${groupDir}, skipping`);
+      return;
+    }
+    
+    const tutorialFile = tutorialExists ? `${featureKey}.md` : null;
+    
+    if (!tutorialExists) {
+      console.warn(`No tutorial.md found for feature group ${groupName} in ${groupDir}`);
+    }
+    
+    // Read and process metadata
+    try {
+      const metadataContent = fs.readFileSync(metadataPath, 'utf8');
+      const metadata = JSON.parse(metadataContent);
+      
+      // Add additional fields
+      metadata.title = metadata.title || matchingGroup;
+      metadata.sidebar_order = metadata.sidebar_order || 0;
+      metadata.deprecated = metadata.deprecated || false;
+      
+      // Add feature group information
+      metadata.feature_group = matchingGroup;
+      metadata.features = Object.keys(featureGroups[matchingGroup] || {});
+      
+      // Create the feature entry
+      featuresObject[featureKey] = {
+        tutorial: tutorialFile,
+        metadata: metadata
+      };
+    } catch (error) {
+      console.error(`Error processing metadata file ${metadataPath}: ${error.message}`);
+    }
+  });
+  
+  return featuresObject;
+};
+
+try {
+  // Main execution
+  const featureGroupDirs = findFeatureGroupDirectories();
+  
+  if (featureGroupDirs.length === 0) {
+    console.warn('No feature group directories found. Output file will be empty.');
+  }
+  
+  const features = processFeatureGroups(featureGroupDirs);
+
+  // Create the final passport-features.json
+  fs.writeFileSync(OUTPUT_FILE, JSON.stringify(features, null, 2));
+  console.log(`Created ${OUTPUT_FILE}`);
+} catch (error) {
+  console.error(`Fatal error: ${error.message}`);
+  process.exit(1);
+}
\ No newline at end of file
diff --git a/.github/scripts/process-passport-tutorials.sh b/.github/scripts/process-passport-tutorials.sh
new file mode 100755
index 000000000..1100e3ce0
--- /dev/null
+++ b/.github/scripts/process-passport-tutorials.sh
@@ -0,0 +1,69 @@
+#!/bin/bash
+
+set -e
+set -x
+
+# Directory where docs repo is cloned
+DOCS_REPO_DIR="${CLONE_DIR:-"./imx-docs"}"
+
+# Root of the Passport features
+PASSPORT_ROOT="./sample/Assets/Scripts/Passport"
+TUTORIALS_DIR="${PASSPORT_ROOT}/_tutorials"
+
+echo "Processing Passport tutorials..."
+
+# Load features.json to get feature groups
+FEATURES_JSON="${PASSPORT_ROOT}/features.json"
+if [ ! -f "${FEATURES_JSON}" ]; then
+  echo "Error: features.json not found at ${FEATURES_JSON}"
+  exit 1
+fi
+
+# Create _tutorials directory in docs repo
+DOCS_TUTORIALS_DIR="${DOCS_REPO_DIR}/docs/main/example/zkEVM/unity/passport-examples/_tutorials"
+mkdir -p "${DOCS_TUTORIALS_DIR}"
+
+# Check if _tutorials directory exists
+if [ ! -d "${TUTORIALS_DIR}" ]; then
+  echo "Warning: _tutorials directory not found at ${TUTORIALS_DIR}"
+else
+  # Process each feature group directory in _tutorials
+  find "${TUTORIALS_DIR}" -mindepth 1 -maxdepth 1 -type d -print0 | while IFS= read -r -d '' GROUP_DIR; do
+    echo "Processing feature group: ${GROUP_DIR}"
+    
+    # Extract feature group name from directory
+    GROUP_NAME=$(basename "${GROUP_DIR}")
+    
+    # Tutorial file path
+    TUTORIAL_FILE="${GROUP_DIR}/tutorial.md"
+    
+    if [ -f "${TUTORIAL_FILE}" ]; then
+      echo "Found tutorial for ${GROUP_NAME}"
+      
+      # Use the folder name directly for the destination filename
+      OUTPUT_FILENAME="${GROUP_NAME}.md"
+      
+      # Copy the tutorial file
+      cp "${TUTORIAL_FILE}" "${DOCS_TUTORIALS_DIR}/${OUTPUT_FILENAME}"
+      echo "Copied ${TUTORIAL_FILE} to ${DOCS_TUTORIALS_DIR}/${OUTPUT_FILENAME}"
+    else
+      echo "Warning: No tutorial.md found for feature group ${GROUP_NAME}"
+    fi
+  done
+fi
+
+# Copy the generated JSON file
+JSON_FILE="./_parsed/passport-features.json"
+if [ -f "${JSON_FILE}" ]; then
+  # Create directory for JSON file if it doesn't exist
+  JSON_DIR="${DOCS_REPO_DIR}/docs/main/example/zkEVM/unity/passport-examples"
+  mkdir -p "${JSON_DIR}"
+  
+  # Copy JSON file
+  cp "${JSON_FILE}" "${JSON_DIR}/passport-features.json"
+  echo "Copied ${JSON_FILE} to ${JSON_DIR}/passport-features.json"
+else
+  echo "Warning: No passport-features.json found at ${JSON_FILE}"
+fi
+
+echo "Passport tutorial processing complete." 
\ No newline at end of file
diff --git a/.github/workflows/publish-passport-tutorials.yml b/.github/workflows/publish-passport-tutorials.yml
new file mode 100644
index 000000000..44f07ee74
--- /dev/null
+++ b/.github/workflows/publish-passport-tutorials.yml
@@ -0,0 +1,83 @@
+name: Publish Passport Tutorials
+
+on:
+  # Run when changes are pushed to Passport tutorials or metadata
+  push:
+    branches:
+      # - main
+      - chore/sample-app-tutorial
+    paths:
+      - 'sample/Assets/Scripts/Passport/features.json'
+      - 'sample/Assets/Scripts/Passport/_tutorials/**/*'
+
+  # Allow manual triggering
+  workflow_dispatch:
+
+concurrency:
+  group: passport-tutorials
+  cancel-in-progress: false
+
+jobs:
+  PublishPassportTutorials:
+    name: Process and Publish Passport Tutorials
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Unity SDK Repo
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        with:
+          fetch-depth: 0
+
+      - name: Create Parsed Directory
+        run: mkdir -p _parsed
+
+      - name: Checkout Docs Repo
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        with:
+          repository: immutable/docs
+          token: ${{ secrets.UNITY_SDK_DOCS_WORKFLOW }}
+          path: imx-docs
+          ref: 'main'
+
+      - name: Setup environment variables
+        run: echo "CLONE_DIR=./imx-docs" >> $GITHUB_ENV
+
+      - name: Setup Git
+        run: |
+          git config --global user.name "${GITHUB_ACTOR}"
+          git config --global user.email "${GITHUB_ACTOR}@users.noreply.github.com"
+
+      - name: Install Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y jq
+
+      - name: Process Passport Tutorials
+        run: |
+          # Make scripts executable
+          chmod +x .github/scripts/aggregate-passport-metadata.js
+          chmod +x .github/scripts/process-passport-tutorials.sh
+          
+          # Generate aggregated JSON file
+          node .github/scripts/aggregate-passport-metadata.js
+          
+          # Process tutorials and copy to docs repo
+          .github/scripts/process-passport-tutorials.sh
+        shell: bash
+
+      - name: Commit and Push Changes to Docs Repo
+        run: |
+          cd "$CLONE_DIR"
+          if git status --porcelain | grep -q .; then
+            git add .
+            
+            # Commit with reference to source commit
+            COMMIT_MSG="docs: Update Passport tutorials from Unity SDK (Ref: ${GITHUB_SHA::8})"
+            git commit -m "$COMMIT_MSG"
+            
+            # Push to the target branch
+            git push -u origin main
+            echo "Successfully pushed Passport tutorial changes to docs repo"
+          else
+            echo "No changes to commit"
+          fi
+        shell: bash
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_prompts/tutorial-generation-prompt.txt b/sample/Assets/Scripts/Passport/_prompts/tutorial-generation-prompt.txt
index bc9005790..21a5d22c7 100644
--- a/sample/Assets/Scripts/Passport/_prompts/tutorial-generation-prompt.txt
+++ b/sample/Assets/Scripts/Passport/_prompts/tutorial-generation-prompt.txt
@@ -1,99 +1,156 @@
-# Passport Feature Tutorial Generator
+# Passport Feature Group Tutorial Generator
 ## Task Overview
-Analyze the sample/Assets/Scripts/Passport/{FeatureName}/ directory and create documentation files for the atomic Passport feature example. For the specified feature, you will create:
-1. A comprehensive tutorial.md file
-2. A metadata.json file
+Analyze the specified {FEATURE_GROUP} from sample/Assets/Scripts/Passport/features.json and create comprehensive documentation for it. You will create:
+1. A comprehensive tutorial.md file covering all features in the specified group
+2. A metadata.json file for the feature group
+
+## Input Required
+- FEATURE_GROUP: The exact name of the specific feature group to document, as it appears in features.json
+
+## Structure of features.json
+The features.json file has the following structure:
+```json
+{
+  "features": {
+    "{FEATURE_GROUP}": {
+      "feature1": { ... },
+      "feature2": { ... },
+      ...
+    },
+    "anotherFeatureGroup": {
+      ...
+    }
+  }
+}
+```
+
+You will be analyzing one specific {FEATURE_GROUP} and all features contained within it.
+
+## Special Case: Single-Feature Groups
+IMPORTANT: If the specified {FEATURE_GROUP} contains only one feature, treat it as a standalone feature rather than a feature group. This means:
+- Do not refer to it as a "feature group" in the documentation
+- Skip the "Feature Group Overview" section that discusses relationships between features
+- Focus solely on documenting the single feature in depth
+- Adjust headings and terminology accordingly to avoid references to a "group"
+- For the "Running the Feature Example" section (note: not "Examples"), provide steps specific to this single feature
 
 ## Preparation
 Before starting:
-- Read through all SDK documentation (in the /src/Packages and /src/Packages folders)
+- Read through all SDK documentation (in the /src/Packages folders)
 - Understand the SDK's key features, functionality, and integration patterns
 - Focus on the Passport SDK the most. That's your area of specialty.
+- Familiarize yourself with the specified feature group defined in features.json
 
-## Process for Each Atomic Feature Example
-For the specified atomic feature in sample/Assets/Scripts/Passport/{FeatureName}/ that doesn't already have both tutorial.md and metadata.json:
+## Process for the Specified Feature Group
 
 ### 1. Analysis Phase
-- Read all C# code files in the feature directory
-- Identify the Passport feature being demonstrated. Reference features.json at the Passport root for the feature name and order.
-- Understand the feature's architecture, components, and data flow
+- Identify the specified {FEATURE_GROUP} and all member features from features.json
+- For each feature in the group, read all C# code files in the feature's directory (sample/Assets/Scripts/Passport/{FeatureName}/)
+- Understand how the features in the group relate to each other
+- Identify the common patterns, architecture, components, and data flow across the feature group
 - Note all frameworks, libraries, and dependencies used
-- IMPORTANT: Focus only on the logic for this atomic feature, not on unrelated features or SDK initialization.
+- IMPORTANT: Focus on the logical connections between features in the group while maintaining focus on each feature's specific implementation details.
+
+### 2. Create tutorial.md in sample/Assets/Scripts/Passport/_tutorials/{FEATURE_GROUP}/
+Create a tutorial.md file for the feature group with the following structure:
 
-### 2. Create tutorial.md
-Create a tutorial.md file in the feature's root with the following structure:
+#### Group Introduction
+- Brief overview of the feature group's purpose and importance
+- Which specific SDK capabilities the group demonstrates
+- Link to the sample app GitHub repository. (The Github repository MUST BE linked with this message: "View feature group on Github")
 
-#### Introduction
-- Brief overview of the feature's purpose
-- Which specific SDK capability it demonstrates
-- Link to the feature's GitHub repository. (The Github repository MUST BE linked to this message: "View feature on Github")
+Note: For single-feature cases, rename this section to "Feature Introduction" and adjust the link text to "View feature on Github"
 
-IMPORTANT: The TITLE (the text that starts with #) of the feature that comes before the "View feature on Github" link must be wrapped in a <div class="display-none"> tag. Ensure that the format looks like this:
+IMPORTANT: The TITLE (the text that starts with #) of the feature group that comes before the "View feature group on Github" link must be wrapped in a <div class="display-none"> tag. Ensure that the format looks like this:
 <div class="display-none">
 
-# Title
+# Group Title
 
 </div>
 
-IMPORTANT: The "View feature on Github" link must be wrapped in a <div class="button-component"> tag. Ensure that the format looks like this:
+IMPORTANT: The "View feature group on Github" link must be wrapped in a <div class="button-component"> tag. Ensure that the format looks like this:
 <div class="button-component">
 
-[View feature on Github](<link to the github repo>) <span class="button-component-arrow">→</span>
+[View feature group on Github](<link to the github repo>) <span class="button-component-arrow">→</span>
 
 </div>
 
-IMPORTANT: The feature's description will come before the "View feature on Github" link.
+IMPORTANT: The feature group's description will come before the "View feature group on Github" link.
+
+#### {FeatureGroup} Overview
+- List all features included in this group
+- Explain how these features work together and their relationships
+- High-level description of common patterns across features in this group
+
+Note: For single-feature cases, skip this section entirely.
 
-#### Feature Overview
-- State the single Passport feature demonstrated in this atomic example
+#### Unity SDK {FeatureGroup} Features
+For each feature in the group, create a section with:
 
-> IMPORTANT: Focus on how this atomic feature is implemented. Do NOT include Passport SDK initialization or unrelated features—focus only on the feature-specific implementation details.
-#### SDK Integration Details
-For this Passport feature:
-- Brief description of what the feature does. 
-- Code snippets showing how the feature is implemented (CodeBlock should be linked to the relevant github repo) IMPORTANT: related snippets should be under a single code block rather than dividing them across multiple codeblocks. Only include the relevant snippets (method calls, etc) and not Unity-specific boilerplate (such as Start, Update, etc, when it's irrelevant) to ensure that the focus is on the most important code snippet relevant to the feature.
+Note: For single-feature cases, rename this section to "Unity SDK {feature} Implementation" and adjust content accordingly.
+
+##### Feature: [Feature Name]
+- Brief description of what the specific feature does
+- Code snippets showing how the feature is implemented (CodeBlock should be linked to the relevant github repo)
+- IMPORTANT: related snippets should be under a single code block rather than dividing them across multiple codeblocks. Only include the relevant snippets (method calls, etc) and not Unity-specific boilerplate (such as Start, Update, etc, when it's irrelevant) to ensure that the focus is on the most important code snippet relevant to the feature.
     - Example structure: ```csharp title="<feature name>" manualLink="<github repo link containing the code snippet(don't specify the line, just the file's link)>"
                                 <code snippet>
                         ```
 - Clear explanation of how the code works
+- When relevant, note how this feature connects with others in the group
 
-
-#### Running the Feature Example
+#### Running the Feature Group Examples
 - Prerequisites (including a link to Immutable Hub for environment setup)
-- Step-by-step instructions to run the feature example locally (using Unity Editor)
+- Step-by-step instructions to run all features in the group locally (using Unity Editor)
+- Note any sequence dependencies (if certain features should be run before others)
+
+Note: For single-feature cases, rename this section to "Running the Feature Example" and adjust the content accordingly.
 
 #### Summary
-- Concise recap of what was demonstrated
+- Concise recap of what the feature group demonstrates
+- Best practices when using these features together
 - Any key takeaways for developers
 
 #### Formatting Requirements
 - Use proper Markdown syntax throughout
-- Use heading levels (H1, H2, H3) appropriately
+- Use heading levels (H1, H2, H3, H4) appropriately
 - Format all code with proper syntax highlighting
 - Use bulleted lists for features and steps
+- Include clear transitions between different features in the group
 
-### 3. Create metadata.json
-IMPORTANT: UI LIBRARY IS NOT A FEATURE OR TECH STACK.. IN GENERAL, NEVER INCLUDE UI LIBRARY IN THE METADATA.JSON FILE.
-Create a metadata.json file in the feature's root with the following structure:
+### 3. Create metadata.json in sample/Assets/Scripts/Passport/_tutorials/{FEATURE_GROUP}/
+IMPORTANT: UI LIBRARY IS NOT A FEATURE OR TECH STACK. IN GENERAL, NEVER INCLUDE UI LIBRARY IN THE METADATA.JSON FILE.
+Create a metadata.json file for the feature group with the following structure:
 {
-"title": "[Descriptive title of the atomic feature]",
-"description": "[Concise overview of what the atomic feature demonstrates]",
-"keywords": ["Immutable", "SDK", "[Feature]", ...],
+"title": "[Descriptive title of the feature group]",
+"description": "[Concise overview of what the feature group demonstrates]",
+"keywords": ["Immutable", "SDK", "[Feature Group]", "[Feature 1]", "[Feature 2]", ...],
 "tech_stack": ["Unity", "C#", "[Library]", ...],
 "product": "Passport",
 "programming_language": "C#"
 }
 
+For single-feature cases, use this structure instead:
+{
+"title": "[Descriptive title of the feature]",
+"description": "[Concise overview of what the feature demonstrates]",
+"keywords": ["Immutable", "SDK", "[Feature Name]", ...],
+"tech_stack": ["Unity", "C#", "[Library]", ...],
+"product": "Passport",
+"programming_language": "C#"
+}
 
 ### 4. Handling Existing Files
-If either tutorial.md or metadata.json already exists but is incomplete:
+If the feature group already has tutorial.md or metadata.json but is incomplete:
 - Enhance the content while preserving any accurate existing information
 - Ensure it meets all the format requirements specified above
+- Update to include all features in the group according to the latest features.json
 
-## Final Verification for Each Atomic Feature Example
-- The Passport feature is documented in tutorial.md
+## Final Verification
+- All features in the specified feature group are documented thoroughly in tutorial.md
+- The tutorial shows the logical connections between features in the group
 - The tutorial is free of generic SDK initialization boilerplate
 - All links to GitHub repositories are correct
-- metadata.json contains accurate and comprehensive information
-- Both files are properly formatted
+- metadata.json contains accurate and comprehensive information covering all features in the group
+- Both files are properly formatted and placed in the correct directory structure
 
diff --git a/sample/Assets/Scripts/Passport/_tutorials/Authentication/metadata.json b/sample/Assets/Scripts/Passport/_tutorials/Authentication/metadata.json
new file mode 100644
index 000000000..61bd2f6d1
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/Authentication/metadata.json
@@ -0,0 +1,8 @@
+{
+  "title": "Immutable Passport Authentication",
+  "description": "Implement user authentication in Unity games with Immutable Passport SDK, supporting both Device Code and PKCE flows",
+  "keywords": ["Immutable", "SDK", "Authentication", "Login", "Logout", "Relogin", "Reconnect", "Passport", "Unity"],
+  "tech_stack": ["Unity", "C#", "UniTask", "Immutable Passport SDK"],
+  "product": "Passport",
+  "programming_language": "C#"
+} 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/Authentication/tutorial.md b/sample/Assets/Scripts/Passport/_tutorials/Authentication/tutorial.md
new file mode 100644
index 000000000..219cebfe4
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/Authentication/tutorial.md
@@ -0,0 +1,220 @@
+<div class="display-none">
+
+# Authentication
+
+</div>
+
+The Authentication feature group provides essential tools for integrating user authentication into your Unity application using the Immutable Passport SDK. These features allow players to log in, log out, and maintain their authentication state across sessions, which is fundamental for any blockchain application.
+
+<div class="button-component">
+
+[View feature group on Github](https://github.com/immutable/unity-immutable-sdk/tree/main/sample/Assets/Scripts/Passport) <span class="button-component-arrow">→</span>
+
+</div>
+
+## Authentication Overview
+
+The Authentication feature group contains four key features:
+
+- **Login**: Authenticate users using Device Code Auth or PKCE flow
+- **Logout**: End a user's authenticated session
+- **Relogin**: Restore a previously authenticated session using cached credentials
+- **Reconnect**: Restore authentication and blockchain connections in a single operation
+
+These features work together to create a complete authentication flow for your application. The Login and Logout features handle the primary authentication process, while Relogin and Reconnect provide convenience methods for maintaining session state across application restarts or network interruptions.
+
+## Unity SDK Authentication Features
+
+### Feature: Login
+
+The Login feature allows users to authenticate with Immutable Passport using either Device Code Auth or PKCE (Proof Key for Code Exchange) authentication flows.
+
+```csharp title="Login" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/Login/LoginScript.cs"
+public async void Login()
+{
+    var timeoutMs = GetDeviceCodeTimeoutMs();
+    string formattedTimeout = timeoutMs != null ? $"{timeoutMs} ms" : "none";
+    ShowOutput($"Logging in (timeout: {formattedTimeout})...");
+    try
+    {
+        if (SampleAppManager.UsePKCE)
+        {
+            await Passport.LoginPKCE();
+        }
+        else
+        {
+            await Passport.Login(timeoutMs: timeoutMs);
+        }
+        NavigateToAuthenticatedScene();
+    }
+    catch (OperationCanceledException)
+    {
+        ShowOutput("Failed to login: cancelled");
+    }
+    catch (Exception ex)
+    {
+        ShowOutput($"Failed to login: {ex.Message}");
+    }
+}
+```
+
+This implementation checks which authentication method to use based on the `SampleAppManager.UsePKCE` flag. For Device Code Auth (the default on non-WebGL platforms), it calls `Passport.Login()` with an optional timeout parameter. For PKCE auth (required for WebGL), it calls `Passport.LoginPKCE()`. Upon successful login, it navigates to the authenticated scene.
+
+### Feature: Logout
+
+The Logout feature ends the user's authenticated session with Immutable Passport.
+
+```csharp title="Logout" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/Logout/LogoutScript.cs"
+private async UniTaskVoid LogoutAsync()
+{
+    if (Passport.Instance == null)
+    {
+        Debug.LogError("Passport instance is null");
+        return;
+    }
+    try
+    {
+        if (SampleAppManager.UsePKCE)
+        {
+            await Passport.Instance.LogoutPKCE();
+        }
+        else
+        {
+            await Passport.Instance.Logout();
+        }
+        SampleAppManager.IsConnectedToImx = false;
+        SampleAppManager.IsConnectedToZkEvm = false;
+        AuthenticatedSceneManager.NavigateToUnauthenticatedScene();
+    }
+    catch (System.Exception ex)
+    {
+        Debug.LogError($"Failed to logout: {ex.Message}");
+    }
+}
+```
+
+Similar to the Login feature, Logout checks the authentication method and calls the appropriate logout function (`LogoutPKCE()` or `Logout()`). It also resets the connection states for IMX and zkEVM before navigating back to the unauthenticated scene.
+
+### Feature: Relogin
+
+The Relogin feature allows users to authenticate again using cached credentials, providing a smoother user experience for returning users.
+
+```csharp title="Relogin" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/Relogin/ReloginScript.cs"
+private async UniTaskVoid ReloginAsync()
+{
+    if (Passport.Instance == null)
+    {
+        ShowOutput("Passport Instance is null");
+        return;
+    }
+    ShowOutput("Re-logging into Passport using saved credentials...");
+    try
+    {
+        bool loggedIn = await Passport.Instance.Login(useCachedSession: true);
+        if (loggedIn)
+        {
+            NavigateToAuthenticatedScene();
+        }
+        else
+        {
+            ShowOutput("Could not re-login using saved credentials");
+        }
+    }
+    catch (System.Exception ex)
+    {
+        ShowOutput($"Failed to re-login: {ex.Message}");
+    }
+}
+```
+
+The Relogin feature calls `Passport.Instance.Login()` with the `useCachedSession` parameter set to `true`, which attempts to restore the user's previous session without requiring them to go through the full authentication flow again. If successful, it navigates to the authenticated scene.
+
+### Feature: Reconnect
+
+The Reconnect feature combines re-authentication with reconnecting to blockchain services (IMX) in a single operation.
+
+```csharp title="Reconnect" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/Reconnect/ReconnectScript.cs"
+private async UniTaskVoid ReconnectAsync()
+{
+    if (Passport.Instance == null)
+    {
+        ShowOutput("Passport Instance is null");
+        return;
+    }
+    ShowOutput("Reconnecting to Passport using saved credentials...");
+    try
+    {
+        bool connected = await Passport.Instance.ConnectImx(useCachedSession: true);
+        if (connected)
+        {
+            // Set IMX and zkEVM state and update UI as if user clicked Connect to IMX/EVM
+            SampleAppManager.IsConnectedToImx = true;
+            SampleAppManager.IsConnectedToZkEvm = true;
+            SampleAppManager.PassportInstance = Passport.Instance;
+            var sceneManager = GameObject.FindObjectOfType<AuthenticatedSceneManager>();
+            if (sceneManager != null)
+            {
+                sceneManager.UpdateImxButtonStates();
+                sceneManager.UpdateZkEvmButtonStates();
+            }
+            NavigateToAuthenticatedScene();
+        }
+        else
+        {
+            ShowOutput("Could not reconnect using saved credentials");
+        }
+    }
+    catch (System.Exception ex)
+    {
+        ShowOutput($"Failed to reconnect: {ex.Message}");
+    }
+}
+```
+
+The Reconnect feature calls `Passport.Instance.ConnectImx()` with the `useCachedSession` parameter set to `true`, which not only tries to reestablish the authentication session but also reconnects to the IMX blockchain. If successful, it updates the connection states for both IMX and zkEVM, updates the UI, and navigates to the authenticated scene.
+
+## Running the Authentication Examples
+
+### Prerequisites
+
+Before running the authentication examples, you need to:
+
+1. Set up an Immutable Hub account at [Immutable Hub](https://hub.immutable.com/)
+2. Clone the Unity Immutable SDK repository
+3. Open the sample app in Unity Editor (2022.3 LTS or newer recommended)
+4. Ensure you have the required packages installed (UniTask, TextMeshPro)
+
+### Step-by-Step Instructions
+
+1. Open the sample app scene located at `sample/Assets/Scenes/Passport/InitialisationScene.unity`
+2. Enter Play mode in the Unity Editor
+3. In the Initialisation Scene:
+   - For non-WebGL builds, choose between "Use Device Code Auth" or "Use PKCE"
+   - For WebGL builds, PKCE is automatically selected
+4. After initialization, you'll be taken to the Unauthenticated Scene where you can:
+   - Use "Login" to authenticate with a new session
+   - Use "Relogin" to try authenticating with cached credentials
+   - Use "Reconnect" to authenticate and reconnect to blockchain services
+
+### Authentication Flow Sequence
+
+For optimal testing:
+1. Start with "Login" to create a new authenticated session
+2. Use the "Logout" button on the Authenticated Scene to end your session
+3. Try "Relogin" to test session restoration
+4. If you previously connected to IMX, try "Reconnect" to test combined authentication and blockchain reconnection
+
+## Summary
+
+The Authentication feature group provides a comprehensive set of tools for handling user authentication in your Unity application with Immutable Passport. It supports both Device Code Auth and PKCE authentication methods, allowing for cross-platform compatibility including WebGL builds.
+
+### Best Practices
+
+- Initialize Passport before attempting any authentication operations
+- Handle authentication exceptions appropriately in your implementation
+- For WebGL applications, always use PKCE authentication
+- For returning users, try the Relogin or Reconnect features before falling back to a full Login
+- Always check if the Passport instance exists before attempting operations
+- Clear connection states when logging out to maintain proper application state
+
+These authentication features provide the foundation for all other Immutable operations in your Unity application, as users must be authenticated before interacting with blockchain services like IMX and zkEVM. 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/ClearStorageAndCache/metadata.json b/sample/Assets/Scripts/Passport/_tutorials/ClearStorageAndCache/metadata.json
new file mode 100644
index 000000000..b62c8d826
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/ClearStorageAndCache/metadata.json
@@ -0,0 +1,8 @@
+{
+  "title": "Clear Storage and Cache on Mobile Devices",
+  "description": "Learn how to clear WebView storage and cache on Android and iOS devices using the Immutable Passport SDK",
+  "keywords": ["Immutable", "SDK", "ClearStorageAndCache", "Mobile", "Android", "iOS", "WebView"],
+  "tech_stack": ["Unity", "C#", "WebView"],
+  "product": "Passport",
+  "programming_language": "C#"
+} 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/ClearStorageAndCache/tutorial.md b/sample/Assets/Scripts/Passport/_tutorials/ClearStorageAndCache/tutorial.md
new file mode 100644
index 000000000..7284509f8
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/ClearStorageAndCache/tutorial.md
@@ -0,0 +1,86 @@
+<div class="display-none">
+
+# Clear Storage and Cache
+
+</div>
+
+The Clear Storage and Cache feature in the Immutable Passport SDK provides a way to clear WebView storage and cache on mobile devices (Android and iOS). This is particularly useful for testing login flows, handling user log out completely, or managing authentication state for your application.
+
+<div class="button-component">
+
+[View feature on Github](https://github.com/immutable/unity-immutable-sdk/tree/main/sample/Assets/Scripts/Passport/ClearStorageAndCache) <span class="button-component-arrow">→</span>
+
+</div>
+
+#### Unity SDK Clear Storage and Cache Implementation
+
+The Clear Storage and Cache feature provides two main functions:
+
+1. `ClearStorage()` - Clears all underlying WebView storage currently being used by JavaScript storage APIs, including Web SQL Database and HTML5 Web Storage APIs.
+2. `ClearCache(bool includeDiskFiles)` - Clears the underlying WebView resource cache, with an option to include disk files.
+
+##### Feature: Clear Storage and Cache
+
+```csharp title="ClearStorageAndCacheScript" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ClearStorageAndCache/ClearStorageAndCacheScript.cs"
+public void ClearStorageAndCache()
+{
+    if (Passport.Instance == null)
+    {
+        ShowOutput("Passport instance is null. Initialise Passport first.");
+        return;
+    }
+
+#if UNITY_ANDROID && !UNITY_EDITOR
+    ShowOutput("Clearing storage and cache...");
+    Passport.Instance.ClearStorage();
+    Passport.Instance.ClearCache(true);
+    ShowOutput("Storage and cache cleared (on Android).");
+#elif UNITY_IPHONE && !UNITY_EDITOR
+    ShowOutput("Clearing storage and cache...");
+    Passport.Instance.ClearStorage();
+    Passport.Instance.ClearCache(true);
+    ShowOutput("Storage and cache cleared (on iOS).");
+#else
+    ShowOutput("ClearStorageAndCache is only available on Android and iOS devices.");
+#endif
+}
+```
+
+The implementation is straightforward:
+
+1. First, it checks if the Passport instance has been initialized
+2. Then, based on the platform:
+   - On Android and iOS devices, it calls `ClearStorage()` to clear WebView storage and `ClearCache(true)` to clear the WebView cache including disk files
+   - On other platforms, it displays a message indicating that the feature is only available on mobile devices
+
+Note that this feature is specifically designed for mobile platforms (Android and iOS) and is not available in the Unity Editor or on desktop platforms.
+
+#### Running the Feature Example
+
+##### Prerequisites
+
+1. Make sure you have set up your Unity project with the Immutable Passport SDK. For detailed setup instructions, visit [Immutable Hub](https://hub.immutable.com/).
+2. For testing on mobile devices, you need to build the application for Android or iOS.
+
+##### Steps to Run the Example
+
+1. Open the sample project in Unity
+2. Configure the Passport SDK with your application credentials
+3. Build and deploy the application to an Android or iOS device
+4. Navigate to the ClearStorageAndCache feature in the sample app
+5. First login to Passport to initialize the SDK
+6. Click the "Clear Storage and Cache" button to execute the feature
+7. The application will display a message indicating that the storage and cache have been cleared
+
+Note: This feature is particularly useful when testing authentication flows or when you need to clear user data from the device.
+
+#### Summary
+
+The Clear Storage and Cache feature provides a simple way to clear WebView storage and cache on mobile devices. This is useful for:
+
+- Testing authentication flows
+- Ensuring user privacy by clearing stored data
+- Resolving WebView caching issues
+- Completely logging out users and removing saved credentials
+
+When implementing this feature in your own application, remember that it is only available on Android and iOS devices, and requires that the Passport SDK is properly initialized before use. 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/GetUserInfo/metadata.json b/sample/Assets/Scripts/Passport/_tutorials/GetUserInfo/metadata.json
new file mode 100644
index 000000000..867f4dcfb
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/GetUserInfo/metadata.json
@@ -0,0 +1,8 @@
+{
+  "title": "Retrieving User Information from Passport",
+  "description": "Learn how to retrieve authenticated user information including email, Passport ID, access token, ID token, and linked wallet addresses using Immutable Passport SDK.",
+  "keywords": ["Immutable", "SDK", "GetUserInfo", "Passport", "Authentication", "User Information", "Access Token", "ID Token"],
+  "tech_stack": ["Unity", "C#", "Cysharp.Threading.Tasks"],
+  "product": "Passport",
+  "programming_language": "C#"
+} 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/GetUserInfo/tutorial.md b/sample/Assets/Scripts/Passport/_tutorials/GetUserInfo/tutorial.md
new file mode 100644
index 000000000..abe827656
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/GetUserInfo/tutorial.md
@@ -0,0 +1,103 @@
+<div class="display-none">
+
+# Get User Info
+
+</div>
+
+The Passport GetUserInfo feature group provides methods to access authenticated user information from Immutable Passport. This feature group enables developers to retrieve important user identifiers, authentication tokens, and linked wallet addresses that can be used for user management, authentication verification, and integration with other systems.
+
+<div class="button-component">
+
+[View feature group on Github](https://github.com/immutable/unity-immutable-sdk/tree/main/sample/Assets/Scripts/Passport/GetUserInfo) <span class="button-component-arrow">→</span>
+
+</div>
+
+## GetUserInfo Overview
+
+The GetUserInfo feature group consists of a single feature that provides multiple methods to retrieve different pieces of user information:
+
+- Get user email
+- Get Passport ID
+- Get access token
+- Get ID token
+- Get linked addresses
+
+These methods help developers access authenticated user data that can be used for user management, displaying user information, or integrating with other systems that require authentication tokens.
+
+## Unity SDK GetUserInfo Features
+
+### Feature: GetUserInfo
+
+The GetUserInfo feature provides several methods to retrieve authenticated user information from Immutable Passport.
+
+```csharp title="GetUserInfo" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/GetUserInfo/GetUserInfoScript.cs"
+// Retrieving the user's email
+string email = await Passport.Instance.GetEmail();
+
+// Retrieving the user's Passport ID
+string passportId = await Passport.Instance.GetPassportId();
+
+// Retrieving the user's access token
+string accessToken = await Passport.Instance.GetAccessToken();
+
+// Retrieving the user's ID token
+string idToken = await Passport.Instance.GetIdToken();
+
+// Retrieving the user's linked external wallets
+List<string> addresses = await Passport.Instance.GetLinkedAddresses();
+```
+
+#### How It Works
+
+The GetUserInfo feature provides a simple interface to access user information from the authenticated Passport session:
+
+1. **GetEmail()**: Retrieves the email address associated with the user's Passport account. This is useful for user identification and communication purposes.
+
+2. **GetPassportId()**: Returns the unique identifier for the user's Passport account. This ID can be used to uniquely identify users in your application.
+
+3. **GetAccessToken()**: Provides the OAuth access token that can be used to make authenticated API calls to Immutable services or your own backend services. This token proves the user's identity and authorization.
+
+4. **GetIdToken()**: Returns the ID token containing the user's identity information in JWT format. This token can be decoded to access additional user profile information.
+
+5. **GetLinkedAddresses()**: Retrieves a list of external wallet addresses that the user has linked to their Passport account. This is useful for identifying which external wallets the user has associated with their account.
+
+All methods are asynchronous and return `UniTask` results, which can be awaited in async methods. Each method performs validation checks on the Passport instance before attempting to retrieve information, and proper error handling is implemented to catch and report any exceptions.
+
+## Running the GetUserInfo Example
+
+### Prerequisites
+
+- Unity Editor (2020.3 LTS or later)
+- Immutable SDK imported into your project
+- Configured Immutable Hub environment ([Configure Immutable Hub](https://docs.immutable.com/docs/x/sdks/unity))
+
+### Steps to Run the Example
+
+1. Open the sample app in Unity Editor.
+2. Ensure you have already set up and initialized Passport. You must be logged in to retrieve user information.
+3. Navigate to the GetUserInfo scene or component in the sample app.
+4. Each user information method can be tested by clicking the corresponding button in the UI:
+   - Click "Get Email" to retrieve the user's email address
+   - Click "Get Passport ID" to retrieve the user's Passport ID
+   - Click "Get Access Token" to retrieve the user's access token
+   - Click "Get ID Token" to retrieve the user's ID token
+   - Click "Get Linked Addresses" to retrieve the user's linked wallet addresses
+5. The retrieved information will be displayed in the output text field.
+
+Note: You must successfully authenticate (log in) with Passport before you can retrieve user information. If not logged in, the methods will return appropriate error messages.
+
+## Summary
+
+The GetUserInfo feature group provides essential functionality for accessing authenticated user information from Immutable Passport. With these methods, developers can:
+
+- Access user identifiers for account management
+- Retrieve authentication tokens for API requests
+- Get linked wallet addresses for blockchain interactions
+
+Best practices when using the GetUserInfo feature:
+
+1. Always check if the user is authenticated before attempting to retrieve user information
+2. Implement proper error handling for cases where retrieving information fails
+3. Store sensitive information (like access tokens) securely, following security best practices
+4. Use the appropriate method for your specific needs rather than retrieving all information unnecessarily
+5. Consider caching non-sensitive information to reduce API calls 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/Imx/metadata.json b/sample/Assets/Scripts/Passport/_tutorials/Imx/metadata.json
new file mode 100644
index 000000000..85491a03f
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/Imx/metadata.json
@@ -0,0 +1,8 @@
+{
+  "title": "Immutable X Integration with Passport SDK",
+  "description": "How to integrate Immutable X features in your Unity game, including connecting to IMX, registering users, retrieving wallet addresses, and transferring NFTs",
+  "keywords": ["Immutable", "SDK", "Imx", "ImxConnect", "ImxRegister", "ImxGetAddress", "ImxNftTransfer", "ImxIsRegisteredOffchain", "NFT", "Blockchain"],
+  "tech_stack": ["Unity", "C#", "Passport SDK", "Immutable X", "Blockchain"],
+  "product": "Passport",
+  "programming_language": "C#"
+} 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/Imx/tutorial.md b/sample/Assets/Scripts/Passport/_tutorials/Imx/tutorial.md
new file mode 100644
index 000000000..d89da3488
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/Imx/tutorial.md
@@ -0,0 +1,297 @@
+<div class="display-none">
+
+# Immutable X Integration
+
+</div>
+
+Immutable X is a Layer 2 scaling solution for NFTs on Ethereum that provides gas-free minting and trading. The Passport SDK enables your Unity game to integrate seamlessly with Immutable X, giving your players the ability to connect to IMX, check registration status, register if needed, retrieve wallet addresses, and transfer NFTs.
+
+<div class="button-component">
+
+[View feature group on Github](https://github.com/immutable/unity-immutable-sdk/tree/main/sample/Assets/Scripts/Passport) <span class="button-component-arrow">→</span>
+
+</div>
+
+## Immutable X Overview
+
+The Imx feature group includes the following features:
+
+- **ImxConnect**: Connect to Immutable X using saved credentials
+- **ImxRegister**: Register the user with Immutable X (off-chain)
+- **ImxGetAddress**: Retrieve the user's Immutable X wallet address
+- **ImxNftTransfer**: Transfer NFTs to specified receivers
+- **ImxIsRegisteredOffchain**: Check if the user is registered off-chain with Immutable X
+
+These features work together to provide a complete Immutable X integration flow. First, you connect to IMX, then check if the user is registered. If not, you can register them. Once registered, you can retrieve their wallet address and perform NFT transfers.
+
+## Unity SDK Immutable X Features
+
+### Feature: ImxConnect
+
+Connect users to Immutable X by initializing the user's wallet and setting up the Immutable X provider using saved credentials.
+
+```csharp title="ImxConnectScript.cs" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ImxConnect/ImxConnectScript.cs"
+public async UniTaskVoid ConnectImxAsync()
+{
+    if (Passport.Instance == null)
+    {
+        ShowOutput("Passport instance is null");
+        return;
+    }
+    // Set the static property for global access
+    SampleAppManager.PassportInstance = Passport.Instance;
+    ShowOutput("Connecting to Passport using saved credentials...");
+    try
+    {
+        await Passport.Instance.ConnectImx();
+        
+        SampleAppManager.IsConnectedToImx = true;
+        ShowOutput("Connected to IMX");
+
+        // Update UI states based on connection
+        var authSceneManager = FindObjectOfType<AuthenticatedSceneManager>();
+        if (authSceneManager != null)
+        {
+            authSceneManager.UpdateImxButtonStates();
+            authSceneManager.OnImxConnected?.Invoke(); 
+        }
+    }
+    catch (System.Exception ex)
+    {
+        ShowOutput($"Failed to connect to IMX: {ex.Message}");
+    }
+}
+```
+
+The `ConnectImx` method initializes the connection to Immutable X through the Passport SDK. It uses an async operation with UniTask to connect without blocking the main thread. After successful connection, it updates the static `SampleAppManager.IsConnectedToImx` flag and notifies the scene manager to update UI elements accordingly.
+
+### Feature: ImxIsRegisteredOffchain
+
+Check whether a user is registered off-chain with Immutable X.
+
+```csharp title="ImxIsRegisteredOffchainScript.cs" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ImxIsRegisteredOffchain/ImxIsRegisteredOffchainScript.cs"
+private async UniTaskVoid CheckIsRegisteredOffchainAsync()
+{
+    if (Passport.Instance == null)
+    {
+        ShowOutput("Passport not initialised.");
+        return;
+    }
+
+    if (!SampleAppManager.IsConnectedToImx)
+    {
+        ShowOutput("Please connect to Immutable X first.");
+        return;
+    }
+
+    ShowOutput("Checking if registered offchain...");
+    try
+    {
+        bool isRegistered = await SampleAppManager.PassportInstance.IsRegisteredOffchain();
+        
+        if (isRegistered)
+        {
+            ShowOutput("Registered");
+        }
+        else
+        {
+            ShowOutput("User is NOT registered offchain.");
+        }
+    }
+    catch (System.Exception ex)
+    {
+        ShowOutput($"Failed to check registration: {ex.Message}");
+    }
+}
+```
+
+This feature first verifies that the user is connected to IMX before checking if they're registered off-chain. The `IsRegisteredOffchain` method returns a boolean indicating registration status, which determines whether the user can perform operations like transferring NFTs.
+
+### Feature: ImxRegister
+
+Register the user with Immutable X to enable off-chain operations.
+
+```csharp title="ImxRegisterScript.cs" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ImxRegister/ImxRegisterScript.cs"
+public async void RegisterOffchain()
+{
+    ShowOutput("Registering off-chain...");
+    try
+    {
+        RegisterUserResponse response = await Passport.RegisterOffchain();
+        if (response != null)
+        {
+            ShowOutput($"Successfully registered");
+        }
+        else
+        {
+            ShowOutput("Registration failed");
+        }
+    }
+    catch (PassportException e)
+    {
+        ShowOutput($"Unable to register off-chain: {e.Message} ({e.Type})");
+    }
+    catch (Exception e)
+    {
+        ShowOutput($"Unable to register off-chain {e.Message}");
+    }
+}
+```
+
+The `RegisterOffchain` method handles user registration with Immutable X. It returns a `RegisterUserResponse` object containing information about the registration. This step is required before users can perform operations like transferring assets on the Immutable X platform.
+
+### Feature: ImxGetAddress
+
+Retrieve the user's Immutable X wallet address.
+
+```csharp title="ImxGetAddressScript.cs" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ImxGetAddress/ImxGetAddressScript.cs"
+public async void GetAddress()
+{
+    ShowOutput("Retrieving wallet address...");
+    try
+    {
+        string address = await Passport.GetAddress();
+        ShowOutput(string.IsNullOrEmpty(address) ? "No address found" : address);
+    }
+    catch (PassportException e)
+    {
+        ShowOutput($"Unable to retrieve address: {e.Message} ({e.Type})");
+    }
+    catch (Exception)
+    {
+        ShowOutput("Unable to retrieve address");
+    }
+}
+```
+
+The `GetAddress` method retrieves the wallet address associated with the user's Immutable X account. This address is essential for identifying the user in blockchain transactions and can be used for various operations like checking balances or transaction history.
+
+### Feature: ImxNftTransfer
+
+Transfer NFTs to specified receivers.
+
+```csharp title="ImxNftTransferScript.cs" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ImxNftTransfer/ImxNftTransferScript.cs"
+private async UniTaskVoid TransferAsync()
+{
+    if (Passport.Instance == null)
+    {
+        ShowOutput("Passport instance is null");
+        return;
+    }
+    if (!string.IsNullOrWhiteSpace(TokenIdInput1.text) &&
+        !string.IsNullOrWhiteSpace(TokenAddressInput1.text) &&
+        !string.IsNullOrWhiteSpace(ReceiverInput1.text))
+    {
+        ShowOutput("Transferring NFTs...");
+        try
+        {
+            List<NftTransferDetails> transferDetails = GetTransferDetails();
+            if (transferDetails.Count > 1)
+            {
+                CreateBatchTransferResponse response = await Passport.Instance.ImxBatchNftTransfer(transferDetails.ToArray());
+                ShowOutput($"Successfully transferred {response.transfer_ids.Length} NFTs.");
+            }
+            else
+            {
+                NftTransferDetails nftTransferDetail = transferDetails[0];
+                UnsignedTransferRequest transferRequest = UnsignedTransferRequest.ERC721(
+                    nftTransferDetail.receiver,
+                    nftTransferDetail.tokenId,
+                    nftTransferDetail.tokenAddress
+                );
+                CreateTransferResponseV1 response = await Passport.Instance.ImxTransfer(transferRequest);
+                ShowOutput($"NFT transferred successfully. Transfer ID: {response.transfer_id}");
+            }
+        }
+        catch (System.Exception ex)
+        {
+            ShowOutput($"Failed to transfer NFTs: {ex.Message}");
+        }
+    }
+    else
+    {
+        ShowOutput("Please fill in all required fields for the first NFT transfer.");
+    }
+}
+
+private List<NftTransferDetails> GetTransferDetails()
+{
+    List<NftTransferDetails> details = new List<NftTransferDetails>();
+    if (!string.IsNullOrWhiteSpace(TokenIdInput1.text) &&
+        !string.IsNullOrWhiteSpace(TokenAddressInput1.text) &&
+        !string.IsNullOrWhiteSpace(ReceiverInput1.text))
+    {
+        details.Add(new NftTransferDetails(
+            ReceiverInput1.text,
+            TokenIdInput1.text,
+            TokenAddressInput1.text
+        ));
+    }
+    if (!string.IsNullOrWhiteSpace(TokenIdInput2.text) &&
+        !string.IsNullOrWhiteSpace(TokenAddressInput2.text) &&
+        !string.IsNullOrWhiteSpace(ReceiverInput2.text))
+    {
+        details.Add(new NftTransferDetails(
+            ReceiverInput2.text,
+            TokenIdInput2.text,
+            TokenAddressInput2.text
+        ));
+    }
+    return details;
+}
+```
+
+The `ImxNftTransfer` feature demonstrates how to transfer NFTs to specified recipients. The code supports both single and batch transfers, depending on how many inputs are provided. For batch transfers, it uses the `ImxBatchNftTransfer` method, while for single transfers, it uses the `ImxTransfer` method with an `UnsignedTransferRequest` object.
+
+## Running the Feature Group Examples
+
+### Prerequisites
+
+1. Create an account on [Immutable Hub](https://hub.immutable.com/) to set up your development environment
+2. Set up the Unity Editor with the Immutable Passport SDK installed
+3. Configure your Passport settings with your application's client ID and redirect URLs
+
+### Step-by-Step Instructions
+
+1. **Connect to Immutable X**
+   - Open the sample scene containing the IMX features
+   - Click the "Connect" button to initialize the connection to Immutable X
+   - Confirm your connection is successful when "Connected to IMX" message appears
+
+2. **Check Registration Status**
+   - After connecting, click the "Check Registration" button to verify if your account is registered off-chain
+   - If the result shows "Not registered", proceed to the next step
+
+3. **Register Off-chain**
+   - Click the "Register" button to register your account with Immutable X
+   - Wait for the "Successfully registered" message to confirm completion
+
+4. **Get Wallet Address**
+   - Click the "Get Address" button to retrieve your Immutable X wallet address
+   - The address will be displayed in the output field
+
+5. **Transfer NFTs**
+   - Navigate to the NFT Transfer screen
+   - Enter the token ID, token address, and receiver address for the NFT you want to transfer
+   - Click "Transfer" to initiate the transfer
+   - Wait for the success message with the transfer ID
+
+### Feature Sequence Dependencies
+
+For proper functionality, follow this sequence:
+1. Connect to IMX first (ImxConnect)
+2. Check registration status (ImxIsRegisteredOffchain)
+3. Register if needed (ImxRegister)
+4. Then proceed with address retrieval (ImxGetAddress) and transfers (ImxNftTransfer)
+
+## Summary
+
+The Immutable X feature group provides a complete integration path for your Unity game with Immutable's Layer 2 solution. By implementing these features, you enable your players to interact with blockchain assets in a gas-free, carbon-neutral environment while maintaining Ethereum's security.
+
+When using these features together, remember to:
+- Always check for IMX connection before performing operations
+- Verify registration status before attempting transfers
+- Handle exceptions appropriately as blockchain operations may sometimes fail
+- Consider the asynchronous nature of these operations in your UI design
+
+The Immutable X integration through Passport SDK simplifies what would otherwise be complex blockchain interactions, allowing you to focus on creating engaging gameplay while providing your players with true ownership of digital assets. 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/PassportInitialisation/metadata.json b/sample/Assets/Scripts/Passport/_tutorials/PassportInitialisation/metadata.json
new file mode 100644
index 000000000..c58fc8e20
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/PassportInitialisation/metadata.json
@@ -0,0 +1,8 @@
+{
+  "title": "Initializing the Immutable Passport SDK",
+  "description": "Learn how to properly initialize the Immutable Passport SDK in your Unity application to enable authentication and blockchain interactions",
+  "keywords": ["Immutable", "SDK", "PassportInitialisation", "Authentication", "Unity"],
+  "tech_stack": ["Unity", "C#", "UniTask"],
+  "product": "Passport",
+  "programming_language": "C#"
+} 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/PassportInitialisation/tutorial.md b/sample/Assets/Scripts/Passport/_tutorials/PassportInitialisation/tutorial.md
new file mode 100644
index 000000000..286691d83
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/PassportInitialisation/tutorial.md
@@ -0,0 +1,97 @@
+<div class="display-none">
+
+# Passport Initialisation
+
+</div>
+
+Passport initialization is a critical first step in integrating Immutable's blockchain capabilities into your Unity game. This feature demonstrates how to properly initialize the Passport SDK, which is required before using any other Passport functionality like authentication, wallet operations, or blockchain interactions.
+
+<div class="button-component">
+
+[View feature on Github](https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/PassportInitialisation/PassportInitialisationScript.cs) <span class="button-component-arrow">→</span>
+
+</div>
+
+## Unity SDK Passport Initialisation Implementation
+
+### Feature: Passport Initialisation
+
+The Passport Initialisation feature demonstrates how to properly initialize the Immutable Passport SDK in your Unity application. The initialization process configures the SDK with your application's credentials and environment settings, preparing it for authentication and blockchain interactions.
+
+```csharp title="Passport Initialisation" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/PassportInitialisation/PassportInitialisationScript.cs"
+// Set the log level for the SDK
+Passport.LogLevel = LogLevel.Info;
+
+// Don't redact token values from logs
+Passport.RedactTokensInLogs = false;
+
+// Initialise Passport
+string environment = Immutable.Passport.Model.Environment.SANDBOX;
+string clientId = "mp6rxfMDwwZDogcdgNrAaHnG0qMlXuMK";
+Passport passport = await Passport.Init(clientId, environment, redirectUri, logoutRedirectUri);
+```
+
+This initialization process handles several important tasks:
+1. **Log Level Configuration**: Sets the logging verbosity to help with debugging.
+2. **Token Redaction**: Controls whether sensitive token information appears in logs.
+3. **Environment Selection**: Determines whether to connect to the sandbox (for testing) or production environment.
+4. **Client ID**: Specifies your application's unique identifier from the Immutable Hub.
+5. **Redirect URIs**: Configures the authentication flow's redirect paths.
+
+The implementation supports two authentication methods:
+- **Device Code Auth**: Used for desktop applications where the user authenticates in an external browser.
+- **PKCE Flow**: Used for web and mobile platforms where authentication happens in an embedded browser.
+
+The code automatically selects the appropriate authentication method based on the platform, with WebGL defaulting to PKCE due to platform limitations:
+
+```csharp title="Authentication Method Selection" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/PassportInitialisation/PassportInitialisationScript.cs"
+// WebGL does not support Device Code Auth, so we'll use PKCE by default instead.
+#if UNITY_WEBGL
+    UsePKCE();
+#endif
+```
+
+For PKCE authentication, the redirect URIs must be configured correctly based on the platform:
+
+```csharp title="Platform-specific PKCE Configuration" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/PassportInitialisation/PassportInitialisationScript.cs"
+#if UNITY_WEBGL
+    string url = Application.absoluteURL;
+    Uri uri = new Uri(url);
+    string scheme = uri.Scheme;
+    string hostWithPort = uri.IsDefaultPort ? uri.Host : $"{uri.Host}:{uri.Port}";
+    string fullPath = uri.AbsolutePath.EndsWith("/") ? uri.AbsolutePath : uri.AbsolutePath.Substring(0, uri.AbsolutePath.LastIndexOf('/') + 1);
+
+    string redirectUri = $"{scheme}://{hostWithPort}{fullPath}callback.html";
+    string logoutRedirectUri = $"{scheme}://{hostWithPort}{fullPath}logout.html";
+    
+    InitialisePassport(redirectUri: redirectUri, logoutRedirectUri: logoutRedirectUri);
+#else
+    InitialisePassport(redirectUri: "immutablerunner://callback", logoutRedirectUri: "immutablerunner://logout");
+#endif
+```
+
+## Running the Feature Example
+
+### Prerequisites
+- Create an Immutable Hub account and get your client ID from [Immutable Hub](https://hub.immutable.com)
+- Set up the Unity project with the Immutable Passport SDK
+- Configure your project for the appropriate platform (WebGL, Android, iOS, macOS, Windows)
+
+### Steps to Run the Example
+1. Open the Unity project and load the sample scene for Passport Initialisation
+2. Replace the placeholder `clientId` with your own client ID from Immutable Hub
+3. For non-WebGL platforms, you may need to set up custom URL schemes for your application
+4. Run the application in the Unity Editor or build for your target platform
+5. Once the application runs, it will automatically initialize Passport with the appropriate authentication method
+6. If initialization is successful, the application will navigate to the unauthenticated scene, ready for login
+
+## Summary
+
+Properly initializing the Passport SDK is a crucial first step in integrating Immutable's blockchain features into your Unity game. The initialization process sets up the environment, configures authentication methods, and prepares the SDK for subsequent operations like user login, wallet management, and blockchain interactions.
+
+When implementing this feature in your own game:
+- Always store your client ID securely and consider using environment variables for different build configurations
+- Select the appropriate environment (SANDBOX for testing, PRODUCTION for release)
+- Configure platform-specific redirect URIs based on your application's structure
+- Handle exceptions during initialization to provide meaningful feedback to users
+- Consider adjusting log levels based on your build configuration (verbose for debugging, minimal for production) 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/SetCallTimeout/metadata.json b/sample/Assets/Scripts/Passport/_tutorials/SetCallTimeout/metadata.json
new file mode 100644
index 000000000..bdff4f251
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/SetCallTimeout/metadata.json
@@ -0,0 +1,8 @@
+{
+  "title": "Configuring API Call Timeouts in Passport SDK",
+  "description": "Learn how to customize network timeout durations for API calls in the Immutable Passport SDK",
+  "keywords": ["Immutable", "SDK", "SetCallTimeout", "Network Timeout", "API Timeout", "Unity"],
+  "tech_stack": ["Unity", "C#", "Passport SDK"],
+  "product": "Passport",
+  "programming_language": "C#"
+} 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/SetCallTimeout/tutorial.md b/sample/Assets/Scripts/Passport/_tutorials/SetCallTimeout/tutorial.md
new file mode 100644
index 000000000..41f48d7fe
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/SetCallTimeout/tutorial.md
@@ -0,0 +1,93 @@
+<div class="display-none">
+
+# Set Call Timeout
+
+</div>
+
+The Set Call Timeout feature allows developers to configure the timeout duration for API calls within the Immutable Passport SDK. This enables greater control over network operations, allowing customization of how long the application should wait for responses before timing out
+
+<div class="button-component">
+
+[View feature on Github](https://github.com/immutable/unity-immutable-sdk/tree/main/sample/Assets/Scripts/Passport/Other/SetCallTimeout) <span class="button-component-arrow">→</span>
+
+</div>
+
+## Unity SDK Set Call Timeout Implementation
+
+### Feature: SetCallTimeout
+
+The Set Call Timeout feature provides a simple way to adjust the timeout duration for network calls made through the Passport SDK. When making API calls to blockchain networks or authentication services, network latency can sometimes cause delays. This feature gives developers control over how long their application should wait before considering a request as failed due to timeout.
+
+```csharp title="SetCallTimeoutScript" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/Other/SetCallTimeout/SetCallTimeoutScript.cs"
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.SceneManagement;
+using Immutable.Passport;
+
+public class SetCallTimeoutScript : MonoBehaviour
+{
+    [SerializeField] private Text Output;
+    [SerializeField] private InputField TimeoutInput;
+
+    public void SetTimeout()
+    {
+        if (Passport.Instance == null)
+        {
+            ShowOutput("Passport instance is null");
+            return;
+        }
+        if (TimeoutInput == null)
+        {
+            Debug.LogError("[SetCallTimeoutScript] TimeoutInput is not assigned in the Inspector.");
+            ShowOutput("Timeout input field is not assigned.");
+            return;
+        }
+        if (!int.TryParse(TimeoutInput.text, out int timeout))
+        {
+            ShowOutput("Invalid timeout value");
+            return;
+        }
+        Passport.Instance.SetCallTimeout(timeout);
+        ShowOutput($"Set call timeout to: {timeout}ms");
+    }
+}
+```
+
+The implementation is straightforward:
+
+1. The script takes a timeout value in milliseconds from a UI input field.
+2. After validating the input, it calls `Passport.Instance.SetCallTimeout(timeout)` to set the timeout duration.
+3. The default timeout value in the SDK is 60,000 milliseconds (1 minute).
+
+This timeout applies to functions that use the browser communications manager in the Passport SDK, which includes most network operations like authentication and blockchain transactions.
+
+## Running the Feature Example
+
+### Prerequisites
+
+- Unity Editor installed (2021.3 LTS or newer recommended)
+- Immutable SDK integrated into your project
+- Basic knowledge of Unity UI system
+- Valid API credentials set up on [Immutable Hub](https://hub.immutable.com/)
+
+### Steps to Run the Example
+
+1. Open the sample project in Unity Editor.
+2. Ensure you have configured your Passport settings with valid client ID and environment in the Passport initialization scene.
+3. Run the project in the Unity Editor.
+4. Log in to Passport if not already authenticated.
+5. Navigate to the Set Call Timeout scene.
+6. Enter a timeout value in milliseconds in the input field (e.g., 30000 for 30 seconds).
+7. Click the "Set Timeout" button to apply the new timeout value.
+8. The output text will confirm that the timeout has been set to the specified value.
+
+## Summary
+
+The Set Call Timeout feature provides developers with the ability to customize network timeout durations in their applications. This is particularly useful when:
+
+- Working with networks that have varying latency conditions
+- Developing for different platforms with different network capabilities
+- Fine-tuning application responsiveness and error handling
+- Testing network resilience with different timeout settings
+
+By implementing appropriate timeout values, developers can create a better user experience by controlling how long the application will wait for network responses before considering the operation failed, allowing for more graceful error handling. 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/ZkEvm/metadata.json b/sample/Assets/Scripts/Passport/_tutorials/ZkEvm/metadata.json
new file mode 100644
index 000000000..d236d8598
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/ZkEvm/metadata.json
@@ -0,0 +1,8 @@
+{
+  "title": "ZkEvm Integration for Unity Games",
+  "description": "Learn how to integrate Immutable's ZkEvm blockchain with Unity games, including connecting to the network, sending transactions, checking balances, and more.",
+  "keywords": ["Immutable", "SDK", "ZkEvm", "Blockchain", "Unity", "Smart Contracts", "Transactions", "Web3"],
+  "tech_stack": ["Unity", "C#", "Immutable ZkEvm", "Passport SDK", "Cysharp UniTask"],
+  "product": "Passport",
+  "programming_language": "C#"
+} 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/_tutorials/ZkEvm/tutorial.md b/sample/Assets/Scripts/Passport/_tutorials/ZkEvm/tutorial.md
new file mode 100644
index 000000000..2d23b433e
--- /dev/null
+++ b/sample/Assets/Scripts/Passport/_tutorials/ZkEvm/tutorial.md
@@ -0,0 +1,305 @@
+<div class="display-none">
+
+# ZkEvm Integration
+
+</div>
+
+The ZkEvm feature group demonstrates how to integrate Immutable's ZkEvm blockchain capabilities into your Unity game. These features allow games to connect to the Immutable ZkEvm blockchain, perform transactions, check balances, and interact with smart contracts.
+
+<div class="button-component">
+
+[View feature group on Github](https://github.com/immutable/unity-immutable-sdk/tree/main/sample/Assets/Scripts/Passport/ZkEvm) <span class="button-component-arrow">→</span>
+
+</div>
+
+## ZkEvm Overview
+
+The ZkEvm feature group includes the following features:
+
+- **ZkEvmConnect**: Connect to the Immutable ZkEvm network
+- **ZkEvmSendTransaction**: Send transactions to the blockchain
+- **ZkEvmGetBalance**: Check account balances
+- **ZkEvmGetTransactionReceipt**: Verify transaction status
+- **ZkEvmSignTypedData**: Sign structured data using EIP-712
+- **ZkEvmRequestAccounts**: Request user accounts from Passport
+
+These features work together to provide a complete integration with Immutable's ZkEvm blockchain, allowing games to leverage blockchain functionality while maintaining a seamless user experience.
+
+## Unity SDK ZkEvm Features
+
+### Feature: ZkEvm Connect
+
+The ZkEvmConnect feature initializes the connection to the Immutable ZkEvm network. This is a prerequisite for all other ZkEvm operations.
+
+```csharp title="ZkEvmConnectScript" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ZkEvm/ZkEvmConnect/ZkEvmConnectScript.cs"
+public void ConnectZkEvm()
+{
+    ConnectZkEvmAsync();
+}
+
+private async UniTaskVoid ConnectZkEvmAsync()
+{
+    if (Passport.Instance == null)
+    {
+        ShowOutput("Passport not initialised.");
+        return;
+    }
+    // Set the static property for global access
+    SampleAppManager.PassportInstance = Passport.Instance;
+
+    ShowOutput("Connecting to zkEVM...");
+    try
+    {
+        await Passport.Instance.ConnectEvm();
+        
+        // Update connection state and refresh UI
+        SampleAppManager.IsConnectedToZkEvm = true;
+        var sceneManager = FindObjectOfType<AuthenticatedSceneManager>();
+        if (sceneManager != null)
+        {
+            sceneManager.UpdateZkEvmButtonStates();
+            Debug.Log("Updated zkEVM button states after connection");
+        }
+        
+        ShowOutput("Connected to EVM");
+    }
+    catch (System.Exception ex)
+    {
+        ShowOutput($"Failed to connect to zkEVM: {ex.Message}");
+    }
+}
+```
+
+This script establishes a connection to the ZkEvm network through the Passport instance. It updates the UI to reflect the connection status and handles any errors that might occur during the connection process.
+
+### Feature: ZkEvm Send Transaction
+
+The ZkEvmSendTransaction feature allows you to send transactions to the Immutable ZkEvm blockchain.
+
+```csharp title="ZkEvmSendTransactionScript" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ZkEvm/ZkEvmSendTransaction/ZkEvmSendTransactionScript.cs"
+private async UniTaskVoid SendTransactionAsync()
+{
+    if (SampleAppManager.PassportInstance == null)
+    {
+        ShowOutput("Passport instance is null");
+        return;
+    }
+    // Ensure EVM provider is connected
+    try
+    {
+        ShowOutput("Connecting to zkEVM provider...");
+        await SampleAppManager.PassportInstance.ConnectEvm();
+    }
+    catch (Exception ex)
+    {
+        ShowOutput($"Failed to connect to zkEVM provider: {ex.Message}");
+        return;
+    }
+    ShowOutput("Sending transaction...");
+    try
+    {
+        TransactionRequest request = new TransactionRequest
+        {
+            to = ToInputField != null ? ToInputField.text : "",
+            value = ValueInputField != null ? ValueInputField.text : "",
+            data = DataInputField != null ? DataInputField.text : ""
+        };
+        
+        if (ConfirmToggle != null && ConfirmToggle.isOn)
+        {
+            TransactionReceiptResponse response = await SampleAppManager.PassportInstance.ZkEvmSendTransactionWithConfirmation(request);
+            ShowOutput($"Transaction hash: {response.transactionHash}\nStatus: {GetTransactionStatusString(response.status)}");
+        }
+        else
+        {
+            string transactionHash = await SampleAppManager.PassportInstance.ZkEvmSendTransaction(request);
+            
+            if (GetTransactionReceiptToggle != null && GetTransactionReceiptToggle.isOn)
+            {
+                string? status = await PollStatus(transactionHash);
+                ShowOutput($"Transaction hash: {transactionHash}\nStatus: {GetTransactionStatusString(status)}");
+            }
+            else
+            {
+                ShowOutput($"Transaction hash: {transactionHash}");
+            }
+        }
+    }
+    catch (Exception ex)
+    {
+        ShowOutput($"Failed to send transaction: {ex.Message}");
+    }
+}
+```
+
+This script demonstrates sending transactions to the ZkEvm blockchain. It supports both regular transactions and transactions with confirmation, which wait for the transaction to be included in a block. Users can input the target address, value, and transaction data through the UI.
+
+### Feature: ZkEvm Get Balance
+
+The ZkEvmGetBalance feature retrieves the balance of a specific address on the ZkEvm blockchain.
+
+```csharp title="ZkEvmGetBalanceScript" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ZkEvm/ZkEvmGetBalance/ZkEvmGetBalanceScript.cs"
+private async UniTaskVoid GetBalanceAsync()
+{
+    if (SampleAppManager.PassportInstance == null)
+    {
+        ShowOutput("Passport instance is null");
+        return;
+    }
+    ShowOutput("Getting account balance...");
+    try
+    {
+        string balanceHex = await SampleAppManager.PassportInstance.ZkEvmGetBalance(AddressInput.text);
+        var balanceDec = BigInteger.Parse(balanceHex.Replace("0x", ""), NumberStyles.HexNumber);
+        if (balanceDec < 0)
+        {
+            balanceDec = BigInteger.Parse("0" + balanceHex.Replace("0x", ""), NumberStyles.HexNumber);
+        }
+        ShowOutput($"Balance:\nHex: {balanceHex}\nDec: {balanceDec}");
+    }
+    catch (System.Exception ex)
+    {
+        ShowOutput($"Failed to get balance: {ex.Message}");
+    }
+}
+```
+
+This script fetches the balance of an Ethereum address on the ZkEvm network. It displays both the hexadecimal and decimal representations of the balance, after parsing the hexadecimal response from the blockchain.
+
+### Feature: ZkEvm Get Transaction Receipt
+
+The ZkEvmGetTransactionReceipt feature allows you to check the status of a transaction on the ZkEvm blockchain.
+
+```csharp title="ZkEvmGetTransactionReceiptScript" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ZkEvm/ZkEvmGetTransactionReceipt/ZkEvmGetTransactionReceiptScript.cs"
+private async UniTaskVoid GetTransactionReceiptAsync()
+{
+    if (SampleAppManager.PassportInstance == null)
+    {
+        ShowOutput("Passport instance is null");
+        return;
+    }
+    ShowOutput($"Getting transaction receipt for hash: {TransactionHashInput.text}");
+    try
+    {
+        TransactionReceiptResponse receipt = await SampleAppManager.PassportInstance.ZkEvmGetTransactionReceipt(TransactionHashInput.text);
+        
+        string status = receipt.status != null ? GetTransactionStatusString(receipt.status) : "Pending";
+        
+        ShowOutput($"Transaction Hash: {receipt.transactionHash}\nStatus: {status}\nBlock Number: {receipt.blockNumber}\nGas Used: {receipt.gasUsed}");
+    }
+    catch (System.Exception ex)
+    {
+        ShowOutput($"Failed to get transaction receipt: {ex.Message}");
+    }
+}
+```
+
+This script retrieves the receipt for a transaction using its hash, which provides information about the transaction's status, block number, and gas used. This is useful for verifying whether a transaction has been successfully processed by the blockchain.
+
+### Feature: ZkEvm Sign Typed Data
+
+The ZkEvmSignTypedData feature enables signing of structured data according to EIP-712 standard.
+
+```csharp title="ZkEvmSignTypedDataScript" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ZkEvm/ZkEvmSignTypedData/ZkEvmSignTypedDataScript.cs"
+private async UniTaskVoid SignTypedDataAsync()
+{
+    if (SampleAppManager.PassportInstance == null)
+    {
+        ShowOutput("Passport instance is null");
+        return;
+    }
+    ShowOutput("Signing typed data...");
+    try
+    {
+        // Prepare the EIP-712 typed data
+        string typedData = TypedDataInputField.text;
+        
+        // Sign the typed data
+        string signature = await SampleAppManager.PassportInstance.ZkEvmSignTypedDataV4(typedData);
+        
+        ShowOutput($"Signature: {signature}");
+    }
+    catch (System.Exception ex)
+    {
+        ShowOutput($"Failed to sign typed data: {ex.Message}");
+    }
+}
+```
+
+This script demonstrates how to sign structured data (following the EIP-712 standard) using the Passport SDK. This is useful for various on-chain operations where cryptographic signatures are required to prove user intent or authorization.
+
+### Feature: ZkEvm Request Accounts
+
+The ZkEvmRequestAccounts feature retrieves the Ethereum addresses associated with the logged-in Passport user.
+
+```csharp title="ZkEvmRequestAccountsScript" manualLink="https://github.com/immutable/unity-immutable-sdk/blob/main/sample/Assets/Scripts/Passport/ZkEvm/ZkEvmRequestAccounts/ZkEvmRequestAccountsScript.cs"
+private async UniTaskVoid RequestAccountsAsync()
+{
+    if (SampleAppManager.PassportInstance == null)
+    {
+        ShowOutput("Passport instance is null");
+        return;
+    }
+    ShowOutput("Requesting accounts...");
+    try
+    {
+        List<string> accounts = await SampleAppManager.PassportInstance.ZkEvmRequestAccounts();
+        
+        if (accounts.Count > 0)
+        {
+            string accountsString = string.Join("\n", accounts);
+            ShowOutput($"Accounts:\n{accountsString}");
+        }
+        else
+        {
+            ShowOutput("No accounts found");
+        }
+    }
+    catch (System.Exception ex)
+    {
+        ShowOutput($"Failed to request accounts: {ex.Message}");
+    }
+}
+```
+
+This script retrieves the Ethereum addresses associated with the user's Passport account. These addresses can be used for various blockchain operations such as sending transactions or signing messages.
+
+## Running the Feature Group Examples
+
+### Prerequisites
+
+Before running the ZkEvm examples, you need to:
+
+1. Set up your development environment using [Immutable Hub](https://hub.immutable.com/)
+2. Have a Passport account
+3. Have the Unity SDK integrated into your project
+
+### Step-by-Step Instructions
+
+1. Open the Unity Editor with the Immutable SDK sample project
+2. Ensure you have the Passport SDK initialized properly
+3. Navigate to the Passport scene in the sample project
+4. Log in to Passport using the Authentication feature
+5. Once authenticated, you'll be able to access the ZkEvm features
+6. Try connecting to ZkEvm first, which is required for all other ZkEvm operations
+7. After connecting, you can try the other ZkEvm features in any order
+
+### Feature Sequence Dependencies
+
+While you can use most ZkEvm features independently once connected, some operations have dependencies:
+
+1. **ZkEvmConnect** must be called before any other ZkEvm operations
+2. **ZkEvmSendTransaction** should be used before **ZkEvmGetTransactionReceipt** if you want to check a transaction you just sent
+3. **ZkEvmRequestAccounts** can be useful to get the user's address before using **ZkEvmGetBalance**
+
+## Summary
+
+The ZkEvm feature group provides a comprehensive set of tools for integrating Immutable's ZkEvm blockchain into Unity games. By using these features, developers can enable users to connect to the blockchain, send transactions, check balances, and perform other blockchain operations directly from within their games.
+
+When using these features together, follow these best practices:
+
+1. Always check if Passport is initialized and the user is logged in before attempting ZkEvm operations
+2. Handle exceptions properly to provide clear feedback to users when blockchain operations fail
+3. Remember that blockchain operations may take time to process, especially when waiting for transaction confirmations
+4. Use the TransactionReceiptResponse to verify transaction status before proceeding with dependent game logic
+5. Store transaction hashes for important game transactions to allow for later verification 
\ No newline at end of file
diff --git a/sample/Assets/Scripts/Passport/features.json b/sample/Assets/Scripts/Passport/features.json
index 631332847..319ba7eee 100644
--- a/sample/Assets/Scripts/Passport/features.json
+++ b/sample/Assets/Scripts/Passport/features.json
@@ -1,22 +1,37 @@
 {
-    "features": [
-      { "Login": "LoginScript.cs" },
-      { "Logout": "LogoutScript.cs" },
-      { "Relogin": "ReloginScript.cs" },
-      { "Reconnect": "ReconnectScript.cs" },
-      { "GetUserInfo": "GetUserInfoScript.cs" },
-      { "ImxConnect": "ImxConnectScript.cs" },
-      { "ImxRegister": "ImxRegisterScript.cs" },
-      { "ImxGetAddress": "ImxGetAddressScript.cs" },
-      { "ImxNftTransfer": "ImxNftTransferScript.cs" },
-      { "ZkEvmConnect": "ZkEvmConnectScript.cs" },
-      { "ZkEvmSendTransaction": "ZkEvmSendTransactionScript.cs" },
-      { "ZkEvmGetBalance": "ZkEvmGetBalanceScript.cs" },
-      { "ZkEvmGetTransactionReceipt": "ZkEvmGetTransactionReceiptScript.cs" },
-      { "ZkEvmSignTypedData": "ZkEvmSignTypedDataScript.cs" },
-      { "SetCallTimeout": "SetCallTimeoutScript.cs" },
-      { "ClearStorageAndCache": "ClearStorageAndCacheScript.cs" },
-      { "ImxIsRegisteredOffchain": "ImxIsRegisteredOffchainScript.cs" },
-      { "ZkEvmRequestAccounts": "ZkEvmRequestAccountsScript.cs" }
-    ]
-  }
\ No newline at end of file
+    "features": {
+      "Authentication": {
+        "Login": "LoginScript.cs",
+        "Logout": "LogoutScript.cs",
+        "Relogin": "ReloginScript.cs",
+        "Reconnect": "ReconnectScript.cs"
+      },
+      "Imx": {
+        "ImxConnect": "ImxConnectScript.cs",
+        "ImxRegister": "ImxRegisterScript.cs",
+        "ImxGetAddress": "ImxGetAddressScript.cs",
+        "ImxNftTransfer": "ImxNftTransferScript.cs",
+        "ImxIsRegisteredOffchain": "ImxIsRegisteredOffchainScript.cs"
+      },
+      "Zkevm": {
+        "ZkEvmConnect": "ZkEvmConnectScript.cs",
+        "ZkEvmSendTransaction": "ZkEvmSendTransactionScript.cs",
+        "ZkEvmGetBalance": "ZkEvmGetBalanceScript.cs",
+        "ZkEvmGetTransactionReceipt": "ZkEvmGetTransactionReceiptScript.cs",
+        "ZkEvmSignTypedData": "ZkEvmSignTypedDataScript.cs",
+        "ZkEvmRequestAccounts": "ZkEvmRequestAccountsScript.cs"
+      },
+      "GetUserInfo": {
+        "GetUserInfo": "GetUserInfoScript.cs"
+      },
+      "PassportInitialisation": {
+        "PassportInitialisation": "PassportInitialisationScript.cs"
+      },
+      "SetCallTimeout": {
+        "SetCallTimeout": "SetCallTimeoutScript.cs"
+      },
+      "ClearStorageAndCache": {
+        "ClearStorageAndCache": "ClearStorageAndCacheScript.cs"
+      }
+    }
+}
\ No newline at end of file